diff --git a/doc/_src_docs/sampling_methods.rst b/doc/_src_docs/sampling_methods.rst index 0ba338c28..499dfcb7f 100644 --- a/doc/_src_docs/sampling_methods.rst +++ b/doc/_src_docs/sampling_methods.rst @@ -12,6 +12,7 @@ These are listed below. sampling_methods/random sampling_methods/lhs sampling_methods/full_factorial + sampling_methods/pydoe Usage ----- @@ -40,12 +41,12 @@ Usage (50, 2) -.. figure:: sampling_methods_Test_test_random.png +.. figure:: sampling_methods_Test_run_random.png :scale: 80 % :align: center -Problem class API ------------------ +Sampling method class API +------------------------- .. autoclass:: smt.sampling_methods.sampling_method.SamplingMethod diff --git a/doc/_src_docs/sampling_methods.rstx b/doc/_src_docs/sampling_methods.rstx index b96f956da..5eed89abf 100644 --- a/doc/_src_docs/sampling_methods.rstx +++ b/doc/_src_docs/sampling_methods.rstx @@ -12,14 +12,15 @@ These are listed below. sampling_methods/random sampling_methods/lhs sampling_methods/full_factorial + sampling_methods/pydoe Usage ----- -.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , test_random , 80 +.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , run_random , 80 -Problem class API ------------------ +Sampling method class API +------------------------- .. autoclass:: smt.sampling_methods.sampling_method.SamplingMethod diff --git a/doc/_src_docs/sampling_methods/full_factorial.rstx b/doc/_src_docs/sampling_methods/full_factorial.rstx index 5d3e1c938..d9023af78 100644 --- a/doc/_src_docs/sampling_methods/full_factorial.rstx +++ b/doc/_src_docs/sampling_methods/full_factorial.rstx @@ -4,7 +4,7 @@ Full-factorial sampling Usage ----- -.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , test_full_factorial , 80 +.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , run_full_factorial , 80 Options ------- diff --git a/doc/_src_docs/sampling_methods/full_factorial_Test_run_full_factorial.png b/doc/_src_docs/sampling_methods/full_factorial_Test_run_full_factorial.png new file mode 100644 index 000000000..18b6d822e Binary files /dev/null and b/doc/_src_docs/sampling_methods/full_factorial_Test_run_full_factorial.png differ diff --git a/doc/_src_docs/sampling_methods/lhs.rstx b/doc/_src_docs/sampling_methods/lhs.rstx index 64328a13f..1e1956bac 100644 --- a/doc/_src_docs/sampling_methods/lhs.rstx +++ b/doc/_src_docs/sampling_methods/lhs.rstx @@ -14,14 +14,14 @@ The LHS method uses the pyDOE package (Design of Experiments for Python) [1]_. F The four first criteria are the same than in pyDOE (for more details, see [1]_). The last criterion, ESE, is implemented by the authors of SMT (more details about such method could be found in [2]_). -.. [1] https://pythonhosted.org/pyDOE/index.html +.. [1] https://pydoe3.readthedocs.io/en/stable .. [2] Jin, R. and Chen, W. and Sudjianto, A. (2005), "An efficient algorithm for constructing optimal design of computer experiments." Journal of Statistical Planning and Inference, 134:268-287. Usage ----- -.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , test_lhs , 80 +.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , run_lhs , 80 Options ------- diff --git a/doc/_src_docs/sampling_methods/lhs_Test_run_lhs.png b/doc/_src_docs/sampling_methods/lhs_Test_run_lhs.png new file mode 100644 index 000000000..f73628918 Binary files /dev/null and b/doc/_src_docs/sampling_methods/lhs_Test_run_lhs.png differ diff --git a/doc/_src_docs/sampling_methods/pydoe.rst b/doc/_src_docs/sampling_methods/pydoe.rst new file mode 100644 index 000000000..c079e3c5f --- /dev/null +++ b/doc/_src_docs/sampling_methods/pydoe.rst @@ -0,0 +1,266 @@ +pyDOE sampling methods +====================== + +pyDOE is a package for design of experiments [1]_ (LHS implementation in SMT is based on pyDOE LHS). + +Main DOE functions provided by pyDOE are made available through an adapter base +class `PyDoeSamplingMethod` which makes them compliant with the `SamplingMethod` base class interface. + +While historically the sampling method interface of SMT requires to specify a number of points, pyDOE design +methods output a number of points which is only determined by the dimension of x and other method-specific options. + +The following designs are exposed: + +* Box Behnken design +* Plackett-Burman design +* Factorial design +* Generalized Subset Design + +See pyDOE3 documentation [2]_ + +References + +.. [1] https://github.com/relf/pyDOE3 + +.. [2] https://pydoe3.readthedocs.io/en/stable + + +Box Behnken sampling +-------------------- + +Usage +^^^^^ + +.. code-block:: python + + import numpy as np + import matplotlib.pyplot as plt + + from smt.sampling_methods import BoxBehnken + + xlimits = np.array([[0.0, 4.0], [0.0, 3.0], [-6.0, 1.0]]) + sampling = BoxBehnken(xlimits=xlimits) + + x = sampling() + + print(x.shape) + + ax = plt.axes(projection="3d") + ax.plot3D(x[:, 0], x[:, 1], x[:, 2], "o") + + ax.set_xlabel("x0") + ax.set_ylabel("x1") + ax.set_zlabel("x2") + plt.show() + +:: + + (15, 3) + +.. figure:: pydoe_Test_run_box_behnken.png + :scale: 80 % + :align: center + +Options +^^^^^^^ + +.. list-table:: List of options + :header-rows: 1 + :widths: 15, 10, 20, 20, 30 + :stub-columns: 0 + + * - Option + - Default + - Acceptable values + - Acceptable types + - Description + * - xlimits + - None + - None + - ['ndarray'] + - The interval of the domain in each dimension with shape nx x 2 (required) + + +Plackett-Burman sampling +------------------------ + +Usage +^^^^^ + +.. code-block:: python + + import numpy as np + import matplotlib.pyplot as plt + + from smt.sampling_methods import PlackettBurman + + xlimits = np.array([[0.0, 4.0], [0.0, 3.0], [-6.0, 1.0]]) + sampling = PlackettBurman(xlimits=xlimits) + + x = sampling() + + print(x.shape) + + ax = plt.axes(projection="3d") + ax.plot3D(x[:, 0], x[:, 1], x[:, 2], "o") + + ax.set_xlabel("x0") + ax.set_ylabel("x1") + ax.set_zlabel("x2") + plt.show() + +:: + + (4, 3) + +.. figure:: pydoe_Test_run_plackett_burman.png + :scale: 80 % + :align: center + +Options +^^^^^^^ + +.. list-table:: List of options + :header-rows: 1 + :widths: 15, 10, 20, 20, 30 + :stub-columns: 0 + + * - Option + - Default + - Acceptable values + - Acceptable types + - Description + * - xlimits + - None + - None + - ['ndarray'] + - The interval of the domain in each dimension with shape nx x 2 (required) + + +Factorial sampling +------------------ + +Usage +^^^^^ + +.. code-block:: python + + import numpy as np + import matplotlib.pyplot as plt + + from smt.sampling_methods import Factorial + + xlimits = np.array([[0.0, 4.0], [0.0, 3.0], [-6.0, 1.0]]) + sampling = Factorial(xlimits=xlimits, levels=[3, 6, 4]) + + x = sampling() + + print(x.shape) + + ax = plt.axes(projection="3d") + ax.plot3D(x[:, 0], x[:, 1], x[:, 2], "o") + + ax.set_xlabel("x0") + ax.set_ylabel("x1") + ax.set_zlabel("x2") + plt.show() + +:: + + (72, 3) + +.. figure:: pydoe_Test_run_factorial.png + :scale: 80 % + :align: center + +Options +^^^^^^^ + +.. list-table:: List of options + :header-rows: 1 + :widths: 15, 10, 20, 20, 30 + :stub-columns: 0 + + * - Option + - Default + - Acceptable values + - Acceptable types + - Description + * - xlimits + - None + - None + - ['ndarray'] + - The interval of the domain in each dimension with shape nx x 2 (required) + * - levels + - None + - None + - ['list'] + - number of factor levels per factor in design + + +Generalized Subset sampling +--------------------------- + +Usage +^^^^^ + +.. code-block:: python + + import numpy as np + import matplotlib.pyplot as plt + + from smt.sampling_methods import Gsd + + xlimits = np.array([[0.0, 4.0], [0.0, 3.0], [-6.0, 1.0]]) + sampling = Gsd(xlimits=xlimits, levels=[3, 6, 4]) + + x = sampling() + + print(x.shape) + + ax = plt.axes(projection="3d") + ax.plot3D(x[:, 0], x[:, 1], x[:, 2], "o") + + ax.set_xlabel("x0") + ax.set_ylabel("x1") + ax.set_zlabel("x2") + plt.show() + +:: + + (36, 3) + +.. figure:: pydoe_Test_run_gsd.png + :scale: 80 % + :align: center + +Options +^^^^^^^ + +.. list-table:: List of options + :header-rows: 1 + :widths: 15, 10, 20, 20, 30 + :stub-columns: 0 + + * - Option + - Default + - Acceptable values + - Acceptable types + - Description + * - xlimits + - None + - None + - ['ndarray'] + - The interval of the domain in each dimension with shape nx x 2 (required) + * - levels + - None + - None + - ['list'] + - number of factor levels per factor in design + * - reduction + - 2 + - None + - ['int'] + - Reduction factor (bigger than 1). Larger `reduction` means fewer experiments in the design and more possible complementary designs + + diff --git a/doc/_src_docs/sampling_methods/pydoe.rstx b/doc/_src_docs/sampling_methods/pydoe.rstx new file mode 100644 index 000000000..ce6deb86f --- /dev/null +++ b/doc/_src_docs/sampling_methods/pydoe.rstx @@ -0,0 +1,83 @@ +pyDOE sampling methods +====================== + +pyDOE is a package for design of experiments [1]_ (LHS implementation in SMT is based on pyDOE LHS). + +Main DOE functions provided by pyDOE are made available through an adapter base +class `PyDoeSamplingMethod` which makes them compliant with the `SamplingMethod` base class interface. + +While historically the sampling method interface of SMT requires to specify a number of points, pyDOE design +methods output a number of points which is only determined by the dimension of x and other method-specific options. + +The following designs are exposed: + +* Box Behnken design +* Plackett-Burman design +* Factorial design +* Generalized Subset Design + +See pyDOE3 documentation [2]_ + +References + +.. [1] https://github.com/relf/pyDOE3 + +.. [2] https://pydoe3.readthedocs.io/en/stable + + +Box Behnken sampling +-------------------- + +Usage +^^^^^ + +.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , run_box_behnken , 80 + +Options +^^^^^^^ + +.. embed-options-table :: smt.sampling_methods , BoxBehnken , options + + +Plackett-Burman sampling +------------------------ + +Usage +^^^^^ + +.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , run_plackett_burman , 80 + +Options +^^^^^^^ + +.. embed-options-table :: smt.sampling_methods , PlackettBurman , options + + +Factorial sampling +------------------ + +Usage +^^^^^ + +.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , run_factorial , 80 + +Options +^^^^^^^ + +.. embed-options-table :: smt.sampling_methods , Factorial , options + + +Generalized Subset sampling +--------------------------- + +Usage +^^^^^ + +.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , run_gsd , 80 + +Options +^^^^^^^ + +.. embed-options-table :: smt.sampling_methods , Gsd , options + + diff --git a/doc/_src_docs/sampling_methods/pydoe_Test_run_box_behnken.png b/doc/_src_docs/sampling_methods/pydoe_Test_run_box_behnken.png new file mode 100644 index 000000000..7a6d33ec7 Binary files /dev/null and b/doc/_src_docs/sampling_methods/pydoe_Test_run_box_behnken.png differ diff --git a/doc/_src_docs/sampling_methods/pydoe_Test_run_factorial.png b/doc/_src_docs/sampling_methods/pydoe_Test_run_factorial.png new file mode 100644 index 000000000..2d737dc92 Binary files /dev/null and b/doc/_src_docs/sampling_methods/pydoe_Test_run_factorial.png differ diff --git a/doc/_src_docs/sampling_methods/pydoe_Test_run_gsd.png b/doc/_src_docs/sampling_methods/pydoe_Test_run_gsd.png new file mode 100644 index 000000000..585e5816b Binary files /dev/null and b/doc/_src_docs/sampling_methods/pydoe_Test_run_gsd.png differ diff --git a/doc/_src_docs/sampling_methods/pydoe_Test_run_plackett_burman.png b/doc/_src_docs/sampling_methods/pydoe_Test_run_plackett_burman.png new file mode 100644 index 000000000..1d1982122 Binary files /dev/null and b/doc/_src_docs/sampling_methods/pydoe_Test_run_plackett_burman.png differ diff --git a/doc/_src_docs/sampling_methods/random.rstx b/doc/_src_docs/sampling_methods/random.rstx index 9517c457a..22a9ab7a3 100644 --- a/doc/_src_docs/sampling_methods/random.rstx +++ b/doc/_src_docs/sampling_methods/random.rstx @@ -6,7 +6,7 @@ This class creates random samples from a uniform distribution over the design sp Usage ----- -.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , test_random , 80 +.. embed-test-print-plot :: smt.sampling_methods.tests.test_sampling_method_examples , Test , run_random , 80 Options ------- diff --git a/doc/_src_docs/sampling_methods/random_Test_run_random.png b/doc/_src_docs/sampling_methods/random_Test_run_random.png new file mode 100644 index 000000000..790d7f9f4 Binary files /dev/null and b/doc/_src_docs/sampling_methods/random_Test_run_random.png differ diff --git a/doc/_src_docs/sampling_methods_Test_run_random.png b/doc/_src_docs/sampling_methods_Test_run_random.png new file mode 100644 index 000000000..0f10cf336 Binary files /dev/null and b/doc/_src_docs/sampling_methods_Test_run_random.png differ diff --git a/doc/_src_docs/sampling_methods_Test_test_random.png b/doc/_src_docs/sampling_methods_Test_test_random.png index ee9c9b7c9..622338d96 100644 Binary files a/doc/_src_docs/sampling_methods_Test_test_random.png and b/doc/_src_docs/sampling_methods_Test_test_random.png differ diff --git a/doc/embed_directives/directive_embed_options.py b/doc/embed_directives/directive_embed_options.py index d4b6eb75f..5933f050a 100644 --- a/doc/embed_directives/directive_embed_options.py +++ b/doc/embed_directives/directive_embed_options.py @@ -15,7 +15,18 @@ def run(self, file_dir, file_name, embed_num_indent, args): module_path, class_name, attribute_name = args exec("from {} import {}".format(module_path, class_name), globals()) - exec("obj = {}()".format(class_name), globals()) + + # sampling methods requires xlimits option + exec("import numpy as np", globals()) + exec( + "from smt.sampling_methods.sampling_method import SamplingMethod", globals() + ) + exec( + f"params = 'xlimits=np.array([[0, 1]])' if issubclass({class_name}, SamplingMethod) else ''", + globals(), + ) + + exec("obj = {}({})".format(class_name, params), globals()) options = getattr(obj, attribute_name) diff --git a/doc/index.rst b/doc/index.rst index 71830865e..424cb53cf 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -21,7 +21,6 @@ To cite SMT 2.0: P. Saves and R. Lafage and N. Bartoli and Y. Diouane and J. H. `SMT 2.0: A Surrogate Modeling Toolbox with a focus on Hierarchical and Mixed Variables Gaussian Processes, ArXiv 2023 `_. - .. code-block:: none @article{SMT2ArXiv, diff --git a/doc/requirements.txt b/doc/requirements.txt index 0bf29edaa..7d97a1523 100644 --- a/doc/requirements.txt +++ b/doc/requirements.txt @@ -5,4 +5,5 @@ scikit-learn pyDOE3 numpydoc matplotlib +ConfigSpace~=0.6.1 git+https://github.com/hwangjt/sphinx_auto_embed.git # for doc generation \ No newline at end of file diff --git a/smt/applications/mixed_integer.py b/smt/applications/mixed_integer.py index e9076c274..0462b524d 100644 --- a/smt/applications/mixed_integer.py +++ b/smt/applications/mixed_integer.py @@ -42,7 +42,6 @@ def __init__(self, sampling_method_class, design_space, **kwargs): "MixedIntegerSamplingMethod has been deprecated, use DesignSpace.sample_valid_x instead!", category=DeprecationWarning, ) - self._design_space = design_space self._unfolded_xlimits = design_space.get_unfolded_num_bounds() self._output_in_folded_space = kwargs.get("output_in_folded_space", True) @@ -50,7 +49,7 @@ def __init__(self, sampling_method_class, design_space, **kwargs): self._sampling_method = sampling_method_class( xlimits=self._unfolded_xlimits, **kwargs ) - super().__init__() + super().__init__(xlimits=self._unfolded_xlimits) def _compute(self, nt): doe = self._sampling_method(nt) diff --git a/smt/sampling_methods/__init__.py b/smt/sampling_methods/__init__.py index 5247e7b89..08552f6b4 100644 --- a/smt/sampling_methods/__init__.py +++ b/smt/sampling_methods/__init__.py @@ -1,3 +1,4 @@ from .random import Random from .lhs import LHS from .full_factorial import FullFactorial +from .pydoe import BoxBehnken, PlackettBurman, Factorial, Gsd diff --git a/smt/sampling_methods/pydoe.py b/smt/sampling_methods/pydoe.py new file mode 100644 index 000000000..ab0a2abd9 --- /dev/null +++ b/smt/sampling_methods/pydoe.py @@ -0,0 +1,146 @@ +""" +Author: Antoine Averland and Rémi Lafage + +This package is distributed under New BSD license. + +pyDOE3 sampling methods +""" +from pyDOE3 import doe_box_behnken +from pyDOE3 import doe_gsd +from pyDOE3 import doe_factorial +from pyDOE3 import doe_plackett_burman +import numpy as np + +from smt.sampling_methods.sampling_method import SamplingMethod + + +class PyDoeSamplingMethod(SamplingMethod): + """ + Base class adapting pyDOE3 designs to SMT SamplingMethod interface + See https://pydoe3.readthedocs.io/ + """ + + def __init__(self, **kwargs): + super().__init__(**kwargs) + self.nx = self.options["xlimits"].shape[0] + self.levels = None + + def _compute(self, nt: int = None): + """ + Use pydoe3 design to produce [nsamples, nx] matrix + where nsamples depends on the pyDOE3 method and nx is the dimension of x. + Warning: In pyDOE3 design setting user requested number of points nt is not used + """ + xlimits = self.options["xlimits"] + levels = self.levels + + # Retrieve indices from pyDOE3 design + doe = np.array(self._compute_doe(), dtype=int) + + # Compute scaled values for each x components + values = np.zeros((self.nx, max(levels))) + for i in range(self.nx): + values[i, 0 : levels[i]] = np.linspace( + xlimits[i, 0], + xlimits[i, 1], + num=levels[i], + ) + + # Use indices to shape the result array and fill it with values + res = np.zeros(doe.shape) + i = 0 + for idx in doe: + for j in range(self.nx): + res[i, j] = values[j, idx[j]] + i = i + 1 + + return res + + def _compute_doe(): + """Returns a matrix (nsamples, nx) of indices. + + Each indices takes a value in [0, nlevels_i-1] where nlevels_i is + the number of levels of the ith component of x. + This method has to be overriden by subclasses""" + raise NotImplementedError( + "You have to implement DOE computation method _compute_doe()" + ) + + +class BoxBehnken(PyDoeSamplingMethod): + """See https://pydoe3.readthedocs.io/en/latest/rsm.html#box-behnken""" + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + # Box Behnken design has 3 levels [-1, 0, 1] + self.levels = [3] * self.nx # for + + def _compute_doe(self): + # Increment Box Behnken levels to get indices [0, 1, 2] + return doe_box_behnken.bbdesign(self.nx) + 1 + + +class Gsd(PyDoeSamplingMethod): + """See https://pydoe3.readthedocs.io/en/latest/rsm.html#gsd""" + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + self.levels = self.options["levels"] + + def _initialize(self, **kwargs): + self.options.declare( + "levels", + types=list, + desc="number of factor levels per factor in design", + ) + self.options.declare( + "reduction", + types=int, + default=2, + desc="Reduction factor (bigger than 1). Larger `reduction` means fewer experiments in the design and more possible complementary designs", + ) + + def _compute_doe(self): + levels = self.options["levels"] + reduction = self.options["reduction"] + + return doe_gsd.gsd(levels, reduction) + + +class Factorial(PyDoeSamplingMethod): + """See https://pydoe3.readthedocs.io/en/latest/factorial.html#general-full-factorial""" + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + self.levels = self.options["levels"] + + def _initialize(self, **kwargs): + self.options.declare( + "levels", + types=list, + desc="number of factor levels per factor in design", + ) + + def _compute_doe(self): + levels = self.options["levels"] + return doe_factorial.fullfact(levels) + + +class PlackettBurman(PyDoeSamplingMethod): + """See https://pydoe3.readthedocs.io/en/latest/factorial.html#plackett-burman""" + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + # Plackett Burman design has 2 levels [-1, 1] + self.levels = [2] * self.nx + + def _compute_doe(self): + doe = doe_plackett_burman.pbdesign(self.nx) + # Change -1 level to get indices [0, 1] + doe[doe < 0] = 0 + + return doe diff --git a/smt/sampling_methods/sampling_method.py b/smt/sampling_methods/sampling_method.py index 7a311a73a..1d4ce84df 100644 --- a/smt/sampling_methods/sampling_method.py +++ b/smt/sampling_methods/sampling_method.py @@ -7,6 +7,7 @@ """ from abc import ABCMeta, abstractmethod import numpy as np +import warnings from smt.utils.options_dictionary import OptionsDictionary @@ -15,8 +16,9 @@ class SamplingMethod(metaclass=ABCMeta): def __init__(self, **kwargs): """ Constructor where values of options can be passed in. + xlimits keyword argument is required. - For the list of options, see the documentation for the problem being used. + For the list of options, see the documentation for the sampling method being used. Parameters ---------- @@ -37,6 +39,8 @@ def __init__(self, **kwargs): ) self._initialize(**kwargs) self.options.update(kwargs) + if self.options["xlimits"] is None: + raise ValueError("xlimits keyword argument is required") def _initialize(self, **kwargs) -> None: """ @@ -54,16 +58,17 @@ def _initialize(self, **kwargs) -> None: """ pass - def __call__(self, nt: int) -> np.ndarray: + def __call__(self, nt: int = None) -> np.ndarray: """ - Compute the requested number of sampling points. + Compute the samples. + Depending on the concrete sampling method the requested number of samples nt may not be enforced. The number of dimensions (nx) is determined based on `xlimits.shape[0]`. Arguments --------- nt : int - Number of points requested. + Number of points hint. Returns ------- @@ -73,9 +78,10 @@ def __call__(self, nt: int) -> np.ndarray: return self._compute(nt) @abstractmethod - def _compute(self, nt: int) -> np.ndarray: + def _compute(self, nt: int = None) -> np.ndarray: """ - Implemented by sampling methods to compute the requested number of sampling points. + Implemented by sampling methods to compute the samples. + Depending on the concrete sampling method the requested number of samples nt may not be enforced. The number of dimensions (nx) is determined based on `xlimits.shape[0]`. @@ -83,6 +89,7 @@ def _compute(self, nt: int) -> np.ndarray: --------- nt : int Number of points requested. + Depending on the concrete sampling method this requested number of samples may not be enforced. Returns ------- @@ -93,20 +100,25 @@ def _compute(self, nt: int) -> np.ndarray: class ScaledSamplingMethod(SamplingMethod): - """This class describes an sample method which generates samples in the unit hypercube. + """This class represents sample methods which generates samples in the unit hypercube [0, 1]^nx. The __call__ method does scale the generated samples accordingly to the defined xlimits. + Implementation notes: + * When nt is None, it defaults to 2 * nx. + * xlimits is presence is checked. ValueError is raised if not specified. """ - def __call__(self, nt: int) -> np.ndarray: + def __call__(self, nt: int = None) -> np.ndarray: """ - Compute the requested number of sampling points. + Compute the samples. + Depending on the concrete sampling method the requested number of samples nt may not be enforced. + When nt is None, it defaults to 2 * nx. The number of dimensions (nx) is determined based on `xlimits.shape[0]`. Arguments --------- - nt : int + nt : int (optional, default 2*nx) Number of points requested. Returns @@ -114,10 +126,13 @@ def __call__(self, nt: int) -> np.ndarray: ndarray[nt, nx] The sampling locations in the input space. """ - return _scale_to_xlimits(self._compute(nt), self.options["xlimits"]) + xlimits = self.options["xlimits"] + if nt is None: + nt = 2 * xlimits.shape[0] + return _scale_to_xlimits(self._compute(nt), xlimits) @abstractmethod - def _compute(self, nt: int) -> np.ndarray: + def _compute(self, nt: int = None) -> np.ndarray: """ Implemented by sampling methods to compute the requested number of sampling points. diff --git a/smt/sampling_methods/tests/test_pydoe.py b/smt/sampling_methods/tests/test_pydoe.py new file mode 100644 index 000000000..73dfdf5a7 --- /dev/null +++ b/smt/sampling_methods/tests/test_pydoe.py @@ -0,0 +1,118 @@ +import unittest +import numpy as np + +from smt.sampling_methods import pydoe + + +class TestPyDOE3(unittest.TestCase): + def test_bbdesign(self): + xlimits = np.array([[2.0, 5], [-5, 1], [0, 3]]) + sampling = pydoe.BoxBehnken(xlimits=xlimits) + actual = sampling() + self.assertEqual((15, 3), actual.shape) + print(actual) + expected = [ + [2.0, -5.0, 1.5], + [5.0, -5.0, 1.5], + [2.0, 1.0, 1.5], + [5.0, 1.0, 1.5], + [2.0, -2.0, 0.0], + [5.0, -2.0, 0.0], + [2.0, -2.0, 3.0], + [5.0, -2.0, 3.0], + [3.5, -5.0, 0.0], + [3.5, 1.0, 0.0], + [3.5, -5.0, 3.0], + [3.5, 1.0, 3.0], + [3.5, -2.0, 1.5], + [3.5, -2.0, 1.5], + [3.5, -2.0, 1.5], + ] + + np.testing.assert_allclose(actual, expected) + + def test_gsd1(self): + xlimits = np.array([[5, 11], [0, 6], [-3, 4]]) + sampling = pydoe.Gsd(xlimits=xlimits, levels=[3, 4, 6], reduction=4) + actual = sampling() + self.assertEqual((18, 3), actual.shape) + print(actual) + expected = [ + [5, 0, -3], + [5, 0, 2.6], + [5, 2, -1.6], + [5, 2, 4], + [5, 4, -0.2], + [5, 6, 1.2], + [8, 0, -1.6], + [8, 0, 4], + [8, 2, -0.2], + [8, 4, 1.2], + [8, 6, -3], + [8, 6, 2.6], + [11, 0, -0.2], + [11, 2, 1.2], + [11, 4, -3], + [11, 4, 2.6], + [11, 6, -1.6], + [11, 6, 4], + ] + + np.testing.assert_allclose(actual, expected) + + def test_factorial(self): + xlimits = np.array([[4, 10], [-3, 3], [5, 7]]) + sampling = pydoe.Factorial(xlimits=xlimits, levels=[2, 4, 3]) + actual = sampling() + self.assertEqual((24, 3), actual.shape) + print(actual) + expected = [ + [4.0, -3.0, 5.0], + [10.0, -3.0, 5.0], + [4.0, -1.0, 5.0], + [10.0, -1.0, 5.0], + [4.0, 1.0, 5.0], + [10.0, 1.0, 5.0], + [4.0, 3.0, 5.0], + [10.0, 3.0, 5.0], + [4.0, -3.0, 6.0], + [10.0, -3.0, 6.0], + [4.0, -1.0, 6.0], + [10.0, -1.0, 6.0], + [4.0, 1.0, 6.0], + [10.0, 1.0, 6.0], + [4.0, 3.0, 6.0], + [10.0, 3.0, 6.0], + [4.0, -3.0, 7.0], + [10.0, -3.0, 7.0], + [4.0, -1.0, 7.0], + [10.0, -1.0, 7.0], + [4.0, 1.0, 7.0], + [10.0, 1.0, 7.0], + [4.0, 3.0, 7.0], + [10.0, 3.0, 7.0], + ] + np.testing.assert_allclose(actual, expected) + + def test_plackett_burman(self): + xlimits = np.array([[2, 5], [-5, 1], [0, 3], [4, 8], [-1, 2]]) + sampling = pydoe.PlackettBurman(xlimits=xlimits) + actual = sampling() + self.assertEqual((8, 5), actual.shape) + print(actual) + expected = [ + [2.0, -5.0, 3.0, 4.0, 2.0], + [5.0, -5.0, 0.0, 4.0, -1.0], + [2.0, 1.0, 0.0, 4.0, 2.0], + [5.0, 1.0, 3.0, 4.0, -1.0], + [2.0, -5.0, 3.0, 8.0, -1.0], + [5.0, -5.0, 0.0, 8.0, 2.0], + [2.0, 1.0, 0.0, 8.0, -1.0], + [5.0, 1.0, 3.0, 8.0, 2.0], + ] + + np.testing.assert_allclose(actual, expected) + + +if __name__ == "__main__": + unittest.main() diff --git a/smt/sampling_methods/tests/test_sampling_method_examples.py b/smt/sampling_methods/tests/test_sampling_method_examples.py index 6e5224017..b84c26040 100644 --- a/smt/sampling_methods/tests/test_sampling_method_examples.py +++ b/smt/sampling_methods/tests/test_sampling_method_examples.py @@ -10,8 +10,8 @@ class Test(unittest.TestCase): - @unittest.skipIf(NO_MATPLOTLIB, "Matplotlib not installed") - def test_random(self): + @staticmethod + def run_random(): import numpy as np import matplotlib.pyplot as plt @@ -30,8 +30,8 @@ def test_random(self): plt.ylabel("y") plt.show() - @unittest.skipIf(NO_MATPLOTLIB, "Matplotlib not installed") - def test_lhs(self): + @staticmethod + def run_lhs(): import numpy as np import matplotlib.pyplot as plt @@ -50,8 +50,8 @@ def test_lhs(self): plt.ylabel("y") plt.show() - @unittest.skipIf(NO_MATPLOTLIB, "Matplotlib not installed") - def test_full_factorial(self): + @staticmethod + def run_full_factorial(): import numpy as np import matplotlib.pyplot as plt @@ -70,6 +70,104 @@ def test_full_factorial(self): plt.ylabel("y") plt.show() + @staticmethod + def run_box_behnken(): + import numpy as np + import matplotlib.pyplot as plt + + from smt.sampling_methods import BoxBehnken + + xlimits = np.array([[0.0, 4.0], [0.0, 3.0], [-6.0, 1.0]]) + sampling = BoxBehnken(xlimits=xlimits) + + x = sampling() + + print(x.shape) + + ax = plt.axes(projection="3d") + ax.plot3D(x[:, 0], x[:, 1], x[:, 2], "o") + + ax.set_xlabel("x0") + ax.set_ylabel("x1") + ax.set_zlabel("x2") + plt.show() + + @staticmethod + def run_plackett_burman(): + import numpy as np + import matplotlib.pyplot as plt + + from smt.sampling_methods import PlackettBurman + + xlimits = np.array([[0.0, 4.0], [0.0, 3.0], [-6.0, 1.0]]) + sampling = PlackettBurman(xlimits=xlimits) + + x = sampling() + + print(x.shape) + + ax = plt.axes(projection="3d") + ax.plot3D(x[:, 0], x[:, 1], x[:, 2], "o") + + ax.set_xlabel("x0") + ax.set_ylabel("x1") + ax.set_zlabel("x2") + plt.show() + + @staticmethod + def run_factorial(): + import numpy as np + import matplotlib.pyplot as plt + + from smt.sampling_methods import Factorial + + xlimits = np.array([[0.0, 4.0], [0.0, 3.0], [-6.0, 1.0]]) + sampling = Factorial(xlimits=xlimits, levels=[3, 6, 4]) + + x = sampling() + + print(x.shape) + + ax = plt.axes(projection="3d") + ax.plot3D(x[:, 0], x[:, 1], x[:, 2], "o") + + ax.set_xlabel("x0") + ax.set_ylabel("x1") + ax.set_zlabel("x2") + plt.show() + + @staticmethod + def run_gsd(): + import numpy as np + import matplotlib.pyplot as plt + + from smt.sampling_methods import Gsd + + xlimits = np.array([[0.0, 4.0], [0.0, 3.0], [-6.0, 1.0]]) + sampling = Gsd(xlimits=xlimits, levels=[3, 6, 4]) + + x = sampling() + + print(x.shape) + + ax = plt.axes(projection="3d") + ax.plot3D(x[:, 0], x[:, 1], x[:, 2], "o") + + ax.set_xlabel("x0") + ax.set_ylabel("x1") + ax.set_zlabel("x2") + plt.show() + + @unittest.skipIf(NO_MATPLOTLIB, "Matplotlib not installed") + def test_sampling_methods_examples(self): + self.run_lhs() + self.run_full_factorial() + self.run_random() + self.run_plackett_burman + self.run_box_behnken() + self.run_factorial() + self.run_gsd() + if __name__ == "__main__": unittest.main() diff --git a/smt/sampling_methods/tests/test_scaled_sampling_methods.py b/smt/sampling_methods/tests/test_scaled_sampling_methods.py new file mode 100644 index 000000000..ee029c48f --- /dev/null +++ b/smt/sampling_methods/tests/test_scaled_sampling_methods.py @@ -0,0 +1,25 @@ +import os +import unittest +import numpy as np + +from smt.sampling_methods import LHS, FullFactorial, Random + +SCALED_SAMPLINGS = [LHS, FullFactorial, Random] + + +class TestScaledSamplingMethods(unittest.TestCase): + def test_xlimits_missing_error(self): + for method in SCALED_SAMPLINGS: + with self.assertRaises(ValueError) as context: + method() + self.assertEqual( + "xlimits keyword argument is required", str(context.exception) + ) + + def test_default_nt(self): + for method in SCALED_SAMPLINGS: + xlimits = np.array([[-5.5, 3.0], [2.0, 3]]) + nx = xlimits.shape[0] + sampling = method(xlimits=xlimits) + doe = sampling() + self.assertEqual(doe.shape, (2 * nx, nx)) diff --git a/tutorial/NotebookRunTestCases_Paper_SMT_v2.ipynb b/tutorial/NotebookRunTestCases_Paper_SMT_v2.ipynb index 68a4ce0c1..1634beb30 100644 --- a/tutorial/NotebookRunTestCases_Paper_SMT_v2.ipynb +++ b/tutorial/NotebookRunTestCases_Paper_SMT_v2.ipynb @@ -46,24 +46,10 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "6f6d2d12", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: smt in d:\\bartoli\\anaconda3\\lib\\site-packages (2.0b3)\n", - "Requirement already satisfied: pyDOE2 in d:\\bartoli\\anaconda3\\lib\\site-packages (from smt) (1.3.0)\n", - "Requirement already satisfied: scikit-learn in d:\\bartoli\\anaconda3\\lib\\site-packages (from smt) (1.0.2)\n", - "Requirement already satisfied: scipy in d:\\bartoli\\anaconda3\\lib\\site-packages (from smt) (1.9.1)\n", - "Requirement already satisfied: numpy in d:\\bartoli\\anaconda3\\lib\\site-packages (from pyDOE2->smt) (1.21.6)\n", - "Requirement already satisfied: joblib>=0.11 in d:\\bartoli\\anaconda3\\lib\\site-packages (from scikit-learn->smt) (1.1.0)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in d:\\bartoli\\anaconda3\\lib\\site-packages (from scikit-learn->smt) (3.1.0)\n" - ] - } - ], + "outputs": [], "source": [ "#to have the latest version\n", "!pip install smt --pre " @@ -71,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "fff43855", "metadata": {}, "outputs": [], @@ -139,19 +125,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "ccc49c3b", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred_RMSE on the training points 7.397754468383895e-10\n", - "Var_RMSE on the training points 4.657514467135904e-10\n" - ] - } - ], + "outputs": [], "source": [ "def f_neu(x1, x2, x3):\n", " return 2 * x1 + x2 - 0.5 * x3\n", @@ -195,8 +172,7 @@ "\n", "# Perform the mixed integer sampling - LHS DOE\n", "n_doe = 100 \n", - "sampling = MixedIntegerSamplingMethod (LHS , design_space, criterion =\"ese\", random_state =42)\n", - "Xt = sampling (n_doe)\n", + "Xt, _ = design_space.sample_valid_x(n_doe)\n", "Yt = f(Xt)\n", "\n", "# Build the surrogate \n", @@ -209,8 +185,8 @@ " corr=\"abs_exp\",\n", " n_start=5,\n", " print_global=False))\n", - "sm. set_training_values (Xt , Yt)\n", - "sm. train ()\n", + "sm.set_training_values (Xt , Yt)\n", + "sm.train()\n", "\n", "\n", "# Check prediction and variance accuracy \n", @@ -226,21 +202,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "9fc88694", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0.48244912 -0.71338317 -16.70103644] [ 0.48244912 -0.71338317 -16.70103644]\n", - "The outputs must be similar (inactive variables have no effect) 0.0\n", - "[-2.01682311] [9.98277891]\n", - "The outputs must be different (active variables have effect) 11.99960201467982\n" - ] - } - ], + "outputs": [], "source": [ "#To check of some inactive variables have no effect on the output\n", "xv1=np.array([\n", @@ -269,22 +234,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "c122b735", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Activation function ['ISRLU', 'SELU', 'ReLU ']\n", - "Batch size [3, 4, 5]\n", - "Number of hidden neurons -1st layer [2, 2, 2]\n", - "Number of hidden neurons -2nd layer [0, 1, 1]\n", - "Number of hidden neurons -3rd layer [0, 0, 5]\n" - ] - } - ], + "outputs": [], "source": [ "#To have access to the \"real\" values of the input space variables\n", "x2_decoded = design_space.decode_values(xv1, i_dv=2)\n", @@ -342,28 +295,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "1b3c3727", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Name: numba\n", - "Version: 0.55.1\n", - "Summary: compiling Python code using LLVM\n", - "Home-page: https://numba.pydata.org\n", - "Author: \n", - "Author-email: \n", - "License: BSD\n", - "Location: d:\\bartoli\\anaconda3\\lib\\site-packages\n", - "Requires: llvmlite, numpy, setuptools\n", - "Required-by: datashader\n", - "\"Numba used or not in your environment=\" 1\n" - ] - } - ], + "outputs": [], "source": [ "#to check if numba is available\n", "!pip show numba\n", @@ -373,19 +308,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "b2d505b5", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "for 15 points time is = 0.0020842552185058594\n", - "for 150 points time is = 0.0029900074005126953\n" - ] - } - ], + "outputs": [], "source": [ "#compare the CPU time to build a DOE with 15 or 150 points\n", "problem = HierarchicalGoldstein()\n", @@ -465,38 +391,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "34f618b6", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial DOE given\n", - "Internal optimization succeeded at EGO iter = 0.0\n", - "Internal optimization succeeded at EGO iter = 1.0\n", - "Internal optimization succeeded at EGO iter = 2.0\n", - "Internal optimization succeeded at EGO iter = 3.0\n", - "Internal optimization succeeded at EGO iter = 4.0\n", - "Internal optimization succeeded at EGO iter = 5.0\n", - "Internal optimization succeeded at EGO iter = 6.0\n", - "Internal optimization succeeded at EGO iter = 7.0\n", - "Internal optimization succeeded at EGO iter = 8.0\n", - "Internal optimization succeeded at EGO iter = 9.0\n", - "Internal optimization succeeded at EGO iter = 10.0\n", - "Internal optimization succeeded at EGO iter = 11.0\n", - "Internal optimization succeeded at EGO iter = 12.0\n", - "Internal optimization succeeded at EGO iter = 13.0\n", - "Internal optimization succeeded at EGO iter = 14.0\n", - "Internal optimization succeeded at EGO iter = 15.0\n", - "Internal optimization succeeded at EGO iter = 16.0\n", - "Internal optimization succeeded at EGO iter = 17.0\n", - "Internal optimization succeeded at EGO iter = 18.0\n", - "Internal optimization succeeded at EGO iter = 19.0\n" - ] - } - ], + "outputs": [], "source": [ "def f_obj(X):\n", " \"\"\"\n", @@ -602,87 +500,20 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "a8c7967e", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Final results: [1. 1.] [-0.49903471] 6 [[ 8.51755996e-01 8.00000000e+00]\n", - " [ 7.49080238e-02 7.00000000e+00]\n", - " [ 7.89777107e-01 6.00000000e+00]\n", - " [ 3.93981970e-01 5.00000000e+00]\n", - " [ 4.58428930e-01 0.00000000e+00]\n", - " [ 0.00000000e+00 3.00000000e+00]\n", - " [ 1.00000000e+00 1.00000000e+00]\n", - " [ 6.15146961e-01 1.00000000e+00]\n", - " [ 2.55670161e-01 0.00000000e+00]\n", - " [ 1.00000000e+00 7.00000000e+00]\n", - " [ 6.24565300e-01 8.00000000e+00]\n", - " [ 8.96012593e-01 6.00000000e+00]\n", - " [ 1.00000000e+00 0.00000000e+00]\n", - " [ 7.78892358e-01 3.00000000e+00]\n", - " [ 6.21147886e-01 3.00000000e+00]\n", - " [ 0.00000000e+00 4.00000000e+00]\n", - " [-1.38777878e-17 2.00000000e+00]\n", - " [ 5.00000000e-02 4.00000000e+00]\n", - " [ 4.50000000e-01 1.00000000e+00]\n", - " [ 5.50000000e-01 1.00000000e+00]\n", - " [ 2.50000000e-01 3.00000000e+00]\n", - " [ 1.50000000e-01 2.00000000e+00]\n", - " [ 3.50000000e-01 0.00000000e+00]\n", - " [ 9.05436256e-01 7.00000000e+00]\n", - " [ 4.66293670e-15 6.00000000e+00]] [[ 7.75846253e-01]\n", - " [ 1.94629117e+00]\n", - " [ 1.71003723e-01]\n", - " [ 1.84039447e+00]\n", - " [-3.86204555e-01]\n", - " [ 0.00000000e+00]\n", - " [-4.99034713e-01]\n", - " [ 3.68040264e+00]\n", - " [-1.05907676e-01]\n", - " [ 1.50000000e+00]\n", - " [ 9.52481879e-01]\n", - " [-3.34498595e-01]\n", - " [ 3.09016994e-01]\n", - " [-4.67697665e-01]\n", - " [-2.65971458e-01]\n", - " [ 0.00000000e+00]\n", - " [ 1.00000000e+00]\n", - " [-1.25000000e-03]\n", - " [ 3.07458112e+00]\n", - " [ 3.63947848e+00]\n", - " [ 5.46413837e-02]\n", - " [ 6.62785252e-01]\n", - " [ 3.32287251e-01]\n", - " [ 2.37084501e+00]\n", - " [ 1.00000000e+00]]\n" - ] - } - ], + "outputs": [], "source": [ "print(\"Final results:\", x_opt, y_opt, dnk, x_data, y_data)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "fc71d62e", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\n", "%matplotlib inline\n", @@ -730,18 +561,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "00fab0cb", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal point found [9.24399028 2.7837277 ] [0.76323137]\n" - ] - } - ], + "outputs": [], "source": [ "#Branin function with a integer variable and a continuous variable\n", "fun = Branin(ndim=2)\n", @@ -773,38 +596,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "a5ff0799", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[9.24399028 2.7837277 ] [0.76323137]\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Mixed Branin - optimization process')" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# 3 optimal points possible in the continuous Branin function: [-pi, 12.275], [pi, 2.275], [9.42478, 2.475] \n", "#for the modified integer Branin function\n", @@ -825,21 +620,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "a6115410", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", @@ -977,7 +761,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "6d5dc782", "metadata": {}, "outputs": [], @@ -988,38 +772,10 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "fbbe62cc", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial DOE given\n", - "Internal optimization succeeded at EGO iter = 0.0\n", - "Internal optimization succeeded at EGO iter = 1.0\n", - "Internal optimization succeeded at EGO iter = 2.0\n", - "Internal optimization succeeded at EGO iter = 3.0\n", - "Internal optimization succeeded at EGO iter = 4.0\n", - "Internal optimization succeeded at EGO iter = 5.0\n", - "Internal optimization succeeded at EGO iter = 6.0\n", - "Internal optimization succeeded at EGO iter = 7.0\n", - "Internal optimization succeeded at EGO iter = 8.0\n", - "Internal optimization succeeded at EGO iter = 9.0\n", - "Internal optimization succeeded at EGO iter = 10.0\n", - "Internal optimization succeeded at EGO iter = 11.0\n", - "Internal optimization succeeded at EGO iter = 12.0\n", - "Internal optimization succeeded at EGO iter = 13.0\n", - "Internal optimization succeeded at EGO iter = 14.0\n", - "Internal optimization succeeded at EGO iter = 15.0\n", - "Internal optimization succeeded at EGO iter = 16.0\n", - "Internal optimization succeeded at EGO iter = 17.0\n", - "Internal optimization succeeded at EGO iter = 18.0\n", - "Internal optimization succeeded at EGO iter = 19.0\n" - ] - } - ], + "outputs": [], "source": [ "#Build the initial DOE\n", "rseed = 42 #seed for the sampling\n", @@ -1054,21 +810,10 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "f2078a02", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal points [ 0. 0. 100. 20.02801089 50.\n", - " 50. 26.61557871 2. 0. 0.\n", - " 2. ] [33.14003586]\n", - "Optimal design variables in the initial space [0, 0, 99.99999999999999, 20.02801089116878, 50.0, 50.0, 26.61557871013431, 2.0, 0.0, 0.0, 2.0]\n" - ] - } - ], + "outputs": [], "source": [ " print(\"Optimal points\",x_opt, y_opt)\n", "print(\"Optimal design variables in the initial space\", design_space.decode_values(x_opt))\n" @@ -1076,21 +821,10 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "d43ac3eb", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", @@ -1105,14 +839,6 @@ "plt.ylabel(\"Objective value\")\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0882ac1f", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -1131,7 +857,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.8.12" } }, "nbformat": 4, diff --git a/tutorial/README.md b/tutorial/README.md index d1a8d8f50..adc899fd9 100644 --- a/tutorial/README.md +++ b/tutorial/README.md @@ -29,7 +29,12 @@ These tutorials introduce to use the opensource Surrogate Modeling Toolbox where ## Mixed-Integer Gaussian Process and Bayesian Optimization to solve unconstrained problems with mixed variables (continuous, discrete, categorical) -[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/SMTorg/smt/blob/master/tutorial/SMT_MixedInteger_application.ipynb) +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/SMTorg/smt/blob/master/tutorial/SMT_MixedInteger.ipynb) + +## Mixed-Integer Gaussian Process and Bayesian Optimization for Engineering application + +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/SMTorg/smt/blob/master/tutorial/SMT_MixedInteger_Engineering_applications.ipynb) + ## DesignSpace to variables (continuous, discrete, categorical, hierarchical) diff --git a/tutorial/SMT_MixedInteger_application.ipynb b/tutorial/SMT_MixedInteger.ipynb similarity index 96% rename from tutorial/SMT_MixedInteger_application.ipynb rename to tutorial/SMT_MixedInteger.ipynb index 3b097955b..579fe9daa 100644 --- a/tutorial/SMT_MixedInteger_application.ipynb +++ b/tutorial/SMT_MixedInteger.ipynb @@ -7,7 +7,7 @@ "id": "view-in-github" }, "source": [ - "\"Open" + "\"Open" ] }, { @@ -168,7 +168,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 282, "metadata": { "id": "-Y8Vi-hsmu35" }, @@ -1243,346 +1243,6 @@ "\n" ] }, - { - "cell_type": "markdown", - "metadata": { - "id": "SfVsrEH0nolz" - }, - "source": [ - "# Gower mixed based surrogate model 4D function" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "8BHCEbw3nwQ9" - }, - "source": [ - "The database is available at https://www.sciencedirect.com/science/article/abs/pii/S1359835X11000224\n", - "\n", - "The aim is to build a surrogate model for mixed variables in a hybrid composite problem. The trained surrogate model is able to predict the composites characteristics. \n", - "This is a tutorial for the following paper: A mixed-categorical data-driven approach for prediction and\n", - "optimization of hybrid discontinuous composites performance. \n", - "\n", - "The function inputs are:\n", - "\n", - "\n", - "\n", - "> 4 continuous variables **[lf Vc SmAvg G GiicmAvg]**\n", - "\n", - "\n", - "> 2 categorical variables **[Carbon fibres Glass Fibres]** with 16 labels.\n", - "\n", - "\n", - "The possible outputs are **[Initial_stiffness\tUltimate_strain\tPseudo_ductile_strain\tUltimate_strength\tYield_strength]**\n", - "\n", - "In this example, only the most influent continuous inputs are being used (**lf** and **Vc**), and the predicted variable is the **Initial Stiffness**\n", - "\n", - "**lf:** length of the fibre. \n", - "\n", - "**Vc:** Percentage of carbon fibre in the mixture. " - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "id": "6UlDaf1S65MH" - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "from smt.surrogate_models import KRG\n", - "from smt.applications.mixed_integer import MixedIntegerSurrogateModel\n", - "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import r2_score\n", - "from scipy.optimize import curve_fit\n", - "from sklearn.preprocessing import StandardScaler\n", - "plt.rcParams.update({'legend.labelspacing':1.0})" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "id": "xq3a-3gyC-v_" - }, - "outputs": [], - "source": [ - "try :\n", - " from pydrive.auth import GoogleAuth\n", - " from pydrive.drive import GoogleDrive\n", - " from google.colab import auth\n", - " from oauth2client.client import GoogleCredentials\n", - "\n", - " # 1. Authenticate and create the PyDrive client.\n", - " auth.authenticate_user()\n", - " gauth = GoogleAuth()\n", - " gauth.credentials = GoogleCredentials.get_application_default()\n", - " drive = GoogleDrive(gauth)\n", - " json_import = drive.CreateFile({'id':'1fcB39mktJ2npTNqrF8dgZa7PWh3wU55X'})\n", - " json_import.GetContentFile('VTF_properties.json')\n", - " df = pd.read_csv(open('VTF_properties.json'))\n", - "except :\n", - " df = pd.read_csv(open('VTF_properties.csv'))" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 270 - }, - "id": "Jj2kyCk97HAq", - "outputId": "43fa3b18-3ed2-479f-e2dd-e16f0b6d3ef0" - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Carbon_fibreGlass_fibrelfVcSmAvgGGiicmAvgInitial_stiffnessUltimate_strainPseudo_ductile_strainUltimate_strengthYield_strength
0XN-90GF10533.4820400.96601782.3542291056.3708680.734474456482.19820.240.050521864.937397864.937397
1XN-90XN-057808.9466570.99647260.8488041741.2498590.849103466897.16570.240.040624930.878853930.878853
2XN-90GF9323.6783280.24294853.2693801523.6646760.671576169973.97480.180.033303249.346203249.346203
3P120JGF5788.7572080.45363279.6359121662.7670830.776173240985.51420.260.069889458.139055458.139055
4XN-90XN-0511435.5472800.83747261.7365931340.5667440.658034389829.41530.220.042216693.053223693.053223
\n", - "
" - ], - "text/plain": [ - " Carbon_fibre Glass_fibre lf Vc SmAvg G \\\n", - "0 XN-90 GF 10533.482040 0.966017 82.354229 1056.370868 \n", - "1 XN-90 XN-05 7808.946657 0.996472 60.848804 1741.249859 \n", - "2 XN-90 GF 9323.678328 0.242948 53.269380 1523.664676 \n", - "3 P120J GF 5788.757208 0.453632 79.635912 1662.767083 \n", - "4 XN-90 XN-05 11435.547280 0.837472 61.736593 1340.566744 \n", - "\n", - " GiicmAvg Initial_stiffness Ultimate_strain Pseudo_ductile_strain \\\n", - "0 0.734474 456482.1982 0.24 0.050521 \n", - "1 0.849103 466897.1657 0.24 0.040624 \n", - "2 0.671576 169973.9748 0.18 0.033303 \n", - "3 0.776173 240985.5142 0.26 0.069889 \n", - "4 0.658034 389829.4153 0.22 0.042216 \n", - "\n", - " Ultimate_strength Yield_strength \n", - "0 864.937397 864.937397 \n", - "1 930.878853 930.878853 \n", - "2 249.346203 249.346203 \n", - "3 458.139055 458.139055 \n", - "4 693.053223 693.053223 " - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = df.dropna()\n", - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "id": "1r6uCxjML51v" - }, - "outputs": [], - "source": [ - "data = df.sample(n=1000,random_state = 10)\n", - "data.Carbon_fibre = pd.Categorical(data.Carbon_fibre)\n", - "data['Carbon_fibre'] = data.Carbon_fibre.cat.codes \n", - "data.Glass_fibre = pd.Categorical(data.Glass_fibre)\n", - "data['Glass_fibre'] = data.Glass_fibre.cat.codes \n", - "Xd = data.drop(['SmAvg','G','GiicmAvg','Initial_stiffness','Ultimate_strain','Pseudo_ductile_strain','Ultimate_strength',\n", - " 'Yield_strength'],axis = 1)\n", - "\n", - "yd = data.Initial_stiffness\n", - "\n", - "X_train, X_test, y_train, y_test = train_test_split(Xd, yd, test_size = 0.25, random_state = 42)\n", - "X = np.asarray(X_train)\n", - "y = np.asarray(y_train).astype(float)\n", - "\n", - "#to define the variables\n", - "design_space = DesignSpace ([\n", - " CategoricalVariable (['XN-90', 'P120J', 'T1000GB', 'C124', 'T800H', 'M60JB', 'C320',\n", - " 'M40B', 'P75S', 'K13D', 'T300', 'XN-05', 'FliteStrand_S_ZT',\n", - " 'HTA5131', 'GF', 'C100']), #16 choices\n", - " CategoricalVariable (['GF', 'XN-05', 'FliteStrand_S_ZT', 'C124', 'T300', 'T800H', 'C320',\n", - " 'P75S', 'C100', 'XN-90', 'HTA5131', 'T1000GB', 'P120J', 'M40B',\n", - " 'M60JB']), #15 choices\n", - " FloatVariable (501.5425023,11999.96175),\n", - " FloatVariable (2.849e-05,1.0),\n", - "])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "id": "D6Psera9Oaeg" - }, - "outputs": [], - "source": [ - "sm=KRG(design_space = design_space, print_global=False, categorical_kernel=MixIntKernelType.GOWER)\n", - "sm.set_training_values(X, y)\n", - "sm.train()" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 503 - }, - "id": "FJKbqByvxLqf", - "outputId": "5af35de1-3cfc-418b-e8ce-1e593d2a3734" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2_score = 0.9926662329260849\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeIAAAHFCAYAAAAuQPotAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAACBq0lEQVR4nO3deVjUVdvA8e+wDYgwoiiIuKWVFS6luZXihprb+JhLaI6WLVZqvtpjaYu0ama2aNbTplk2WG5ZmYGVW+KGkqhp5b7hyuIGzDDn/ePI4AiaIjII9+e6uGB+c8/M+Z3Im7MblFIKIYQQQriFh7sLIIQQQpRlkoiFEEIIN5JELIQQQriRJGIhhBDCjSQRCyGEEG4kiVgIIYRwI0nEQgghhBtJIhZCCCHcSBKxEEII4UaSiIW4jmbOnInBYGDDhg1X/VqDwUBMTIzz8bZt24iJiWHPnj35YgcPHkytWrUKVcZree3lTJ8+nZkzZ+a7vmfPHgwGQ77n5syZwx133IGfnx8Gg4GkpCQApk6dSt26dfHx8cFgMJCWllbkZRXCnSQRC1FCJSQk8Mgjjzgfb9u2jZdffrnARPziiy+yYMGCYizdv7tUIq5atSoJCQl07drVee3YsWMMHDiQOnXqsGTJEhISErjllltISkpixIgRtG3bll9//ZWEhAQCAgKK8S6EuP683F0AIUTBmjdvfsWxderUuY4lKVpGozHfvf3111/YbDYefPBBIiMjnde3bt0KwKOPPkrTpk2LtZxCFBdpEQtRjAYPHkz58uX5559/6NKlC+XLl6d69eqMHj2arKwsl9gLu6ZnzpxJnz59AGjbti0Gg8Gle7eg7uUPPviA1q1bU6VKFfz9/alfvz6TJk3CZrNd833s2rWLBx54gLCwMIxGIyEhIbRv397ZnVyrVi22bt3K8uXLnWXNLd/FXdODBw/m3nvvBaBfv34YDAbatGlDmzZtePDBBwFo1qwZBoOBwYMHA9CmTRsiIiJYv349rVq1oly5ctx0001MnDgRh8PhUtaMjAyeeeYZateujY+PD9WqVWPkyJGcOXPGJe7bb7+lWbNmmEwm5/s9/PDDzucdDgevvfYat956K35+flSoUIEGDRrw3nvvXXN9irJNWsRCFDObzUaPHj0YMmQIo0ePZsWKFbz66quYTCZeeumlAl/TtWtX3njjDcaNG8cHH3zAXXfdBVy+Jbxz50769+/vTEB//PEHr7/+Otu3b+fzzz+/pnvo0qULOTk5TJo0iRo1anD8+HFWr17tHL9dsGABvXv3xmQyMX36dEC3hAvy4osv0rRpU5566ineeOMN2rZtS2BgIABWq5XXXnuNGTNmUK9ePSpXrux8XUpKCgMGDGD06NGMHz+eBQsWMHbsWMLCwrBYLACcPXuWyMhIDhw4wLhx42jQoAFbt27lpZdeIjk5maVLl2IwGEhISKBfv37069ePmJgYfH192bt3L7/++qvz8yZNmkRMTAwvvPACrVu3xmazsX37dhmzFtdOCSGumxkzZihArV+/Ximl1KBBgxSgvvnmG5e4Ll26qFtvvdXlGqDGjx/vfPztt98qQP3222/5PmfQoEGqZs2alyxHTk6OstlsatasWcrT01OdPHnyil97sePHjytAvfvuu5eNu+OOO1RkZGS+67t371aAmjFjhvPab7/9pgD17bffusReXH+5IiMjFaDWrl3rcv32229XnTp1cj6eMGGC8vDwyPf6uXPnKkAtXrxYKaXU5MmTFaDS0tIueT/dunVTjRo1uuw9C1EY0jUtRDEzGAx0797d5VqDBg3Yu3dvkX7Opk2b6NGjB5UqVcLT0xNvb28sFgs5OTn89ddfhX7fihUrUqdOHd566y2mTJnCpk2b8nUHF4fQ0NB848YX1+MPP/xAREQEjRo1wm63O786deqEwWBg2bJlANx9990A9O3bl2+++YaDBw/m+7ymTZvyxx9/8OSTT/Lzzz+TkZFx/W5OlCmSiIUoZuXKlcPX19flmtFoJDMzs8g+Y9++fbRq1YqDBw/y3nvvsXLlStavX88HH3wAwLlz5wr93gaDgV9++YVOnToxadIk7rrrLipXrsyIESM4depUUd3Cv6pUqVK+a0aj0eXejhw5wubNm/H29nb5CggIQCnF8ePHAWjdujULFy7EbrdjsVgIDw8nIiICq9XqfK+xY8cyefJk1qxZw3333UelSpVo3759oZamCXEhGSMWohRauHAhZ86cYf78+dSsWdN5PXcy1bWqWbMmn332GaBnPH/zzTfExMSQnZ3NRx99VCSfURSCg4Px8/O75Jh4cHCw82ez2YzZbCYrK4s1a9YwYcIE+vfvT61atWjRogVeXl6MGjWKUaNGkZaWxtKlSxk3bhydOnVi//79lCtXrrhuS5QykoiFuEHkTna6ktaswWBweQ2AUopPPvmkyMt1yy238MILLzBv3jw2btzovH5x69QdunXrxhtvvEGlSpWoXbv2Fb3GaDQSGRlJhQoV+Pnnn9m0aRMtWrRwialQoQK9e/fm4MGDjBw5kj179nD77bdfj1sQZYAkYiFuEBEREQB8/PHHBAQE4OvrS+3atQvsoo2KisLHx4fo6GjGjBlDZmYmH374Iampqddcjs2bNzNs2DD69OnDzTffjI+PD7/++iubN2/mueeec8bVr1+f2NhY5syZw0033YSvry/169e/5s+/GiNHjmTevHm0bt2a//u//6NBgwY4HA727dtHXFwco0ePplmzZrz00kscOHCA9u3bEx4eTlpaGu+99x7e3t7Odc3du3cnIiKCJk2aULlyZfbu3cu7775LzZo1ufnmm4v1vkTpIolYiBtE7dq1effdd3nvvfdo06YNOTk5zJgxw7m29kL16tVj3rx5vPDCC/Tq1YtKlSrRv39/Ro0axX333XdN5QgNDaVOnTpMnz6d/fv3YzAYuOmmm3j77bcZPny4M+7ll1/m8OHDPProo5w6dYqaNWsWuCvY9eTv78/KlSuZOHEiH3/8Mbt378bPz48aNWrQoUMH59rmZs2asWHDBp599lmOHTtGhQoVaNKkCb/++it33HEHoNdvz5s3j08//ZSMjAxCQ0OJiorixRdfxNvbu1jvS5QuBqWUcnchhBBCiLJKZk0LIYQQbiRd00IIJ4fD8a9rgr285J8NIYqStIiFEE4PP/xwvjW3F38JIYqWjBELIZz27Nnj3OTiUpo0aVJMpRGibJBELIQQQriRdE0LIYQQbiSzLoqZw+Hg0KFDBAQEOHc/EkIIcWNQSnHq1CnCwsLw8Ciatqwk4mJ26NAhqlev7u5iCCGEuAb79+8nPDy8SN5LEnExCwgIAPR/RD8/P+Li4ujYsaPMRr2AzWaTeimA1EvBpF4KJvVSsGutl4yMDKpXr+78t7woSCIuZrnd0YGBgfj5+VGuXDkCAwPlf5QL2Gw2qZcCSL0UTOqlYFIvBSuqeinKoUWZrCWEEEK4kSRiIYQQwo0kEQshhBBuJIlYCCGEcCNJxEIIIYQbSSIWQggh3EgSsRBCCOFGkoiFEEIIN5JELIQQQriRJGIhhBDCjSQRCyGEEG4kiVgIIYRwI0nEQgghhBtJIhZCCCHcSBKxEEII4UaSiIUQQgg3kkQshBBCuJEkYiGEEMKNJBELIYQQbiSJWAghhHAjScRCCCGEG0kiFkIIIdxIErEQQojSac0aGDgQGjWC1q1h+nQ4e9bdpcrHrYk4JiYGg8Hg8hUaGup8XilFTEwMYWFh+Pn50aZNG7Zu3eryHllZWQwfPpzg4GD8/f3p0aMHBw4ccIlJTU1l4MCBmEwmTCYTAwcOJC0tzSVm3759dO/eHX9/f4KDgxkxYgTZ2dkuMcnJyURGRuLn50e1atV45ZVXUEoVbaUIIYS4dlOmQIsWOhnfcw9UqAAjRkBUlLtLlo/bW8R33HEHhw8fdn4lJyc7n5s0aRJTpkxh2rRprF+/ntDQUKKiojh16pQzZuTIkSxYsIDY2FhWrVrF6dOn6datGzk5Oc6Y/v37k5SUxJIlS1iyZAlJSUkMHDjQ+XxOTg5du3blzJkzrFq1itjYWObNm8fo0aOdMRkZGURFRREWFsb69euZOnUqkydPZsqUKde5hoQQQlyVTZtg9Gh49lnYsQM++AAWLYKkJDh82N2ly0+50fjx41XDhg0LfM7hcKjQ0FA1ceJE57XMzExlMpnURx99pJRSKi0tTXl7e6vY2FhnzMGDB5WHh4dasmSJUkqpbdu2KUCtWbPGGZOQkKAAtX37dqWUUosXL1YeHh7q4MGDzhir1aqMRqNKT09XSik1ffp0ZTKZVGZmpjNmwoQJKiwsTDkcjiu+5/T0dAWo9PR0lZ2drRYuXKiys7Ov+PVlgdRLwaReCib1UrAyXS+PPaZU9epK2Wz5nsp++21dLykphXrrC/8NLypubxH//fffhIWFUbt2bR544AF27doFwO7du0lJSaFjx47OWKPRSGRkJKtXrwYgMTERm83mEhMWFkZERIQzJiEhAZPJRLNmzZwxzZs3x2QyucREREQQFhbmjOnUqRNZWVkkJiY6YyIjIzEajS4xhw4dYs+ePUVcK0IIIQpt2zaIjAQvr7xr6enYZ37FS3MbkZHhA+dzTUng9e8h10+zZs2YNWsWt9xyC0eOHOG1116jZcuWbN26lZSUFABCQkJcXhMSEsLevXsBSElJwcfHh6CgoHwxua9PSUmhSpUq+T67SpUqLjEXf05QUBA+Pj4uMbVq1cr3ObnP1a5du8B7zMrKIisry/k4IyMDAJvNhtf5XxKbzVbga8uq3PqQenEl9VIwqZeClel6CQmB3bshJgZ++gmOHMF+Ip2Hzv2POTntqHM0jZ5+bWDmZ9CgwVW99fWoT7cm4vvuu8/5c/369WnRogV16tThiy++oHnz5gAYDAaX1yil8l272MUxBcUXRYw6P1HrcuWZMGECL7/8cr7rcXFxlCtXDoD4+PhLvr4sk3opmNRLwaReClYm6+WCOUDceSc5OQbeffcuVq4Mx9PTQd++O/i12ctw4ID+ugpnr8Osa7cm4ov5+/tTv359/v77b3r27Ano1mbVqlWdMUePHnW2RENDQ8nOziY1NdWlVXz06FFatmzpjDly5Ei+zzp27JjL+6xdu9bl+dTUVGw2m0tMbuv4ws+B/K32C40dO5ZRo0Y5H2dkZFC9enU6duyIn58f8fHxREVF4e3tffnKKUNsNpvUSwGkXgom9VKwMlsvSumlSjt3gsOB3accD6kvWHkkHC9szPZ7CGOzPkQ1aYJ3o0YwfDiMHXvFb5/bq1mUSlQizsrK4s8//6RVq1bUrl2b0NBQ4uPjufPOOwHIzs5m+fLlvPnmmwA0btwYb29v4uPj6du3LwCHDx9my5YtTJo0CYAWLVqQnp7OunXraNq0KQBr164lPT3dmaxbtGjB66+/zuHDh51JPy4uDqPRSOPGjZ0x48aNIzs7Gx8fH2dMWFhYvi7rCxmNRpdx5Vze3t7O/zku/FnkkXopmNRLwaReClYq6yUxET7+GP7+GypXhj59ICMD9u6FrCxYuxb69MG+dQdDtj3LHNrhhY25t71El0M/sJg+eFepgnenTvDjj/DSS1f80delLots2lchjB49Wi1btkzt2rVLrVmzRnXr1k0FBASoPXv2KKWUmjhxojKZTGr+/PkqOTlZRUdHq6pVq6qMjAznewwdOlSFh4erpUuXqo0bN6p27dqphg0bKrvd7ozp3LmzatCggUpISFAJCQmqfv36qlu3bs7n7Xa7ioiIUO3bt1cbN25US5cuVeHh4WrYsGHOmLS0NBUSEqKio6NVcnKymj9/vgoMDFSTJ0++qnuWWdP/TuqlYFIvBZN6KViprZfXXlMKlKpRQ6l+/ZSqXVs/BqUCA50/2/BU0d7fKFDKi2y1cKxeOZN977159TJ4sFKNG1/Vx1+PWdNuTcT9+vVTVatWVd7e3iosLEz16tVLbd261fm8w+FQ48ePV6GhocpoNKrWrVur5ORkl/c4d+6cGjZsmKpYsaLy8/NT3bp1U/v27XOJOXHihBowYIAKCAhQAQEBasCAASo1NdUlZu/evapr167Kz89PVaxYUQ0bNsxlqZJSSm3evFm1atVKGY1GFRoaqmJiYq5q6ZJSkoivhNRLwaReCib1UrBSWS/x8TrRxsQoZbcrtWGDUp6eSjVrppTB4JqEmZ2XhAMe1El63z6VXaOGrpfUVKWCgpR65pmrKkKpS8RlkSTifyf1UjCpl4JJvRSsVNaL2axUo0ZK5TaA+vdXqm5dpb78Uidhg0HZho1U0b7zdBI22NTCctH6OW9vpTp2VNl+frpeunRRyt9fqV27rqoIpXIdsRBCCHFF/vgDOneG3JUqv/wC0dEwaxbUqYNdeWDZMgZrZi89Jqzux9wmXcfbbBAXB+XL573XokVwiaWnxalETdYSQgghLikgAA4dyntsMIDDAQcOYA+qjIVXsC6ripcXzI36HPNPi2DxJd5r2zYIDCyWYv8baRELIYQo+bKyoEYN+PJLMJmgfn0ID4fZs7FXCcOy6f+w0h8vg5253zgwb4rRr7twn4dWreDWW/XPp08X+y1ciiRiIYQQJVtWFnTrpnfJKldOJ1dfX9i0Cfue/VhWPYo1p69Owup+zKPqQEoK+PnpOF9f3SW9dq1uVYNO6CWEJGIhhBAl2wcfwPLlekx4xw5o2xY2bsSeAxZmYc3plzcmzCLI3f//3Dn9dcst+uSlRYtg2TL93PLlbrqZ/GSMWAghRMn2ySd60442bfTjBQuw7zuEZYg31qWVdRIelYB5pwHWVc076vDuu+Hll/MmeNWpA+c3csKj5LRDJRELIYQo2fbsgSee0BOz1q3DfiwVyyetsC4tj5eHg7mO3pjfWgAerWHLFj1+XLEiNGwIF5xpAOhxZYAOHYr9Ni6l5PxJIIQQQhSkalW9FeXNN2NvcS+WHqlYvy+vx4TbfoA5ZG1eCzc8HHx84N574dNP4fnn4cQJvdXHihXw3Xc6bsAA993PRSQRCyGEKNnuuQfi4rCH1cDS4ZCeHe3pYG7gEMy/Pq3XEueqUAH69oU1a/SBDpMnQ5UqepJWZKSe+JUbV0JIIhZCCFGyKAV2e97jrVux+5uwrHkS69IqOgl3n4XZsUDHXnzm/OTJEBSkW8Q9e0LXrvpwCIAnnyy227hSkoiFEEKUDIcOwbBhOol6e+sE278/9k2bsdTfhNXeR0/MyvkP5uWj4NFHoUsXWHzRrh0hIbpF/MILsHWrPq3p5pthwQJ44w333NtlyGQtIYQQ7rF3L2zfrhNvSIjecCMjQ0/KAjh2DLv1G71EaU1tvWPWt16Yo77Wa4Q9POCxx/Sa4YtVqADjxumvC9ls1/22rpa0iIUQQhSvw4ehe3e9z3PnztCsmZ7pnJ4OZ87oMeHEROxns7E02qzHhLEx9539mHsawN9fJ2G7XbeGmzRxff/MTL35xzff6HXHJZy0iIUQQhSfU6f0euAzZ/QYbvv2et/nrl31eG/t2rBoEXaDNxYLWJNu10mY3pgXnoGn4vWa4DNnYMQIndSfegpWrdIzojds0F8XbmEZFQUzZ0JYmLvu+rIkEQshhCg+M2bArl06+d58c951pfR3uz0vCVvR3dH3zcK85Cf4xQa33Qa1aukx4DNn4MMPYcwY+Pln3cWdmqrfJzQU5s6F/fvhv//VCT8xUY89lzDSNS2EEKL4zJ2rW78XJuHKlfWYL2DffwjL/WfykvBcMKfP0gc+lC+vu639/fWkrr//hpUr4fffYf58/Xy/fnqCVkiI/rlHD52kd+zQmb0EkkQshBCi+Jw5k7eUKFe5cnp2tIePnpi1yD8vCdvn6Y047Hbdpf3ZZzBvHrz2ms7UVitMmKAT9f79ennS7bfrmEOHIDZWP27bFhYudMcd/yvpmhZCCHH9OBywdKluuW7fDkePwldf6fHas2dh3z6oXBl7z95YZnbESl89Jhy9CPPns+D776FuXfjnH92tfaE1ayAnR2/g8c8/+prJpL/XqQONG+vPffhhff3UqeK99yskiVgIIcT18c8/ekONrVv1LOfcZUkAr7yiJ13ddRf2JUuxfNAyb3Y0vTF/uUh3V3t7w+7d8NFHulV7odzx3rNnISJCd1nPn6/3mM697u2tl0TFx8OoUcVy21dLErEQQoiid+4cdOyou4/r1tXX6tWDH37Ii1EKe2KS7o7OTcJ+FsyZ30PP/+hx3lq1wGLR+01frE0b3a398cd6o45HH4U339RLoUJC9ISw556DBx7QfwQ89lhx3PlVk0QshBCi6H3zjW7JfvEFDBqkJ2jFx+s1v3/+CWfOYMczLwl75DC39QeYd62GDg/p1/3zj07El2Iy6Vbu66/rlu+oUbBzpz4y0cNDt5Affli3rBcuhGrVZEMPIYQQZcQvv+jzgI8d0wnxp5/0pKpdu/InYWzMdfTCXCVBjxk//7yeAf3JJ//+OS+/DM8+q1vCNWroMWXQpzB16wZvvaV38IqKur73ew2kRSyEEOL6UEon4cxM3TXctSuMHo391juw7BiXl4QDHsZc7zDM26hfV7EitGihu5b/jYeHTvDPPKOXKWVmQvPmeqb0DUJaxEIIIYpeVJTe4erWW/M263j/fezK0zUJ0xtzpVV6XNfh0OuLTSbYs0dv0HGlKlWC/v11V/QNlIRBErEQQojroU8fPUnr0Uf1pC3A/sFHWPjCNQmbluukm5ioE3arVvqUpO3bYcAA995DMZFELIQQouj5+kJcHAQEwJIl+ceEDX0xs0gf9ABw4ID+fvQoREfrZU/t2rmt+MVJxoiFEEIUncREPUP53Dl9qtIPP2CvVRdL8GKsKW3Pt4T7YK6wAs5vC01QEJw4oX/+/Xc93jt+vF5nXAZIIhZCCFF4drs+9ejrr/UJSEeP6slWFSvC229jrxKGxf6ZTsJeMPfpNZinx8GZHH0Qw9atcPw4BAbqTTv+8x/dmi5DJBELIYQonNOn9UzoFSv0/tEnT+pZ0unpMHUq9tvqY2m9Gys98PJ0MHeuB2ZzKxi9UyfduDi97eStt8KSJXrJURkkY8RCCCEKZ/Ro3RUdHa1btZUqQa9ecN992C0PY3mpJtbTPXR39K0vYDaff13Vqnr977Rp+hCIF18ss0kYJBELIYQojLQ0mDkTPD31SUdKwX33wYoV2H/8GYthFtYfAnV3dJWnMG+bAE8/rTf0OHUKZs/WG240bKi7o8swScRCCCGu3o4dkJ2t1/zm7oD1wgvYt/+DpfYKrPa+eBns+ijDahv0SUgzZ+pTkQID4cEHoVEj3T3t4+POO3E7GSMWQghx9Y4c0d8tFr3UqHx57B9/juXAG1h3Ndfd0VWfxhw+BDZt0ntP33efPhLx7FmdmG+91a23UFJIIhZCCHH1cg9P+P13nYSfHo3l9Vuwgp6YldMbc/ntYF6kjyjs2VMfzNCzpxsLXTJJIhZCCHH1goP192XLsHfpgSX7E6xU1S3hnN56s46/gNatITY27+xgkY8kYiGEEJeWkaHXCR8/rruSO3XSE7TuvRdq1sQeHIpl9eNYT51Pwh79MNfeCjuBWbNg4EB330GJJ4lYCCFEwT76CP77X71euFw5PbZbqxZYrdC8OfYp72O5/wxWuuvzhAf+gNlRHmbv1mcQP/igu+/ghiCzpoUQQuQ3dy488YQ+0Wj/fr3ed/16CAuDTp2w79yLZW4PrETr2dGOXpi/6KXPIX79dfjsszKzReW1khaxEEIIV0rBa69B5866VZybUJs0gZ9+0ntHdzuBdXtNvU54rhfm5h9D5vtQrRp4SWq5GlJbQgghXB05An/8AePG5WvV2ssFYqn4A9btd51PwpzfMSvELUUtDaRrWgghhCuHQ3+/aKaz3a6XDVt3NtUTs5xJWFwLScRCCCFcVa2qZ0h//bXzkjMJW9FJuPNnkoSLiCRiIYQQrgwGGDNG9zu/+CL2kxl5SdhgZ653f8zvtHF3KUsNGSMWQgiR30MPwYED2F9+HcuECKw5/XRLuNwgzHOHQL167i5hqSEtYiGEEPkZDNjHvYSle6pOwh45zB2+AvORT/RsalFkpEUshBAiH+eY8Hflzs+O9sRsbu/uYpVK0iIWQgjhwmVilssSJXE9SItYCCHKmhMnIDkZ/Pz0cYQXbMAhSbj4SYtYCCHKijNn4NFH9e5XbdtC8+Zw003wxReAJGF3kRaxEEKUBQ4H9OgB69bBK6/oDHvyJLz/PgwejD3bgeW3hyQJu4EkYiGEKAt+/hl+/VV/v/12mDYNFiyAw4exexqxPO6LVYGXl2LuXIMk4WIkiVgIIcqCb7+FO+7Q/c+33AJZWQDYK4VgOTVZn6KEjbktp2LuPhIZuSw+UtNCCFEWnD4NQUHQty+EhkL58tg3JGHpcAgr/XUSDh2OecVomDPH3aUtUyQRCyFEWXDXXbBmDeTkwLFj2J8YjuWt+npM2MPBXPpgPvIxtGgBH3/s7tKWKZKIhRCiLHj4YX3OsK8v9tPnsCQM1UnY08Fc/0GYu9r189Wqwa5d7i5tmSKJWAghyoIqVaBjR+xpp7EwC+uKcH2AQ85/MAetgHvv1XGHDumua1FsJBELIUQZYX96NBa+yBsT9orGzCLYtw/GjtWnLiUkwODB7i5qmSKzpoUQogyw28HyRTusGHQSpjdmtRg6dICMDL2+OFeDBu4raBkkiVgIIUqSY8f0Wt+sLD1x6vbb//01hw5BairUrAnly+d7Om/HLINeJ1zhCczHF4EdWLpUB/n4wPDh8P338O67cM89RXpb4tJKTNf0hAkTMBgMjBw50nlNKUVMTAxhYWH4+fnRpk0btm7d6vK6rKwshg8fTnBwMP7+/vTo0YMDBw64xKSmpjJw4EBMJhMmk4mBAweSlpbmErNv3z66d++Ov78/wcHBjBgxguzsbJeY5ORkIiMj8fPzo1q1arzyyisopYq0HoQQZVRODowZA+HhMHAgPPKIXvfbuTMcP17wa9atgzZt9ASriAgICYEnntAt3PPybVv59j7Mxz+DihVh1Ch47z0YORK8vXW39IMPwg8/6IlboliUiES8fv16Pv74Yxpc1B0yadIkpkyZwrRp01i/fj2hoaFERUVx6tQpZ8zIkSNZsGABsbGxrFq1itOnT9OtWzdycnKcMf379ycpKYklS5awZMkSkpKSGDhwoPP5nJwcunbtypkzZ1i1ahWxsbHMmzeP0aNHO2MyMjKIiooiLCyM9evXM3XqVCZPnsyUKVOuY80IIcqMF1+Et9+G55/XreLMTPj6a9i0Cbp00Yn6QuvX6ySckQFffgkrV8Kzz+rXREVBVhY5OQYeesjTddvK+GF6LHjUKP15I0bAO+/AL7/oRLxtm87eovgoNzt16pS6+eabVXx8vIqMjFRPP/20Ukoph8OhQkND1cSJE52xmZmZymQyqY8++kgppVRaWpry9vZWsbGxzpiDBw8qDw8PtWTJEqWUUtu2bVOAWrNmjTMmISFBAWr79u1KKaUWL16sPDw81MGDB50xVqtVGY1GlZ6erpRSavr06cpkMqnMzExnzIQJE1RYWJhyOBxXfL/p6ekKUOnp6So7O1stXLhQZWdnX/HrywKpl4JJvRSsVNTLyZNK+fkp9cIL+Z9bsUIpUOqHH1yvt22rVKNGSp0963p93TqlDAZ19uPPVatW+xUo5eWl1MKFSqkTJ5QyGJS6/Xal7r5bqYv/7ercWanAQP3epdS1/r5c+G94UXF7i/ipp56ia9eudOjQweX67t27SUlJoWPHjs5rRqORyMhIVq9eDUBiYiI2m80lJiwsjIiICGdMQkICJpOJZs2aOWOaN2+OyWRyiYmIiCAsLMwZ06lTJ7KyskhMTHTGREZGYjQaXWIOHTrEnj17iqg2hBBl0rJlcO4cPPZY/ufuvRfq1dNjt7lSUuC333Sr1s/PNf7uu7F36MxD42uxcmX4+b2jzx/gkJqqu5wHDdIt6uHD9TWAtDT9vhkZ8Mwz1+lGRUHcOlkrNjaWxMRENmzYkO+5lJQUAEJCQlyuh4SEsHfvXmeMj48PQUFB+WJyX5+SkkKVKlXyvX+VKlVcYi7+nKCgIHx8fFxiatWqle9zcp+rXbt2gfeYlZVF1vk9XUF3cQPYbDa8zp8BarPZCnxtWZVbH1IvrqReClYq6sVm0wnV21v/fLEKFfLiQJ8n7OenJ2f9+afeCWv1avDwwB51Hw/tfIk5h5vj6elg9mwbXbp46JdWrqy/zp2DDz/UXdlWK9SuDXv2wNmz0LSp7tq+kevzMq719+V6/J65LRHv37+fp59+mri4OHx9fS8ZZzAYXB4rpfJdu9jFMQXFF0WMOj+Z4XLlmTBhAi+//HK+63FxcZQrVw6A+Pj4S76+LJN6KZjUS8Fu6HoxGnVCXLu24Oefe05/X7w475rVqluzqal6rLhNG3JyDLz77l2s3BWOp6eDMWPWYzSmuLyMTz7J+3nWrII/z+UFpVNhf1/Onj1bxCVxYyJOTEzk6NGjNG7c2HktJyeHFStWMG3aNHbs2AHo1mbVqlWdMUePHnW2RENDQ8nOziY1NdWlVXz06FFatmzpjDly5Ei+zz927JjL+6y96H+A1NRUbDabS0xu6/jCz4H8rfYLjR07llGjRjkfZ2RkUL16dTp27Iifnx/x8fFERUXh7e19yfcoa2w2m9RLAaReClZq6uWRR+Cnn3Si7NwZPDxg+3a9NWV6Onz6qd5oIyUF6taFAwf0hK5KlWDTJuz+Jh4a7MHKlZ54YWN2+GiMzdrnr5eMDN1P/ccf+nNq14YVK2DzZj17uoCGQ2lyrb8vGRfMSC8yRTbafJUyMjJUcnKyy1eTJk3Ugw8+qJKTk52Ttd58803na7KysgqcrDVnzhxnzKFDhwqcrLV27VpnzJo1awqcrHXo0CFnTGxsbL7JWhUqVFBZWVnOmIkTJ8pkretA6qVgUi8FKzX1cuqUniwFSlWrplS9evrnmjWV+v13pYKDlWrWTKkdO5TKzMyLBWXDU0UHfq8nZpGtFkZNU9l+fpeulzNnlJo+XamWLfXn9Oyp1Pl/M0u7kjhZy+2zpi904axppXSiM5lMav78+So5OVlFR0erqlWrqoyMDGfM0KFDVXh4uFq6dKnauHGjateunWrYsKGy2+3OmM6dO6sGDRqohIQElZCQoOrXr6+6devmfN5ut6uIiAjVvn17tXHjRrV06VIVHh6uhg0b5oxJS0tTISEhKjo6WiUnJ6v58+erwMBANXny5Ku6R0nE/07qpWBSLwUrVfXicOikO2aMUiNGKBUbq1RWllJvv62Ut7dShw4plZ2tVKdOSnl4KGUyKdudd6toZucl4TG/K+VwqGx//9JTL0WoJCbiEr2z1pgxYzh37hxPPvkkqampNGvWjLi4OAICApwx77zzDl5eXvTt25dz587Rvn17Zs6ciaenpzNm9uzZjBgxwjm7ukePHkybNs35vKenJz/++CNPPvkk99xzD35+fvTv35/Jkyc7Y0wmE/Hx8Tz11FM0adKEoKAgRo0a5dLtLIQQ18RggJYt9deFVqyAyEioWhW++ELvvDV4MPb5i7CE/IyVIH2KUtBQzPvOwt4wcDjccw/iqpWoRLxs2TKXxwaDgZiYGGJiYi75Gl9fX6ZOncrUqVMvGVOxYkW++uqry352jRo1+OGHHy4bU79+fVasWHHZGCGEKHJeXno8GGDmTIiKwv7cC1hmRmFdEqT3jn7lL8x+EXp3Lh8fCAx0a5HFlXP7OmIhhBD/oksX+P13vVTp8GHstzfA8nId11OU7vhHrwW22/Vs6FdfdXepxRUqUS1iIYQQBXjgAZg4Ebp0wV4hGMvsjliPg5dHDnMdvTGXXwE95+lYg0En4n79ysQypNJAWsRCCFHSlSsHS5diDw3HkvR/WI931C1hzwcwx9yl96b+5RcICtLLnR580N0lFldBErEQouxQ6oY90MAeVgNL7ZW6O9pg1+cJtzoJvr4wdCh0765PX5owwd1FFVdJErEQovTbv18nK5NJbyN5yy36zN0bJCnnO8pwngfmL+7XW1W++SYsX663q1y9Wm9hKW4oMkYshCjddu/Wy4GUgqef1jtJ/fqrPthg5Ur45hu4YLmj22VlQWKiPvawUSPsfgGuSXgumM0egEVnZ3HDk0QshCjdnnlGd9+uWaO7bkGPo/bpAz17woIF0Lu3W4sI6D8U3n1Xdy0fOwaA3d+EpcZvWP+884Ik7N5iiqInXdNCiNLr5En47judjC/eE95s1i3lGTPcU7aLvf66PtbwP/+B9euxb0rGUmu5TsIGuyThUkwSsRCi9Dp6VHfxNmxY8PMNG8LBg8VbpoKkpupEPGYM/O9/2Bs1wTIpAuvWhnrHLHU/5puS3V1KcZ1IIhZClF6hoXpy1vr1BT+/YYM+09edDh+Ghx7SO2fNn4/94cew9EjNGxOe48Bc6XfdLy1KJUnEQojSq0IFPf47eTLs2+f63Fdf6QQ9ZIhbigbA1q26Vb5kCRgM2KPuwzKnC9afzu8dPRfM93vpow5Pn3ZfOcV1JYlYCFG6vfWW3nu5QQMYPhymTIFu3WDgQBg0SK+/dQelYMAA3WpfuBC78sCy7VmsZ3vqMWGPfphbHoO//tJfd97pnnKK605mTQshSrdq1WDtWp2AZ8/W47G33Qaff64TscFQNJ9z/Lh+z5UrdXd4164QHa13xSrIunXwxx/w88/Y20Zhqfgj1uXV8PJSzP38LOZHv4cP7oC4OJ2sS8LMbnFdSCIWQpR+VarovZonTrw+779mjT6Y4exZaNsWTp2CRx/Vm2388gtUr57/NTt2AGBv2RrLIAPWk530tpX2Ppg/TwejUR/cUKEC/PSTXoIlSiXpmhZCiGtx9qxeV3T77Xoc+qefYNkyPf6bnQ39+xf8uuBg7Hhi6ZuZNzErNgfzx131EYbnzukziHfsgKZNi/WWRPGSFrEQQlyLb77RG3AkJOiWd67bboP33tObhmzcCHfd5fIye5sOWIzfYP2pgu6OnmvAbPYFHtXJfdEimDYNgoOL9XZE8ZNELIQQ12LjRt0avumm/M917aq/b9rkkojtdrA84oM1q5fujr41BvPZCPi+PHz7LXz5JYwYod9XlHqSiIUQ4lr4++uJWna77l++0JEj+nv58s5L+Q5wGLsZc9wv0P8NHVCrlm5JDx9ePOUXbidjxEIIcS369NEJ12rN/9w77+hE3bkzUEASngvmVxrryV5HjuhTonbu1K3hoprNLUo8aRELIcS1uOsu6NcPHnkE/vlH/3z2LHz8MXzyCcTEQGBgwUn4wr2jLxxfFmWKJGIhhLhWs2bB2LHw9tvwyiv6mtGoW7UxMdi/mY+l/Dys6+rKKUoiH+maFkKIa+Xjo5PwoUN6fNfHR597PGUK9s9nYcmYppOwR44kYZGPtIiFEKKoBATARx9Bs2YQF4fdy1d3Rx9AJ2FHL8w1YgDZrlLkkRaxEEIUlXXr4M8/dXd0bhLOHRP+FszVEmHmTHeXUpQwkoiFEKKopKQAYL/1jvwTs3p5Qr16+thDIS4giVgIIYpK7dp628r+tvyzozMzISlJjx0LcQFJxEIIUUTstzfQpyitCD+/beX5JKyUXsZ08qR7zz8WJZJM1hJCiCLgXCece4qS38OYf6sEmyvBd99BYiJMngy33OLuoooSRhKxEEJco3ybdXyYhnlrMMyfr09RatpUnyscFeXuoooSSBKxEEJcg4J3zKoMvKO3uBTiX8gYsRBCFNK/blspxBWQRCyEEIUgSVgUFUnEQghxlSQJi6IkiVgIIa6CJGFR1CQRCyHEFZIkLK4HScRCCHEFJAmL60USsRBC/AuXJOyRw9w6z2J+syWMHy97R4trJolYCCEuwyUJY2OuzwDMd+2HWrVgyhS44w5Yv97dxRQ3MNnQQwghLiFfEr71BcwJH0JQkA44eRK6doXevWHnTt1nLcRVkhaxEEIUwCUJezqYS2/M3wzIS8IAFSvChx/Cvn3w44/uK6y4oUkiFkKIi+SbmNVvLubKCdCgQf7gRo0gOBi2bi32corSQRKxEEJcoMDZ0S2OQno6pKXlf0Fqqn6uQoXiLqooJSQRCyHEeZdconT//eBw6MlZF8u9dv/9xVpWUXoUambBxo0b8fb2pn79+gB89913zJgxg9tvv52YmBh8fHyKtJBCCHG9XXadcNWqMG4cvPIK7N2rA5WCWbPgyy8hJgZCQtxZfHEDK1SL+PHHH+evv/4CYNeuXTzwwAOUK1eOb7/9ljFjxhRpAYUQ4nq7os06YmLggw9g2TLo0EGfLbx8ub720ktuKLUoLQqViP/66y8aNWoEwLfffkvr1q35+uuvmTlzJvPmzSvK8gkhxHV1xTtmGQzw5JOwaxds26a/du3S1wyGYi+3KD0K1TWtlMLhcACwdOlSunXrBkD16tU5fvx40ZVOCCGuo0JtW+npCbfdVizlE2VDoVrETZo04bXXXuPLL79k+fLldO3aFYDdu3cTIuMkQogbgOwdLUqKQiXid999l40bNzJs2DCef/556tatC8DcuXNp2bJlkRZQCCGKjFKAJGFRshSqa7pBgwYkJyfnu/7WW2/h6el5zYUSQogis2MHTJgA8+fD2bPYGzfD4jUb6+pakoRFiXBNG6NmZ2dz9OhR53hxrho1alxToYQQokgkJkK7dmAywejR2IMqY5lwG9aUWvoUpbmekoSF2xUqEf/1118MGTKE1atXu1xXSmEwGMjJySmSwgkhxFVzOGDBAvj8c/jtN/Dxgbfewt6rL5ZBBqwp548ydPTCXCMGuNPdJRZlXKES8UMPPYSXlxc//PADVatWxSBT94UQJYHdDtHRur+5USM4dw6qV8f+wAAstWpg3dNCd0fPAfOIRJgxA+6URCzcq1CJOCkpicTEROrVq1fU5RFCiMKbPl23hufPB19f6NIFe9yvWKJtWBNq6VOU5npgNnvCJ/Vh/353l1iIws2avv3222W9sBCi5Jk+Hbp108cSLl6MHU8sAx06CRvszK35jB4Tttlg82aQ+SyiBChUi/jNN99kzJgxvPHGG9SvXx9vb2+X5wMDA4ukcEIIccVsNj1D+q+/YMkS7OUrYGEW1pXVdUt40GLM1o+AKfD223DoEDz8sLtLLUThEnGHDh0AaN++vct1mawlhHCbadP099atsS/4HstTAXqdMDbmOvpi3rhHT9xq3x5+/VUf4tCwoVuLLAQUMhH/9ttvRV0OIYS4NtOmwR13YN/2F5YhXlgXnN+s47V/MI/9DpKU3p4yKwu++Qb69HF3iYUACpmIIyMji7ocQghxbY4fx/7+dD0xa4GfXqL08nbMxngwGnXMnj1yXKEocQo1WQsgLS2Nt99+m0ceeYRHH32Ud955h/T09Kt6jw8//JAGDRoQGBhIYGAgLVq04KeffnI+r5QiJiaGsLAw/Pz8aNOmDVu3bnV5j6ysLIYPH05wcDD+/v706NGDAwcOuMSkpqYycOBATCYTJpOJgQMHkpaW5hKzb98+unfvjr+/P8HBwYwYMYLs7GyXmOTkZCIjI/Hz86NatWq88sorqPNb5gkhismpU7r1264dNG8O//0vAHblieXD5lgz/6MnZtEb8/MRMGYMVKwId98tSViUSIVKxBs2bKBOnTq88847nDx5kuPHjzNlyhTq1KnDxo0br/h9wsPDmThxIhs2bGDDhg20a9cOs9nsTLaTJk1iypQpTJs2jfXr1xMaGkpUVBSnTp1yvsfIkSNZsGABsbGxrFq1itOnT9OtWzeXcer+/fuTlJTEkiVLWLJkCUlJSQwcOND5fE5ODl27duXMmTOsWrWK2NhY5s2bx+jRo50xGRkZREVFERYWxvr165k6dSqTJ09mypQphalCIURB7HZIStI7YmVl5X/+8GFo0gRGjgR/f30K0sKF5OQYeEh9gTUuWHdHL/DCfOwz+PNP+OMPOH4cuncv7rsR4sqoQrj33nvV4MGDlc1mc16z2Wxq0KBBqlWrVoV5S6egoCD16aefKofDoUJDQ9XEiROdz2VmZiqTyaQ++ugjpZRSaWlpytvbW8XGxjpjDh48qDw8PNSSJUuUUkpt27ZNAWrNmjXOmISEBAWo7du3K6WUWrx4sfLw8FAHDx50xlitVmU0GlV6erpSSqnp06crk8mkMjMznTETJkxQYWFhyuFwXPH9paenK0Clp6er7OxstXDhQpWdnX01VVTqSb0UrFTXi8Oh1LRpSlWrppQ+mkGp4GClXn1VqZycvLguXXTMjh3OS2fTTqtWrfYrUMqLbLWw/xylzv9/q9atU+rOO5WqUkWpEyeK+abcq1T/vlyDa62XC/8NLyqFbhE/++yzeHnlDTF7eXkxZswYNmzYUKg/CHJycoiNjeXMmTO0aNGC3bt3k5KSQseOHZ0xRqORyMhI59aaiYmJ2Gw2l5iwsDAiIiKcMQkJCZhMJpo1a+aMad68OSaTySUmIiKCsLAwZ0ynTp3IysoiMTHRGRMZGYkxd6zpfMyhQ4fYs2dPoe5ZCHHehAkwbBhERcGKFZCQAP37w/jxMHy4jtm9GxYvhtdfh1tuAXQD+qHH/Vi5MlzPjq73AuY5/aFyZQgOhqZNISMD4uN197QQJVChJmsFBgayb9++fDtr7d+/n4CAgKt6r+TkZFq0aEFmZibly5dnwYIF3H777c4kefH5xiEhIezduxeAlJQUfHx8CAoKyheTkpLijKlSpUq+z61SpYpLzMWfExQUhI+Pj0tMrVq18n1O7nO1a9cu8P6ysrLIuqCLLSMjAwCbzeb8Q8ZmsxX42rIqtz6kXlyV2npJTYXJk+G55+CVV/KuN24Mdero6yNGwD//gJ8ftG0LNptOwg95MmeOB56eDmY3fosuN+3D9vMu+P57PZYcEQEdOujZ0qWt3v5Fqf19uUbXWi/Xoz4LlYj79evHkCFDmDx5Mi1btsRgMLBq1Sr++9//Eh0dfVXvdeutt5KUlERaWhrz5s1j0KBBLF++3Pn8xftYq/NrlS/n4piC4osiRp2fqHW58kyYMIGXX3453/W4uDjKlSsHQHx8/CVfX5ZJvRSsVNbLjBn6++LFrtdr1tSHBm/frh9brbBpEzkbknj33btYuTIcT08HY8asx9jsDhZzB2zaBOHhOj4nB37+ufjuowQqlb8vRaCw9XL27NkiLkkhE/HkyZMxGAxYLBbsdjsA3t7ePPHEE0ycOPGq3svHx4e6desC0KRJE9avX897773Hs88+C+jWZtWqVZ3xR48edbZEQ0NDyc7OJjU11aVVfPToUVq2bOmMOXLkSL7PPXbsmMv7rF271uX51NRUbDabS0xu6/jCz4H8rfYLjR07llGjRjkfZ2RkUL16dTp27Iifnx/x8fFERUXl252sLLPZbFIvBSi19fLRR/DSS3DkCBT0R22DBvCf/+iYhg2x39GQh7ytrFzpiZeXYvZsG0ZjClEPP4z3nDkgyyuBUvz7co2utV5yezWLUqESsY+PD++99x4TJkxg586dKKWoW7eus4V3LZRSZGVlUbt2bUJDQ4mPj+fO86ejZGdns3z5ct58800AGjdujLe3N/Hx8fTt2xeAw4cPs2XLFiZNmgRAixYtSE9PZ926dTRt2hSAtWvXkp6e7kzWLVq04PXXX+fw4cPOpB8XF4fRaKRx48bOmHHjxpGdnY2Pj48zJiwsLF+X9YWMRqPLuHIub29v5y/BhT+LPFIvBSt19VK/PqSl6XHhi5Pojh26NXzHHeDri/21iQzpe445eOptK1/dQZekL1ncrBne7drh3b59wcm8DCt1vy9FpLD1cl3qssimfRXC2LFj1YoVK9Tu3bvV5s2b1bhx45SHh4eKi4tTSik1ceJEZTKZ1Pz581VycrKKjo5WVatWVRkZGc73GDp0qAoPD1dLly5VGzduVO3atVMNGzZUdrvdGdO5c2fVoEEDlZCQoBISElT9+vVVt27dnM/b7XYVERGh2rdvrzZu3KiWLl2qwsPD1bBhw5wxaWlpKiQkREVHR6vk5GQ1f/58FRgYqCZPnnxV9yyzpv+d1EvBSm29OBxK3XqrUqGhSvXvr1S7dkrdfLNS4eFKlSunlNGo1KRJynb0pIqOVnmzo+mhFKjs0FBdL6dPu/tOSpRS+/tyjUrirOkrbhH36tWLmTNnEhgYSK9evS4bO3/+/Ct6zyNHjjBw4EAOHz6MyWSiQYMGLFmyhKioKADGjBnDuXPnePLJJ0lNTaVZs2bExcW5TAh755138PLyom/fvpw7d4727dszc+ZMPD09nTGzZ89mxIgRztnVPXr0YFruvrSAp6cnP/74I08++ST33HMPfn5+9O/fn8mTJztjTCYT8fHxPPXUUzRp0oSgoCBGjRrl0u0shLgKDgf88gu88YY+qEEp+Prr/HGentjHvojl+dpYbb31OuFvvTDXnwJnX4NatfTe0ed7qoS40VxxIjaZTM5JSYGBgf86YepKfPbZZ5d93mAwEBMTQ0xMzCVjfH19mTp1KlOnTr1kTMWKFfnqq68u+1k1atTghx9+uGxM/fr1WbFixWVjhBBXYNcu6NkTkpP1Yy8vvRYpMBDOntU/AwwZgj3xDyz/vIj1dA+9ROmLLMw9ywN1dIzMChY3uCtOxDNyZzUCM2fOvB5lEUKUBZmZ0LGjHssNCdHLixo3htGj9ZpfgFatYM0a7DO+xOITizWzhx4TVv0wH28DjHDnHQhRpAq1oUe7du3y7dUMejZZu3btrrVMQojS7NtvYedOeP99PVP6wQdh1SrdNV25so753/+wRw/EErhA7x2NjbmPxWNueQzWrXNv+YUoYoVKxMuWLct3IAJAZmYmK1euvOZCCSFKsaVL9X7Rt96qH7/9NuTOKzl2DAB7n2gsyx7GmtZFn6JEb8wNdsPJk3pTDyFKkatavrR582bnz9u2bXNZV5uTk8OSJUuoVq1a0ZVOCFF61aoFAQF6olVoKKSkwH33Yf8pDsu2Z7Gqe3QSvnsS5rWL4ERT2LZN78IlRClyVYm4UaNGGAwGDAZDgV3Qfn5+l500JYQQREXBrFl6/+fck9TO/1Fv/ykOC7OwqmjdHR0yAvPaj3TMxIl67LhTJzcVXIjr46oS8e7du1FKcdNNN7Fu3Toq547noDf5qFKlisuyISGEyKd3b32Yw3/+ox9XrgwnTmB3GHQSpr9OwvTGfHhR3uu6d4cPPwSPQh+jLkSJdFWJuGbNmgA4HI7rUhghRBmweDEcOqRnTwMcO4Ydz/xJmEXg7a33i/7qK7jKfeyFuFEU6k/LCRMm8Pnnn+e7/vnnnzu3nxRCCBdK6STcr59esnReviTs0VcnYdCtXy+vvEMchCiFCpWI//e//+U7AhHgjjvu4KOPPrrmQgkhSpkffoA774SuXfVmHedPWSqwJfxQpbxdsv76S8+wHj5cJ3IhSqFCJeKLT0TKVblyZQ4fPnzNhRJClCLz50OPHvpnPz8wGsHhKCAJ99Et4c8+09tfAqxcCc8/D3/8kbcLlxClTKEScfXq1fn999/zXf/9998JCwu75kIJIUqJnBx4+mm9deUff8C5c5CVlT8J+1kwV0nIe13uFpeZmZDb+3Z+jbEQpU2hjkF85JFHGDlyJDabzbmM6ZdffmHMmDGMHj26SAsohLhBHD8OM2ZAUpJeH9y3r+5iPnAAKlaEli3hzz+xp53G4mPFmnV/Xkv43HdwroD3bNFC77oFcNNNxXk3QhSbQiXiMWPGcPLkSZ588knnDlu+vr48++yzjB07tkgLKIS4ASxZopcl2e3QtCkcPgz/+19ea3bwYJgyBfvrb2J5scb5JGzXY8K+cYCvbv1WqQLp6ZCVBffcAyYTxMTotcO1a7vxBoW4fgqViA0GA2+++SYvvvgif/75J35+ftx8880YjcaiLp8QoqQ7cAB69YL27XWLODhYd0lHR+t9pUEnYTyxvNMIq6Oj6xKl86uY8PCAo0f1zwYDVKumt8GsWBFkEqgoxa5pZXz58uW5++67iYiIkCQsRFn18cfg6QmzZ+skDPDYYzoJn998w+4XoMeEj59Pwvd9nrdEqWpV3YXtcED58vpa+fKwdSv897+QmKi3wxSilLriFnGvXr2YOXMmgYGB9OrV67Kx83M3cBdClH5r1+p1weXKwW+/6UlZn3+uk+n//od9gAWL/XOs9M5rCa/8Ne/1KSl6aVJQEKSm6hnW33yjZ1cLUQZccSI2mUwYDAbnz0IIAYCvL/zzj55MtX9/3nWHA/uixbolbOuNl8HOXM9ozPZFcPb8Rh3ly0NaGtSpA23aQP/+0Lat7poWooy44kQ8Y8aMAn8WQpRxt94KixZB69Z616zzpyPZM+1Y5nTRS5QMduZ6PoDZPk+/xuHQ3dENG+rNOnr1kuQryqxCTdYSQghAz27+7jvdul2/HlasgHvuwf77Gix+32I900N3R6vemGcPgC23w6uvwi23wI4d7i69ECXCFSfiO++809k1/W82btxY6AIJIW4Qq1frluyRI3rDjowMAJ2EmZWXhGuMxhyaAtOnw549+rXPPuu+cgtRwlxxIu7Zs6fz58zMTKZPn87tt99OixYtAFizZg1bt27lySefLPJCCiFKmAMH4L77oFIl/fj8fgL2kGpYjkxy3Tv60GLIDnaeOUxUFAwa5KaCC1HyXHEiHj9+vPPnRx55hBEjRvDqq6/mi9l/4WQNIUTp4XDo4wu9vfX+z6dOOVvBettKLywn3sFKH52Ep+zHPC4ObEqvDzYYYMoUGDZML3cSQgCFHCP+9ttv2bBhQ77rDz74IE2aNCnwiEQhxA1KKd2t/PbbsHu363Pdu0Pdutjfmaq7o+198lrCq7x0S3nlSr2z1l13wciR7rgDIUq0Qm3o4efnx6rc/V8vsGrVKnx9fa+5UEKIEuSZZ3QrNjAQLBa9uUbufJHu3bFPnIyl7mqsROsk7PmA3qzju+9g/Hh45RXYtw/GjHHrbQhRUhWqRTxy5EieeOIJEhMTad68OaDHiD///HNeeumlIi2gEMKNfv9ddyeDTqb//ANnzujjDM+dw/7s81iWPoz1n7vx8lLM9X8Ec/r5DX1ycnQirlZNJ+W77nLffQhRghUqET/33HPcdNNNvPfee3z99dcA3HbbbcycOZO+ffsWaQGFEG7icOgTlAwGWLgQunWDLVv02t/sbL13dOq7WL/xxMsL5n5+CvPbf8Af51//f/+n95/u1EkvbxJCFKjQ/3f07dtXkq4Qpdmvv+rJWTfdpLedBKhbF8qXx163Hpak/8ubHe0zCPPgOXn7RYeE6I09PK5pO3shyoRC/1+SlpbGp59+yrhx4zh58iSg1w8fPHiwyAonhHCjpUuhQgW9beWRI/raggXYladrEvYdiLlNut6mEsBm0wdBSBIW4ooUqkW8efNmOnTogMlkYs+ePTzyyCNUrFiRBQsWsHfvXmbNmlXU5RRCuIOPD5w+rXfCCgrCvvcAlso/YT0TdX52dB/MWYtgsdLxDRvqAx9kPFiIK1aoP1lHjRrF4MGD+fvvv11mSd93332sWLGiyAonhHCTM2d0i/joUbDbISNDJ2FmYT0WlbdEKWInNGigX/Pqq5CUJElYiKtUqES8fv16Hn/88XzXq1WrRkru7jlCiJLj6FF46SW4/XaoWRPuvx+WL88fl5EBDz6ox3kTE52X7XjqJHzhjln+v8DBg/rIwnvuAdnaVohCKVQi9vX1JSN3R50L7Nixg8qVK19zoYQQRWjXLmjcGN55B1q21EcN/vWXPnbwnXd0zJ49MHSo3rJy9uy81957r94x6+IkzCL48EO9tvjVV6FyZTh71h13J8QNr1CJ2Gw288orr2Cz2QAwGAzs27eP5557jvvvv79ICyiEuEaPPQZGoz7t6NNPYcIE2LwZ/vtfGDVKH2HYpAl89ZVe+wvODTvs93XHUm6uaxKudr6l/Mcf8MQTukW8dKl+DyHEVStUIp48eTLHjh2jSpUqnDt3jsjISOrWrUtAQACvv/56UZdRCFFY//wDv/yid7cKC8u7bjDktWQff1xvulGtmt6oAyAgQLeEnw/HetaszxP26KtbwocP6xhfXwgO1ttY2mw64QshrlqhZk0HBgayatUqfv31VzZu3IjD4eCuu+6iQ4cORV0+IcS12LlTf7/nnvzPGY1Qr57eC/q//4WxY/NOUco449odXfVpzIcW6tc5HPr7ihUwcaL++ZtvoEaN63svQpRSV52I7XY7vr6+JCUl0a5dO9q1a3c9yiWEKApVqujvO3boSVoXio2FhAT98+jR+ruPD/bsHCyeX2PN6Zu3TvjQHN2KVueXKYWE6FawUvokptwNP4QQV+2qu6a9vLyoWbMmObljSUKIkqtRI4iIgNdeg6ysvOuffQbR0XppUq4GDXQSZlZeEqY35sw5+vncJFypkk7qa9aA2az3kxZCFFqhxohfeOEFxo4d69xRSwhRQhkMMG0arFsHTZvCRx/B++/rcWHQSdXHB7y9sVeuisXLmn929IXv1bKl3uayalWYPx/mztXnEwshCq1QY8Tvv/8+//zzD2FhYdSsWRN/f3+X5zfKekIhSo7ISL1m+OWX4ckn81q2ERFQvTr89JNeJ/zbQ1gdfVyTcG53dO/euhUdGOjeexGiFCpUIu7ZsycGgwGV+z+0EKJka9YMvv0WwsP1+O6OHbBhAzRpgr1CMJa097A6+uUlYc8fITBIJ+//+z94911JwkJcJ1eViM+ePct///tfFi5ciM1mo3379kydOpXg4ODrVT4hRFE4eFCPE6el6d21AO65B/uWP7EYvsRKtE7C5R/CfPYH+O8YPSP6+eehVy+9tEkIcV1c1Rjx+PHjmTlzJl27diU6OpqlS5fyxBNPXK+yCSGuVVoaPPCA7oL+6CN9bfVqAOyJSXpilorGyyNHt4RPz9bLk+acn6Dl75/3OiHEdXFVLeL58+fz2Wef8cADDwAwYMAA7rnnHnJycvD09LwuBRRCFJLdDl266F20lAIvL32ta1fsPy5xXSdcfgjmjPNjwkFB+hxioxGeegoqVnT3nQhRql1Vi3j//v20atXK+bhp06Z4eXlx6NChIi+YEOIa/fijXiecO5fj/FIl+28rsfh+k5eEvaIxZ3ypE/XGjRAXp5c6ZWXp1rQQ4rq6qkSck5ODj4+PyzUvLy/sF65FFEKUDF9/DZ6e+jCGRo0gJAR73XpYzn6INbOXTsKVn8Rsn6fjW7fW3dL/+59+3KWLXqokhLiurqprWinF4MGDMRqNzmuZmZkMHTrUZQnT/Pnzi66EQojC2bZNJ1YPD7DbsR85juXUR1jpmTc7+tgFS5R+/VWf0lSunL72wQfuvgMhyoSrSsSDBg3Kd+3BBx8sssIIIYrIqVN6prRS+gCHLX/qMeGzPfHygrkt3se88vxmHf7+cO4cLFigzy1+7jm47z6oVcuttyBEWXFViXjGjBnXqxxCiKKyaxe0bw+pqWAwYD9nc52Y1Wkm5l9eyIs/fVovT3rjDb1tZePGed3TQojrrlBbXAohSqDUVPjzT+jTR0+8GjgQe2BFLPbPXLet/PExyMzUr8ld7RAWpk9Pio3Vy5sqVXLffQhRxkgiFuJGt28f9O2rT1q6/XY987lqVeyDhmA5NU2vE8bG3Eav620rq1fXr+vTR++2BXo8eM4c6NdP7z0thCg2hdriUghRQhw+nHfW8Ftv6W0rZ8/Gvv0fLD1SsToeyGsJZ2zRLeD9++Gxx2DqVOjeHW65RXdHCyHcQhKxEDeyN9/UE62mTYOYGNixQx/gcGyynh1tsDP3i3OY39oNW3brRNy1K7RtC+3a6THhRYv0zGohhFvI/31C3KhycuCTT/QSpeho2LsXe4tWWDxmXzAm3Adzp0zdUu7SRW/q8eOPOj4nB37+WV8XQriNtIiFuBH9/rtu2Z49q78Ae6YNS8JQrJw/RanmaMx7F8ILlaFCBZ10Bw6EF1/Ua4XlIAchSgRJxELcaHbtgg4d9MxnT0/IycFueRjL8oex7r1HJ2GPfpj3f6fjP/kETCYYM0Yfa+gl/9sLUZLI/5FC3GimT9cbddSuDbt36zHh9cOw7r1TjwlXeAzzuZ8g0wEREXDyJPz1l964QwhR4sgYsRA3mvh48PPTe0cHh2LxnI31z/NJ+I4YzKkzdWvZw0PvlNWqlSRhIUowaRELcaPJyQFfX+zpZ7BkTMOac//5MeH/Yk6/aJ/3o0dh+HD3lFMIcUWkRSxESbZlCzz9tJ7ZPHSovnbPPdizcrBsH4s1+368PB3Mbfch5j3vwbFjuiXs4aFnU7/0Ut46YyFEieTWRDxhwgTuvvtuAgICqFKlCj179mTHjh0uMUopYmJiCAsLw8/PjzZt2rB161aXmKysLIYPH05wcDD+/v706NGDAwcOuMSkpqYycOBATCYTJpOJgQMHkpaW5hKzb98+unfvjr+/P8HBwYwYMYLs7GyXmOTkZCIjI/Hz86NatWq88sorqNzzXoUoCjYbzJ+v1/nWr6+PMzQa9Y5ZgP3ICSyp7+XtmOX5AOZ7jkPLlrpLWimdiDt31pOzhBAlmlsT8fLly3nqqadYs2YN8fHx2O12OnbsyJkzZ5wxkyZNYsqUKUybNo3169cTGhpKVFQUp06dcsaMHDmSBQsWEBsby6pVqzh9+jTdunUjJyfHGdO/f3+SkpJYsmQJS5YsISkpiYEDBzqfz8nJoWvXrpw5c4ZVq1YRGxvLvHnzGD16tDMmIyODqKgowsLCWL9+PVOnTmXy5MlMmTLlOteUKDO2boVbb4X774ffftMznI8f15tuZGaSk2PgoZ8HYCU6b8es7G/h1Vf1HtG5RxqazTB3rrvvRghxJVQJcvToUQWo5cuXK6WUcjgcKjQ0VE2cONEZk5mZqUwmk/roo4+UUkqlpaUpb29vFRsb64w5ePCg8vDwUEuWLFFKKbVt2zYFqDVr1jhjEhISFKC2b9+ulFJq8eLFysPDQx08eNAZY7ValdFoVOnp6UoppaZPn65MJpPKzMx0xkyYMEGFhYUph8NxRfeYnp6uAJWenq6ys7PVwoULVXZ29lXVU2lXZuvl9GmlqlVTqn59pVq1UsrLSymdVpUCdbZcoGrVar8CpbzIVgu/zFDqww+VeuoppQYMUGrkSKXefVepP/90950UqzL7+/IvpF4Kdq31cuG/4UWlRI0Rp6enA1CxYkUAdu/eTUpKCh07dnTGGI1GIiMjWb16NQCJiYnYbDaXmLCwMCIiIpwxCQkJmEwmmjVr5oxp3rw5JpPJJSYiIoKwsDBnTKdOncjKyiIxMdEZExkZidFodIk5dOgQe/bsKcqqEGXR11/rvaMXLICEBL0L1tChsG8f9mEjeSj7E1auDM9rCXc8p5+fNg2++greeUePJ9er5+47EUJchRIza1opxahRo7j33nuJiIgAICUlBYCQkBCX2JCQEPbu3euM8fHxISgoKF9M7utTUlKoUqVKvs+sUqWKS8zFnxMUFISPj49LTK2LDkvPfU1KSgq1a9fO9xlZWVlkZWU5H2dkZABgs9nwOr+xgs1mK7BOyqrc+ihz9bJqFbRurTfs8PaGqlXh/fex2+Ghva8wxx6Ap6eD2f5D6GKLx+bhoceTy7gy+/vyL6ReCnat9XI96rPEJOJhw4axefNmVq1ale85g8Hg8lgple/axS6OKSi+KGLU+YlalyrPhAkTeLmACTNxcXGUK1cOgPj4+MvdSplV5uqlVy/9/exZsFoByPn+J9599y5WrgzH09PBmDHrMTa7n8Xcr7e5FE5l7vflCkm9FKyw9XL2/JayRalEJOLhw4ezaNEiVqxYQXh4uPN6aGgooFubVatWdV4/evSosyUaGhpKdnY2qampLq3io0eP0rJlS2fMkSNH8n3usWPHXN5n7dq1Ls+npqZis9lcYnJbxxd+DuRvtecaO3Yso0aNcj7OyMigevXqdOzYET8/P+Lj44mKisLb2/tyVVSm2Gy2slkv/fvrAxnOT7iy46W7o3PC8TLkMDvwEYzNehL18MN4Oxy6G9vT092ldrsy+/vyL6ReCnat9ZLbq1mU3JqIlVIMHz6cBQsWsGzZsnxdu7Vr1yY0NJT4+HjuvPNOALKzs1m+fDlvvvkmAI0bN8bb25v4+Hj69u0LwOHDh9myZQuTJk0CoEWLFqSnp7Nu3TqaNm0KwNq1a0lPT3cm6xYtWvD6669z+PBhZ9KPi4vDaDTS+PxZrS1atGDcuHFkZ2fjc/7w9Li4OMLCwvJ1WecyGo0uY8q5vL29nb8EF/4s8pSpepk1K2+Ws6cn9hwYwqfMyT3AQfWmS2Y8i+mJ97lzePfuDb6+7i1zCVOmfl+ugtRLwQpbL9elLots2lchPPHEE8pkMqlly5apw4cPO7/Onj3rjJk4caIymUxq/vz5Kjk5WUVHR6uqVauqjIwMZ8zQoUNVeHi4Wrp0qdq4caNq166datiwobLb7c6Yzp07qwYNGqiEhASVkJCg6tevr7p16+Z83m63q4iICNW+fXu1ceNGtXTpUhUeHq6GDRvmjElLS1MhISEqOjpaJScnq/nz56vAwEA1efLkK75nmTX978pcvTgcSplMSvn4KHXzzcqGp4pmdt7saHooBSq7SxddL8HBSh096u5Slxhl7vflCkm9FKwkzpp2ayIGCvyaMWOGM8bhcKjx48er0NBQZTQaVevWrVVycrLL+5w7d04NGzZMVaxYUfn5+alu3bqpffv2ucScOHFCDRgwQAUEBKiAgAA1YMAAlZqa6hKzd+9e1bVrV+Xn56cqVqyohg0b5rJUSSmlNm/erFq1aqWMRqMKDQ1VMTExV7x0SSlJxFeizNXLsmV6iVJYmLIFh6ro+1LzJWEFKtvPT9fLtm3uLnGJUuZ+X66Q1EvBSmIidnvX9L8xGAzExMQQExNzyRhfX1+mTp3K1KlTLxlTsWJFvvrqq8t+Vo0aNfjhhx8uG1O/fn1WrFhx2Rghrsr27QDYDx3F0ngL1p8q4OUFc7/IwnysHTwXp3fMiozU8XXrurGwQoiiViImawlRZqSnw8yZsGSJ3gu6XTsIDtZHGfIF1sRbdRKeC2ZzeUi1wOjRcH6GvRCi9JFELERx2b4dOnSAI0cgKkrvHz1+PPZygVg8v8aa01dPzOozH3Pl6vD1HhgzRp+2VLUqXLRWXghROkgiFqI4OBx6/2iTSe+aVb06cL47uv4mrDmddBL2isY8dxFYL9g0oG1bve/0W2+5qfBCiOupRG1xKUSptWwZbNsGr70GaWmQlobdDpZnqmA9eT4Jt5yC2T4vb7esypWhY0dYuxbat4f77nPnHQghrhNJxEIUh8WL9dGEvXpBgwbYK4VguWklVqs+YGlu8FDMbTLg11/h/Lp1jh2DNWvg8cfh++9l8w4hSinpmhaiKOXk6CMLv/tO/3zPPdCwIbz7ru6eDgrCXuMmLMnPYN3fSreEPzmNefg3EPC87obesAH274dTp6BWrbyJWrJnsBClkiRiIYrKb7/pceDUVP3Yzw9mz9Yt4Zwc8PDA/sRwLLtfxvoHeBnszFW9Mc9MhzNnoE+fvPc6P4YshCj9pGtaiKKwYoWeEZ2RAcOG6S0r77tPb8WRkwPe3thHP4vljVt1d7Sng7kTd2L2WgzLl8MTT0CdOu6+CyGEG0giFuJaKQVDhuiu5w8/hKlTYeBAmDcPzh/4Ybc5sHzRHiv9dXd0zn8wP1tPv9bDA95/3803IYRwF0nEQlyr9evhn3/0zz17wrffwrhx8MYb0Lnz+c06ZmE92l53R/sPwuzxg96oIzAQAgJkIpYQZZiMEQtxrfbsyfu5bl3dPV2zJqSmYs84o5Mw/XUSXuCFOepTeC4Y3n5bv2bQILcUWwhRMkiLWIhr8cEHrok0I0O3bh95BPuBFCw+c/K6o9X9mMc3gqFDYf58He/llZeQhRBlkrSIhSiMXbugd2/YtCn/cw4H9hdjsHzdFWv2/ToJG/pirrAS/kiFP/7QcZUr60RcqVLxll0IUaJIIhbiaqWm6vW+J07oxwaDnnR1nl156O7oP+/USdj0COb0hTD/Nx138iTUq6cnaC1b5pZbEEKUHJKIhbha06bpDTdyk2/uOmGTCbuHD5bUd/O6o6s8hbnCGkgHfHygZUv9mqNHYc4cePJJt92GEKJkkDFiIa7Ghg0wYULeY29vOHsWHn4Ye/ppLDmf5yVhemOOLqdnVHt76007jh7V48Nt2oCvr15zfDn//KNj6tSBiAh9bfPm63Z7QojiJ4lYiCtx6hR07Qp33w3nzuW1hm02uO027K3bYTHOwZrRTSdhnwGYWQQHDuj1xSaTPsAhJETvvhUUpDfyCAu79Gf+/jvceac+nLhbN71PNehu8dzJXkKIG550TQtxJR56CFau1Inz0CGXcWH7rn1YBhuwcn9eSzh7kX7d99/DCy9ATIxeb3zkiF7idMcdl/+8nBwYMEAn4sWLoXx5nfQXL9ZJedAgfSKTyXR971sIcd1Ji1iIf/P333qXrJYtdRK+gN6s4wvX7mjOJ+H69XWL+NVX9ZKm5s3BbP73JAwQFwd798I77+gkfKE339Stcqu1iG5QCOFOkoiF+De5M5t//jnvJCSl8nbMujgJ+/jo8d+4OL1EqTB27tTvk3sk4oVCQ+Gmm/J28xJC3NAkEQvxb86c0d89PSEzEwwG7EZ/LI23FdwS9vGBH37QCbOwqlSB7Gy9Xvlip07BwYN6vFkIccOTRCzE5SxeDGPH6p9zcvRmHcoDS9bHWBNvyZ+EBw/WXcrt21/b53brBhUqwPjxerLXhd55B7KyoH//a/sMIUSJIJO1hLjYH3/ozTZWrNBdxIGBuiXM+THhij9gPdn5fBLug9m0XK8TBmjaFCpWvPYylCunyzBokE7sDz8MRqO+/vbb8MorUK3atX+OEMLtpEUsxIViY/W47M8/68ceHpCeDp6eeWPCziTcGzPf6ed9fXWXtM1WdGUZOFC3yJXSs7aHDNHXP/1Un+4khCgVJBELkevIEd21XLs2HDumJ0Pl5ABgz8F1Ylb1/9Pd0R4eeinTqFF6TLdVq6ItU+fOetlURgbs26ev9elTtJ8hhHArScRCbN8OTzwBt92mx17/+UfvYuXhAd7eBc+O3v+Bfq2nJzRrplup7dvrdb/XQ0CArBkWopSSMWJRts2ZozfOcDhcDm5g40YA7A6DaxJ+aDHmhSshFZ2obTZYs0YnY1nXK4QoBGkRi7Jr/349DuvlBdWr510PDgbOT8wyfOnaEjYugRYtdJyXl56YtXgxrF5d+DXDQogyTVrEouz69FM9vpuVpcdfPT31mHCHDthXr8Oy71WsKtp1idJH6NcA1KwJS5dCjRpuvQ0hxI1NErEomw4dgilT9ASrXLkTs2K/LXjHLIDevfVyoh079DInPz83FF4IUZpI17Qoe7Kz9WSs06fzPXXJbStBjwnfeqs+vGHsWEnCQogiIS3iG4nNpo/OO3kSbr8973xacXkHD8Jvv+mf27SBzz6D1FSdWHN3rapXD/vOvVhsn16QhPvkJWHQsW+8odfwPvtssd+GEKJ0kkR8o5gzB/7v/+Dw4bxr994LX3yhDwAQ+WVmwrBhMHOms9sZT0+9QxXoTTjOngXAvv1vLB6zsdIvf0vY21t/z92sY+jQvHFiIYS4RtI1fSP4/nt44AG45x69rCYtTR8Mn5KiW3gnT7q7hCXTI4/A7NkwebKuo9RUfS7w+eTrTMK53dGOi5Kw1/m/U7284OOP9c9KwS+/FP+9CCFKLUnEJZ1S8NJLEBUF33yjN4wwmeA//4Fff4WjR/XsX5Hn5EmdLGfPhqlT4emn9cSqRx/VZwPnio7G/r/PLj0mnLuuOC5Ob/oRGOh6XQghioAk4pJu/35IStI7P13cHVq9OvToAQsXuqNkJc+mTXDffVCpEnTooK+tXQsNGkDbtjB3rsssabv1GyzjwgtOwnfcob8bDLpHYvJkaNlSP27btphvTAhRmkkiLunOn/pzye0NTaa8mLIsMVHv87xrF3Ttqs8CNhh0b8GWLfnCnd3RJzrmT8IAW7fqyVweHjBpkh4WWLECoqOhVq3iuy8hRKknibikq11bHxK/YEH+57Kz9QH0uTs9lWXPPKOT76FDOmHedlvBXcheXpdfogQQHg5Vq+rJWZ6e+tqKFdCpU95YsRBCFBFJxCWdtzcMHw4ffggzZuTN/k1N1WfVnjgBTz3l3jK628GDsGyZnrzWvDkcOKDHdf39XeOMRuwG74KTsNGY1/UfG5u35Cn36MGvvtIT5C5+TyGEuEaSiG8EY8fqgwkeflh3i95zD4SF6Vby11/rNcVl2YkT+vu5c/DWWzB6tD6t6MwZlzB7tuOidcIXtISzsnQLunlzXb8Gg56RXq+enjXdsWPx3pMQosyQdcQ3Ak9PvV542DA9Ezg1Fbp314fFh4S4u3TuV7Om88jCSx1DaMcTi5p56e5o0HtGL1mS9/jvv2HCBLj/fjnQQQhx3UgivpHcfbf+Eq7OndOt2aysAp/+1zFh0OO/P/+sW8OdOunu7YUL9WYp7713/e9BCFFmSde0uLGdPKm7jy+xtveKkrC/P3z3nR4TrldPL1fauVNvZ7lmjfQ6CCGuK2kRixvbm29CenqBT11REga9xMlo1GPCbdpc1+IKIcTFpEUsblyZmfDuuwU+dUVJOCJCjwk/8MD1L6sQQlyCtIjFjencOT2T+cLzhM/71yTs5aWXgf34o56gJYQQbiQtYnFjeu89WL063+UragkrpXffkiQshCgBJBGLG9Mnn+SboHXFY8K+vvDRR8VUUCGEuDxJxOLGtHevSyK+oiTscf7X/dNPoVq1YiysEEJcmiRicWPJzIT4eChXznnpipKwp6feLatHD+jbt5gLLYQQlyaJWNw43ngDKlbUk7ROnQKuojs6J0cfDDF3bl7LWAghSgCZNS1KPqVg8GCYNcvl8hUn4VwBAXobTCGEKEGkaSBKNqXg//5PJ2GDwXksoU7CX15ZEq5YUSfgDz4oxoILIcSVkUQsSrb58/P2elYKHA6dhL2tWIn+9yT8n//oXbNCQ+HwYX2QgxBClCCSiEXJNm0ahIfrnwMDsSsP3R1t63PpJFyhAjRrpn9esEAn4P379eNNm4qt6EIIcSUkEYuS69lnISEB7HYA7Jn2vDFhjxzmVnmq4Jawnx9s2FDwe77wgj4oQgghSghJxKJkUUrPbgZYtEjPcD5yRHdHZ3+SNybs6IU5dWbe63x88n4+fFjPks7Vqxf076/fa/duWb4khChRJBGLkmX6dL1rFuhlSpGRed3RF0/MstnyXpe753T58q7vV6WKni399ddgsejW9S+/XLrFLIQQxUwSsSg5srLguefyHm/ciP3nXy5Kwn0uPTGrXDlo0ABMprxrR49CXJze0vLpp/Pifvnl+t2HEEJcBbcm4hUrVtC9e3fCwsIwGAwsXLjQ5XmlFDExMYSFheHn50ebNm3YunWrS0xWVhbDhw8nODgYf39/evTowYEDB1xiUlNTGThwICaTCZPJxMCBA0lLS3OJ2bdvH927d8ff35/g4GBGjBhB9kUn+yQnJxMZGYmfnx/VqlXjlVdeQV3iQHpRCKNGwenT8NhjANh/W4mlR+pFLeHvdGyFCvnXBJ89C2vW5J1P3KQJrFypt8N8/HH9c+4OWwZD8d2XEEJchlsT8ZkzZ2jYsCHTpk0r8PlJkyYxZcoUpk2bxvr16wkNDSUqKopT53dVAhg5ciQLFiwgNjaWVatWcfr0abp160bOBWOE/fv3JykpiSVLlrBkyRKSkpIYOHCg8/mcnBy6du3KmTNnWLVqFbGxscybN4/Ro0c7YzIyMoiKiiIsLIz169czdepUJk+ezJQpU65DzZQxZ87Am2/Chx/qx7/+Sk6OgYce8sD6nb+emEVvzBVW5CVRb2+oW1fHe3joMeIqVVyT8zPPwL336mu7dsGECXD33frzOnYs/vsUQoiCqBICUAsWLHA+djgcKjQ0VE2cONF5LTMzU5lMJvXRRx8ppZRKS0tT3t7eKjY21hlz8OBB5eHhoZYsWaKUUmrbtm0KUGvWrHHGJCQkKEBt375dKaXU4sWLlYeHhzp48KAzxmq1KqPRqNLT05VSSk2fPl2ZTCaVmZnpjJkwYYIKCwtTDofjiu8zPT1dASo9PV1lZ2erhQsXquzs7Ct+famyebNSr7yiVKVKSulpWkqBOutbXrVqtV+BUl5eDrXwgwN5z/v6KlWrllIeHvqxj4++Nnx43vuOH6+f8/RUqkcPpfr3V8poVCo0VKnAQKW6dHHbLV+LMv/7cglSLwWTeinYtdbLhf+GF5USO0a8e/duUlJS6HhBy8VoNBIZGcnq8+fQJiYmYrPZXGLCwsKIiIhwxiQkJGAymWiWu64UaN68OSaTySUmIiKCsLAwZ0ynTp3IysoiMTHRGRMZGYnRaHSJOXToEHv27Cn6CijNTp/WG200aAAvvwwnTjifsj8/nofsn7FyZbjujn48HnO1DXn7Qz/wADRtCsOG6fOIn3xSjy0PH573/jExeiOQ4GA989pqBYcDUlIgMlI/FkKIEqLE7jWdkpICQEhIiMv1kJAQ9u7d64zx8fEhKCgoX0zu61NSUqhSpUq+969SpYpLzMWfExQUhI+Pj0tMrVq18n1O7nO1a9cu8D6ysrLIyspyPs7IyADAZrPh5eXl/LlMeewx+P13+PxznUBDQuDNN7EPGsJD7zRijr0nnp4OZvs9RJfP52P7HL07Vvny8OOPejlSQAA89RRs3w7vvw+1arnOou7WTX9t2wa//aavtWsHt92mf74B6zz396TM/b78C6mXgkm9FOxa6+V61GeJTcS5DBdNqlFK5bt2sYtjCoovihh1fqLW5cozYcIEXn755XzX4+LiKHf+KL/4+PhLvr5U6tdPfwHMng1ATo6BdxtvZeXKcDw9HYwZsx5jsz4sps+l3+fuu/N+Xrz40nG5fyTt3q2/bnBl7vflCkm9FEzqpWCFrZezZ88WcUlKcCIODQ0FdGuzatWqzutHjx51tkRDQ0PJzs4mNTXVpVV89OhRWrZs6Yw5cuRIvvc/duyYy/usXbvW5fnU1FRsNptLTG7r+MLPgfyt9guNHTuWUaNGOR9nZGRQvXp1OnbsiJ+fH/Hx8URFReFdVk4F+vRTvWPWoUOwcye0aIH94cd46PgUVq70wAsbswMexdjsP0Q9/DDe587pCVeffAIXDB2URTabrez9vlwBqZeCSb0U7FrrJbdXsyiV2ERcu3ZtQkNDiY+P58477wQgOzub5cuX8+abbwLQuHFjvL29iY+Pp+/53ZIOHz7Mli1bmDRpEgAtWrQgPT2ddevW0bRpUwDWrl1Lenq6M1m3aNGC119/ncOHDzuTflxcHEajkcaNGztjxo0bR3Z2Nj7nd3GKi4sjLCwsX5f1hYxGo8u4ci5vb2/nL8GFP5d6SsG5c+DlBXfcgd3hwZD/3cMcuwdeXoq55R+ly+OhLAa8z53Du25dvQ5YOJWp35erIPVSMKmXghW2Xq5HXbp1stbp06dJSkoiKSkJ0BO0kpKS2LdvHwaDgZEjR/LGG2+wYMECtmzZwuDBgylXrhz9+/cHwGQyMWTIEEaPHs0vv/zCpk2bePDBB6lfvz4dOnQA4LbbbqNz5848+uijrFmzhjVr1vDoo4/SrVs3br31VgA6duzI7bffzsCBA9m0aRO//PILzzzzDI8++iiBgYGAXgJlNBoZPHgwW7ZsYcGCBbzxxhuMGjXqX7vKxQXat9e7W8XGYscLS63lWO3nD3Do8D/MaV/Avn158XJ0oRCitCuy+deF8Ntvvykg39egQYOUUnoJ0/jx41VoaKgyGo2qdevWKjk52eU9zp07p4YNG6YqVqyo/Pz8VLdu3dS+fftcYk6cOKEGDBigAgICVEBAgBowYIBKTU11idm7d6/q2rWr8vPzUxUrVlTDhg1zWaqklFKbN29WrVq1UkajUYWGhqqYmJirWrqkVCldvrRzp1LvvKPUxIlK/fqrUv9WJ/ffr2zlK6joFrv1EiWDTS2kh3OJUna5crpepk4tluLfKErN70sRk3opmNRLwUri8iW3dk23adPmsjtTGQwGYmJiiImJuWSMr68vU6dOZerUqZeMqVixIl999dVly1KjRg1++OGHy8bUr1+fFStWXDamTLHZ9PKhzz7Ts5qNRr2rVaNG+vjBS3TZ2z+diSUiEWtCLd0S9huE+ewivSFH/fp6eRLo3bCEEKKUK7HriMUNYMwY+OILvXzoxAlITYVff4WMDOjUSa/vvYjdDpYny2M9GKnHhC3fY36hvl4TnJICS5fqtcVCCFFGlNjJWqKEO3FCb0n54ot6c41cbdvCwoV6s4758yE62vmU3a4PQLJa9VytuXMNmM29ir/sQghRgkgiFoWzapVu8Q4alP+5iAi45RZ4912dsHv3xh4celESBrO52EsthBAljiRicW0MBvjjD32O8MaNkJMDhw/rbmaAdeuwDx+JJegHrKmdJQkLIcRFJBGLwrnnHj05a/hw+O47fcZvZqbe0zlXy5bYH3oUy9hqWI9H6YlZH5/CbK7ovnILIUQJI5O1ROEEB8P99+skbDTqlvFdd7mE2FevxfLaLToJG+zMNfTFvO75S7/n/v16Alju1pVPPAGbNl3HmxBCCPeTRCwKL/dc6Kwsfcbvhg36sacn9rZRWJiFdW9L3RIesx6zWghffunaas6VlKSXPX36qd7SEvQ49N13w5w5xXAzQgjhHpKIReH88Qf88IOeeXXvvfpEpPPsOWBZ8QhW+uskXPFxzBvH6yfPnMm/rEkpGDBArzveuRPeeUdf37RJH3s4eDAcP14styWEEMVNErEonEmT9Liwhwc0bgxLloCHB3Y8sXjMxprTVydhemN+PBR++QV8fKBqVfD1dX2v33/XxxVOngwXHmnp5aVnXiulW9JCCFEKSSIWhbNoEVSuDNnZMHUqnD2LPSAIi+FLrI5+Ogn7D8bMIp2EHQ49o/rxx/V48oX+/lt/b9Uq/+cEB+szhP/66/rfkxBCuIEkYnH13n8fTp/OO5zB4dAt4fT3sarovJbwma/18+vW6e/NmunJWBerXFl/37Ej/3OZmbB3b16MEEKUMpKIxdXZtAmeflr/7OEBPj46CTMrb0yY3rol7O2tu6NBT7r65Rfw88v/nlFRep/pmJj8E7nef19vnfngg9f1toQQwl0kEYur8/77OgG3agV2O/baNxechEEnYqX09wUL8o8N5zIadff2vHkQGam33wJ46CF49ln473/1Tl1CCFEKSSIWV+f333Wrdfx43RLeMS4vCXv01Um4fHmdrM+e1Sc0jR8P1apd/n379oWfftKJe+hQfe2PP+Cjj+DNN6//fQkhhJvIzlri6nh66tnRdzTMawkb7MytOBTzye90zK23woEDcOQIhIQUPC5ckE6d9NexY/o0psTEvK5tIYQopaRFLP7duXMwaxY89RSUK4fdYcDyn1N5LeFXt2Pe/W5eq3f7dp2E69SBGjV01/TVqFBBf794drUQQpRC0iIWl7dxI3Trpg9yqF8f+4l03RJeU1u3hFVvzJNXwOcV4eBBvfbXywuaNNE7b9Wt6+47EEKIEk1axOLSTp2CLl0gPBz+/hv7xs1YWu/Jawmr+/WYcFoa7Nqlx3c9PaFfP70P9Y4d8Oij7r4LIYQo0aRFLC7tq6/0eO26ddjDaujzhGMN+ijD7l9jXvg9VAiC9HQdf++9+lSm5cvh449h9Gho08attyCEECWdtIjFpf3+OzRvnpeEreSdJzy1g24Bz5ypk3VMjP4+cyb4++vlSm+9JeO8QgjxL6RFLC7N2xv76cz8SdgM/HVGx/j4QMWK8OKL+ksIIcRVkUQsLsnepQeWmVFYN1+UhEGv7w0MLHh/aCGEEFdMEnFZtWOHPuc3PR0iIvSGGv7+zqftdrDMN2PFQ0/MGr4ac8emcPAkTJumjyp87TWX1wghhLh6MkZc1jgcMGwY1KsHU6boM4WHDNHrfZctA84nYQtYYz3w8lLMvfMNzO+00ccehofrbS7Hj4dx49x6K0IIURpIi7ismTQJpk/X5/w+/rje/3n3br3MqHt37Ju3YXm++gVjwgbM5vHwZ199ipKfH3TsmLfphhBCiGsiibgsyc7WXcpDh+adoARQuzbMn489vBaWbiexbquef0z4ttv0lxBCiCIlXdNlyV9/wdGj8MAD+Z6ylwvEUvEHrNsa5k/CQgghrhtJxKWdzQbvvQd33AGNGulrDz4IHTro4wX//jtvTHhvS71tpSRhIYQoNpKISzO7HXr31jtc3XabPoQBYP9+WLsWPvsMe70ILPfu0mPC2Jg7cJEkYSGEKEaSiEuz2bNh0SL4/nt9MtKBAzopA9hs2O9qiiUsHuvam3QSDnoM85RI95ZZCCHKGEnEpdlnn+nzfVu1gs8/10l40iTo2hV7lh3LLxasB1rrJOwzAPOq/0KlSu4utRBClCmSiEuz/fuhcWP45x84fRq6doVnnsH+489YQuP1KUoeOcytNBRz9rcQG+vuEgshRJkjy5dKs/Bw2LBBjxUDtGqF3ebAUnUp1sNtdEs4VmH+9AD8XRsmTtSbfVSp4t5yCyFEGSIt4tJswACIi9M7aFWsiD0gCIvhy7wk3O5DzLduh/h4va7Y4dCnJgkhhCg2kohLsxMnwMMDlMJe/04sJ9/BqqJ1EqY3Zo/v9TKm+vXhkUf0FpYZGe4utRBClCnSNV2azZgBDz6IPaIRllfrYqV7XhJmESwF+vXThzj88QecOgUNG7q71EIIUaZIi7g027sXe5PmWDb9H9ZT3fUBDsFDMUfs0vtMGwz6oOHsbHjiCbjlFt1CFkIIUWwkEZdi9rAaWN5r7HqAw09PwOHD8OmnYDRCjx5Qq5be+nLePN2VLYQQotjIv7qllN0OlsCFWHc21S3h3G0rmzTJS7hVq0JWFkyYAFu36nOJhRBCFCsZIy6FnHtHb6mPF3bmeg7AHF8ZTtwFmzbBzJl67+nlyyEw0N3FFUKIMk0ScSnjTMK53dGzsjFvvVnvsvXBBxAaCiNGwJgxkoSFEKIEkERciuRLwnPBbC4HvAavvaYDvOQ/uRBClCQyRlxKFJyELwqSJCyEECWOJOJS4IqSsBBCiBJJEvENTpKwEELc2CQR38AkCQshxI1PEvENSpKwEEKUDpKIb0CShIUQovSQRHyDkSQshBCliyTiG4gkYSGEKH0kEd8gJAkLIUTpJIn4BiBJWAghSi/ZaqmYKaUAyMjIwGazcfbsWTIyMvD29i4w3m7XRwfPnQuenjBrFrRtCxkZxVnq4nUl9VIWSb0UTOqlYFIvBbvWesk4/49v7r/lRcGgivLdxL86cOAA1atXd3cxhBBCXIP9+/cTHh5eJO8libiYORwODh06REBAAKdOnaJ69ers37+fQDkJySkjI0PqpQBSLwWTeimY1EvBrrVelFKcOnWKsLAwPDyKZnRXuqaLmYeHh/OvKIPBAEBgYKD8j1IAqZeCSb0UTOqlYFIvBbuWejGZTEVaFpmsJYQQQriRJGIhhBDCjSQRu5HRaGT8+PEYjUZ3F6VEkXopmNRLwaReCib1UrCSWC8yWUsIIYRwI2kRCyGEEG4kiVgIIYRwI0nEQgghhBtJIhZCCCHcSBKxm0yfPp3atWvj6+tL48aNWblypbuLdMVWrFhB9+7dCQsLw2AwsHDhQpfnlVLExMQQFhaGn58fbdq0YevWrS4xWVlZDB8+nODgYPz9/enRowcHDhxwiUlNTWXgwIGYTCZMJhMDBw4kLS3NJWbfvn10794df39/goODGTFiBNnZ2S4xycnJREZG4ufnR7Vq1XjllVeKdJ9YgAkTJnD33XcTEBBAlSpV6NmzJzt27HCJKYv18uGHH9KgQQPn5gktWrTgp59+KtN1UpAJEyZgMBgYOXKk81pZrJuYmBgMBoPLV2hoaOmvEyWKXWxsrPL29laffPKJ2rZtm3r66aeVv7+/2rt3r7uLdkUWL16snn/+eTVv3jwFqAULFrg8P3HiRBUQEKDmzZunkpOTVb9+/VTVqlVVRkaGM2bo0KGqWrVqKj4+Xm3cuFG1bdtWNWzYUNntdmdM586dVUREhFq9erVavXq1ioiIUN26dXM+b7fbVUREhGrbtq3auHGjio+PV2FhYWrYsGHOmPT0dBUSEqIeeOABlZycrObNm6cCAgLU5MmTi7ROOnXqpGbMmKG2bNmikpKSVNeuXVWNGjXU6dOny3S9LFq0SP34449qx44daseOHWrcuHHK29tbbdmypczWycXWrVunatWqpRo0aKCefvpp5/WyWDfjx49Xd9xxhzp8+LDz6+jRo6W+TiQRu0HTpk3V0KFDXa7Vq1dPPffcc24qUeFdnIgdDocKDQ1VEydOdF7LzMxUJpNJffTRR0oppdLS0pS3t7eKjY11xhw8eFB5eHioJUuWKKWU2rZtmwLUmjVrnDEJCQkKUNu3b1dK6T8IPDw81MGDB50xVqtVGY1GlZ6erpRSavr06cpkMqnMzExnzIQJE1RYWJhyOBxFWBOujh49qgC1fPlypZTUy4WCgoLUp59+KnWilDp16pS6+eabVXx8vIqMjHQm4rJaN+PHj1cNGzYs8LnSXCfSNV3MsrOzSUxMpGPHji7XO3bsyOrVq91UqqKze/duUlJSXO7PaDQSGRnpvL/ExERsNptLTFhYGBEREc6YhIQETCYTzZo1c8Y0b94ck8nkEhMREUFYWJgzplOnTmRlZZGYmOiMiYyMdFm836lTJw4dOsSePXuKvgLOS09PB6BixYqA1AtATk4OsbGxnDlzhhYtWkidAE899RRdu3alQ4cOLtfLct38/fffhIWFUbt2bR544AF27dpV6utEEnExO378ODk5OYSEhLhcDwkJISUlxU2lKjq593C5+0tJScHHx4egoKDLxlSpUiXf+1epUsUl5uLPCQoKwsfH57IxuY+vV30rpRg1ahT33nsvERERLp9VFuslOTmZ8uXLYzQaGTp0KAsWLOD2228v03UCEBsbS2JiIhMmTMj3XFmtm2bNmjFr1ix+/vlnPvnkE1JSUmjZsiUnTpwo1XUipy+5Se7JS7mUUvmu3cgKc38XxxQUXxQx6vxkiutV38OGDWPz5s2sWrUq33NlsV5uvfVWkpKSSEtLY968eQwaNIjly5dfthylvU7279/P008/TVxcHL6+vpeMK2t1c9999zl/rl+/Pi1atKBOnTp88cUXNG/e/JLluNHrRFrExSw4OBhPT898fzEdPXo0319XN6LcGY6Xu7/Q0FCys7NJTU29bMyRI0fyvf+xY8dcYi7+nNTUVGw222Vjjh49CuT/y7ooDB8+nEWLFvHbb7+5HBpeluvFx8eHunXr0qRJEyZMmEDDhg157733ynSdJCYmcvToURo3boyXlxdeXl4sX76c999/Hy8vr0u2rMpC3VzI39+f+vXr8/fff5fq3xdJxMXMx8eHxo0bEx8f73I9Pj6eli1buqlURad27dqEhoa63F92djbLly933l/jxo3x9vZ2iTl8+DBbtmxxxrRo0YL09HTWrVvnjFm7di3p6ekuMVu2bOHw4cPOmLi4OIxGI40bN3bGrFixwmXZQVxcHGFhYdSqVavI7lspxbBhw5g/fz6//vortWvXdnm+rNZLQZRSZGVllek6ad++PcnJySQlJTm/mjRpwoABA0hKSuKmm24qs3VzoaysLP7880+qVq1aun9frmpqlygSucuXPvvsM7Vt2zY1cuRI5e/vr/bs2ePuol2RU6dOqU2bNqlNmzYpQE2ZMkVt2rTJufxq4sSJymQyqfnz56vk5GQVHR1d4BKD8PBwtXTpUrVx40bVrl27ApcYNGjQQCUkJKiEhARVv379ApcYtG/fXm3cuFEtXbpUhYeHuywxSEtLUyEhISo6OlolJyer+fPnq8DAwCJfdvHEE08ok8mkli1b5rL04uzZs86YslgvY8eOVStWrFC7d+9WmzdvVuPGjVMeHh4qLi6uzNbJpVw4a1qpslk3o0ePVsuWLVO7du1Sa9asUd26dVMBAQHOfxtLa51IInaTDz74QNWsWVP5+Piou+66y7nM5Ubw22+/KSDf16BBg5RSepnB+PHjVWhoqDIajap169YqOTnZ5T3OnTunhg0bpipWrKj8/PxUt27d1L59+1xiTpw4oQYMGKACAgJUQECAGjBggEpNTXWJ2bt3r+ratavy8/NTFStWVMOGDXNZTqCUUps3b1atWrVSRqNRhYaGqpiYmCJfjlJQfQBqxowZzpiyWC8PP/yw8/e8cuXKqn379s4kXFbr5FIuTsRlsW5y1wV7e3ursLAw1atXL7V169ZSXydyDKIQQgjhRjJGLIQQQriRJGIhhBDCjSQRCyGEEG4kiVgIIYRwI0nEQgghhBtJIhZCCCHcSBKxEEII4UaSiIUQbtemTRtGjhzp7mII4RaSiIW4ARkMhst+DR48uFjK0b1793xn6eZKSEjAYDCwcePGYimLEDcqOQZRiBvQhZvRz5kzh5deeokdO3Y4r/n5+bnE22w2vL29i7wcQ4YMoVevXuzdu5eaNWu6PPf555/TqFEj7rrrriL/XCFKE2kRC3EDCg0NdX6ZTCYMBoPzcWZmJhUqVOCbb76hTZs2+Pr68tVXXxETE0OjRo1c3ufdd9/Nd1LMjBkzuO222/D19aVevXpMnz79kuXo1q0bVapUYebMmS7Xz549y5w5cxgyZAgnTpwgOjqa8PBwypUrR/369bFarZe9P4PBwMKFC12uVahQweVzDh48SL9+/QgKCqJSpUqYzWb27NnjfH7ZsmU0bdoUf39/KlSowD333MPevXsv+7lCuIMkYiFKqWeffZYRI0bw559/0qlTpyt6zSeffMLzzz/P66+/zp9//skbb7zBiy++yBdffFFgvJeXFxaLhZkzZ3LhtvXffvst2dnZDBgwgMzMTBo3bswPP/zAli1beOyxxxg4cCBr164t9L2dPXuWtm3bUr58eVasWMGqVasoX748nTt3Jjs7G7vdTs+ePYmMjGTz5s0kJCTw2GOPFekh9kIUFemaFqKUGjlyJL169bqq17z66qu8/fbbztfVrl2bbdu28b///Y9BgwYV+JqHH36Yt956i2XLltG2bVtAd0v36tWLoKAggoKCeOaZZ5zxw4cPZ8mSJXz77bc0a9asUPcWGxuLh4cHn376qTO5zpgxgwoVKrBs2TKaNGlCeno63bp1o06dOgDcdttthfosIa43ScRClFJNmjS5qvhjx46xf/9+hgwZwqOPPuq8brfbMZlMl3xdvXr1aNmyJZ9//jlt27Zl586drFy5kri4OABycnKYOHEic+bM4eDBg2RlZZGVlYW/v3/hbgxITEzkn3/+ISAgwOV6ZmYmO3fupGPHjgwePJhOnToRFRVFhw4d6Nu3L1WrVi30ZwpxvUgiFqKUujjReXh4cPGppzabzfmzw+EAdPf0xS1VT0/Py37WkCFDGDZsGB988AEzZsygZs2atG/fHoC3336bd955h3fffZf69evj7+/PyJEjyc7OvuT7GQyGfy1r48aNmT17dr7XVq5cGdAt5BEjRrBkyRLmzJnDCy+8QHx8PM2bN7/svQhR3CQRC1FGVK5cmZSUFJRSzu7cpKQk5/MhISFUq1aNXbt2MWDAgKt67759+/L000/z9ddf88UXX/Doo486P2PlypWYzWYefPBBQCfRv//++7JdxZUrV3aZGf73339z9uxZ5+O77rqLOXPmUKVKFQIDAy/5PnfeeSd33nknY8eOpUWLFnz99deSiEWJI5O1hCgj2rRpw7Fjx5g0aRI7d+7kgw8+4KeffnKJiYmJYcKECbz33nv89ddfJCcnM2PGDKZMmXLZ9y5fvjz9+vVj3LhxHDp0yGUdc926dYmPj2f16tX8+eefPP7446SkpFz2/dq1a8e0adPYuHEjGzZsYOjQoS7LrwYMGEBwcDBms5mVK1eye/duli9fztNPP82BAwfYvXs3Y8eOJSEhgb179xIXF8dff/0l48SiRJJELEQZcdtttzF9+nQ++OADGjZsyLp161wmUQE88sgjfPrpp8ycOZP69esTGRnJzJkzqV279r++/5AhQ0hNTaVDhw7UqFHDef3FF1/krrvuolOnTrRp04bQ0FB69ux52fd6++23qV69Oq1bt6Z///4888wzlCtXzvl8uXLlWLFiBTVq1KBXr17cdtttPPzww5w7d47AwEDKlSvH9u3buf/++7nlllt47LHHGDZsGI8//vjVVZoQxcCgLh6IEUIIIUSxkRaxEEII4UaSiIUQQgg3kkQshBBCuJEkYiGEEMKNJBELIYQQbiSJWAghhHAjScRCCCGEG0kiFkIIIdxIErEQQgjhRpKIhRBCCDeSRCyEEEK4kSRiIYQQwo3+HzJHT6NGRF1rAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "y_pred2 =sm.predict_values(np.asarray(X_test))\n", - "y_pred2[y_pred2<0]=0\n", - "\n", - "print(\"r2_score = \", r2_score(y_test, y_pred2))\n", - "\n", - "plt.scatter(y_test, y_pred2, s=30, facecolors='none', edgecolors='r')\n", - "plt.xlabel('True Values')\n", - "plt.ylabel('Predictions')\n", - "plt.title('Initial_stiffness')\n", - "plt.axis('equal')\n", - "plt.axis('square')\n", - "plt.grid()\n", - "_ = plt.plot([-500000, 500000], [-500000, 500000],'b')" - ] - }, { "cell_type": "markdown", "metadata": { @@ -1594,7 +1254,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 482, "metadata": { "id": "Pq98b6w6mu4J", "outputId": "fcf8d847-9d9f-4533-f85a-ab2691cee161" @@ -1627,9 +1287,38 @@ "Internal optimization succeeded at EGO iter = 15.0\n", "Internal optimization succeeded at EGO iter = 16.0\n", "Internal optimization succeeded at EGO iter = 17.0\n", - "Internal optimization succeeded at EGO iter = 18.0\n", - "Internal optimization succeeded at EGO iter = 19.0\n", - "[ 2. 0. 0. -5.] [-15.]\n" + "Internal optimization succeeded at EGO iter = 18.0\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_2090/1613752696.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 54\u001b[0m )\n\u001b[1;32m 55\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mx_opt\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my_opt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mego\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunction_test_mixed_integer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 58\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_opt\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my_opt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/smt/smt/applications/ego.py\u001b[0m in \u001b[0;36moptimize\u001b[0;34m(self, fun)\u001b[0m\n\u001b[1;32m 145\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mp\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_parallel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 146\u001b[0m \u001b[0;31m# find next best x-coord point to evaluate\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 147\u001b[0;31m x_et_k, success = self._find_best_point(\n\u001b[0m\u001b[1;32m 148\u001b[0m \u001b[0mx_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"enable_tunneling\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 149\u001b[0m )\n", + "\u001b[0;32m~/smt/smt/applications/ego.py\u001b[0m in \u001b[0;36m_find_best_point\u001b[0;34m(self, x_data, y_data, enable_tunneling)\u001b[0m\n\u001b[1;32m 361\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 362\u001b[0m opt_all.append(\n\u001b[0;32m--> 363\u001b[0;31m minimize(\n\u001b[0m\u001b[1;32m 364\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj_k\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 365\u001b[0m \u001b[0mx_start\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mii\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/lib/python3.8/site-packages/scipy/optimize/_minimize.py\u001b[0m in \u001b[0;36mminimize\u001b[0;34m(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options)\u001b[0m\n\u001b[1;32m 703\u001b[0m **options)\n\u001b[1;32m 704\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mmeth\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'slsqp'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 705\u001b[0;31m res = _minimize_slsqp(fun, x0, args, jac, bounds,\n\u001b[0m\u001b[1;32m 706\u001b[0m constraints, callback=callback, **options)\n\u001b[1;32m 707\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mmeth\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'trust-constr'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/lib/python3.8/site-packages/scipy/optimize/_slsqp_py.py\u001b[0m in \u001b[0;36m_minimize_slsqp\u001b[0;34m(func, x0, args, jac, bounds, constraints, maxiter, ftol, iprint, disp, eps, callback, finite_diff_rel_step, **unknown_options)\u001b[0m\n\u001b[1;32m 372\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 373\u001b[0m \u001b[0;31m# ScalarFunction provides function and gradient evaluation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 374\u001b[0;31m sf = _prepare_scalar_function(func, x, jac=jac, args=args, epsilon=eps,\n\u001b[0m\u001b[1;32m 375\u001b[0m \u001b[0mfinite_diff_rel_step\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfinite_diff_rel_step\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 376\u001b[0m bounds=new_bounds)\n", + "\u001b[0;32m~/miniconda3/lib/python3.8/site-packages/scipy/optimize/_optimize.py\u001b[0m in \u001b[0;36m_prepare_scalar_function\u001b[0;34m(fun, x0, jac, args, bounds, epsilon, finite_diff_rel_step, hess)\u001b[0m\n\u001b[1;32m 330\u001b[0m \u001b[0;31m# ScalarFunction caches. Reuse of fun(x) during grad\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 331\u001b[0m \u001b[0;31m# calculation reduces overall function evaluations.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 332\u001b[0;31m sf = ScalarFunction(fun, x0, args, grad, hess,\n\u001b[0m\u001b[1;32m 333\u001b[0m finite_diff_rel_step, bounds, epsilon=epsilon)\n\u001b[1;32m 334\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/lib/python3.8/site-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, fun, x0, args, grad, hess, finite_diff_rel_step, finite_diff_bounds, epsilon)\u001b[0m\n\u001b[1;32m 175\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_grad_impl\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mupdate_grad\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 177\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 178\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 179\u001b[0m \u001b[0;31m# Hessian Evaluation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/lib/python3.8/site-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36m_update_grad\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 254\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_update_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 255\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mg_updated\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 256\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_grad_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 257\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mg_updated\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 258\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/lib/python3.8/site-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36mupdate_grad\u001b[0;34m()\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_fun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 172\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mngev\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 173\u001b[0;31m self.g = approx_derivative(fun_wrapped, self.x, f0=self.f,\n\u001b[0m\u001b[1;32m 174\u001b[0m **finite_diff_options)\n\u001b[1;32m 175\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/lib/python3.8/site-packages/scipy/optimize/_numdiff.py\u001b[0m in \u001b[0;36mapprox_derivative\u001b[0;34m(fun, x0, method, rel_step, abs_step, f0, bounds, sparsity, as_linear_operator, args, kwargs)\u001b[0m\n\u001b[1;32m 503\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 504\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0msparsity\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 505\u001b[0;31m return _dense_difference(fun_wrapped, x0, f0, h,\n\u001b[0m\u001b[1;32m 506\u001b[0m use_one_sided, method)\n\u001b[1;32m 507\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/lib/python3.8/site-packages/scipy/optimize/_numdiff.py\u001b[0m in \u001b[0;36m_dense_difference\u001b[0;34m(fun, x0, f0, h, use_one_sided, method)\u001b[0m\n\u001b[1;32m 574\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx0\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mh_vecs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 575\u001b[0m \u001b[0mdx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mx0\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# Recompute dx as exactly representable number.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 576\u001b[0;31m \u001b[0mdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mf0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 577\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'3-point'\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0muse_one_sided\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 578\u001b[0m \u001b[0mx1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx0\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mh_vecs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/lib/python3.8/site-packages/scipy/optimize/_numdiff.py\u001b[0m in \u001b[0;36mfun_wrapped\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 454\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 455\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfun_wrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 456\u001b[0;31m \u001b[0mf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0matleast_1d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 457\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 458\u001b[0m raise RuntimeError(\"`fun` return value has \"\n", + "\u001b[0;32m~/miniconda3/lib/python3.8/site-packages/scipy/optimize/_differentiable_functions.py\u001b[0m in \u001b[0;36mfun_wrapped\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 135\u001b[0m \u001b[0;31m# Overwriting results in undefined behaviour because\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[0;31m# fun(self.x) will change self.x, with the two no longer linked.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 137\u001b[0;31m \u001b[0mfx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 138\u001b[0m \u001b[0;31m# Make sure the function returns a true scalar\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misscalar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/smt/smt/applications/ego.py\u001b[0m in \u001b[0;36m\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 362\u001b[0m opt_all.append(\n\u001b[1;32m 363\u001b[0m minimize(\n\u001b[0;32m--> 364\u001b[0;31m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj_k\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 365\u001b[0m \u001b[0mx_start\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mii\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 366\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/smt/smt/applications/ego.py\u001b[0m in \u001b[0;36m\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 347\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 348\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcriterion\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"EI\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 349\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj_k\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mEI\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0matleast_2d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menable_tunneling\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 350\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mcriterion\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"SBO\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 351\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj_k\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSBO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0matleast_2d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/smt/smt/applications/ego.py\u001b[0m in \u001b[0;36mEI\u001b[0;34m(self, points, enable_tunneling, x_data)\u001b[0m\n\u001b[1;32m 190\u001b[0m \u001b[0mf_min\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0my_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 191\u001b[0m \u001b[0mpred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpoints\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 192\u001b[0;31m \u001b[0msig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_variances\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpoints\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 193\u001b[0m \u001b[0margs0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mf_min\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mpred\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0msig\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 194\u001b[0m \u001b[0margs1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mf_min\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mpred\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcdf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/smt/smt/applications/mixed_integer.py\u001b[0m in \u001b[0;36mpredict_variances\u001b[0;34m(self, x, is_acting)\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mpredict_variances\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_acting\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 274\u001b[0m \u001b[0mx_corr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_acting\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_x_for_surrogate_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 275\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_surrogate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_variances\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_corr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_acting\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mis_acting\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 276\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 277\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mpredict_variances_all_levels\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_acting\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/smt/smt/surrogate_models/krg_based.py\u001b[0m in \u001b[0;36mpredict_variances\u001b[0;34m(self, x, is_acting)\u001b[0m\n\u001b[1;32m 1475\u001b[0m \u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1476\u001b[0m \u001b[0mx2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1477\u001b[0;31m \u001b[0ms2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_predict_variances\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_acting\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mis_acting\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1478\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0ms2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mny\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1479\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/smt/smt/surrogate_models/krg_based.py\u001b[0m in \u001b[0;36m_predict_variances\u001b[0;34m(self, x, is_acting)\u001b[0m\n\u001b[1;32m 1499\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mij\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcross_distances\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1500\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_continuous\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1501\u001b[0;31m dx = gower_componentwise_distances(\n\u001b[0m\u001b[1;32m 1502\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1503\u001b[0m \u001b[0mx_is_acting\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mis_acting\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/smt/smt/utils/kriging.py\u001b[0m in \u001b[0;36mgower_componentwise_distances\u001b[0;34m(X, x_is_acting, design_space, hierarchical_kernel, y, y_is_acting)\u001b[0m\n\u001b[1;32m 319\u001b[0m \u001b[0;31m# X_cat( not(x_cat_is_acting)) = 0 ###IMPUTED TO FIRST VALUE IN LIST (index 0)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 320\u001b[0m \u001b[0mD_cat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompute_D_cat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_cat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_cat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 321\u001b[0;31m D_num, ij = compute_D_num(\n\u001b[0m\u001b[1;32m 322\u001b[0m \u001b[0mX_num\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 323\u001b[0m \u001b[0mY_num\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/smt/smt/utils/kriging.py\u001b[0m in \u001b[0;36mcompute_D_num\u001b[0;34m(X_num, Y_num, x_num_is_acting, y_num_is_acting, num_is_decreed, y, hierarchical_kernel)\u001b[0m\n\u001b[1;32m 396\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0my\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 397\u001b[0m \u001b[0ml2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mk2\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mk1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 398\u001b[0;31m \u001b[0mD_num\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindD\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_num\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mY_num\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0ml2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 399\u001b[0m \u001b[0mindD\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 400\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], @@ -1937,7 +1626,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.8.12" } }, "nbformat": 4, diff --git a/tutorial/SMT_MixedInteger_Engineering_applications.ipynb b/tutorial/SMT_MixedInteger_Engineering_applications.ipynb new file mode 100644 index 000000000..b1bd51889 --- /dev/null +++ b/tutorial/SMT_MixedInteger_Engineering_applications.ipynb @@ -0,0 +1,1443 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mDCpNW2-mu3w" + }, + "source": [ + "
\n", + " \n", + "This tutorial describes how to perform a mixed optimization using the SMT toolbox for engineering applications.\n", + "
\n", + " \n", + " May 2023 - version SMT 2.0 \n", + " \n", + " Paul Saves and Raul Carreira Rufato and Joseph Morlier" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "

Some updates

\n", + "
    - EGO applied to mixed integer problems (1D, 2D and 4D) using continuous relaxation
\n", + "
    - Manipulation of mixed integer DOE
\n", + "
    - Gower distance to build surrogate model of mixed integer functions (2D and 4D)
\n", + "
    - EGO applied to mixed integer problems (4D) using Gower distance
\n", + "
    - EGO applied to mixed integer problems using Homoscedastic or Heteroscedastic kernel
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gDeEbi7nmu32" + }, + "source": [ + "

\n", + "To use SMT models, please follow this link : https://github.com/SMTorg/SMT/blob/master/README.md. The documentation is available here: http://smt.readthedocs.io/en/latest/\n", + "

\n", + "\n", + "The reference paper is available \n", + "here https://www.sciencedirect.com/science/article/pii/S0965997818309360?via%3Dihub \n", + "\n", + "or as a preprint: http://mdolab.engin.umich.edu/content/python-surrogate-modeling-framework-derivatives" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uU32V-7bmu33" + }, + "source": [ + "For mixed integer with continuous relaxation, the reference paper is available here https://www.sciencedirect.com/science/article/pii/S0925231219315619" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "EweBFT9Ap8Ay", + "outputId": "4c016eb0-6a75-46f7-d2db-c4ff17ec284a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING: Ignoring invalid distribution -umpy (/stck/psaves/miniconda3/lib/python3.8/site-packages)\u001b[0m\u001b[33m\n", + "\u001b[0mRequirement already satisfied: ConfigSpace in /stck/psaves/miniconda3/lib/python3.8/site-packages (0.7.1)\n", + "Requirement already satisfied: numpy in /stck/psaves/miniconda3/lib/python3.8/site-packages (from ConfigSpace) (1.23.5)\n", + "Requirement already satisfied: pyparsing in /stck/psaves/miniconda3/lib/python3.8/site-packages (from ConfigSpace) (3.0.4)\n", + "Requirement already satisfied: scipy in /stck/psaves/miniconda3/lib/python3.8/site-packages (from ConfigSpace) (1.10.1)\n", + "Requirement already satisfied: typing-extensions in /stck/psaves/miniconda3/lib/python3.8/site-packages (from ConfigSpace) (4.7.1)\n", + "Requirement already satisfied: more-itertools in /stck/psaves/miniconda3/lib/python3.8/site-packages (from ConfigSpace) (9.0.0)\n", + "\u001b[33mWARNING: Ignoring invalid distribution -umpy (/stck/psaves/miniconda3/lib/python3.8/site-packages)\u001b[0m\u001b[33m\n", + "\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m22.0.4\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.3.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", + "\u001b[33mWARNING: Ignoring invalid distribution -umpy (/stck/psaves/miniconda3/lib/python3.8/site-packages)\u001b[0m\u001b[33m\n", + "\u001b[0mRequirement already satisfied: numba in /stck/psaves/miniconda3/lib/python3.8/site-packages (0.58.1)\n", + "Requirement already satisfied: llvmlite<0.42,>=0.41.0dev0 in /stck/psaves/miniconda3/lib/python3.8/site-packages (from numba) (0.41.1)\n", + "Requirement already satisfied: numpy<1.27,>=1.22 in /stck/psaves/miniconda3/lib/python3.8/site-packages (from numba) (1.23.5)\n", + "Requirement already satisfied: importlib-metadata in /stck/psaves/miniconda3/lib/python3.8/site-packages (from numba) (4.13.0)\n", + "Requirement already satisfied: zipp>=0.5 in /stck/psaves/miniconda3/lib/python3.8/site-packages (from importlib-metadata->numba) (3.16.2)\n", + "\u001b[33mWARNING: Ignoring invalid distribution -umpy (/stck/psaves/miniconda3/lib/python3.8/site-packages)\u001b[0m\u001b[33m\n", + "\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m22.0.4\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.3.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", + "\u001b[33mWARNING: Ignoring invalid distribution -umpy (/stck/psaves/miniconda3/lib/python3.8/site-packages)\u001b[0m\u001b[33m\n", + "\u001b[0mRequirement already satisfied: smt in /stck/psaves/miniconda3/lib/python3.8/site-packages (2.0)\n", + "Requirement already satisfied: scikit-learn in /stck/psaves/miniconda3/lib/python3.8/site-packages (from smt) (1.0.2)\n", + "Requirement already satisfied: pyDOE2 in /stck/psaves/miniconda3/lib/python3.8/site-packages (from smt) (1.3.0)\n", + "Requirement already satisfied: scipy in /stck/psaves/miniconda3/lib/python3.8/site-packages (from smt) (1.10.1)\n", + "Requirement already satisfied: numpy in /stck/psaves/miniconda3/lib/python3.8/site-packages (from pyDOE2->smt) (1.23.5)\n", + "Requirement already satisfied: joblib>=0.11 in /stck/psaves/miniconda3/lib/python3.8/site-packages (from scikit-learn->smt) (1.2.0)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /stck/psaves/miniconda3/lib/python3.8/site-packages (from scikit-learn->smt) (3.1.0)\n", + "\u001b[33mWARNING: Ignoring invalid distribution -umpy (/stck/psaves/miniconda3/lib/python3.8/site-packages)\u001b[0m\u001b[33m\n", + "\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m22.0.4\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.3.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n" + ] + } + ], + "source": [ + "#to install smt\n", + "!pip install ConfigSpace\n", + "!pip install numba\n", + "!pip install smt\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "-Y8Vi-hsmu35" + }, + "outputs": [], + "source": [ + "%matplotlib inline \n", + "\n", + "from math import exp\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import colors\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "from scipy.stats import norm\n", + "from scipy.optimize import minimize\n", + "import scipy\n", + "import six\n", + "from smt.applications import EGO\n", + "from smt.surrogate_models import KRG\n", + "from smt.sampling_methods import FullFactorial\n", + "from smt.sampling_methods import LHS\n", + "from sklearn import gaussian_process\n", + "from sklearn.gaussian_process.kernels import Matern, WhiteKernel, ConstantKernel\n", + "import matplotlib.font_manager\n", + "# Import necessary libraries\n", + "import pandas as pd\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.neural_network import MLPRegressor\n", + "from sklearn.metrics import r2_score\n", + "from sklearn.preprocessing import LabelEncoder, StandardScaler\n", + "\n", + "from smt.surrogate_models import MixIntKernelType\n", + "from smt.applications.mixed_integer import MixedIntegerKrigingModel, MixedIntegerSurrogateModel\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import r2_score\n", + "from scipy.optimize import curve_fit\n", + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "#to ignore warning messages\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "from smt.applications.mixed_integer import MixedIntegerSamplingMethod\n", + "\n", + "\n", + "from smt.utils.design_space import (\n", + " DesignSpace,\n", + " FloatVariable,\n", + " IntegerVariable,\n", + " OrdinalVariable,\n", + " CategoricalVariable,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "haRq-u4bmu37" + }, + "source": [ + "Definition of the plot function " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SfVsrEH0nolz" + }, + "source": [ + "# Modeling a 4D structural problem" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8BHCEbw3nwQ9" + }, + "source": [ + "__Background__: Hybrid composite problem involves the integration of different types of composite materials in a structural or functional application. Composites are materials made from two or more distinct constituents with different properties, combined to achieve enhanced performance. In a hybrid composite problem, the challenge lies in optimizing the combination of materials, such as fiber-reinforced polymers, metal matrix composites, or ceramic matrix composites, to achieve specific desired characteristics, such as strength, weight reduction, or thermal resistance. \n", + "\n", + "\n", + "The database is available at https://www.sciencedirect.com/science/article/abs/pii/S1359835X11000224\n", + "\n", + "The aim is to build a surrogate model for mixed variables in a hybrid composite problem. The trained surrogate model is able to predict the composites characteristics. \n", + "This is a tutorial for the following paper: A mixed-categorical data-driven approach for prediction and\n", + "optimization of hybrid discontinuous composites performance. \n", + "\n", + "The function inputs are:\n", + "\n", + "\n", + "\n", + "> 4 continuous variables **[lf Vc SmAvg G GiicmAvg]**\n", + "\n", + "\n", + "> 2 categorical variables **[Carbon fibres Glass Fibres]** with 16 levels.\n", + "\n", + "\n", + "The possible outputs are **[Initial_stiffness\tUltimate_strain\tPseudo_ductile_strain\tUltimate_strength\tYield_strength]**\n", + "\n", + "In this example, only the most influent continuous inputs are being used (**lf** and **Vc**), and the predicted variable is the **Initial Stiffness**\n", + "\n", + "**lf:** length of the fibre. \n", + "\n", + "**Vc:** Percentage of carbon fibre in the mixture. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "6UlDaf1S65MH" + }, + "outputs": [], + "source": [ + "plt.rcParams.update({'legend.labelspacing':1.0})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "xq3a-3gyC-v_" + }, + "outputs": [], + "source": [ + "try :\n", + " from pydrive.auth import GoogleAuth\n", + " from pydrive.drive import GoogleDrive\n", + " from google.colab import auth\n", + " from oauth2client.client import GoogleCredentials\n", + "\n", + " # 1. Authenticate and create the PyDrive client.\n", + " auth.authenticate_user()\n", + " gauth = GoogleAuth()\n", + " gauth.credentials = GoogleCredentials.get_application_default()\n", + " drive = GoogleDrive(gauth)\n", + " json_import = drive.CreateFile({'id':'1fcB39mktJ2npTNqrF8dgZa7PWh3wU55X'})\n", + " json_import.GetContentFile('VTF_properties.json')\n", + " df = pd.read_csv(open('VTF_properties.json'))\n", + "except :\n", + " df = pd.read_csv(open('composite_material.csv'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 270 + }, + "id": "Jj2kyCk97HAq", + "outputId": "43fa3b18-3ed2-479f-e2dd-e16f0b6d3ef0" + }, + "outputs": [], + "source": [ + "df = df.dropna()\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1r6uCxjML51v" + }, + "outputs": [], + "source": [ + "data = df.sample(n=1000,random_state = 10)\n", + "data.Carbon_fibre = pd.Categorical(data.Carbon_fibre)\n", + "data['Carbon_fibre'] = data.Carbon_fibre.cat.codes \n", + "data.Glass_fibre = pd.Categorical(data.Glass_fibre)\n", + "data['Glass_fibre'] = data.Glass_fibre.cat.codes \n", + "Xd = data.drop(['SmAvg','G','GiicmAvg','Initial_stiffness','Ultimate_strain','Pseudo_ductile_strain','Ultimate_strength',\n", + " 'Yield_strength'],axis = 1)\n", + "\n", + "yd = data.Initial_stiffness\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(Xd, yd, test_size = 0.25, random_state = 42)\n", + "X = np.asarray(X_train)\n", + "y = np.asarray(y_train).astype(float)\n", + "\n", + "#to define the variables\n", + "design_space = DesignSpace ([\n", + " CategoricalVariable (['XN-90', 'P120J', 'T1000GB', 'C124', 'T800H', 'M60JB', 'C320',\n", + " 'M40B', 'P75S', 'K13D', 'T300', 'XN-05', 'FliteStrand_S_ZT',\n", + " 'HTA5131', 'GF', 'C100']), #16 choices\n", + " CategoricalVariable (['GF', 'XN-05', 'FliteStrand_S_ZT', 'C124', 'T300', 'T800H', 'C320',\n", + " 'P75S', 'C100', 'XN-90', 'HTA5131', 'T1000GB', 'P120J', 'M40B',\n", + " 'M60JB']), #15 choices\n", + " FloatVariable (501.5425023,11999.96175),\n", + " FloatVariable (2.849e-05,1.0),\n", + "])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "D6Psera9Oaeg" + }, + "outputs": [], + "source": [ + "sm=KRG(design_space = design_space, print_global=False, categorical_kernel=MixIntKernelType.GOWER)\n", + "sm.set_training_values(X, y)\n", + "sm.train()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 503 + }, + "id": "FJKbqByvxLqf", + "outputId": "5af35de1-3cfc-418b-e8ce-1e593d2a3734" + }, + "outputs": [], + "source": [ + "y_pred2 =sm.predict_values(np.asarray(X_test))\n", + "y_pred2[y_pred2<0]=0\n", + "\n", + "print(\"r2_score = \", r2_score(y_test, y_pred2))\n", + "\n", + "plt.scatter(y_test, y_pred2, s=30, facecolors='none', edgecolors='r')\n", + "plt.xlabel('True Values')\n", + "plt.ylabel('Predictions')\n", + "plt.title('Initial_stiffness')\n", + "plt.axis('equal')\n", + "plt.axis('square')\n", + "plt.grid()\n", + "_ = plt.plot([-500000, 500000], [-500000, 500000],'b')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Modeling a complex system" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SfVsrEH0nolz" + }, + "source": [ + "__Background__: Lithium-ion batteries are commonly used for portable electronics, electric vehicles, and aerospace applications. During discharge, Lithium ions move from the negative electrode through an electrolyte to the positive electrode to create a voltage and current. During recharging, the ions migrate back to the negative electrode. The crystal structure (monoclinic, orthorhombic, triclinic) is available for 339 different chemicals that contain Li-ion.\n", + "\n", + "The database is available at [Lithium-ion Chemical Properties and Crystal Structure Data](https://apmonitor.com/pds/uploads/Main/lithium_ion.txt)\n", + "\n", + "\n", + "__Objective__: Predict the crystal structure type (monoclinic, orthorhombic, triclinic) from Lithium-ion physical and chemical compound information.\n", + "\n", + "This tutorial covers the following:\n", + "- Categorical transformation techniques\n", + "- Feature creation\n", + "- Feature selection\n", + "\n", + "\n", + "The function inputs are:\n", + "\n", + "> 5 continuous variables **[Formation Energy (eV) \tE Above Hull (eV) \tBand Gap (eV) \tNsites \tDensity (gm/cc) \tVolume]**\n", + "\n", + "> 1 ordinal variable **[Nsites]**\n", + "\n", + "> 4 categorical variables **[Materials Id \tFormula \tSpacegroup \tHas Bandstructure]** with respectively: 339, 114 and 44 levels.\n", + "\n", + "\n", + "The relaxed dimension by one-hot-encoding is 503\n", + "# => REALLY HIGH CATEGORICAL DIMENSION" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Materials IdFormulaSpacegroupFormation Energy (eV)E Above Hull (eV)Band Gap (eV)NsitesDensity (gm/cc)VolumeHas BandstructureCrystal System
0mp-849394Li2MnSiO4Pc-2.6990.0063.462162.993178.513Truemonoclinic
1mp-783909Li2MnSiO4P21/c-2.6960.0082.879322.926365.272Truemonoclinic
2mp-761311Li4MnSi2O7Cc-2.7750.0123.653282.761301.775Truemonoclinic
3mp-761598Li4Mn2Si3O10C2/c-2.7830.0133.015382.908436.183Truemonoclinic
4mp-767709Li2Mn3Si3O10C2/c-2.7470.0162.578363.334421.286Truemonoclinic
\n", + "
" + ], + "text/plain": [ + " Materials Id Formula Spacegroup Formation Energy (eV) \\\n", + "0 mp-849394 Li2MnSiO4 Pc -2.699 \n", + "1 mp-783909 Li2MnSiO4 P21/c -2.696 \n", + "2 mp-761311 Li4MnSi2O7 Cc -2.775 \n", + "3 mp-761598 Li4Mn2Si3O10 C2/c -2.783 \n", + "4 mp-767709 Li2Mn3Si3O10 C2/c -2.747 \n", + "\n", + " E Above Hull (eV) Band Gap (eV) Nsites Density (gm/cc) Volume \\\n", + "0 0.006 3.462 16 2.993 178.513 \n", + "1 0.008 2.879 32 2.926 365.272 \n", + "2 0.012 3.653 28 2.761 301.775 \n", + "3 0.013 3.015 38 2.908 436.183 \n", + "4 0.016 2.578 36 3.334 421.286 \n", + "\n", + " Has Bandstructure Crystal System \n", + "0 True monoclinic \n", + "1 True monoclinic \n", + "2 True monoclinic \n", + "3 True monoclinic \n", + "4 True monoclinic " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "try:\n", + " import chemparse\n", + " import smt\n", + "except:\n", + " !pip install chemparse\n", + " print('May need to restart kernel to use chemparse')\n", + "# Import libraries and data\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "from sklearn.preprocessing import LabelEncoder, MinMaxScaler\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.feature_extraction import FeatureHasher\n", + "from sklearn.metrics import confusion_matrix,plot_confusion_matrix\n", + "\n", + "from sklearn.datasets import make_circles, make_classification, make_moons\n", + "from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n", + "from sklearn.ensemble import AdaBoostClassifier, RandomForestClassifier\n", + "from sklearn.gaussian_process import GaussianProcessClassifier\n", + "from sklearn.gaussian_process.kernels import RBF\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.naive_bayes import GaussianNB\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.neural_network import MLPClassifier\n", + "from sklearn.pipeline import make_pipeline\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.svm import SVC\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "\n", + "from smt.utils.design_space import FloatVariable, IntegerVariable, OrdinalVariable,CategoricalVariable\n", + "import pandas as pd \n", + "import numpy as np\n", + "from smt.applications.mixed_integer import (\n", + " MixedIntegerContext,\n", + " MixedIntegerSamplingMethod,\n", + " MixedIntegerKrigingModel\n", + ")\n", + "from smt.surrogate_models import (\n", + " KRG,\n", + " GEKPLS,\n", + " KPLS,\n", + " QP,\n", + " MixIntKernelType,\n", + " MixHrcKernelType,\n", + ")\n", + "# Load and display data\n", + "url = 'http://apmonitor.com/pds/uploads/Main/lithium_ion.txt'\n", + "data = pd.read_csv(url)\n", + "datatype = data.dtypes\n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "indy = 10 #Crystal\n", + "design_space_battery = []\n", + "catlists=[]\n", + "for indi,i in enumerate(datatype) : \n", + " if indi != 8 :\n", + " if i == \"object\" or i == \"bool\" : \n", + " ilist =list(np.unique(np.array(data[data.columns[indi]]))) \n", + " if i == \"object\" : \n", + " catlists.append(ilist)\n", + " design_space_battery.append(CategoricalVariable(ilist))\n", + " elif i == \"int64\" : \n", + " ilist =list(np.unique(np.array(data[data.columns[indi]]))) \n", + " design_space_battery.append(IntegerVariable(min(ilist),max(ilist)))\n", + " elif i == \"float64\" : \n", + " ilist =list(np.unique(np.array(data[data.columns[indi]]))) \n", + " design_space_battery.append(FloatVariable(min(ilist)-1e-9,max(ilist)+1e-9))\n", + "\n", + "Training_data=data.sample(int(339*0.3),random_state=42)\n", + "Val_data = pd.concat([data,Training_data]).drop_duplicates(keep=False)\n", + "index_train = np.array(list(enumerate(Training_data.T))).T[1]\n", + "index_val = np.array(list(enumerate(Val_data.T))).T[1]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Separate into numerical features that don't need preprocessing, and categorical features that need to be transformed\n", + "num_feat = data.select_dtypes(include=['int64','float64']).columns\n", + "cat_feat = data.select_dtypes(include=['object','bool']).columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Count elements to transform data to ordinal values\n", + "ord_feat = ['Formation Energy (eV)','E Above Hull (eV)','Band Gap (eV)',\n", + " 'Nsites','Density (gm/cc)','Volume','Has Bandstructure',\n", + " 'Spacegroup (ordinal)','Formula (#)' ]\n", + "\n", + "hash_feat = ['Formation Energy (eV)','E Above Hull (eV)','Band Gap (eV)',\n", + " 'Nsites','Density (gm/cc)','Volume','Has Bandstructure',\n", + " 'Spacegroup0','Spacegroup1','Spacegroup2',\n", + " 'Formula (#)'\n", + " ]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## USING A RANDOM FOREST CLASSIFIER\n", + "\n", + "#### 1. Original Numerical features only\n", + "Method: Ignore categorical variables and treat only the continuous ones.\n", + "\n", + "Pros: Simple and quick. We can use directly the continuous models\n", + "\n", + "Cons: Lose a lot of information. \n", + "\n", + "#### 2. Encode to ordinal variables\n", + "Method: assign each unique value to a unique number. The categorical variables representative of molecules are separated by atom types to help.\n", + "\n", + "Example: Spacegroup = Pc is assigned to 0, Spacegroup = P21/c is assigned to 1, etc. \n", + "\n", + "Pros: simple and quick, 1 column in -> 1 column out\n", + "\n", + "Cons: residual \"structure\" (number assigned is arbitrary, and it leads algorithms to assume that a Spacegroup with a value of 20 is higher value than a Spacegroup of value 1)\n", + "\n", + "#### 3. Feature Hashing\n", + "Method: Encode each unique category into a non-binary vector. The categorical variables representative of molecules are separated by atom types to help.\n", + "\n", + "Example: Spacegroup = Pc is assigned to [1,0,0], Spacegroup = P21/c is assigned to [1,2,-1], etc. Specify number of columns (length of vector)\n", + "\n", + "Pros: low dimensionality so really efficient.\n", + "\n", + "Cons: potential collisions (for example the 1st value in example has both Spacegroups sharing a '1'); hashed features aren't interpretable so can't be used in feature importance. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Save new features in dataframe\n", + "data.to_csv('lithium_ion_data.csv',index=False)\n", + "\n", + "# Option 2: Ordinal number encoding\n", + "data['Spacegroup (ordinal)'] = pd.factorize(data['Spacegroup'])[0]\n", + "\n", + "# Can also order by most common to least common\n", + "data['Spacegroup'].rank(method=\"dense\").astype(int)\n", + "\n", + "# Option 2: Ordinal number encoding\n", + "data['Formula (#)'] = pd.factorize(data['Formula'])[0]\n", + "\n", + "\n", + "\n", + "# Option 3: Feature Hashing\n", + "n = 3\n", + "fh = FeatureHasher(n_features=n, input_type='string')\n", + "hashed_tag = fh.fit_transform(data['Spacegroup']).toarray()\n", + "ht_df = pd.DataFrame(hashed_tag)\n", + "ht_df.columns = ['Spacegroup'+str(i) for i in range(n)]\n", + "\n", + "data = data.join(ht_df)\n", + "# Encode Crystal System to ordinal values for multi-class problem\n", + "labelencoder = LabelEncoder() #initializing an object of class LabelEncoder\n", + "data['Crystal System (#)'] = labelencoder.fit_transform(data['Crystal System']) \n", + "\n", + "\n", + "# For a multi-label problem, use one-hot encoding\n", + "data[['monoclinic','orthorhombic','triclinic']] = pd.get_dummies(data['Crystal System'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# All new numerical features (Crystal System excluded, since it's int32)\n", + "features = list(data.select_dtypes(include=['int64','float64']).columns.values)\n", + "\n", + "ord_feat = ['Formation Energy (eV)','E Above Hull (eV)','Band Gap (eV)',\n", + " 'Nsites','Density (gm/cc)','Volume','Has Bandstructure',\n", + " 'Spacegroup (ordinal)','Formula (#)'\n", + " ]\n", + "\n", + "hash_feat = ['Formation Energy (eV)','E Above Hull (eV)','Band Gap (eV)',\n", + " 'Nsites','Density (gm/cc)','Volume','Has Bandstructure',\n", + " 'Spacegroup0','Spacegroup1','Spacegroup2',\n", + " 'Formula (#)'\n", + " ]\n", + "\n", + "labels = ['Crystal System (#)']\n", + "\n", + "plt.figure(figsize=(16,5))\n", + "\n", + "titles = ['Original Numerical Features Only',\n", + " 'With Encoded Features\\n(Ordinal Spacegroup)',\n", + " 'With Encoded Features\\n(Hashed Spacegroup)'\n", + " ]\n", + "\n", + "for i, feat in enumerate([num_feat,ord_feat,hash_feat]):\n", + " X = data[feat]\n", + " y = data[labels]\n", + "\n", + " # 80% training data and 20% testing\n", + " Xtrain = X.iloc[list(index_train)]\n", + " Xtest = X.iloc[list(index_val)]\n", + " ytrain = y.iloc[list(index_train)]\n", + " ytest = y.iloc[list(index_val)]\n", + " \n", + " dtree = RandomForestClassifier( max_depth=5, n_estimators=10, max_features=1, random_state=42)\n", + " dtree.fit(Xtrain,ytrain)\n", + " yp = dtree.predict(Xtest)\n", + " \n", + " # Plot confusion matrix\n", + " plt.subplot(1,3,i+1)\n", + " cm = confusion_matrix(ytest,yp)\n", + " sns.heatmap(cm,annot=True)\n", + " plt.title(titles[i])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4. Mixed integer Kriging by Continuous relaxation and Gower distance\n", + "Method: Build a mixed integer Kriging model for prediction based on Gower distance.\n", + "\n", + "Pros: Simple to use thanks to SMT. Fast to build. No need to treat the data (black-box). Perfect predictions.\n", + "\n", + "Cons: None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Feat = ['Materials Id','Formula', 'Spacegroup', 'Formation Energy (eV)', 'E Above Hull (eV)', 'Band Gap (eV)', 'Nsites', 'Density (gm/cc)', 'Volume', 'Has Bandstructure']\n", + "data= data[Feat]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Ydata = Training_data[Training_data.columns[indy]]\n", + "Yt = np.array(Ydata)\n", + "Yt2 = np.copy(Yt)\n", + "indi=0\n", + "for yt in Yt :\n", + " if yt ==\"triclinic\" :\n", + " Yt2[indi] = 2\n", + " elif yt ==\"orthorhombic\" :\n", + " Yt2[indi] = 1\n", + " elif yt ==\"monoclinic\" :\n", + " Yt2[indi] = 0\n", + " indi = indi+1\n", + "Yt = Yt2\n", + "Yt=Yt.astype(float)\n", + "\n", + "Training_data.drop(Training_data.columns[indy], axis=1, inplace=True)\n", + "Xtd=np.array(Training_data)\n", + "Xt = np.copy(Xtd)\n", + "indcat=-1\n", + "for i in range(np.shape(Xtd)[1]) : \n", + " if type(Xtd[0,i]) == str :\n", + " indcat = indcat+1\n", + " for j in range(np.shape(Xtd)[0]) :\n", + " Xt[j,i]=np.float64(catlists[indcat].index(Xtd[j,i]))\n", + " elif type(Xtd[0,i]) == bool :\n", + " for j in range(np.shape(Xtd)[0]) :\n", + " if Xtd[j,i] ==True :\n", + " Xt[j,i]=1\n", + " else : \n", + " Xt[j,i] = 0\n", + " else : \n", + " for j in range(np.shape(Xtd)[0]) :\n", + " Xt[j,i]=np.float64(Xtd[j,i])\n", + "Xt=Xt.astype(float)\n", + "\n", + "\n", + "sm = MixedIntegerKrigingModel (\n", + " surrogate =KRG( design_space = design_space_battery, \n", + " categorical_kernel = MixIntKernelType.GOWER,\n", + " theta0=[1e-2],\n", + " corr=\"squar_exp\",\n", + " n_start=30,\n", + " ))\n", + "sm.set_training_values (Xt , Yt)\n", + "sm.train()\n", + "\n", + "Yvalid = np.array(Val_data[Val_data.columns[indy]])\n", + "Yt2 = np.copy(Yvalid)\n", + "indi=0\n", + "for yt in Yvalid :\n", + " if yt ==\"triclinic\" :\n", + " Yt2[indi] = 2\n", + " elif yt ==\"orthorhombic\" :\n", + " Yt2[indi] = 1\n", + " elif yt ==\"monoclinic\" :\n", + " Yt2[indi] = 0\n", + " indi = indi+1\n", + "Yvalid = Yt2\n", + "Yvalid=Yvalid.astype(float)\n", + "\n", + "Val_data.drop(Val_data.columns[indy], axis=1, inplace=True)\n", + "Xtv=np.array(Val_data)\n", + "\n", + "Xvalid = np.copy(Xtv)\n", + "indcat=-1\n", + "for i in range(np.shape(Xtv)[1]) : \n", + " if type(Xtv[0,i]) == str :\n", + " indcat = indcat+1\n", + " for j in range(np.shape(Xtv)[0]) :\n", + " Xvalid[j,i]=np.float64(catlists[indcat].index(Xtv[j,i]))\n", + " elif type(Xtv[0,i]) == bool :\n", + " for j in range(np.shape(Xtv)[0]) :\n", + " if Xtv[j,i] ==True :\n", + " Xvalid[j,i]=1\n", + " else : \n", + " Xvalid[j,i] = 0\n", + " else : \n", + " for j in range(np.shape(Xtd)[0]) :\n", + " Xvalid[j,i]=np.float64(Xtv[j,i])\n", + "Xvalid=Xvalid.astype(float)\n", + "\n", + "plt.figure()\n", + "cm = confusion_matrix(np.atleast_2d(np.abs(np.around(sm.predict_values(Xvalid).T,0)))[0],Yvalid)\n", + "sns.heatmap(cm,annot=True)\n", + "plt.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Additive Manufacturing\n", + "\n", + "Additive manufacturing is the process of building from a computer controlled 3-dimensional printer. The material can be polymer (plastic), ceramic, metallic powder, liquid, or any material that is joined together through deposition, solidification, or fusion. It speeds the development of prototypes by precisely converting a computer aided design (CAD) drawing into a physical device. Additive manufacturing can be either a prototype or scaled up to full product production, but typically for applications that require customization or with low production volumes.\n", + "\n", + "Background: A 3D print data set of additive manufacturing test conditions is available for Polylactic Acid (PLA) and Acrylonitrile Butadiene Styrene (ABS). PLA can print at lower temperatures of 180°C compared to 250°C for ABS. PLA is more brittle than ABS and is not typically suitable for high strength applications. The data was collected by researchers in the Mechanical Engineering department at Selçuk Üniversitesi on a Ultimaker S5 3D printer. The study focused on how the parameters in a specific 3D printer affects the print quality, accuracy and final part strength. This work is based on the settings and PLA or ABS filaments. Material and strength tests were carried out on a Sincotec GMBH tester capable of pulling 20 kN.\n", + "Nine parameters were adjusted for the Ultimaker S5 3D printer.\n", + "\n", + "\n", + "* Layer Height (mm)\n", + "* Wall Thickness (mm)\n", + "* Infill Density (%)\n", + "* Infill Pattern (Honeycomb or Grid)\n", + "* Nozzle Temperature (ºC)\n", + "* Bed Temperature (ºC)\n", + "* Print Speed (mm/s)\n", + "* Material (PLA or ABS)\n", + "* Fan Speed (%)\n", + "* After the part was manufactured, three parameters were measured for each product.\n", + "* Roughness (µm)\n", + "* Tension Strength (MPa)\n", + "* Elongation (%)\n", + "\n", + "\n", + "\n", + "The labeled data is a combination of PLA and ABS material, print patterns, and conditions with 66 samples from a first repository and 50 samples from a second repository. The combined set is 70 samples with the duplicates removed and one outlier added. The label associated with each filament is pla or abs. The print pattern is grid or honeycomb. One-hot encoding translates character labels into a binary representation (0 or 1) for classification." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Layer HeightWall ThicknessInfill DensityInfill PatternNozzle TemperatureBed TemperaturePrint SpeedMaterialFan SpeedRoughnessTension StrengthElongation
00.028.090grid2206040abs025181.2
10.027.090honeycomb2256540abs2532161.4
20.021.080grid2307040abs504080.8
30.024.070honeycomb2407540abs7568100.5
40.026.090grid2508040abs1009250.7
\n", + "
" + ], + "text/plain": [ + " Layer Height Wall Thickness Infill Density Infill Pattern \\\n", + "0 0.02 8.0 90 grid \n", + "1 0.02 7.0 90 honeycomb \n", + "2 0.02 1.0 80 grid \n", + "3 0.02 4.0 70 honeycomb \n", + "4 0.02 6.0 90 grid \n", + "\n", + " Nozzle Temperature Bed Temperature Print Speed Material Fan Speed \\\n", + "0 220 60 40 abs 0 \n", + "1 225 65 40 abs 25 \n", + "2 230 70 40 abs 50 \n", + "3 240 75 40 abs 75 \n", + "4 250 80 40 abs 100 \n", + "\n", + " Roughness Tension Strength Elongation \n", + "0 25 18 1.2 \n", + "1 32 16 1.4 \n", + "2 40 8 0.8 \n", + "3 68 10 0.5 \n", + "4 92 5 0.7 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load data from URL\n", + "url = \"https://apmonitor.com/pds/uploads/Main/manufacturing.txt\"\n", + "data = pd.read_table(url, delimiter=',')\n", + "\n", + "# Change and store variable names\n", + "parameters = [\"Layer Height\", \"Wall Thickness\", \"Infill Density\",\n", + " \"Infill Pattern\", \"Nozzle Temperature\", \"Bed Temperature\",\n", + " \"Print Speed\", \"Material\", \"Fan Speed\",\n", + " \"Roughness\", \"Tension Strength\", \"Elongation\"]\n", + "data.columns = parameters\n", + "\n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Save new features in dataframe\n", + "data.to_csv('additive_manufacturing.csv',index=False)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Surrogate Modeling Toolbox -> Kringing method with mixed variables" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Decode the data back to its original form\n", + "label_encoder_infill = LabelEncoder()\n", + "label_encoder_material = LabelEncoder()\n", + "data['Infill Pattern'] = label_encoder_infill.fit_transform(data['Infill Pattern'])\n", + "data['Material'] = label_encoder_material.fit_transform(data['Material'])\n", + "data.head()\n", + "X = data.drop('Tension Strength', axis=1)\n", + "y = data['Tension Strength']\n", + "#scaler = StandardScaler()\n", + "#X = scaler.fit_transform(X)\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n", + "data['Infill Pattern'] = label_encoder_infill.inverse_transform(data['Infill Pattern'])\n", + "data['Material'] = label_encoder_material.inverse_transform(data['Material'])\n", + "data['Infill Pattern']= pd.Categorical(data['Infill Pattern'])\n", + "data['Infill Pattern'] = data['Infill Pattern'].cat.codes\n", + "\n", + "data['Material']= pd.Categorical(data['Material'])\n", + "data['Material'] = data['Material'].cat.codes\n", + "\n", + "X = data.drop('Tension Strength', axis=1)\n", + "y = data['Tension Strength']\n", + "\n", + "# Identify the indices of the non-categorical columns\n", + "non_categorical_indices = [0,1,2,4,5,6,8,9,10]\n", + "\n", + "# Extract the non-categorical features\n", + "X_non_categorical = X.iloc[:, non_categorical_indices]\n", + "\n", + "# Apply StandardScaler only to the non-categorical features\n", + "#scaler = StandardScaler()\n", + "#X_non_categorical_scaled = scaler.fit_transform(X_non_categorical)\n", + "\n", + "# Replace the non-categorical features in the original matrix with the scaled values\n", + "X.iloc[:, non_categorical_indices] = X_non_categorical\n", + "X_ = np.asarray(X)\n", + "y_ = np.asarray(y).astype(float)\n", + "X_train, X_test, y_train, y_test = train_test_split(X_, y_, test_size=0.3, random_state=42)\n", + "# Create the design space\n", + "design_space = DesignSpace(\n", + " [\n", + " FloatVariable (data[\"Layer Height\"].min(),data[\"Layer Height\"].max()), # Layer Height\n", + " FloatVariable (data[\"Wall Thickness\"].min(),data[\"Wall Thickness\"].max()), # Wall Thickness\n", + " FloatVariable (data[\"Infill Density\"].min(),data[\"Infill Density\"].max()), # Infill Density\n", + " CategoricalVariable(list(label_encoder_infill.classes_)), # Infill Pattern\n", + " FloatVariable (data[\"Nozzle Temperature\"].min(),data[\"Nozzle Temperature\"].max()), # Nozzle Temperature\n", + " FloatVariable (data[\"Bed Temperature\"].min(),data[\"Bed Temperature\"].max()), # Bed Temperature\n", + " FloatVariable (data[\"Print Speed\"].min(),data[\"Print Speed\"].max()), # Layer Height\n", + " CategoricalVariable(list(label_encoder_material.classes_) ), # Material\n", + " FloatVariable (data[\"Fan Speed\"].min(),data[\"Fan Speed\"].max()), # Fan Speed\n", + " FloatVariable (data[\"Roughness\"].min(),data[\"Roughness\"].max()), # Roughness\n", + " FloatVariable (data[\"Elongation\"].min(),data[\"Elongation\"].max()), # Layer Height\n", + " ]\n", + ")\n", + "\n", + "# Initialize the mixed-integer kriging model\n", + "sm=KRG(design_space = design_space, \n", + " corr=\"abs_exp\",\n", + " n_start=30,\n", + " print_global=False,\n", + " categorical_kernel=MixIntKernelType.HOMO_HSPHERE)\n", + "sm.set_training_values(X_train, np.atleast_2d(y_train).T)\n", + "sm.train()\n", + "# Predict on train and test sets\n", + "y_train_pred_smt = sm.predict_values(X_train).T[0]\n", + "y_test_pred_smt = sm.predict_values(X_test).T[0]\n", + "\n", + "# Calculate R2 scores\n", + "r2_train_smt = r2_score(y_train, y_train_pred_smt)\n", + "r2_test_smt = r2_score(y_test, y_test_pred_smt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Preprocessing for continuous models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Encode categorical variables (Infill Pattern and Material)**" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "label_encoder_infill = LabelEncoder()\n", + "label_encoder_material = LabelEncoder()\n", + "data['Infill Pattern'] = label_encoder_infill.fit_transform(data['Infill Pattern'])\n", + "data['Material'] = label_encoder_material.fit_transform(data['Material'])\n", + "data.head()\n", + "X = data.drop('Tension Strength', axis=1)\n", + "y = data['Tension Strength']\n", + "scaler = StandardScaler()\n", + "X = scaler.fit_transform(X)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Linear model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize the model\n", + "linear_model = LinearRegression()\n", + "\n", + "# Fit the model\n", + "linear_model.fit(X_train, y_train)\n", + "\n", + "# Predict on train and test sets\n", + "y_train_pred_linear = linear_model.predict(X_train)\n", + "y_test_pred_linear = linear_model.predict(X_test)\n", + "\n", + "# Calculate R2 scores\n", + "r2_train_linear = r2_score(y_train, y_train_pred_linear)\n", + "r2_test_linear = r2_score(y_test, y_test_pred_linear)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Neural Network (Deep Learning)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize the model\n", + "nn_model = MLPRegressor(hidden_layer_sizes=(100,), max_iter=500)\n", + "\n", + "# Fit the model\n", + "nn_model.fit(X_train, y_train)\n", + "\n", + "# Predict on train and test sets\n", + "y_train_pred_nn = nn_model.predict(X_train)\n", + "y_test_pred_nn = nn_model.predict(X_test)\n", + "\n", + "# Calculate R2 scores\n", + "r2_train_nn = r2_score(y_train, y_train_pred_nn)\n", + "r2_test_nn = r2_score(y_test, y_test_pred_nn)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Surrogate Modeling Toolbox -> KPLS with automatic number of component" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize the model\n", + "sm_model_Q = KPLS(eval_n_comp=True,print_global = False)\n", + "sm_model_Q.set_training_values(np.array(X_train), np.array(y_train).reshape(-1,1))\n", + "\n", + "# Fit the model\n", + "sm_model_Q.train()\n", + "\n", + "# Predict on train and test sets\n", + "y_train_pred_KPLS = sm_model_Q.predict_values(np.array(X_train)).T[0] \n", + "y_test_pred_KPLS = sm_model_Q.predict_values(np.array(X_test)).T[0]\n", + "\n", + "# Calculate R2 scores\n", + "r2_train_KPLS = r2_score(y_train, y_train_pred_KPLS)\n", + "r2_test_KPLS = r2_score(y_test, y_test_pred_KPLS)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Results 3D printing" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Linear Regression:\n", + "Train R2: 0.8080\n", + "Test R2: 0.6566\n", + "\n", + "Neural Network:\n", + "Train R2: -1.8152\n", + "Test R2: -1.9407\n", + "\n", + "SMT KPLS cont:\n", + "Train R2: 1.0000\n", + "Test R2: 0.7156\n", + "\n", + "SMT KRG Mixed:\n", + "Train R2: 1.0000\n", + "Test R2: 0.7592\n", + "\n" + ] + } + ], + "source": [ + "# Print R2 scores for each model on train and test sets\n", + "print(\"Linear Regression:\")\n", + "print(f\"Train R2: {r2_train_linear:.4f}\")\n", + "print(f\"Test R2: {r2_test_linear:.4f}\\n\")\n", + "\n", + "print(\"Neural Network:\")\n", + "print(f\"Train R2: {r2_train_nn:.4f}\")\n", + "print(f\"Test R2: {r2_test_nn:.4f}\\n\")\n", + "\n", + "print(\"SMT KPLS cont:\")\n", + "print(f\"Train R2: {r2_train_KPLS:.4f}\")\n", + "print(f\"Test R2: {r2_test_KPLS:.4f}\\n\")\n", + "\n", + "print(\"SMT KRG Mixed:\")\n", + "print(f\"Train R2: {r2_train_smt:.4f}\")\n", + "print(f\"Test R2: {r2_test_smt:.4f}\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Parity Plot\n", + "A parity plot is a scatter plot with predicted versus measured. A parity plot of the training and test data is a good way to see the overall fit of tension strength." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Function to create a parity plot\n", + "def parity_plot(ax, y_true, y_pred, title):\n", + " ax.scatter(y_true, y_pred, color='blue', alpha=0.6)\n", + " ax.plot([min(y_true), max(y_true)], [min(y_true), max(y_true)], linestyle='--', color='red', linewidth=2)\n", + " ax.set_title(title)\n", + " ax.set_xlabel('Measured Tension (MPa)')\n", + " ax.set_ylabel('Predicted (MPa)')\n", + " ax.grid(True)\n", + "\n", + "# Create subplots\n", + "fig, axs = plt.subplots(4, 2, figsize=(8, 8))\n", + "fig.suptitle('Parity Plots', fontsize=16)\n", + "# Parity plot for Linear Regression\n", + "parity_plot(axs[0, 0], y_train, y_train_pred_linear, 'Linear Regression (Train)')\n", + "parity_plot(axs[0, 1], y_test, y_test_pred_linear, 'Linear Regression (Test)')\n", + "\n", + "# Parity plot for Neural Network\n", + "parity_plot(axs[1, 0], y_train, y_train_pred_nn, 'Neural Network (Train)')\n", + "parity_plot(axs[1, 1], y_test, y_test_pred_nn, 'Neural Network (Test)')\n", + "\n", + "# Parity plot for SMT\n", + "parity_plot(axs[2, 0], y_train, y_train_pred_KPLS, 'SMT KPLS (Train)')\n", + "parity_plot(axs[2, 1], y_test, y_test_pred_KPLS, 'SMT KPLS (Test)')\n", + "\n", + "# Parity plot for SMT\n", + "parity_plot(axs[3, 0], y_train, y_train_pred_smt, 'SMT Mixed (Train)')\n", + "parity_plot(axs[3, 1], y_test, y_test_pred_smt, 'SMT Mixed (Test)')\n", + "\n", + "# Adjust layout\n", + "plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "include_colab_link": true, + "name": "SMT_MixedInteger_application.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/additive_manufacturing.csv b/tutorial/additive_manufacturing.csv new file mode 100644 index 000000000..c60e1293d --- /dev/null +++ b/tutorial/additive_manufacturing.csv @@ -0,0 +1,71 @@ +Layer Height,Wall Thickness,Infill Density,Infill Pattern,Nozzle Temperature,Bed Temperature,Print Speed,Material,Fan Speed,Roughness,Tension Strength,Elongation +0.02,8.0,90,grid,220,60,40,abs,0,25,18,1.2 +0.02,7.0,90,honeycomb,225,65,40,abs,25,32,16,1.4 +0.02,1.0,80,grid,230,70,40,abs,50,40,8,0.8 +0.02,4.0,70,honeycomb,240,75,40,abs,75,68,10,0.5 +0.02,6.0,90,grid,250,80,40,abs,100,92,5,0.7 +0.02,10.0,40,honeycomb,200,60,40,pla,0,60,24,1.1 +0.02,5.0,10,grid,205,65,40,pla,25,55,12,1.3 +0.02,10.0,10,honeycomb,210,70,40,pla,50,21,14,1.5 +0.02,9.0,70,grid,215,75,40,pla,75,24,27,1.4 +0.02,8.0,40,honeycomb,220,80,40,pla,100,30,25,1.7 +0.06,6.0,80,grid,220,60,60,abs,0,75,37,2.4 +0.06,2.0,20,honeycomb,225,65,60,abs,25,92,12,1.4 +0.06,10.0,50,grid,230,70,60,abs,50,118,16,1.3 +0.06,6.0,10,honeycomb,240,75,60,abs,75,200,9,0.8 +0.06,3.0,50,grid,250,80,60,abs,100,220,10,1.0 +0.06,10.0,90,honeycomb,200,60,60,pla,0,126,27,2.2 +0.06,3.0,40,grid,205,65,60,pla,25,145,23,1.9 +0.06,8.0,30,honeycomb,210,70,60,pla,50,88,26,1.6 +0.06,5.0,80,grid,215,75,60,pla,75,92,33,2.1 +0.06,10.0,50,honeycomb,220,80,60,pla,100,74,29,2.0 +0.1,1.0,40,grid,220,60,120,abs,0,120,16,1.2 +0.1,2.0,30,honeycomb,225,65,120,abs,25,144,12,1.1 +0.1,1.0,50,grid,230,70,120,abs,50,265,10,0.9 +0.1,9.0,80,honeycomb,240,75,120,abs,75,312,19,0.8 +0.1,2.0,60,grid,250,80,120,abs,100,368,8,0.4 +0.1,1.0,50,honeycomb,200,60,120,pla,0,180,11,1.6 +0.1,4.0,40,grid,205,65,120,pla,25,176,12,1.2 +0.1,3.0,50,honeycomb,210,70,120,pla,50,128,18,1.8 +0.1,4.0,90,grid,215,75,120,pla,75,138,34,2.9 +0.1,1.0,30,honeycomb,220,80,120,pla,100,121,14,1.5 +0.15,4.0,50,grid,220,60,60,abs,0,168,27,2.4 +0.15,7.0,10,honeycomb,225,65,60,abs,25,154,19,1.8 +0.15,6.0,50,grid,230,70,60,abs,50,225,18,1.4 +0.15,1.0,50,honeycomb,240,75,60,abs,75,289,9,0.6 +0.15,7.0,80,grid,250,80,60,abs,100,326,13,0.7 +0.15,3.0,80,honeycomb,200,60,60,pla,0,192,33,2.8 +0.15,4.0,50,grid,205,65,60,pla,25,212,24,1.8 +0.15,10.0,30,honeycomb,210,70,60,pla,50,168,26,2.1 +0.15,6.0,40,grid,215,75,60,pla,75,172,22,2.3 +0.15,1.0,10,honeycomb,220,80,60,pla,100,163,4,0.7 +0.2,4.0,80,grid,220,60,40,abs,0,212,35,3.3 +0.2,9.0,90,honeycomb,225,65,40,abs,25,276,34,3.1 +0.2,7.0,30,grid,230,70,40,abs,50,298,28,2.2 +0.2,6.0,90,honeycomb,240,75,40,abs,75,360,28,1.6 +0.2,3.0,80,grid,250,80,40,abs,100,357,21,1.1 +0.2,5.0,60,honeycomb,200,60,40,pla,0,321,28,2.7 +0.2,4.0,20,grid,205,65,40,pla,25,265,14,1.8 +0.2,5.0,60,honeycomb,210,70,40,pla,50,278,30,3.2 +0.2,7.0,40,grid,215,75,40,pla,75,244,29,3.2 +0.2,3.0,60,honeycomb,220,80,40,pla,100,220,27,3.1 +0.02,8.0,90,grid,250,100,40,abs,100,98,5,0.95 +0.06,5.0,90,grid,215,95,60,pla,75,92,38,2.2 +0.09,8.0,60,honeycomb,210,70,60,pla,50,98,26,1.6 +0.03,8.0,90,grid,220,60,40,abs,0,25,18,1.2 +0.03,10.0,20,honeycomb,220,60,60,abs,0,75,37,2.4 +0.02,6.0,10,grid,205,65,40,pla,25,55,12,1.3 +0.06,10.0,100,honeycomb,200,60,60,pla,0,126,27,2.2 +0.02,6.0,12,grid,205,65,40,pla,28,55,12,1.8 +0.1,6.0,80,honeycomb,250,75,120,abs,75,312,19,0.8 +0.1,4.0,95,grid,220,75,120,pla,100,121,14,1.5 +0.15,3.0,10,honeycomb,225,65,70,abs,25,154,19,1.8 +0.15,7.0,50,grid,230,70,60,abs,50,225,18,1.4 +0.15,3.0,85,honeycomb,220,60,60,pla,0,192,33,2.8 +0.15,3.0,90,grid,215,260,360,pla,0,-1,33,2.8 +0.06,12.0,50,honeycomb,230,80,65,pla,100,74,29,2.1 +0.06,9.0,10,honeycomb,200,75,80,abs,75,200,9,0.9 +0.04,2.0,80,grid,230,70,40,abs,50,40,12,0.8 +0.02,4.5,70,honeycomb,240,85,40,abs,75,68,10,0.8 +0.05,6.0,10,honeycomb,245,75,85,abs,75,205,5,0.5 +0.15,1.0,50,grid,220,60,120,abs,0,120,16,1.5 diff --git a/tutorial/VTF_properties.csv b/tutorial/composite_material.csv similarity index 100% rename from tutorial/VTF_properties.csv rename to tutorial/composite_material.csv diff --git a/tutorial/lithium_ion_data.csv b/tutorial/lithium_ion_data.csv new file mode 100644 index 000000000..f7ebc8ecf --- /dev/null +++ b/tutorial/lithium_ion_data.csv @@ -0,0 +1,340 @@ +Materials Id,Formula,Spacegroup,Formation Energy (eV),E Above Hull (eV),Band Gap (eV),Nsites,Density (gm/cc),Volume,Has Bandstructure,Crystal System +mp-849394,Li2MnSiO4,Pc,-2.699,0.006,3.462,16,2.993,178.513,True,monoclinic +mp-783909,Li2MnSiO4,P21/c,-2.696,0.008,2.879,32,2.926,365.272,True,monoclinic +mp-761311,Li4MnSi2O7,Cc,-2.775,0.012,3.653,28,2.761,301.775,True,monoclinic +mp-761598,Li4Mn2Si3O10,C2/c,-2.783,0.013,3.015,38,2.908,436.183,True,monoclinic +mp-767709,Li2Mn3Si3O10,C2/c,-2.747,0.016,2.578,36,3.334,421.286,True,monoclinic +mp-761517,Li4MnSi2O7,C2,-2.763,0.024,3.293,14,2.792,149.207,True,monoclinic +mp-850949,LiMnSiO4,P21,-2.65,0.027,1.052,28,3.507,291.575,False,monoclinic +mp-853204,Li2MnSiO4,P21/c,-2.676,0.029,3.384,32,2.927,365.179,False,monoclinic +mp-767360,LiMn(SiO3)2,C2/c,-2.822,0.038,0.612,20,3.255,218.36,True,monoclinic +mp-764791,Li2Mn(SiO3)2,Cc,-2.823,0.04,3.447,22,2.7,271.853,True,monoclinic +mp-782667,Li2MnSiO4,P21/c,-2.66,0.044,2.785,32,2.977,358.984,True,monoclinic +mp-767686,Li2Mn(SiO3)2,C2/c,-2.818,0.045,3.397,22,2.702,271.581,True,monoclinic +mp-772591,Li2Mn2Si2O7,P21/c,-2.697,0.049,2.461,52,3.047,636.288,True,monoclinic +mp-849242,Li10Mn(SiO5)2,C2/m,-2.496,0.052,0.988,46,2.4,471.249,True,monoclinic +mp-780126,Li3MnSi2O7,P21,-2.721,0.058,0.921,78,2.89,840.856,False,monoclinic +mp-868532,Li5Mn(SiO4)2,C2,-2.649,0.067,0.584,16,2.588,175.701,False,monoclinic +mp-850142,Li2Mn(Si2O5)2,P21/c,-2.942,0.069,3.823,68,2.31,980.879,False,monoclinic +mp-767853,Li2Mn2Si3O10,Cc,-2.712,0.073,1.262,34,2.847,429.302,True,monoclinic +mp-849428,Li2Mn2(SiO3)3,P21/c,-2.769,0.077,3.188,64,2.517,929.064,False,monoclinic +mp-761329,LiMn(SiO3)2,C2/c,-2.782,0.078,1.497,20,3.104,228.983,True,monoclinic +mp-761653,Li2MnSi3O8,P21,-2.871,0.082,2.736,28,2.672,349.386,True,monoclinic +mp-769543,Li3Mn2(SiO4)2,P21,-2.612,0.083,0.0,30,2.887,362.254,True,monoclinic +mp-849217,Li4Mn(SiO3)3,C2,-2.794,0.083,2.862,34,2.649,389.814,True,monoclinic +mp-767695,Li2MnSi3O8,P21,-2.868,0.085,3.261,28,2.628,355.18,True,monoclinic +mp-767303,Li2Mn(SiO3)2,C2,-2.778,0.085,3.169,22,2.92,251.377,True,monoclinic +mp-780037,LiMn2Si2O7,Cc,-2.653,0.085,0.716,24,3.281,288.498,True,monoclinic +mp-774171,Li3Mn2(SiO4)2,Pc,-2.608,0.087,0.0,30,2.892,361.543,True,monoclinic +mp-778631,Li3Mn2(SiO4)2,Pc,-2.607,0.087,0.37,30,2.911,359.241,True,monoclinic +mp-780872,LiMnSiO4,P21/c,-2.589,0.088,0.982,56,3.361,608.454,True,monoclinic +mp-761765,Li3Mn3SiO8,P2/m,-2.329,0.088,0.915,15,3.853,147.276,True,monoclinic +mp-780287,Li3Mn2(SiO4)2,P21,-2.605,0.089,0.0,30,2.898,360.853,True,monoclinic +mp-774356,Li3Mn2(SiO4)2,Pc,-2.604,0.09,0.0,30,2.91,359.343,True,monoclinic +mp-850760,Li2MnSi4O11,C2/c,-2.832,0.091,1.37,36,2.868,413.524,True,monoclinic +mp-775353,Li5Mn(SiO3)4,C2,-2.79,0.091,1.342,132,2.584,1518.85,False,monoclinic +mp-769538,Li3Mn2(SiO4)2,P21,-2.601,0.093,0.0,30,3.001,348.469,True,monoclinic +mp-767011,Li7Mn3(SiO6)2,C2/m,-2.439,0.095,1.291,24,3.671,208.787,True,monoclinic +mp-510708,LiFe(SiO3)2,C2/c,-2.82,0.0,2.703,20,3.287,217.186,True,monoclinic +mp-19061,LiFe(SiO3)2,P21/c,-2.82,0.001,2.755,40,3.309,431.516,True,monoclinic +mp-646320,Li2FeSiO4,P21/c,-2.625,0.001,3.443,32,3.067,350.466,False,monoclinic +mp-763629,Li2FeSiO4,Pc,-2.621,0.005,3.027,16,3.073,174.862,True,monoclinic +mp-763264,Li2FeSiO4,P21,-2.619,0.007,3.401,32,3.005,357.648,True,monoclinic +mp-868123,LiFe(Si2O5)2,P2/c,-2.985,0.009,3.362,32,2.43,457.962,False,monoclinic +mp-761968,Li4FeSi2O7,Cc,-2.731,0.011,3.415,28,2.81,297.609,True,monoclinic +mp-762639,LiFeSiO4,Pc,-2.61,0.012,3.026,28,2.852,360.726,True,monoclinic +mp-762893,LiFeSiO4,Cc,-2.608,0.014,2.967,112,2.849,1444.106,False,monoclinic +mp-762925,LiFeSiO4,Cc,-2.608,0.014,2.969,112,2.848,1444.706,False,monoclinic +mp-767077,Li5Fe(SiO4)2,C2,-2.677,0.014,2.466,16,2.616,174.413,True,monoclinic +mp-767027,Li4FeSi2O7,C2,-2.722,0.02,3.442,14,2.824,148.024,True,monoclinic +mp-764348,LiFeSiO4,P21/c,-2.601,0.02,2.904,28,2.873,358.057,True,monoclinic +mp-761394,Li4Fe2Si3O10,C2/c,-2.71,0.021,3.159,38,2.978,427.934,True,monoclinic +mp-775228,LiFeSiO4,Pc,-2.599,0.023,0.401,14,2.87,179.222,True,monoclinic +mp-762554,Li2FeSiO4,P21/c,-2.603,0.023,3.448,32,3.028,354.961,False,monoclinic +mp-761644,Li2Fe3Si3O10,C2/c,-2.635,0.024,3.028,36,3.463,408.228,True,monoclinic +mp-764344,Li2FeSiO4,P21,-2.603,0.024,2.931,16,3.06,175.643,True,monoclinic +mp-778685,LiFe(SiO3)2,Cc,-2.793,0.028,3.273,20,2.602,274.334,False,monoclinic +mp-762645,LiFeSiO4,Pc,-2.59,0.032,2.839,28,2.843,361.8,True,monoclinic +mp-762786,Li3Fe2(SiO4)2,P21,-2.586,0.038,1.378,30,2.921,360.017,True,monoclinic +mp-765961,LiFeSi3O8,P21/c,-2.887,0.04,3.144,52,2.69,679.101,True,monoclinic +mp-764784,LiFeSiO4,Cc,-2.577,0.045,3.01,14,2.366,217.361,True,monoclinic +mp-765881,LiFeSi3O8,C2/c,-2.879,0.049,3.186,52,2.656,687.841,True,monoclinic +mp-762861,LiFeSiO4,P21/c,-2.572,0.05,3.028,84,2.857,1080.318,False,monoclinic +mp-762613,Li2Fe2Si2O7,P21/c,-2.598,0.051,3.159,52,3.149,619.645,True,monoclinic +mp-780866,LiFe2Si2O7,P21/c,-2.598,0.051,2.01,48,2.911,654.481,True,monoclinic +mp-762862,LiFeSiO4,P21/c,-2.571,0.051,3.042,84,2.872,1074.67,False,monoclinic +mp-767973,Li2Fe(SiO3)2,C2/c,-2.754,0.051,3.222,22,2.758,267.162,True,monoclinic +mp-762796,LiFeSiO4,Cc,-2.57,0.052,2.899,14,2.719,189.186,True,monoclinic +mp-762565,Li10Fe(SiO5)2,C2/m,-2.476,0.055,1.715,46,2.399,472.581,True,monoclinic +mp-764355,LiFeSiO4,Pc,-2.566,0.055,2.955,14,2.644,194.528,True,monoclinic +mp-763619,Li2Fe(SiO3)2,P21,-2.748,0.058,3.392,22,2.878,256.015,True,monoclinic +mp-761624,LiFeSi3O8,C2,-2.868,0.059,3.215,26,2.59,352.651,True,monoclinic +mp-767938,LiFeSiO4,P21/c,-2.562,0.059,2.871,28,2.843,361.839,True,monoclinic +mp-762650,Li3Fe2(SiO4)2,P21,-2.564,0.06,1.331,30,3.026,347.513,True,monoclinic +mp-763781,Li3Fe2(SiO4)2,Pc,-2.564,0.06,1.684,30,2.741,383.694,True,monoclinic +mp-767668,Li9Fe5(SiO8)2,P2/m,-2.324,0.06,1.646,32,3.782,287.056,True,monoclinic +mp-762656,LiFeSiO4,Pc,-2.561,0.061,2.724,28,2.895,355.354,True,monoclinic +mp-767283,LiFeSiO4,Pc,-2.56,0.062,2.587,14,2.947,174.534,True,monoclinic +mp-774106,Li3Fe2(SiO4)2,Pc,-2.562,0.062,1.511,30,2.991,351.593,True,monoclinic +mp-767838,LiFeSiO4,P21,-2.56,0.062,2.727,28,2.889,356.057,True,monoclinic +mp-762571,Li2Fe(Si2O5)2,P21/c,-2.913,0.062,3.661,68,2.417,940.148,False,monoclinic +mp-765416,Li2Fe2Si8O19,C2,-2.955,0.063,3.031,31,2.711,400.68,True,monoclinic +mp-762723,Li3Fe2(SiO4)2,P21,-2.561,0.063,1.259,30,2.943,357.383,False,monoclinic +mp-762586,LiFeSiO4,P21,-2.555,0.066,2.576,28,3.068,335.324,True,monoclinic +mp-761546,LiFeSiO4,P2,-2.553,0.068,2.736,84,2.499,1234.971,False,monoclinic +mp-778622,Li3Fe2(SiO4)2,Pc,-2.556,0.069,1.923,30,2.891,363.781,True,monoclinic +mp-762646,LiFeSiO4,P21/c,-2.553,0.069,2.164,56,3.289,625.575,True,monoclinic +mp-767963,Li2FeSi3O8,P21,-2.84,0.069,3.081,28,2.665,351.384,True,monoclinic +mp-762535,Li2Fe2(SiO3)3,P21/c,-2.696,0.072,3.017,64,2.611,899.949,False,monoclinic +mp-762539,Li2FeSiO4,P21/c,-2.553,0.073,2.649,32,2.877,373.622,True,monoclinic +mp-762562,Li2Fe(Si2O5)2,P21/m,-2.898,0.077,3.171,68,2.518,902.44,True,monoclinic +mp-761782,Li7Fe3(SiO6)2,C2/m,-2.409,0.078,1.658,24,3.692,208.83,True,monoclinic +mp-767149,Li2FeSi3O8,P21,-2.827,0.081,2.614,28,2.719,344.39,True,monoclinic +mp-762541,Li4Fe(SiO3)3,C2,-2.758,0.082,3.073,34,2.702,383.352,True,monoclinic +mp-761991,Li3Fe3SiO8,P2/m,-2.257,0.083,1.476,15,3.942,145.111,True,monoclinic +mp-762585,LiFeSiO4,P21/c,-2.528,0.094,2.351,28,3.058,336.427,True,monoclinic +mp-766984,Li2Fe(Si2O5)3,P21,-2.89,0.095,0.332,48,2.555,621.599,True,monoclinic +mp-762714,Li2FeSi4O11,C2/c,-2.785,0.098,0.03,36,2.788,426.538,False,monoclinic +mp-761452,Li2Fe(Si2O5)3,Cc,-2.876,0.109,0.264,48,2.309,687.797,True,monoclinic +mp-780871,LiFe2(SiO4)2,P2,-2.423,0.117,2.528,78,2.474,1219.453,False,monoclinic +mp-763301,Li2CoSiO4,Pc,-2.537,0.0,2.957,16,3.216,170.265,True,monoclinic +mp-764958,Li2CoSiO4,P21,-2.523,0.014,2.934,16,3.201,171.08,True,monoclinic +mp-763512,Li2CoSiO4,P21/c,-2.516,0.02,2.769,32,3.15,347.706,True,monoclinic +mp-763470,Li2CoSiO4,P21/c,-2.515,0.021,2.827,32,3.108,352.365,True,monoclinic +mp-764634,Li2CoSiO4,C2/m,-2.51,0.027,2.457,16,3.088,177.349,True,monoclinic +mp-763396,Li4Co2Si3O10,C2/c,-2.617,0.038,2.876,38,3.078,420.615,True,monoclinic +mp-763465,Li2CoSiO4,P21/c,-2.495,0.042,2.684,32,3.13,349.97,True,monoclinic +mp-781591,Li3Co2(SiO4)2,Pc,-2.452,0.043,0.0,30,3.115,344.253,True,monoclinic +mp-763382,Li2Co2Si2O7,P21/c,-2.478,0.047,2.825,52,3.322,599.601,True,monoclinic +mp-763575,Li10Co(SiO5)2,C2/m,-2.444,0.048,1.941,46,2.409,474.87,True,monoclinic +mp-773761,LiCo(SiO3)2,Cc,-2.638,0.052,1.711,20,2.745,263.753,True,monoclinic +mp-763389,Li2Co(SiO3)2,C2/c,-2.687,0.053,3.233,22,2.861,261.142,True,monoclinic +mp-762751,Li3Co2(SiO4)2,Pc,-2.438,0.057,0.315,30,3.035,353.345,False,monoclinic +mp-767356,LiCo(SiO3)2,C2/c,-2.632,0.058,1.238,20,3.405,212.692,True,monoclinic +mp-762812,Li3Co2(SiO4)2,Pc,-2.436,0.059,0.35,30,3.052,351.323,False,monoclinic +mp-762978,LiCoSiO4,Cc,-2.376,0.06,1.281,112,2.998,1399.85,False,monoclinic +mp-774355,Li3Co2(SiO4)2,Pc,-2.433,0.063,0.541,30,3.092,346.722,True,monoclinic +mp-763592,LiCoSiO4,Pc,-2.372,0.063,1.468,28,2.961,354.341,True,monoclinic +mp-763255,LiCoSiO4,Pc,-2.372,0.064,1.373,14,2.964,176.961,True,monoclinic +mp-779186,Li3Co2(SiO4)2,P21,-2.431,0.064,0.022,30,3.032,353.617,True,monoclinic +mp-762886,LiCoSiO4,P21/c,-2.369,0.066,1.374,28,3.015,347.967,True,monoclinic +mp-763256,LiCoSiO4,Pc,-2.369,0.067,1.59,14,2.998,174.957,True,monoclinic +mp-763399,Li2Co2(SiO3)3,P21/c,-2.598,0.069,2.727,64,2.739,872.856,True,monoclinic +mp-765005,Li2Co(SiO3)2,P21,-2.669,0.072,2.883,22,2.947,253.565,True,monoclinic +mp-763385,Li2Co(Si2O5)2,P21/c,-2.858,0.075,3.254,68,2.429,943.786,False,monoclinic +mp-779222,Li3Co2(SiO4)2,Pc,-2.418,0.078,0.147,30,3.003,357.078,True,monoclinic +mp-763313,LiCoSiO4,P21,-2.357,0.079,1.434,14,2.952,177.732,True,monoclinic +mp-762976,LiCoSiO4,P21/c,-2.352,0.083,1.403,84,3.017,1043.295,False,monoclinic +mp-764963,Li2CoSi3O8,P21,-2.772,0.085,3.159,28,2.771,341.661,True,monoclinic +mp-763253,LiCoSiO4,Pc,-2.349,0.086,1.474,14,3.096,169.421,True,monoclinic +mp-764463,Li3Co2Si3O10,Cc,-2.539,0.089,0.724,36,2.914,436.508,True,monoclinic +mp-762974,LiCoSiO4,P21/c,-2.347,0.089,1.494,84,2.999,1049.613,False,monoclinic +mp-763384,Li2Co(Si2O5)2,P21/m,-2.842,0.091,2.499,68,2.564,894.099,False,monoclinic +mp-763364,Li4Co(SiO3)3,C2,-2.706,0.092,2.938,34,2.754,379.735,True,monoclinic +mp-763500,LiCoSiO4,P21/c,-2.341,0.095,0.892,28,3.84,273.243,True,monoclinic +mp-850488,LiCoSiO4,Pc,-2.338,0.098,1.255,28,3.019,347.495,False,monoclinic +mp-763246,LiCoSiO4,Pc,-2.338,0.098,1.386,14,2.841,184.681,True,monoclinic +mp-767301,Li3Co2(SiO4)2,C2,-2.396,0.099,0.637,15,2.931,182.928,True,monoclinic +mp-762293,LiCoSiO4,Cc,-2.333,0.102,1.266,14,2.884,181.921,True,monoclinic +mp-849671,Li5Co2(SiO5)2,Pc,-2.301,0.103,0.235,38,2.838,431.503,True,monoclinic +mp-765142,LiCoSiO4,Cc,-2.332,0.104,1.552,14,2.724,192.593,True,monoclinic +mp-566680,Li2MnSiO4,P21nm,-2.705,0.0,3.052,16,3.039,175.842,True,orthorhombic +mp-763876,Li2MnSiO4,Pcmn,-2.705,0.0,3.07,32,3.013,354.747,True,orthorhombic +mp-849238,Li2MnSiO4,Pmnb,-2.695,0.01,2.882,32,2.97,359.824,True,orthorhombic +mp-775454,Li2MnSiO4,Pna21,-2.694,0.011,2.88,32,2.957,361.437,True,orthorhombic +mp-780918,Li2MnSiO4,Pna21,-2.694,0.011,2.965,32,2.926,365.204,True,orthorhombic +mp-780833,Li2MnSiO4,C2221,-2.691,0.014,2.962,16,2.882,185.391,True,orthorhombic +mp-850110,Li2Mn(SiO3)2,Fdd2,-2.849,0.014,3.487,22,2.74,267.86,True,orthorhombic +mp-768020,Li2MnSiO4,Pbn21,-2.685,0.019,2.823,32,2.997,356.585,True,orthorhombic +mp-868361,Li2Mn2Si2O7,C2cm,-2.712,0.033,2.869,26,3.3,293.746,True,orthorhombic +mp-761776,LiMn(SiO3)2,Pbca,-2.824,0.036,0.037,80,3.343,850.626,False,orthorhombic +mp-780533,LiMnSiO4,Pmnb,-2.632,0.046,0.99,28,3.598,284.227,True,orthorhombic +mp-762836,Li3Mn(Si2O5)3,Cmce,-2.972,0.051,1.369,100,2.603,1235.941,False,orthorhombic +mp-780325,LiMnSiO4,Cmcm,-2.626,0.052,0.0,14,3.609,141.676,True,orthorhombic +mp-762828,LiMnSiO4,Pna21,-2.623,0.054,0.11,84,3.55,864.216,False,orthorhombic +mp-850152,Li2MnSiO4,Pca21,-2.65,0.054,2.852,64,2.8,763.324,True,orthorhombic +mp-761523,Li2Mn2(Si2O5)3,Cmce,-2.95,0.055,3.376,100,2.634,1342.122,False,orthorhombic +mp-761666,Li3Mn(Si2O5)3,Pcmn,-2.968,0.055,1.154,100,2.76,1165.318,False,orthorhombic +mp-762845,Li4Mn2Si4O13,Pna21,-2.757,0.059,1.363,92,3.047,998.5,False,orthorhombic +mp-775449,Li2Mn(SiO3)2,Fdd2,-2.802,0.061,3.072,66,2.661,827.376,True,orthorhombic +mp-850153,Li2Mn2(SiO3)3,Pnma,-2.779,0.067,3.077,64,3.034,770.62,True,orthorhombic +mp-780089,Li3MnSi2O7,Pbnm,-2.709,0.069,1.472,52,2.895,559.694,True,orthorhombic +mp-761485,Li2Mn(SiO3)2,Pmn21,-2.791,0.072,2.607,66,2.933,750.79,True,orthorhombic +mp-849442,Li2Mn(Si2O5)2,P212121,-2.939,0.073,3.783,68,2.29,989.646,False,orthorhombic +mp-780825,LiMnSiO4,Pcmn,-2.603,0.074,1.059,28,3.325,307.52,True,orthorhombic +mp-774444,Li2Mn3(SiO3)4,Pnma,-2.762,0.076,1.527,84,2.856,1123.305,False,orthorhombic +mp-780637,Li3MnSiO5,P21nb,-2.529,0.077,0.235,40,2.798,436.412,True,orthorhombic +mp-763718,Li2Mn(SiO3)2,Pm21n,-2.784,0.079,2.76,66,2.933,750.671,True,orthorhombic +mp-767364,Li2Mn2Si2O7,C2cm,-2.666,0.079,2.696,26,2.944,329.286,True,orthorhombic +mp-761619,LiMn(SiO3)2,Pbca,-2.78,0.08,1.2,80,3.306,860.04,True,orthorhombic +mp-775156,LiMnSiO4,Pbca,-2.595,0.082,1.267,56,2.994,683.102,True,orthorhombic +mp-849469,Li2Mn2(SiO3)3,Pnma,-2.764,0.083,3.248,64,2.436,959.619,False,orthorhombic +mp-850969,LiMnSiO4,Pna21,-2.591,0.087,1.569,28,2.988,342.286,True,orthorhombic +mp-780790,Li2Mn2Si2O9,Pnca,-2.481,0.088,0.889,60,3.573,602.169,True,orthorhombic +mp-780750,LiMnSiO4,Ibmm,-2.584,0.093,0.0,14,3.855,132.65,True,orthorhombic +mp-761352,LiMnSiO4,Imma,-2.581,0.097,0.903,14,3.739,136.74,True,orthorhombic +mp-764790,Li2FeSiO4,Pcmn,-2.626,0.0,3.121,32,3.094,347.336,True,orthorhombic +mp-18968,Li2FeSiO4,P21nm,-2.626,0.001,3.124,16,3.123,172.094,True,orthorhombic +mp-761416,LiFe(SiO3)2,Pbca,-2.818,0.003,2.745,80,3.333,856.726,True,orthorhombic +mp-764346,Li2FeSiO4,P21cn,-2.621,0.005,2.993,32,3.065,350.604,True,orthorhombic +mp-763645,Li2FeSiO4,Pmnb,-2.621,0.005,3.089,32,3.049,352.518,True,orthorhombic +mp-764341,Li3FeSiO5,P21nb,-2.56,0.008,2.314,40,2.831,433.391,True,orthorhombic +mp-762557,Li2FeSiO4,Pna21,-2.618,0.009,2.946,32,3.01,357.063,True,orthorhombic +mp-863851,LiFeSiO4,Pbnm,-2.611,0.01,2.3,28,3.563,288.72,True,orthorhombic +mp-765849,LiFe(SiO3)2,C222,-2.81,0.011,3.023,10,2.523,141.451,True,orthorhombic +mp-762566,Li2FeSiO4,C2221,-2.615,0.011,2.965,16,2.948,182.303,True,orthorhombic +mp-762540,Li2FeSiO4,Pbn21,-2.613,0.014,2.924,32,3.07,350.111,True,orthorhombic +mp-767964,Li2Fe(SiO3)2,Fdd2,-2.791,0.015,3.314,22,2.807,262.576,True,orthorhombic +mp-762581,LiFeSiO4,Pn21a,-2.604,0.018,2.961,28,2.89,355.979,True,orthorhombic +mp-764340,Li2FeSiO4,Pc21n,-2.607,0.02,2.957,32,2.986,359.989,True,orthorhombic +mp-763641,LiFeSiO4,Pb21a,-2.598,0.023,2.959,56,2.881,714.127,True,orthorhombic +mp-762799,LiFeSiO4,Pb21a,-2.598,0.024,2.979,56,2.875,715.629,True,orthorhombic +mp-763635,LiFeSiO4,Pna21,-2.597,0.025,2.963,28,2.866,358.902,True,orthorhombic +mp-767253,LiFeSiO4,C2221,-2.597,0.025,2.874,14,2.863,179.638,True,orthorhombic +mp-766714,Li3Fe(Si2O5)3,Cmce,-2.976,0.032,3.386,100,2.592,1243.201,False,orthorhombic +mp-762643,LiFeSiO4,Cmcm,-2.588,0.034,1.657,14,3.628,141.773,True,orthorhombic +mp-766664,LiFeSiO4,Pna21,-2.587,0.035,1.675,84,3.644,846.947,True,orthorhombic +mp-761764,Li3Fe(Si2O5)3,Pcmn,-2.971,0.037,3.262,100,2.735,1178.251,False,orthorhombic +mp-762844,Li4Fe2Si4O13,Pna21,-2.743,0.038,2.78,92,3.104,983.89,False,orthorhombic +mp-868323,LiFeSiO4,Pbnm,-2.582,0.04,1.989,28,3.634,283.063,True,orthorhombic +mp-767850,LiFeSiO4,Pc21n,-2.58,0.042,2.87,28,2.914,353.0,True,orthorhombic +mp-766989,LiFe(Si2O5)2,Pnc2,-2.952,0.043,3.053,32,2.798,397.806,True,orthorhombic +mp-761405,Li2Fe2Si2O7,C2cm,-2.603,0.046,3.129,26,3.414,285.751,True,orthorhombic +mp-773415,Li2Fe2(Si2O5)3,Cmce,-2.904,0.05,3.152,100,2.651,1338.234,False,orthorhombic +mp-761767,LiFe(SiO3)2,Pbca,-2.77,0.051,2.981,80,3.098,921.698,False,orthorhombic +mp-767743,LiFeSiO4,Pbn21,-2.569,0.052,2.833,28,2.869,358.537,True,orthorhombic +mp-762703,LiFeSiO4,P21nb,-2.566,0.055,2.63,28,2.882,356.872,True,orthorhombic +mp-762545,Li2FeSiO4,Pca21,-2.571,0.056,2.78,64,2.875,747.562,True,orthorhombic +mp-762587,LiFeSiO4,Pb21a,-2.565,0.057,2.855,56,2.874,715.92,True,orthorhombic +mp-762570,Li3FeSi2O7,Pbnm,-2.691,0.057,2.512,52,2.89,562.749,True,orthorhombic +mp-851283,LiFeSiO4,Pc21n,-2.564,0.058,2.73,28,2.856,360.121,True,orthorhombic +mp-863911,Li2Fe(SiO3)2,Fdd2,-2.748,0.058,2.917,66,2.723,811.767,True,orthorhombic +mp-762804,LiFeSiO4,P21nb,-2.563,0.059,2.551,28,2.966,346.859,True,orthorhombic +mp-766752,Li7Fe7SiO16,C222,-2.142,0.062,1.438,31,4.186,287.012,True,orthorhombic +mp-863885,LiFe(SiO3)2,C2221,-2.757,0.064,3.23,40,2.375,601.224,True,orthorhombic +mp-775303,Li2Fe(Si2O5)3,Cmce,-2.918,0.067,3.155,96,2.527,1257.084,False,orthorhombic +mp-761559,LiFeSiO4,Pna21,-2.554,0.068,2.603,28,2.934,350.638,True,orthorhombic +mp-761450,LiFeSi3O8,P212121,-2.858,0.069,3.182,52,2.676,682.572,True,orthorhombic +mp-868349,LiFeSiO4,Pna21,-2.551,0.07,2.631,28,2.984,344.706,True,orthorhombic +mp-766964,Li2Fe2SiO6,C222,-2.365,0.072,2.493,11,2.625,157.939,True,orthorhombic +mp-762620,Li2Fe(Si2O5)2,P212121,-2.899,0.076,3.435,68,2.323,977.912,False,orthorhombic +mp-773468,LiFeSiO4,Imma,-2.546,0.076,1.311,14,3.898,131.954,True,orthorhombic +mp-863888,Li2Fe(SiO3)2,Pmn21,-2.73,0.076,2.624,66,3.023,731.236,True,orthorhombic +mp-762576,Li2Fe2Si2O7,C2cm,-2.573,0.076,2.7,26,3.039,320.953,True,orthorhombic +mp-762534,Li2Fe2(SiO3)3,Pnma,-2.69,0.077,3.087,64,3.128,751.301,True,orthorhombic +mp-762648,LiFeSiO4,P212121,-2.544,0.078,1.873,28,3.34,307.957,True,orthorhombic +mp-762533,Li2Fe2(SiO3)3,Pnma,-2.69,0.078,3.114,64,2.573,913.228,False,orthorhombic +mp-762686,LiFeSiO4,Pna21,-2.544,0.078,2.38,28,2.872,358.225,True,orthorhombic +mp-763624,Li2Fe(SiO3)2,Pm21n,-2.726,0.08,2.88,66,3.017,732.676,True,orthorhombic +mp-762696,LiFeSiO4,Pbca,-2.539,0.083,1.791,56,2.96,694.96,True,orthorhombic +mp-762746,Li2Fe2SiO6,Fdd2,-2.348,0.089,2.223,66,2.98,834.696,True,orthorhombic +mp-868335,Li2Fe2Si3O10,F2dd,-2.647,0.092,3.04,34,2.286,537.355,True,orthorhombic +mp-865154,LiFe(Si3O7)2,Icma,-2.981,0.093,2.647,88,2.807,1077.384,False,orthorhombic +mp-762827,Li5Fe(SiO4)2,Pnma,-2.598,0.094,2.082,128,2.655,1374.684,False,orthorhombic +mp-762638,LiFeSiO4,P21nb,-2.527,0.095,2.128,56,2.635,780.749,True,orthorhombic +mp-762775,Li2Fe2Si2O9,Pnca,-2.339,0.111,0.033,60,3.442,628.652,False,orthorhombic +mp-763746,Li2FeSiO5,Pmc21,-2.342,0.112,0.0,36,3.125,377.974,True,orthorhombic +mp-775750,LiFe(Si2O5)3,Cmce,-2.836,0.122,2.611,92,2.508,1248.278,False,orthorhombic +mp-767128,Li2CoSiO4,P21nm,-2.532,0.005,2.72,16,3.249,168.54,True,orthorhombic +mp-764641,Li2CoSiO4,Pc21n,-2.532,0.005,2.918,32,3.181,344.33,True,orthorhombic +mp-763304,Li2CoSiO4,Pc21n,-2.532,0.005,2.994,32,3.148,347.939,True,orthorhombic +mp-763309,Li2CoSiO4,Pcmn,-2.531,0.006,2.841,32,3.231,338.972,True,orthorhombic +mp-764956,Li2CoSiO4,C2221,-2.527,0.01,2.8,16,3.104,176.442,True,orthorhombic +mp-763391,Li2Co(SiO3)2,F2dd,-2.729,0.012,2.973,22,2.888,258.73,True,orthorhombic +mp-763485,Li2CoSiO4,Pmnb,-2.523,0.014,2.693,32,3.159,346.674,True,orthorhombic +mp-764957,Li2CoSiO4,Pbn21,-2.522,0.015,2.757,32,3.226,339.508,True,orthorhombic +mp-763492,Li3CoSiO5,P21nb,-2.418,0.033,1.176,40,2.941,424.186,True,orthorhombic +mp-762880,LiCoSiO4,Pn21a,-2.376,0.06,1.422,28,3.033,345.946,True,orthorhombic +mp-763240,LiCoSiO4,C2221,-2.374,0.062,1.265,14,2.98,176.01,True,orthorhombic +mp-543100,LiCoSiO4,Pbn21,-2.371,0.065,1.398,28,2.985,351.446,True,orthorhombic +mp-763443,Li2Co(SiO3)2,Fdd2,-2.675,0.065,2.969,66,2.861,783.351,True,orthorhombic +mp-763589,LiCoSiO4,Pb21a,-2.37,0.066,1.194,56,3.014,696.129,True,orthorhombic +mp-763584,LiCoSiO4,Pb21a,-2.369,0.067,1.31,56,3.029,692.711,True,orthorhombic +mp-772320,Li2CoSiO4,Pca21,-2.467,0.07,2.916,64,3.046,719.179,True,orthorhombic +mp-763369,Li2Co2Si2O7,C2cm,-2.455,0.07,2.344,26,3.213,309.993,True,orthorhombic +mp-779191,LiCoSiO4,Pbn21,-2.365,0.07,1.527,28,3.029,346.421,False,orthorhombic +mp-763386,Li2Co2Si2O7,C2cm,-2.453,0.072,2.84,26,3.579,278.304,True,orthorhombic +mp-763376,Li2Co(Si2O5)2,P212121,-2.858,0.075,3.273,68,2.37,967.213,True,orthorhombic +mp-763406,Li2Co2(SiO3)3,Pnma,-2.591,0.076,2.744,64,2.658,899.635,True,orthorhombic +mp-762722,LiCoSiO4,P21nb,-2.353,0.082,1.411,28,3.112,337.098,True,orthorhombic +mp-762892,LiCoSiO4,Pcmn,-2.352,0.083,0.77,28,3.736,280.858,True,orthorhombic +mp-763260,LiCoSiO4,Pc21n,-2.352,0.083,1.367,28,2.935,357.496,True,orthorhombic +mp-762888,LiCoSiO4,Cmcm,-2.351,0.084,0.871,14,3.762,139.432,True,orthorhombic +mp-779192,LiCoSiO4,P21nb,-2.351,0.084,1.323,28,3.0,349.762,True,orthorhombic +mp-763360,Li2Co2(SiO3)3,Pnma,-2.574,0.094,2.842,64,3.249,735.894,True,orthorhombic +mp-762860,LiCoSiO4,Pcmn,-2.339,0.097,0.736,28,3.605,291.06,True,orthorhombic +mp-762247,LiCoSiO4,P212121,-2.327,0.109,0.702,28,3.203,327.583,True,orthorhombic +mp-762883,LiCoSiO4,Imcm,-2.291,0.144,0.511,14,4.15,126.395,True,orthorhombic +mp-763534,Li2Co2SiO6,Ccme,-2.012,0.19,0.717,22,3.927,216.338,True,orthorhombic +mp-767711,Li2Mn2Si4O11,P1,-2.904,0.012,0.904,38,3.098,441.742,True,triclinic +mp-868265,Li2Mn4Si4O13,P1,-2.755,0.019,2.346,46,3.481,528.536,True,triclinic +mp-761470,Li2Mn2Si5O13,P1,-2.946,0.02,3.286,44,3.009,521.131,True,triclinic +mp-868673,Li15Mn15SiO32,P1,-2.194,0.028,0.311,63,4.093,595.723,False,triclinic +mp-761381,Li2Mn5(Si2O7)2,P1,-2.69,0.031,0.0,25,3.434,302.156,True,triclinic +mp-766967,Li2Mn3(Si3O8)2,P1,-2.894,0.043,2.865,54,3.012,665.118,True,triclinic +mp-767443,Li2Mn5Si5O16,P1,-2.736,0.045,2.164,28,2.985,381.117,True,triclinic +mp-850240,Li2Mn3(SiO4)2,P1,-2.61,0.05,2.045,45,3.062,590.331,True,triclinic +mp-850159,Li2Mn(Si2O5)2,P1,-2.958,0.054,3.036,34,2.633,430.361,True,triclinic +mp-761439,LiMn(SiO3)2,P1,-2.801,0.059,0.714,80,3.314,858.022,True,triclinic +mp-768071,Li5Mn17(SiO16)2,P1,-2.172,0.059,0.348,56,4.201,607.507,True,triclinic +mp-761417,Li2Mn2Si4O11,P1,-2.847,0.069,0.0,38,2.897,472.42,True,triclinic +mp-868526,Li9Mn5(SiO8)2,P1,-2.372,0.07,1.154,32,3.706,290.951,True,triclinic +mp-767282,Li2MnSi3O8,P1,-2.872,0.082,2.655,14,2.497,186.943,True,triclinic +mp-761967,LiMnSi3O8,P1,-2.868,0.09,1.055,26,2.963,307.264,False,triclinic +mp-767982,Li3Mn2(SiO4)2,P1,-2.605,0.09,0.0,15,2.938,177.985,True,triclinic +mp-761430,Li7Mn11(Si3O16)2,P1,-2.439,0.092,0.361,56,3.909,566.407,False,triclinic +mp-780147,LiMnSiO4,P1,-2.58,0.098,0.995,28,3.294,310.44,True,triclinic +mp-767274,Li3MnSi2O7,P1,-2.68,0.099,1.161,13,2.709,149.499,True,triclinic +mp-780196,LiMnSiO4,P1,-2.577,0.1,0.409,28,2.984,342.663,True,triclinic +mp-761735,Li2Fe2Si4O11,P1,-2.837,0.013,1.892,38,3.189,431.059,True,triclinic +mp-765915,LiFe(SiO3)2,P1,-2.791,0.03,3.056,20,2.2,324.509,True,triclinic +mp-868566,LiFe(SiO3)2,P1,-2.79,0.031,2.427,30,3.193,335.392,True,triclinic +mp-761402,Li2Fe5(Si2O7)2,P1,-2.563,0.031,0.0,25,3.492,299.319,True,triclinic +mp-761459,LiFeSi3O8,P1,-2.896,0.032,3.342,26,2.76,330.953,False,triclinic +mp-761705,Li2Fe4Si4O13,P1,-2.632,0.032,3.118,46,3.599,514.551,False,triclinic +mp-761475,Li2Fe2Si5O13,P1,-2.875,0.034,3.394,44,3.086,510.174,True,triclinic +mp-773691,LiFe(SiO3)2,P1,-2.785,0.036,2.596,80,3.251,878.288,False,triclinic +mp-767996,Li3Fe2(SiO4)2,P1,-2.585,0.039,1.626,15,2.951,178.21,True,triclinic +mp-761820,LiFeSi3O8,P1,-2.886,0.041,3.16,26,2.703,337.873,True,triclinic +mp-767726,Li2Fe2Si3O10,P1,-2.694,0.044,2.325,34,2.821,435.364,True,triclinic +mp-763810,Li17Fe6(Si2O7)6,P1,-2.691,0.046,0.0,77,2.868,846.546,False,triclinic +mp-767707,Li2Fe5Si5O16,P1,-2.62,0.049,2.117,28,3.101,369.232,True,triclinic +mp-761382,Li2Fe3(Si3O8)2,P1,-2.817,0.05,2.826,54,3.088,651.656,True,triclinic +mp-762716,Li2Fe3(SiO4)2,P1,-2.482,0.051,2.23,45,3.204,568.378,True,triclinic +mp-780681,LiFe3(SiO4)2,P1,-2.468,0.058,0.631,42,3.133,570.329,True,triclinic +mp-763739,Li3Fe2(SiO4)2,P1,-2.565,0.059,1.14,15,3.034,173.298,True,triclinic +mp-761622,Li7Fe7SiO16,P1,-2.144,0.06,1.955,31,3.232,371.739,True,triclinic +mp-768001,Li6Fe(SiO4)2,P1,-2.595,0.063,3.736,17,2.678,174.618,True,triclinic +mp-772589,Li2Fe(Si2O5)2,P1,-2.911,0.064,3.079,34,2.633,431.422,False,triclinic +mp-764102,Li3Fe2(SiO4)2,P1,-2.558,0.066,0.931,30,2.911,361.337,True,triclinic +mp-761513,LiFeSi3O8,P1,-2.859,0.068,2.413,26,2.896,315.39,False,triclinic +mp-850922,Li3Fe2(SiO4)2,P1,-2.555,0.069,1.854,15,2.925,179.798,True,triclinic +mp-762655,LiFeSiO4,P1,-2.551,0.071,2.292,28,2.969,346.461,True,triclinic +mp-763637,Li4Fe2SiO7,P1,-2.356,0.071,1.851,14,3.787,122.581,True,triclinic +mp-767328,Li5Fe5Si7O24,P1,-2.647,0.072,2.373,41,2.501,593.87,True,triclinic +mp-868319,Li5Fe5Si7O24,P1,-2.646,0.072,2.598,41,2.546,583.402,True,triclinic +mp-863852,Li5Fe5Si7O24,P1,-2.646,0.073,2.391,41,2.55,582.533,True,triclinic +mp-772382,Li2FeSi3O8,P1,-2.833,0.076,3.041,14,2.524,185.499,True,triclinic +mp-766744,Li2Fe2Si4O11,P1,-2.768,0.081,0.0,38,2.958,464.73,True,triclinic +mp-779820,Li3Fe4(Si3O10)2,P1,-2.633,0.082,0.054,33,2.777,438.109,True,triclinic +mp-868418,Li2FeSi3O8,P1,-2.826,0.082,0.0,28,2.507,373.616,True,triclinic +mp-773385,Li3FeSiO5,P1,-2.486,0.083,2.254,20,3.575,171.619,True,triclinic +mp-767276,Li5Fe5Si7O24,P1,-2.635,0.084,1.827,41,2.433,610.604,True,triclinic +mp-762704,Li4Fe(SiO4)2,P1,-2.543,0.089,0.232,15,2.781,159.895,False,triclinic +mp-767753,Li2Fe2Si8O19,P1,-2.927,0.091,3.508,31,2.776,391.367,True,triclinic +mp-762705,Li3FeSiO5,P1,-2.474,0.094,2.173,20,3.615,169.712,True,triclinic +mp-762768,Li9Fe4(SiO5)4,P1,-2.391,0.094,0.005,37,2.617,455.754,False,triclinic +mp-778793,Li4Fe3(SiO4)3,P1,-2.524,0.099,0.976,22,3.031,258.368,True,triclinic +mp-761351,Li2Fe(Si2O5)3,P1,-2.882,0.104,0.189,24,2.624,302.599,False,triclinic +mp-761343,Li16Fe4SiO16,P1,-2.132,0.106,2.139,37,2.668,384.899,True,triclinic +mp-762762,LiFe2(SiO4)2,P1,-2.426,0.114,0.0,39,2.753,547.911,False,triclinic +mp-761348,Li7Fe7SiO16,P1,-2.087,0.118,1.492,31,3.233,371.607,True,triclinic +mp-763462,Li2Co3(SiO4)2,P1,-2.343,0.024,2.47,45,3.408,547.959,True,triclinic +mp-762851,Li3Co2(SiO4)2,P1,-2.441,0.055,0.376,15,3.088,173.602,True,triclinic +mp-764452,Li3Co2(SiO4)2,P1,-2.439,0.057,0.23,15,3.024,177.312,True,triclinic +mp-770682,Li2Co(Si2O5)2,P1,-2.862,0.07,3.06,34,2.74,418.368,True,triclinic +mp-764961,Li6Co(SiO4)2,P1,-2.545,0.071,2.685,17,2.753,171.772,True,triclinic +mp-849520,LiCo3(SiO4)2,P1,-2.25,0.076,0.005,42,3.318,552.402,True,triclinic +mp-849656,Li5Co4(Si3O10)2,P1,-2.529,0.082,0.176,35,2.94,428.648,True,triclinic +mp-763557,LiCoSiO4,P1,-2.348,0.087,1.333,14,2.451,214.044,True,triclinic +mp-767320,Li3Co2(SiO4)2,P1,-2.406,0.09,0.323,15,3.043,176.207,False,triclinic