\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input output\n",
+ " x0 x1 y\n",
+ "0 finished 0.773956 0.438878 18.573435\n",
+ "1 finished 0.858598 0.697368 21.308662\n",
+ "2 finished 0.094177 0.975622 21.815402\n",
+ "3 finished 0.761140 0.786064 20.719672\n",
+ "4 finished 0.128114 0.450386 21.396762\n",
+ "5 finished 0.370798 0.926765 21.396784\n",
+ "6 finished 0.643865 0.822762 21.112180\n",
+ "7 finished 0.443414 0.227239 19.952145\n",
+ "8 finished 0.554585 0.063817 21.959833\n",
+ "9 finished 0.827631 0.631664 21.527180"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from f3dasm import ExperimentData\n",
+ "# 1. Sample the points from the domain\n",
+ "experiment_data = ExperimentData.from_sampling(sampler='random', domain=domain, n_samples=10, seed=42)\n",
+ "\n",
+ "# 2. Evaluate the points with the built-in Ackley function\n",
+ "experiment_data.evaluate('Ackley', scale_bounds=[[0., 1.], [0., 1.]], offset=False)\n",
+ "\n",
+ "experiment_data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we will use the built-in optimization algorithm `'Nelder-Mead'` to minimize the output paramater `'y'`"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Method 1: Using the Optimizer Name as a String\n",
+ "\n",
+ "You can easily initiate optimization by calling the `optimize()` method of the `ExperimentData` object and passing the optimizer's name as a string.\n",
+ "\n",
+ "- **Iterative Optimization Process**: Since optimization occurs iteratively, you need to evaluate new points and update the `ExperimentData` object with the resulting data. To facilitate this, pass a `DataGenerator` object as an argument to the `optimize()` method. Any additional arguments for the `DataGenerator` can be provided as a dictionary through the `kwargs` parameter.\n",
+ "- **Default and Custom Hyperparameters**: By default, the optimizer runs with predefined hyperparameters. To customize them, pass the desired hyperparameters as keyword arguments to the `optimize()` method.\n",
+ "- **Specifying Iterations**: Use the `iterations` keyword to specify the number of function evaluations to perform during optimization.\n",
+ "- **Initial Point Strategy (`x0_strategy`)**: This argument defines how the starting point of the optimization is selected:\n",
+ " - `'best'` (default): Uses the best point in the `ExperimentData` object as the starting point.\n",
+ " - `'last'`: Uses the most recently added point in the `ExperimentData` object as the starting point.\n",
+ " - `'new'`: Samples a new random point from the search space. Optionally, you can specify a `sampler` argument to control how the initial point is sampled (defaults to random uniform sampling)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/home/martin/mambaforge/envs/f3dasm_env3/lib/python3.8/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+ " from .autonotebook import tqdm as notebook_tqdm\n",
+ "/home/martin/mambaforge/envs/f3dasm_env3/lib/python3.8/site-packages/scipy/optimize/_minimize.py:549: RuntimeWarning: Method Nelder-Mead does not use gradient information (jac).\n",
+ " warn('Method %s does not use gradient information (jac).' % method,\n"
+ ]
+ }
+ ],
+ "source": [
+ "experiment_data.optimize(optimizer='nelder mead', data_generator='ackley',\n",
+ " kwargs={'scale_bounds': [[0., 1.], [0., 1.]], 'offset': False},\n",
+ " iterations=10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "output | \n", + "|
|---|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "y | \n", + "
| 0 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "18.573435 | \n", + "
| 1 | \n", + "finished | \n", + "0.858598 | \n", + "0.697368 | \n", + "21.308662 | \n", + "
| 2 | \n", + "finished | \n", + "0.094177 | \n", + "0.975622 | \n", + "21.815402 | \n", + "
| 3 | \n", + "finished | \n", + "0.761140 | \n", + "0.786064 | \n", + "20.719672 | \n", + "
| 4 | \n", + "finished | \n", + "0.128114 | \n", + "0.450386 | \n", + "21.396762 | \n", + "
| 5 | \n", + "finished | \n", + "0.370798 | \n", + "0.926765 | \n", + "21.396784 | \n", + "
| 6 | \n", + "finished | \n", + "0.643865 | \n", + "0.822762 | \n", + "21.112180 | \n", + "
| 7 | \n", + "finished | \n", + "0.443414 | \n", + "0.227239 | \n", + "19.952145 | \n", + "
| 8 | \n", + "finished | \n", + "0.554585 | \n", + "0.063817 | \n", + "21.959833 | \n", + "
| 9 | \n", + "finished | \n", + "0.827631 | \n", + "0.631664 | \n", + "21.527180 | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input output\n",
+ " x0 x1 y\n",
+ "0 finished 0.773956 0.438878 18.573435\n",
+ "1 finished 0.858598 0.697368 21.308662\n",
+ "2 finished 0.094177 0.975622 21.815402\n",
+ "3 finished 0.761140 0.786064 20.719672\n",
+ "4 finished 0.128114 0.450386 21.396762\n",
+ "5 finished 0.370798 0.926765 21.396784\n",
+ "6 finished 0.643865 0.822762 21.112180\n",
+ "7 finished 0.443414 0.227239 19.952145\n",
+ "8 finished 0.554585 0.063817 21.959833\n",
+ "9 finished 0.827631 0.631664 21.527180\n",
+ "10 finished 0.773956 0.438878 21.465102\n",
+ "11 finished 0.773956 0.438878 21.465102\n",
+ "12 finished 0.773956 0.438878 21.465102\n",
+ "13 finished 0.773956 0.438878 21.465102\n",
+ "14 finished 0.773956 0.438878 21.465102\n",
+ "15 finished 0.773956 0.438878 21.465102\n",
+ "16 finished 0.773956 0.438878 21.465102\n",
+ "17 finished 0.773956 0.438878 21.465102\n",
+ "18 finished 0.773956 0.438878 21.465102\n",
+ "19 finished 0.773956 0.438878 21.465102"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "experiment_data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Method 2: Importing the optimizer from the `f3dasm.optimization` module\n",
+ "\n",
+ "Alternatively, you can import the optimizer from the `f3dasm.optimization` module and use it directly. This method provides more flexibility in customizing the optimizer's hyperparameters and behavior."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Recreate the experiment data before optimizing\n",
+ "experiment_data = ExperimentData.from_sampling(\n",
+ " sampler='random', domain=domain, n_samples=10, seed=42\n",
+ " )\n",
+ "\n",
+ "experiment_data.evaluate('Ackley', scale_bounds=[[0., 1.], [0., 1.]], offset=False)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from f3dasm.optimization import nelder_mead"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The `nelder_mead` function can be called without parameters to use the default hyperparameters. To customize the optimizer, pass the desired hyperparameters as keyword arguments to the constructor:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "optimizer = nelder_mead()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now, we call the `optimize()` method with the optimizer object to perform the optimization."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/home/martin/mambaforge/envs/f3dasm_env3/lib/python3.8/site-packages/scipy/optimize/_minimize.py:549: RuntimeWarning: Method Nelder-Mead does not use gradient information (jac).\n",
+ " warn('Method %s does not use gradient information (jac).' % method,\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "output | \n", + "|
|---|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "y | \n", + "
| 0 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "18.573435 | \n", + "
| 1 | \n", + "finished | \n", + "0.858598 | \n", + "0.697368 | \n", + "21.308662 | \n", + "
| 2 | \n", + "finished | \n", + "0.094177 | \n", + "0.975622 | \n", + "21.815402 | \n", + "
| 3 | \n", + "finished | \n", + "0.761140 | \n", + "0.786064 | \n", + "20.719672 | \n", + "
| 4 | \n", + "finished | \n", + "0.128114 | \n", + "0.450386 | \n", + "21.396762 | \n", + "
| 5 | \n", + "finished | \n", + "0.370798 | \n", + "0.926765 | \n", + "21.396784 | \n", + "
| 6 | \n", + "finished | \n", + "0.643865 | \n", + "0.822762 | \n", + "21.112180 | \n", + "
| 7 | \n", + "finished | \n", + "0.443414 | \n", + "0.227239 | \n", + "19.952145 | \n", + "
| 8 | \n", + "finished | \n", + "0.554585 | \n", + "0.063817 | \n", + "21.959833 | \n", + "
| 9 | \n", + "finished | \n", + "0.827631 | \n", + "0.631664 | \n", + "21.527180 | \n", + "
| 10 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 11 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 12 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 13 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 14 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 15 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 16 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 17 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 18 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 19 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input output\n",
+ " x0 x1 y\n",
+ "0 finished 0.773956 0.438878 18.573435\n",
+ "1 finished 0.858598 0.697368 21.308662\n",
+ "2 finished 0.094177 0.975622 21.815402\n",
+ "3 finished 0.761140 0.786064 20.719672\n",
+ "4 finished 0.128114 0.450386 21.396762\n",
+ "5 finished 0.370798 0.926765 21.396784\n",
+ "6 finished 0.643865 0.822762 21.112180\n",
+ "7 finished 0.443414 0.227239 19.952145\n",
+ "8 finished 0.554585 0.063817 21.959833\n",
+ "9 finished 0.827631 0.631664 21.527180\n",
+ "10 finished 0.773956 0.438878 21.465102\n",
+ "11 finished 0.773956 0.438878 21.465102\n",
+ "12 finished 0.773956 0.438878 21.465102\n",
+ "13 finished 0.773956 0.438878 21.465102\n",
+ "14 finished 0.773956 0.438878 21.465102\n",
+ "15 finished 0.773956 0.438878 21.465102\n",
+ "16 finished 0.773956 0.438878 21.465102\n",
+ "17 finished 0.773956 0.438878 21.465102\n",
+ "18 finished 0.773956 0.438878 21.465102\n",
+ "19 finished 0.773956 0.438878 21.465102"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "experiment_data.optimize(optimizer='nelder mead', data_generator='ackley',\n",
+ " kwargs={'scale_bounds': [[0., 1.], [0., 1.]], 'offset': False},\n",
+ " iterations=10)\n",
+ "\n",
+ "experiment_data"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "f3dasm_env3",
+ "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.17"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/source/notebooks/builtins/builtinsamplers.ipynb b/docs/source/notebooks/builtins/builtinsamplers.ipynb
new file mode 100644
index 00000000..6d922a45
--- /dev/null
+++ b/docs/source/notebooks/builtins/builtinsamplers.ipynb
@@ -0,0 +1,389 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Use the built-in sampling strategies\n",
+ "\n",
+ "In this example, we will use the built-in sampling strategies provided by `f3dasm` to generate samples for a data-driven experiment.\n",
+ "We first create 2D continuous input domain with the `make_nd_continuous_domain()` helper function:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Domain(input_space={'x0': ContinuousParameter(lower_bound=0.0, upper_bound=1.0, log=False), 'x1': ContinuousParameter(lower_bound=0.0, upper_bound=1.0, log=False)}, output_space={})"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from f3dasm.design import make_nd_continuous_domain\n",
+ "domain = make_nd_continuous_domain(bounds=[[0., 1.], [0., 1.]])\n",
+ "domain"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Sampling from this domain can be done in two ways:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Method 1: Providing a sampler name as a string:\n",
+ "\n",
+ "\n",
+ "simply call the `ExperimentData.from_sampling` method of the with the domain and the name of the sampler as a string. Some sampler require additional parameters, which can be passed as keyword arguments:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "output | \n", + "|
|---|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "y | \n", + "
| 0 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "18.573435 | \n", + "
| 1 | \n", + "finished | \n", + "0.858598 | \n", + "0.697368 | \n", + "21.308662 | \n", + "
| 2 | \n", + "finished | \n", + "0.094177 | \n", + "0.975622 | \n", + "21.815402 | \n", + "
| 3 | \n", + "finished | \n", + "0.761140 | \n", + "0.786064 | \n", + "20.719672 | \n", + "
| 4 | \n", + "finished | \n", + "0.128114 | \n", + "0.450386 | \n", + "21.396762 | \n", + "
| 5 | \n", + "finished | \n", + "0.370798 | \n", + "0.926765 | \n", + "21.396784 | \n", + "
| 6 | \n", + "finished | \n", + "0.643865 | \n", + "0.822762 | \n", + "21.112180 | \n", + "
| 7 | \n", + "finished | \n", + "0.443414 | \n", + "0.227239 | \n", + "19.952145 | \n", + "
| 8 | \n", + "finished | \n", + "0.554585 | \n", + "0.063817 | \n", + "21.959833 | \n", + "
| 9 | \n", + "finished | \n", + "0.827631 | \n", + "0.631664 | \n", + "21.527180 | \n", + "
| 10 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 11 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 12 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 13 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 14 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 15 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 16 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 17 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 18 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
| 19 | \n", + "finished | \n", + "0.773956 | \n", + "0.438878 | \n", + "21.465102 | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input \n",
+ " x0 x1\n",
+ "0 open 0.773956 0.438878\n",
+ "1 open 0.858598 0.697368\n",
+ "2 open 0.094177 0.975622\n",
+ "3 open 0.761140 0.786064\n",
+ "4 open 0.128114 0.450386\n",
+ "5 open 0.370798 0.926765\n",
+ "6 open 0.643865 0.822762\n",
+ "7 open 0.443414 0.227239\n",
+ "8 open 0.554585 0.063817\n",
+ "9 open 0.827631 0.631664"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from f3dasm import ExperimentData\n",
+ "\n",
+ "samples = ExperimentData.from_sampling(sampler='random', domain=domain,\n",
+ " seed=42, n_samples=10)\n",
+ "\n",
+ "samples"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Method 2: Importing the sampler from the `f3dasm.design` module\n",
+ "\n",
+ "Another way is to import e.g. the `random()` sampler from the `f3dasm.design` module and pass it to the `ExperimentData.from_sampling` method:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from f3dasm.design import random\n",
+ "\n",
+ "sampler = random(seed=42)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "|
|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "
| 0 | \n", + "open | \n", + "0.773956 | \n", + "0.438878 | \n", + "
| 1 | \n", + "open | \n", + "0.858598 | \n", + "0.697368 | \n", + "
| 2 | \n", + "open | \n", + "0.094177 | \n", + "0.975622 | \n", + "
| 3 | \n", + "open | \n", + "0.761140 | \n", + "0.786064 | \n", + "
| 4 | \n", + "open | \n", + "0.128114 | \n", + "0.450386 | \n", + "
| 5 | \n", + "open | \n", + "0.370798 | \n", + "0.926765 | \n", + "
| 6 | \n", + "open | \n", + "0.643865 | \n", + "0.822762 | \n", + "
| 7 | \n", + "open | \n", + "0.443414 | \n", + "0.227239 | \n", + "
| 8 | \n", + "open | \n", + "0.554585 | \n", + "0.063817 | \n", + "
| 9 | \n", + "open | \n", + "0.827631 | \n", + "0.631664 | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input \n",
+ " x0 x1\n",
+ "0 open 0.773956 0.438878\n",
+ "1 open 0.858598 0.697368\n",
+ "2 open 0.094177 0.975622\n",
+ "3 open 0.761140 0.786064\n",
+ "4 open 0.128114 0.450386\n",
+ "5 open 0.370798 0.926765\n",
+ "6 open 0.643865 0.822762\n",
+ "7 open 0.443414 0.227239\n",
+ "8 open 0.554585 0.063817\n",
+ "9 open 0.827631 0.631664"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "samples = ExperimentData.from_sampling(sampler=sampler, domain=domain,\n",
+ " n_samples=10)\n",
+ "\n",
+ "samples"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Text(0, 0.5, 'x1')"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "| \n", + " | jobs | \n", + "input | \n", + "|
|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "
| 0 | \n", + "open | \n", + "0.773956 | \n", + "0.438878 | \n", + "
| 1 | \n", + "open | \n", + "0.858598 | \n", + "0.697368 | \n", + "
| 2 | \n", + "open | \n", + "0.094177 | \n", + "0.975622 | \n", + "
| 3 | \n", + "open | \n", + "0.761140 | \n", + "0.786064 | \n", + "
| 4 | \n", + "open | \n", + "0.128114 | \n", + "0.450386 | \n", + "
| 5 | \n", + "open | \n", + "0.370798 | \n", + "0.926765 | \n", + "
| 6 | \n", + "open | \n", + "0.643865 | \n", + "0.822762 | \n", + "
| 7 | \n", + "open | \n", + "0.443414 | \n", + "0.227239 | \n", + "
| 8 | \n", + "open | \n", + "0.554585 | \n", + "0.063817 | \n", + "
| 9 | \n", + "open | \n", + "0.827631 | \n", + "0.631664 | \n", + "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "fig, ax = plt.subplots(figsize=(4, 4))\n",
+ "\n",
+ "df_random, _ = samples.to_pandas()\n",
+ "ax.scatter(df_random.iloc[:, 0], df_random.iloc[:, 1])\n",
+ "ax.set_xlabel(domain.input_names[0])\n",
+ "ax.set_ylabel(domain.input_names[1])"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "f3dasm_env3",
+ "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.17"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/source/notebooks/data-driven/block.png b/docs/source/notebooks/data-driven/block.png
new file mode 100644
index 00000000..b1c0eb57
Binary files /dev/null and b/docs/source/notebooks/data-driven/block.png differ
diff --git a/docs/source/notebooks/data-driven/block.svg b/docs/source/notebooks/data-driven/block.svg
new file mode 100644
index 00000000..33f8603f
--- /dev/null
+++ b/docs/source/notebooks/data-driven/block.svg
@@ -0,0 +1,221 @@
+
+
+
+
diff --git a/docs/source/notebooks/data-driven/blocks.ipynb b/docs/source/notebooks/data-driven/blocks.ipynb
new file mode 100644
index 00000000..29c343e6
--- /dev/null
+++ b/docs/source/notebooks/data-driven/blocks.ipynb
@@ -0,0 +1,142 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Blocks\n",
+ "\n",
+ "In the `f3dasm` framework, every component of the data-driven process is encapsulated as a `Block`. A block is an object designed to work with an `ExperimentData` instance. When invoked, it processes the data within the `ExperimentData` instance and produces a new `ExperimentData` instance. By chaining different blocks, you can construct a complete data-driven pipeline."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The block base class looks like this:\n",
+ "\n",
+ "```python\n",
+ "\n",
+ "class Block(ABC):\n",
+ " def arm(self, data: ExperimentData) -> None:\n",
+ " self.data = data\n",
+ "\n",
+ " @abstractmethod\n",
+ " def call(self, **kwargs) -> ExperimentData:\n",
+ " pass\n",
+ "\n",
+ "```\n",
+ "\n",
+ "To create a new block, subclass the `Block` class and implement the `call` method. This method is executed when the block is invoked, accepting any keyword arguments and returning an `ExperimentData` instance. Before the `call` method runs, the `arm` method is used to equip the block with the `ExperimentData` instance it will process.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Dimensions: (iterations: 3, input_dim: 2, output_dim: 1)\n",
+ "Coordinates:\n",
+ " * iterations (iterations) int64 0 1 2\n",
+ " * input_dim (input_dim) object 'x0' 'x1'\n",
+ " * output_dim (output_dim) object 'y'\n",
+ "Data variables:\n",
+ " input (iterations, input_dim) float64 0.1 0.4 0.2 0.5 0.3 0.6\n",
+ " output (iterations, output_dim) float64 0.5 0.6 nan"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "experimentdata.to_xarray()"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "f3dasm_env3",
+ "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.17"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/source/notebooks/experimentdata/input_data.csv b/docs/source/notebooks/experimentdata/input_data.csv
new file mode 100644
index 00000000..4fd60426
--- /dev/null
+++ b/docs/source/notebooks/experimentdata/input_data.csv
@@ -0,0 +1,4 @@
+,x0,x1
+0,0.1,0.4
+1,0.2,0.5
+2,0.3,0.6
diff --git a/docs/source/notebooks/experimentdata/my_project/experiment_data/domain.json b/docs/source/notebooks/experimentdata/my_project/experiment_data/domain.json
new file mode 100644
index 00000000..46af0a52
--- /dev/null
+++ b/docs/source/notebooks/experimentdata/my_project/experiment_data/domain.json
@@ -0,0 +1,30 @@
+{
+ "input_space": {
+ "x0": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 0.0,
+ "upper_bound": 1.0,
+ "log": false
+ },
+ "x1": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 0.0,
+ "upper_bound": 1.0,
+ "log": false
+ }
+ },
+ "output_space": {
+ "y": {
+ "type": "object",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null
+ }
+ }
+}
\ No newline at end of file
diff --git a/docs/source/notebooks/experimentdata/my_project/experiment_data/input.csv b/docs/source/notebooks/experimentdata/my_project/experiment_data/input.csv
new file mode 100644
index 00000000..4fd60426
--- /dev/null
+++ b/docs/source/notebooks/experimentdata/my_project/experiment_data/input.csv
@@ -0,0 +1,4 @@
+,x0,x1
+0,0.1,0.4
+1,0.2,0.5
+2,0.3,0.6
diff --git a/docs/source/notebooks/experimentdata/my_project/experiment_data/jobs.csv b/docs/source/notebooks/experimentdata/my_project/experiment_data/jobs.csv
new file mode 100644
index 00000000..f78a9d54
--- /dev/null
+++ b/docs/source/notebooks/experimentdata/my_project/experiment_data/jobs.csv
@@ -0,0 +1,4 @@
+,0
+0,FINISHED
+1,OPEN
+2,OPEN
diff --git a/docs/source/notebooks/experimentdata/my_project/experiment_data/output.csv b/docs/source/notebooks/experimentdata/my_project/experiment_data/output.csv
new file mode 100644
index 00000000..19b41063
--- /dev/null
+++ b/docs/source/notebooks/experimentdata/my_project/experiment_data/output.csv
@@ -0,0 +1,4 @@
+,y
+0,0.5
+1,0.6
+2,
diff --git a/docs/source/notebooks/hydra/usehydra.ipynb b/docs/source/notebooks/hydra/usehydra.ipynb
new file mode 100644
index 00000000..a2aed022
--- /dev/null
+++ b/docs/source/notebooks/hydra/usehydra.ipynb
@@ -0,0 +1,203 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Combining hydra configurations with `f3dasm`\n",
+ "\n",
+ "[hydra](https://hydra.cc/) is an open-source configuration management framework that is widely used in machine learning and other software development domains. It is designed to help developers manage and organize complex configuration settings for their projects, making it easier to experiment with different configurations, manage multiple environments, and maintain reproducibility in their work.\n",
+ "\n",
+ "[hydra](https://hydra.cc/) can be seamlessly integrated with the worfklows in f3dasm to manage the configuration settings for the project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from hydra import compose, initialize\n",
+ "\n",
+ "from f3dasm import ExperimentData\n",
+ "from f3dasm.design import Domain"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## `Domain` from a [hydra](https://hydra.cc/) configuration file\n",
+ "\n",
+ "If you are using [hydra](https://hydra.cc/) to manage your configuration files, you can create a `Domain` from a configuration file. Your config needs to have a key (e.g. `'domain'`) that has two keys: `'input_space'` and `'output_space'`. Each design space dictionary can have parameter names (e.g. `'param_1'`) as keys and a dictionary with an optional parameter type (`'type'`) and the corresponding arguments as values:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```yaml\n",
+ "domain:\n",
+ " input:\n",
+ " param_1:\n",
+ " type: float\n",
+ " low: -1.0\n",
+ " high: 1.0\n",
+ " param_2:\n",
+ " type: int\n",
+ " low: 1\n",
+ " high: 10\n",
+ " param_3:\n",
+ " type: category\n",
+ " categories: ['red', 'blue', 'green', 'yellow', 'purple']\n",
+ " param_4:\n",
+ " type: constant\n",
+ " value: some_value\n",
+ " output:\n",
+ " y:\n",
+ " to_disk: False\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In order to run the following code snippet, you need to have a configuration file named `'config.yaml'` in the current working directory."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```python\n",
+ "with initialize(version_base=None, config_path=\".\"):\n",
+ " config = compose(config_name=\"config\")\n",
+ "\n",
+ "domain = Domain.from_yaml(config.domain)\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## `ExperimentData` from a [hydra](https://hydra.cc/) configuration file"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If you are using [hydra](https://hydra.cc/) for configuring your experiments, you can use it to construct an `ExperimentData` object from the information in the `'config.yaml'` file with the `from_yaml()` method:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### `ExperimentData` from file\n",
+ "\n",
+ "You can create an `ExperimentData` object in the same way as the `from_file()` method, but with the `'from_file'` key in the `'config.yaml'` file:\n",
+ "\n",
+ "```yaml\n",
+ "experimentdata:\n",
+ " from_file: ./example_project_dir\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```python\n",
+ "\n",
+ "with initialize(version_base=None, config_path=\".\"):\n",
+ " config = compose(config_name=\"config\")\n",
+ "\n",
+ "\n",
+ "experiment_data = ExperimentData.from_yaml(config.experimentdata)\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## `ExperimentData` from sampling with [hydra](https://hydra.cc/)\n",
+ "\n",
+ "To create the `ExperimentData` object with the `from_sampling()` method, you can use the following configuration:\n",
+ "\n",
+ "```yaml\n",
+ "domain:\n",
+ " input:\n",
+ " param_1:\n",
+ " type: float\n",
+ " low: -1.0\n",
+ " high: 1.0\n",
+ " param_2:\n",
+ " type: int\n",
+ " low: 1\n",
+ " high: 10\n",
+ " param_3:\n",
+ " type: category\n",
+ " categories: ['red', 'blue', 'green', 'yellow', 'purple']\n",
+ " param_4:\n",
+ " type: constant\n",
+ " value: some_value\n",
+ " output:\n",
+ " y:\n",
+ " to_disk: False\n",
+ "\n",
+ "experimentdata:\n",
+ " from_sampling:\n",
+ " domain: ${domain}\n",
+ " sampler: random\n",
+ " seed: 1\n",
+ " n_samples: 1\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```python\n",
+ "\n",
+ "with initialize(version_base=None, config_path=\".\"):\n",
+ " config = compose(config_name=\"config\")\n",
+ "\n",
+ "experiment_data = ExperimentData.from_yaml(config.experimentdata)\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "> You can also combine both approaches to create the `ExperimentData` object by continuing an existing experiment with new samples. This can be done by providing both keys `'from_sampling'` and '`from_file'`"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "f3dasm_env3",
+ "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.17"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/source/readme.rst b/docs/source/readme.rst
index 2fa4d79a..8521ed4f 100644
--- a/docs/source/readme.rst
+++ b/docs/source/readme.rst
@@ -21,7 +21,7 @@ The best way to get started is to:
* Read the :ref:`overview` section, containing a brief introduction to the framework and a statement of need.
* Follow the :ref:`installation-instructions` to get going!
-* Check out the :ref:`examples` section, containing a collection of examples to get you familiar with the framework.
+* Check out the :ref:`tutorials` section, containing a collection of examples to get you familiar with the framework.
----
@@ -31,6 +31,28 @@ Authorship & Citation
.. [1] PhD Candiate, Delft University of Technology, `Website `_):
+
+ .. code-block:: bibtex
+
+ @article{vanderSchelling2024,
+ title = {f3dasm: Framework for Data-Driven Design and Analysis of Structures and Materials},
+ author = {M. P. van der Schelling and B. P. Ferreira and M. A. Bessa},
+ doi = {10.21105/joss.06912},
+ url = {https://doi.org/10.21105/joss.06912},
+ year = {2024},
+ publisher = {The Open Journal},
+ volume = {9},
+ number = {100},
+ pages = {6912},
+ journal = {Journal of Open Source Software}
+ }
+
+
----
Contribute
@@ -42,8 +64,9 @@ Contribute
Useful links
------------
* `GitHub repository `_ (source code)
-* `Wiki for development `_
+* `Journal of Open Source Software `_ (paper)
* `PyPI package `_
Related extension libraries
---------------------------
@@ -53,7 +76,7 @@ Related extension libraries
License
-------
-Copyright 2024, Martin van der Schelling
+Copyright 2025, Martin van der Schelling
All rights reserved.
diff --git a/docs/source/rst_doc_files/defaults.rst b/docs/source/rst_doc_files/defaults.rst
index 76d5b9a6..d583169a 100644
--- a/docs/source/rst_doc_files/defaults.rst
+++ b/docs/source/rst_doc_files/defaults.rst
@@ -1,6 +1,85 @@
Built-in functionalities
========================
+:mod:`f3dasm` provides a set of built-in functionalities that can be used to perform data-driven optimization and sensitivity analysis.
+All built-ins are implementations of the :class:`~f3dasm.Block` class and can be used on your :class:`~f3dasm.ExperimentData` object.
+
+Blocks can be run on a :class:`~f3dasm.ExperimentData` object by calling the :meth:`~f3dasm.ExperimentData.run` method.
+Alternatively, you can use the following methods for specific parts of the data-driven process.
+
+=============================== ======================================= ===================================================
+Part of the data-driven process Submodule for built-ins Method on :class:`~f3dasm.ExperimentData`
+=============================== ======================================= ===================================================
+Sampling :mod:`f3dasm.design` :meth:`f3dasm.ExperimentData.sample`
+Data generation :mod:`f3dasm.datageneration` :meth:`f3dasm.ExperimentData.evaluate`
+Optimization :mod:`f3dasm.optimization` :meth:`f3dasm.ExperimentData.optimize`
+=============================== ======================================= ===================================================
+
+:mod:`f3dasm` provides two ways to use the built-in functionalities:
+
+1. Call the built-in functions
+
+You can import the built-in functions directly from the respective submodules and call them to change the (hyper)parameters.
+
+.. code-block:: python
+
+ from f3dasm.design import random
+ from f3dasm.datageneration import ackley
+
+ # Call the random uniform sampler with a specific seed
+ sampler_block = random(seed=123)
+
+ # Create a 2D instance of the 'Ackley' function with its box-constraints scaled to [0, 1]
+ data_generation_block = ackley(scale_bounds=[[0., 1.], [0., 1.]])
+
+ # Create an empty Domain
+ domain = Domain()
+
+ # Add two continuous parameters 'x0' and 'x1'
+ domain.add_float(name='x0', low=0.0, high=1.0)
+ domain.add_float(name='x1', low=0.0, high=1.0)
+
+ # Create an empty ExperimentData object with the domain
+ experiment_data = ExperimentData(domain=domain)
+
+ # 1. Sampling
+ experiment_data.sample(sampler=sampler_block, n_samples=10)
+
+ # 2. Evaluating the samples
+ experiment_data.evaluate(data_generator=data_generation_block)
+
+
+2. Use a string argument
+
+Alternatively, you can use a string argument to specify the built-in function you want to use. The default parameters will be used.
+
+
+.. code-block:: python
+
+ # Create an empty Domain
+ domain = Domain()
+
+ # Add two continuous parameters 'x0' and 'x1'
+ domain.add_float(name='x0', low=0.0, high=1.0)
+ domain.add_float(name='x1', low=0.0, high=1.0)
+
+ # Create an empty ExperimentData object with the domain
+ experiment_data = ExperimentData(domain=domain)
+
+ # 1. Sampling
+ experiment_data.sample(sampler='random', n_samples=10)
+
+ # 2. Evaluating the samples
+ experiment_data.evaluate(data_generator='ackley')
+
+
+.. warning::
+
+ The built-in functionalities are designed with the built-in parameters in mind!
+ This means that in order to make use of the samplers, benchmark functions and optimizers,
+ you are restricted to add parameters via the :meth:`~f3dasm.design.Domain.add_float`, :meth:`~f3dasm.design.Domain.add_int`,
+ :meth:`~f3dasm.design.Domain.add_category` and :meth:`~f3dasm.design.Domain.add_constant` methods.
+
.. _implemented samplers:
Implemented samplers
@@ -8,14 +87,14 @@ Implemented samplers
The following built-in implementations of samplers can be used in the data-driven process.
-======================== ====================================================================== ===========================================================================================================
-Name Method Reference
-======================== ====================================================================== ===========================================================================================================
-``"random"`` Random Uniform sampling `numpy.random.uniform `_
-``"latin"`` Latin Hypercube sampling `SALib.latin `_
-``"sobol"`` Sobol Sequence sampling `SALib.sobol_sequence `_
-``"grid"`` Grid Search sampling `itertools.product `_
-======================== ====================================================================== ===========================================================================================================
+======================== ============================= ======================================== ===========================================================================================================
+Name Key-word Function Reference
+======================== ============================= ======================================== ===========================================================================================================
+Random Uniform sampling ``"random"`` :func:`~f3dasm.design.random` `numpy.random.uniform `_
+Latin Hypercube sampling ``"latin"`` :func:`~f3dasm.design.latin` `SALib.latin `_
+Sobol Sequence sampling ``"sobol"`` :func:`~f3dasm.design.sobol` `SALib.sobol_sequence `_
+Grid Search sampling ``"grid"`` :func:`~f3dasm.design.grid` `itertools.product `_
+======================== ============================= ======================================== ===========================================================================================================
.. _implemented-benchmark-functions:
@@ -33,116 +112,113 @@ The following implementations of benchmark functions can instantiated with the n
Convex functions
^^^^^^^^^^^^^^^^
-======================== ====================================================== ===========================
-Name Docs of the Python class Data-generator argument
-======================== ====================================================== ===========================
-Ackley N. 2 :class:`~f3dasm.datageneration.AckleyN2` ``"Ackley N. 2"``
-Bohachevsky N. 1 :class:`~f3dasm.datageneration.BohachevskyN1` ``"Bohachevsky N. 1"``
-Booth :class:`~f3dasm.datageneration.Booth` ``"Booth"``
-Brent :class:`~f3dasm.datageneration.Brent` ``"Brent"``
-Brown :class:`~f3dasm.datageneration.Brown` ``"Brown"``
-Bukin N. 6 :class:`~f3dasm.datageneration.BukinN6` ``"Bukin N. 6"``
-Dixon Price :class:`~f3dasm.datageneration.DixonPrice` ``"Dixon Price"``
-Exponential :class:`~f3dasm.datageneration.Exponential` ``"Exponential"``
-Matyas :class:`~f3dasm.datageneration.Matyas` ``"Matyas"``
-McCormick :class:`~f3dasm.datageneration.McCormick` ``"McCormick"``
-Perm 0, d, beta :class:`~f3dasm.datageneration.PermZeroDBeta` ``"Perm 0, d, beta"``
-Powell :class:`~f3dasm.datageneration.Powell` ``"Powell"``
-Rotated Hyper-Ellipsoid :class:`~f3dasm.datageneration.RotatedHyperEllipsoid` ``"Rotated Hyper-Ellipsoid"``
-Schwefel 2.20 :class:`~f3dasm.datageneration.Schwefel2_20` ``"Schwefel 2.20"``
-Schwefel 2.21 :class:`~f3dasm.datageneration.Schwefel2_21` ``"Schwefel 2.21"``
-Schwefel 2.22 :class:`~f3dasm.datageneration.Schwefel2_22` ``"Schwefel 2.22"``
-Schwefel 2.23 :class:`~f3dasm.datageneration.Schwefel2_23` ``"Schwefel 2.23"``
-Sphere :class:`~f3dasm.datageneration.Sphere` ``"Sphere"``
-Sum Squares :class:`~f3dasm.datageneration.SumSquares` ``"Sum Squares"``
-Thevenot :class:`~f3dasm.datageneration.Thevenot` ``"Thevenot"``
-Trid :class:`~f3dasm.datageneration.Trid` ``"Trid"``
-Xin She Yang N.3 :class:`~f3dasm.datageneration.XinSheYangN3` ``"Xin She Yang N.3"``
-Xin-She Yang N.4 :class:`~f3dasm.datageneration.XinSheYangN4` ``"Xin-She Yang N.4"``
-======================== ====================================================== ===========================
+======================== ====================================================== ===============================================================
+Name Key-word Function
+======================== ====================================================== ===============================================================
+Ackley N. 2 ``"Ackley N. 2"`` :func:`~f3dasm.datageneration.functions.ackleyn2`
+Bohachevsky N. 1 ``"Bohachevsky N. 1"`` :func:`~f3dasm.datageneration.functions.bohachevskyn1`
+Booth ``"Booth"`` :func:`~f3dasm.datageneration.functions.booth`
+Brent ``"Brent"`` :func:`~f3dasm.datageneration.functions.brent`
+Brown ``"Brown"`` :func:`~f3dasm.datageneration.functions.brown`
+Bukin N. 6 ``"Bukin N. 6"`` :func:`~f3dasm.datageneration.functions.bukinn6`
+Dixon Price ``"Dixon Price"`` :func:`~f3dasm.datageneration.functions.dixonprice`
+Exponential ``"Exponential"`` :func:`~f3dasm.datageneration.functions.exponential`
+Matyas ``"Matyas"`` :func:`~f3dasm.datageneration.functions.matyas`
+McCormick ``"McCormick"`` :func:`~f3dasm.datageneration.functions.mccormick`
+Powell ``"Powell"`` :func:`~f3dasm.datageneration.functions.powell`
+Rotated Hyper-Ellipsoid ``"Rotated Hyper-Ellipsoid"`` :func:`~f3dasm.datageneration.functions.rotatedhyperellipsoid`
+Schwefel 2.20 ``"Schwefel 2.20"`` :func:`~f3dasm.datageneration.functions.schwefel2_20`
+Schwefel 2.21 ``"Schwefel 2.21"`` :func:`~f3dasm.datageneration.functions.schwefel2_21`
+Schwefel 2.22 ``"Schwefel 2.22"`` :func:`~f3dasm.datageneration.functions.schwefel2_22`
+Schwefel 2.23 ``"Schwefel 2.23"`` :func:`~f3dasm.datageneration.functions.schwefel2_23`
+Sphere ``"Sphere"`` :func:`~f3dasm.datageneration.functions.sphere`
+Sum Squares ``"Sum Squares"`` :func:`~f3dasm.datageneration.functions.sumsquares`
+Thevenot ``"Thevenot"`` :func:`~f3dasm.datageneration.functions.thevenot`
+Trid ``"Trid"`` :func:`~f3dasm.datageneration.functions.trid`
+======================== ====================================================== ===============================================================
+
Seperable functions
^^^^^^^^^^^^^^^^^^^
-======================== ============================================== ============================
-Name Docs of the Python class Data-generator argument
-======================== ============================================== ============================
-Ackley :class:`~f3dasm.datageneration.Ackley` ``"Ackley"``
-Bohachevsky N. 1 :class:`~f3dasm.datageneration.BohachevskyN1` ``"Bohachevsky N. 1"``
-Easom :class:`~f3dasm.datageneration.Easom` ``"Easom"``
-Egg Crate :class:`~f3dasm.datageneration.EggCrate` ``"Egg Crate"``
-Exponential :class:`~f3dasm.datageneration.Exponential` ``"Exponential"``
-Griewank :class:`~f3dasm.datageneration.Griewank` ``"Griewank"``
-Michalewicz :class:`~f3dasm.datageneration.Michalewicz` ``"Michalewicz"``
-Powell :class:`~f3dasm.datageneration.Powell` ``"Powell"``
-Qing :class:`~f3dasm.datageneration.Qing` ``"Qing"``
-Quartic :class:`~f3dasm.datageneration.Quartic` ``"Quartic"``
-Rastrigin :class:`~f3dasm.datageneration.Rastrigin` ``"Rastrigin"``
-Schwefel :class:`~f3dasm.datageneration.Schwefel` ``"Schwefel"``
-Schwefel 2.20 :class:`~f3dasm.datageneration.Schwefel2_20` ``"Schwefel 2.20"``
-Schwefel 2.21 :class:`~f3dasm.datageneration.Schwefel2_21` ``"Schwefel 2.21"``
-Schwefel 2.22 :class:`~f3dasm.datageneration.Schwefel2_22` ``"Schwefel 2.22"``
-Schwefel 2.23 :class:`~f3dasm.datageneration.Schwefel2_23` ``"Schwefel 2.23"``
-Sphere :class:`~f3dasm.datageneration.Sphere` ``"Sphere"``
-Styblinski Tank :class:`~f3dasm.datageneration.StyblinskiTank` ``"Styblinski Tank"``
-Sum Squares :class:`~f3dasm.datageneration.SumSquares` ``"Sum Squares"``
-Thevenot :class:`~f3dasm.datageneration.Thevenot` ``"Thevenot"``
-Xin She Yang :class:`~f3dasm.datageneration.XinSheYang` ``"Xin She Yang"``
-======================== ============================================== ============================
+======================== ============================================== ==========================================================
+Name Key-word Function
+======================== ============================================== ==========================================================
+Ackley ``"Ackley"`` :func:`~f3dasm.datageneration.functions.ackley`
+Bohachevsky N. 1 ``"Bohachevsky N. 1"`` :func:`~f3dasm.datageneration.functions.bohachevskyn1`
+Easom ``"Easom"`` :func:`~f3dasm.datageneration.functions.easom`
+Egg Crate ``"Egg Crate"`` :func:`~f3dasm.datageneration.functions.eggcrate`
+Exponential ``"Exponential"`` :func:`~f3dasm.datageneration.functions.exponential`
+Griewank ``"Griewank"`` :func:`~f3dasm.datageneration.functions.griewank`
+Michalewicz ``"Michalewicz"`` :func:`~f3dasm.datageneration.functions.michalewicz`
+Powell ``"Powell"`` :func:`~f3dasm.datageneration.functions.powell`
+Qing ``"Qing"`` :func:`~f3dasm.datageneration.functions.qing`
+Quartic ``"Quartic"`` :func:`~f3dasm.datageneration.functions.quartic`
+Rastrigin ``"Rastrigin"`` :func:`~f3dasm.datageneration.functions.rastrigin`
+Schwefel ``"Schwefel"`` :func:`~f3dasm.datageneration.functions.schwefel`
+Schwefel 2.20 ``"Schwefel 2.20"`` :func:`~f3dasm.datageneration.functions.schwefel2_20`
+Schwefel 2.21 ``"Schwefel 2.21"`` :func:`~f3dasm.datageneration.functions.schwefel2_21`
+Schwefel 2.22 ``"Schwefel 2.22"`` :func:`~f3dasm.datageneration.functions.schwefel2_22`
+Schwefel 2.23 ``"Schwefel 2.23"`` :func:`~f3dasm.datageneration.functions.schwefel2_23`
+Sphere ``"Sphere"`` :func:`~f3dasm.datageneration.functions.sphere`
+Styblinski Tank ``"Styblinski Tank"`` :func:`~f3dasm.datageneration.functions.styblinskitang`
+Sum Squares ``"Sum Squares"`` :func:`~f3dasm.datageneration.functions.sumsquares`
+Thevenot ``"Thevenot"`` :func:`~f3dasm.datageneration.functions.thevenot`
+Xin She Yang ``"Xin She Yang"`` :func:`~f3dasm.datageneration.functions.xin_she_yang`
+======================== ============================================== ==========================================================
Multimodal functions
^^^^^^^^^^^^^^^^^^^^
-======================== ================================================ ==========================
-Name Docs of the Python class Data-generator argument
-======================== ================================================ ==========================
-Ackley :class:`~f3dasm.datageneration.Ackley` ``"Ackley"``
-Ackley N. 3 :class:`~f3dasm.datageneration.AckleyN3` ``"Ackley N. 3"``
-Ackley N. 4 :class:`~f3dasm.datageneration.AckleyN4` ``"Ackley N. 4"``
-Adjiman :class:`~f3dasm.datageneration.Adjiman` ``"Adjiman"``
-Bartels :class:`~f3dasm.datageneration.Bartels` ``"Bartels"``
-Beale :class:`~f3dasm.datageneration.Beale` ``"Beale"``
-Bird :class:`~f3dasm.datageneration.Bird` ``"Bird"``
-Bohachevsky N. 2 :class:`~f3dasm.datageneration.BohachevskyN2` ``"Bohachevsky N. 2"``
-Bohachevsky N. 3 :class:`~f3dasm.datageneration.BohachevskyN3` ``"Bohachevsky N. 3"``
-Branin :class:`~f3dasm.datageneration.Branin` ``"Branin"``
-Bukin N. 6 :class:`~f3dasm.datageneration.BukinN6` ``"Bukin N. 6"``
-Colville :class:`~f3dasm.datageneration.Colville` ``"Colville"``
-Cross-in-Tray :class:`~f3dasm.datageneration.CrossInTray` ``"Cross-in-Tray"``
-De Jong N. 5 :class:`~f3dasm.datageneration.DeJongN5` ``"De Jong N. 5"``
-Deckkers-Aarts :class:`~f3dasm.datageneration.DeckkersAarts` ``"Deckkers-Aarts"``
-Easom :class:`~f3dasm.datageneration.Easom` ``"Easom"``
-Egg Crate :class:`~f3dasm.datageneration.EggCrate` ``"Egg Crate"``
-Egg Holder :class:`~f3dasm.datageneration.EggHolder` ``"Egg Holder"``
-Goldstein-Price :class:`~f3dasm.datageneration.GoldsteinPrice` ``"Goldstein-Price"``
-Happy Cat :class:`~f3dasm.datageneration.HappyCat` ``"Happy Cat"``
-Himmelblau :class:`~f3dasm.datageneration.Himmelblau` ``"Himmelblau"``
-Holder-Table :class:`~f3dasm.datageneration.HolderTable` ``"Holder-Table"``
-Keane :class:`~f3dasm.datageneration.Keane` ``"Keane"``
-Langermann :class:`~f3dasm.datageneration.Langermann` ``"Langermann"``
-Levy :class:`~f3dasm.datageneration.Levy` ``"Levy"``
-Levy N. 13 :class:`~f3dasm.datageneration.LevyN13` ``"Levy N. 13"``
-McCormick :class:`~f3dasm.datageneration.McCormick` ``"McCormick"``
-Michalewicz :class:`~f3dasm.datageneration.Michalewicz` ``"Michalewicz"``
-Periodic :class:`~f3dasm.datageneration.Periodic` ``"Periodic"``
-Perm d, beta :class:`~f3dasm.datageneration.PermDBeta` ``"Perm d, beta"``
-Qing :class:`~f3dasm.datageneration.Qing` ``"Qing"``
-Quartic :class:`~f3dasm.datageneration.Quartic` ``"Quartic"``
-Rastrigin :class:`~f3dasm.datageneration.Rastrigin` ``"Rastrigin"``
-Rosenbrock :class:`~f3dasm.datageneration.Rosenbrock` ``"Rosenbrock"``
-Salomon :class:`~f3dasm.datageneration.Salomon` ``"Salomon"``
-Schwefel :class:`~f3dasm.datageneration.Schwefel` ``"Schwefel"``
-Shekel :class:`~f3dasm.datageneration.Shekel` ``"Shekel"``
-Shubert :class:`~f3dasm.datageneration.Shubert` ``"Shubert"``
-Shubert N. 3 :class:`~f3dasm.datageneration.ShubertN3` ``"Shubert N. 3"``
-Shubert N. 4 :class:`~f3dasm.datageneration.ShubertN4` ``"Shubert N. 4"``
-Styblinski Tank :class:`~f3dasm.datageneration.StyblinskiTank` ``"Styblinski Tank"``
-Thevenot :class:`~f3dasm.datageneration.Thevenot` ``"Thevenot"``
-Xin She Yang :class:`~f3dasm.datageneration.XinSheYang` ``"Xin She Yang"``
-Xin She Yang N.2 :class:`~f3dasm.datageneration.XinSheYangN2` ``"Xin She Yang N.2"``
-======================== ================================================ ==========================
+======================== ================================================ ===========================================================
+Name Key-word Function
+======================== ================================================ ===========================================================
+Ackley ``"Ackley"`` :func:`~f3dasm.datageneration.functions.ackley`
+Ackley N. 3 ``"Ackley N. 3"`` :func:`~f3dasm.datageneration.functions.ackleyn3`
+Ackley N. 4 ``"Ackley N. 4"`` :func:`~f3dasm.datageneration.functions.ackleyn4`
+Adjiman ``"Adjiman"`` :func:`~f3dasm.datageneration.functions.adjiman`
+Bartels ``"Bartels"`` :func:`~f3dasm.datageneration.functions.bartels`
+Beale ``"Beale"`` :func:`~f3dasm.datageneration.functions.beale`
+Bird ``"Bird"`` :func:`~f3dasm.datageneration.functions.bird`
+Bohachevsky N. 2 ``"Bohachevsky N. 2"`` :func:`~f3dasm.datageneration.functions.bohachevskyn2`
+Bohachevsky N. 3 ``"Bohachevsky N. 3"`` :func:`~f3dasm.datageneration.functions.bohachevskyn3`
+Branin ``"Branin"`` :func:`~f3dasm.datageneration.functions.branin`
+Bukin N. 6 ``"Bukin N. 6"`` :func:`~f3dasm.datageneration.functions.bukinn6`
+Colville ``"Colville"`` :func:`~f3dasm.datageneration.functions.colville`
+Cross-in-Tray ``"Cross-in-Tray"`` :func:`~f3dasm.datageneration.functions.crossintray`
+De Jong N. 5 ``"De Jong N. 5"`` :func:`~f3dasm.datageneration.functions.dejongn5`
+Deckkers-Aarts ``"Deckkers-Aarts"`` :func:`~f3dasm.datageneration.functions.deckkersaarts`
+Easom ``"Easom"`` :func:`~f3dasm.datageneration.functions.easom`
+Egg Crate ``"Egg Crate"`` :func:`~f3dasm.datageneration.functions.eggcrate`
+Egg Holder ``"Egg Holder"`` :func:`~f3dasm.datageneration.functions.eggholder`
+Goldstein-Price ``"Goldstein-Price"`` :func:`~f3dasm.datageneration.functions.goldsteinprice`
+Happy Cat ``"Happy Cat"`` :func:`~f3dasm.datageneration.functions.happycat`
+Himmelblau ``"Himmelblau"`` :func:`~f3dasm.datageneration.functions.himmelblau`
+Holder-Table ``"Holder-Table"`` :func:`~f3dasm.datageneration.functions.holdertable`
+Keane ``"Keane"`` :func:`~f3dasm.datageneration.functions.keane`
+Langermann ``"Langermann"`` :func:`~f3dasm.datageneration.functions.langermann`
+Levy ``"Levy"`` :func:`~f3dasm.datageneration.functions.levy`
+Levy N. 13 ``"Levy N. 13"`` :func:`~f3dasm.datageneration.functions.levyn13`
+McCormick ``"McCormick"`` :func:`~f3dasm.datageneration.functions.mccormick`
+Michalewicz ``"Michalewicz"`` :func:`~f3dasm.datageneration.functions.michalewicz`
+Periodic ``"Periodic"`` :func:`~f3dasm.datageneration.functions.periodic`
+Qing ``"Qing"`` :func:`~f3dasm.datageneration.functions.qing`
+Quartic ``"Quartic"`` :func:`~f3dasm.datageneration.functions.quartic`
+Rastrigin ``"Rastrigin"`` :func:`~f3dasm.datageneration.functions.rastrigin`
+Rosenbrock ``"Rosenbrock"`` :func:`~f3dasm.datageneration.functions.rosenbrock`
+Salomon ``"Salomon"`` :func:`~f3dasm.datageneration.functions.salomon`
+Schwefel ``"Schwefel"`` :func:`~f3dasm.datageneration.functions.schwefel`
+Shekel ``"Shekel"`` :func:`~f3dasm.datageneration.functions.shekel`
+Shubert ``"Shubert"`` :func:`~f3dasm.datageneration.functions.shubert`
+Shubert N. 3 ``"Shubert N. 3"`` :func:`~f3dasm.datageneration.functions.shubertn3`
+Shubert N. 4 ``"Shubert N. 4"`` :func:`~f3dasm.datageneration.functions.shubertn4`
+Styblinski Tank ``"Styblinski Tank"`` :func:`~f3dasm.datageneration.functions.styblinskitang`
+Thevenot ``"Thevenot"`` :func:`~f3dasm.datageneration.functions.thevenot`
+Xin She Yang ``"Xin She Yang"`` :func:`~f3dasm.datageneration.functions.xin_she_yang`
+======================== ================================================ ===========================================================
+
.. _implemented optimizers:
@@ -152,14 +228,14 @@ Implemented optimizers
The following implementations of optimizers can found under the :mod:`f3dasm.optimization` module:
These are ported from `scipy-optimize `_
-======================== ========================================================================= ===============================================================================================
-Name Key-word Reference
-======================== ========================================================================= ===============================================================================================
-Conjugate Gradient ``"CG"`` `scipy.minimize CG `_
-L-BFGS-B ``"LBFGSB"`` `scipy.minimize L-BFGS-B `_
-Nelder Mead ``"NelderMead"`` `scipy.minimize NelderMead `_
-Random search ``"RandomSearch"`` `numpy `_
+L-BFGS-B ``"lbfgsb"`` :func:`~f3dasm.optimization.lbfgsb` `scipy.minimize L-BFGS-B `_
+Nelder Mead ``"nelder_mead"`` :func:`~f3dasm.optimization.nelder_mead` `scipy.minimize NelderMead `_
+Random search ``"random_search"`` :func:`~f3dasm.optimization.random_search` `numpy `_ or `Mamba `_.
If you installed Python with conda, we recommend to create a dedicated
conda environment with all the build dependencies of f3dasm:
@@ -142,15 +131,6 @@ Building from source is required to work on a contribution (bug fix, new feature
pip install --verbose --no-build-isolation --editable .
-4. In order to check your installation you can use
-
- .. code-block:: console
-
- $ python -c "import f3dasm"
- >>> 2023-07-05 14:56:40,015 - Imported f3dasm (version: 1.x.x)
-
-
-
.. note::
You can check if the package is linked to your local clone of f3dasm by running :code:`pip show list` and look for f3dasm.
diff --git a/docs/source/rst_doc_files/general/overview.rst b/docs/source/rst_doc_files/general/overview.rst
index 61b9b4fa..29c74339 100644
--- a/docs/source/rst_doc_files/general/overview.rst
+++ b/docs/source/rst_doc_files/general/overview.rst
@@ -10,7 +10,7 @@ A quick overview of the f3dasm package.
Conceptual framework
--------------------
-``f3dasm`` is a Python project that provides a general and user-friendly data-driven framework for researchers and practitioners working on the design and analysis of materials and structures.
+``f3dasm`` is a Python project that provides a general and user-friendly data-driven framework for researchers and practitioners working on the design and analysis of materials and structures [1]_.
The package aims to streamline the data-driven process and make it easier to replicate research articles in this field, as well as share new work with the community.
In the last decades, advancements in computational resources have accelerated novel inverse design approaches for structures and materials.
@@ -22,7 +22,7 @@ This lack of shared practices also leads to compatibility issues for benchmarkin
In this work we introduce an interface for researchers and practitioners working on design and analysis of materials and structures.
The package is called ``f3dasm`` (Framework for Data-driven Design \& Analysis of Structures and Materials).
-This work generalizes the original closed-source framework proposed by the Bessa and co-workers [1]_, making it more flexible and adaptable to different applications,
+This work generalizes the original closed-source framework proposed by the Bessa and co-workers [2]_, making it more flexible and adaptable to different applications,
namely by allowing the integration of different choices of software packages needed in the different steps of the data-driven process:
- **Design of experiments**, in which input variables describing the microstructure, properties and external conditions of the system are determined and sampled.
@@ -51,21 +51,24 @@ Computational framework
- The framework automatically manages I/O processes, saving you time and effort implementing these common procedures.
-- :doc:`Easy parallelization <../../auto_examples/005_workflow/001_cluster_computing>`
+- Easy parallelization
- The framework manages parallelization of experiments, and is compatible with both local and high-performance cluster computing.
-- :doc:`Built-in defaults <../defaults>`
+- Built-in defaults
- The framework includes a collection of :ref:`benchmark functions `, :ref:`optimization algorithms ` and :ref:`sampling strategies ` to get you started right away!
-- :doc:`Hydra integration <../../auto_examples/006_hydra/001_hydra_usage>`
+- Hydra integration
- The framework is integrated with `hydra `_ from scratch.
-The grid search sampler is a simple sampler that evaluates all possible combinations of the parameters in the domain. This is useful for small domains, but it can become computationally expensive for larger domains.
-We will show how to create this sampler and use it in a :mod:`f3dasm` data-driven experiment.
-"""
-
-from __future__ import annotations
-
-from itertools import product
-from typing import Dict, Optional
-
-import numpy as np
-import pandas as pd
-
-from f3dasm import ExperimentData
-from f3dasm.design import Domain
-
-###############################################################################
-# When integrating your sampling strategy into the data-driven process, you have to create a function that will take the domain as argument:
-# Several other optional arguments can be passed to the function as well, such as:
-#
-# * :code:`n_samples`: The number of samples you wish to generate. It's not always necessary to define this upfront, as some sampling methods might inherently determine the number of samples based on certain criteria or properties of the domain.
-# * :code:`seed`: A seed for the random number generator to replicate the sampling process. This enables you to control the randomness of the sampling process [1]_. By setting a seed, you ensure reproducibility, meaning that if you run the sampling function with the same seed multiple times, you'll get the same set of samples.
-#
-# .. [1] If no seed is provided, the function should use a random seed.
-#
-# Additionally, the function can accept any other keyword arguments that you might need to pass to the sampling function.
-# This also means that you shoud handle arbitrary keyword arguments in your function with the `**kwargs` syntax.
-# The function should return the samples (``input_data``) in one of the following formats:
-#
-# * A :class:`~pandas.DataFrame` object
-# * A :class:`~numpy.ndarray` object
-#
-# For our implementation of the grid-search sampler, we need to handle the case of continous parameters.
-# We require the user to pass down a dictionary with the discretization stepsize for each continuous parameter.
-
-
-def grid(
- domain: Domain, stepsize_continuous_parameters:
- Optional[Dict[str, float] | float] = None, **kwargs) -> pd.DataFrame:
-
- # Extract the continous part of the domain
- continuous = domain.continuous
-
- # If therei s no continuos space, we can return an empty dictionary
- if not continuous.space:
- discrete_space = {}
-
- else:
- discrete_space = {key: continuous.space[key].to_discrete(
- step=value) for key,
- value in stepsize_continuous_parameters.items()}
-
- continuous_to_discrete = Domain(discrete_space)
-
- _iterdict = {}
-
- # For all the categorical parameters, we will iterate over the categories
- for k, v in domain.categorical.space.items():
- _iterdict[k] = v.categories
-
- # For all the discrete parameters, we will iterate over the range of values
- for k, v, in domain.discrete.space.items():
- _iterdict[k] = range(v.lower_bound, v.upper_bound+1, v.step)
-
- # For all the continuous parameters, we will iterate over the range of values
- # based on the stepsize provided
- for k, v, in continuous_to_discrete.space.items():
- _iterdict[k] = np.arange(
- start=v.lower_bound, stop=v.upper_bound, step=v.step)
-
- # We will create a dataframe with all the possible combinations using
- # the itertools.product function
- df = pd.DataFrame(list(product(*_iterdict.values())),
- columns=_iterdict, dtype=object)[domain.names]
-
- # return the samples
- return df
-
-###############################################################################
-# To test our implementation, we will create a domain with a mix of continuous, discrete, and categorical parameters.
-
-
-domain = Domain()
-domain.add_float("param_1", -1.0, 1.0)
-domain.add_int("param_2", 1, 5)
-domain.add_category("param_3", ["red", "blue", "green", "yellow", "purple"])
-
-###############################################################################
-# We will now sample the domain using the grid sampler we implemented.
-# We can create an empty ExperimentData object and call the :meth:`~f3dasm.data.ExperimentData.sample` method to add the samples to the object:
-
-experiment_data = ExperimentData(domain=domain)
-experiment_data.sample(
- sampler=grid, stepsize_continuous_parameters={"param_1": 0.2})
-
-###############################################################################
-# We can print the samples to see the results:
-
-print(experiment_data)
diff --git a/examples/001_domain/003_builtin_sampler.py b/examples/001_domain/003_builtin_sampler.py
deleted file mode 100644
index 67dfcf79..00000000
--- a/examples/001_domain/003_builtin_sampler.py
+++ /dev/null
@@ -1,51 +0,0 @@
-"""
-Use the built-in sampling strategies
-====================================
-
-In this example, we will use the built-in sampling strategies provided by :mod:`f3dasm` to generate samples for a data-driven experiment.
-"""
-
-from matplotlib import pyplot as plt
-
-from f3dasm import ExperimentData
-from f3dasm.design import make_nd_continuous_domain
-
-###############################################################################
-# We create 2D continuous input domain with the :func:`~f3dasm.design.make_nd_continuous_domain` helper function:
-
-domain = make_nd_continuous_domain(bounds=[[0., 1.], [0., 1.]])
-print(domain)
-
-###############################################################################
-# You can create an :class:`~f3dasm.ExperimentData` object with the :meth:`~f3dasm.ExperimentData.from_sampling` constructor directly:
-
-data_random = ExperimentData.from_sampling(
- domain=domain, n_samples=10, sampler='random', seed=42)
-
-fig, ax = plt.subplots(figsize=(4, 4))
-
-print(data_random)
-
-df_random, _ = data_random.to_pandas()
-ax.scatter(df_random.iloc[:, 0], df_random.iloc[:, 1])
-ax.set_xlabel(domain.names[0])
-ax.set_ylabel(domain.names[1])
-
-###############################################################################
-# :mod:`f3dasm` provides several built-in samplers.
-# The example below shows how to use the Latin Hypercube Sampling (LHS) sampler:
-
-data_lhs = ExperimentData.from_sampling(
- domain=domain, n_samples=10, sampler='latin', seed=42)
-
-fig, ax = plt.subplots(figsize=(4, 4))
-
-print(data_lhs)
-
-df_lhs, _ = data_lhs.to_pandas()
-ax.scatter(df_lhs.iloc[:, 0], df_lhs.iloc[:, 1])
-ax.set_xlabel(domain.names[0])
-ax.set_ylabel(domain.names[1])
-
-###############################################################################
-# More information all the available samplers can be found in :ref:`here `.
diff --git a/examples/001_domain/README.rst b/examples/001_domain/README.rst
deleted file mode 100644
index 26d0da6a..00000000
--- a/examples/001_domain/README.rst
+++ /dev/null
@@ -1,4 +0,0 @@
-Design-of-experiments
-^^^^^^^^^^^^^^^^^^^^^
-
-The submodule :mod:`f3dasm.design` contains the :class:`~f3dasm.design.Domain` object that makes up your feasible search space.
diff --git a/examples/002_experimentdata/001_experimentdata.py b/examples/002_experimentdata/001_experimentdata.py
deleted file mode 100644
index 05e3b90c..00000000
--- a/examples/002_experimentdata/001_experimentdata.py
+++ /dev/null
@@ -1,138 +0,0 @@
-"""
-Creating an ExperimentData object from various external sources
-===============================================================
-
-The :class:`~f3dasm.ExperimentData` object is the main object used to store implementations of a design-of-experiments,
-keep track of results, perform optimization and extract data for machine learning purposes.
-
-All other processses of :mod:`f3dasm` use this object to manipulate and access data about your experiments.
-
-The :class:`~f3dasm.ExperimentData` object consists of the following attributes:
-
-- domain: The feasible :class:`~f3dasm.design.Domain` of the Experiment. Used for sampling and optimization.
-- input_data: Tabular data containing the input variables of the experiments as column and the experiments as rows.
-- output_data: Tabular data containing the tracked outputs of the experiments.
-- project_dir: A user-defined project directory where all files related to your data-driven process will be stored.
-"""
-
-###############################################################################
-# The :class:`~f3dasm.ExperimentData` object can be constructed in several ways:
-#
-# You can construct a :class:`~f3dasm.ExperimentData` object by providing it input data,
-# output data, a :class:`~f3dasm.design.Domain` object and a project directory.
-
-import numpy as np
-import pandas as pd
-
-from f3dasm import ExperimentData
-from f3dasm.design import Domain
-
-###############################################################################
-# domain
-# ^^^^^^
-# The domain object is used to define the feasible space of the experiments.
-
-domain = Domain()
-domain.add_float('x0', 0., 1.)
-domain.add_float('x1', 0., 1.)
-
-###############################################################################
-# input_data
-# ^^^^^^^^^^
-#
-# Input data describes the input variables of the experiments.
-# The input data is provided in a tabular manner, with the number of rows equal to the number of experiments and the number of columns equal to the number of input variables.
-#
-# Single parameter values can have any of the basic built-in types: ``int``, ``float``, ``str``, ``bool``. Lists, tuples or array-like structures are not allowed.
-#
-# We can give the input data as a :class:`~pandas.DataFrame` object with the input variable names as columns and the experiments as rows.
-
-input_data = pd.DataFrame({
- 'x0': [0.1, 0.2, 0.3],
- 'x1': [0.4, 0.5, 0.6]
-})
-
-experimentdata = ExperimentData(domain=domain, input_data=input_data)
-print(experimentdata)
-
-###############################################################################
-# or a two-dimensional :class:`~numpy.ndarray` object with shape (, ):
-
-input_data = np.array([
- [0.1, 0.4],
- [0.2, 0.5],
- [0.3, 0.6]
-])
-
-experimentdata = ExperimentData(domain=domain, input_data=input_data)
-print(experimentdata)
-
-###############################################################################
-# .. note::
-#
-# When providing a :class:`~numpy.ndarray` object, you need to provide a :class:`~f3dasm.design.Domain` object as well.
-# Also, the order of the input variables is inferred from the order of the columns in the :class:`~f3dasm.design.Domain` object.
-
-###############################################################################
-# Another option is a path to a ``.csv`` file containing the input data.
-# The ``.csv`` file should contain a header row with the names of the input variables
-# and the first column should be indices for the experiments.
-#
-# output_data
-# ^^^^^^^^^^^
-#
-# Output data describes the output variables of the experiments.
-# The output data is provided in a tabular manner, with the number of rows equal to the number of experiments and the number of columns equal to the number of output variables.
-#
-# The same rules apply for the output data as for the input data:
-
-output_data = pd.DataFrame({
- 'y': [1.1, 1.2, 1.3],
-})
-
-experimentdata = ExperimentData(domain=domain, input_data=input_data,
- output_data=output_data)
-
-print(experimentdata)
-
-###############################################################################
-# .. note::
-#
-# When the output to an ExperimentData object is provided, the job will be set to finished,
-# as the output data is considerd the result of the experiment.
-#
-# Adding data after constructing
-# ------------------------------
-#
-# If you have constructed your :class:`~f3dasm.ExperimentData` object,
-# you can add ``input_data``, ``output_data``, a ``domain`` or the ``project_dir`` using the :meth:`~f3dasm.ExperimentData.add` method:
-
-new_data = pd.DataFrame({
- 'x0': [1.5, 1.7],
- 'x1': [1.3, 1.9]
-})
-experimentdata.add(input_data=new_data, domain=domain)
-print(experimentdata)
-
-###############################################################################
-# Exporting the data to various formats
-# -------------------------------------
-#
-# You can convert the input- and outputdata of your data-driven process to other well-known datatypes:
-#
-# * :meth:`~f3dasm.ExperimentData.to_numpy`; creates a tuple of two :class:`~numpy.ndarray` objects containing the input- and outputdata.
-
-arr_input, arr_output = experimentdata.to_numpy()
-print(arr_input)
-
-###############################################################################
-# * :meth:`~f3dasm.ExperimentData.to_xarray`; creates a :class:`~xarray.Dataset` object containing the input- and outputdata.
-
-ds = experimentdata.to_xarray()
-print(ds)
-
-###############################################################################
-# * :meth:`~f3dasm.ExperimentData.to_pandas`; creates a tuple of two :class:`~pd.DataFrame` object containing the input- and outputdata.
-
-df_input, df_output = experimentdata.to_pandas()
-print(df_input)
diff --git a/examples/002_experimentdata/002_experimentdata_storing.py b/examples/002_experimentdata/002_experimentdata_storing.py
deleted file mode 100644
index 39d66a39..00000000
--- a/examples/002_experimentdata/002_experimentdata_storing.py
+++ /dev/null
@@ -1,50 +0,0 @@
-"""
-Storing experiment data to disk
-===============================
-
-In this example, we will show how to store the experiment data to disk using the :meth:`~f3dasm.ExperimentData.store` method and
-how to load the stored data using the :meth:`~f3dasm.ExperimentData.from_file` method.
-"""
-
-###############################################################################
-# project directory
-# ^^^^^^^^^^^^^^^^^
-#
-# The ``project_dir`` argument is used to store the ExperimentData to disk
-# You can provide a string or a path to a directory. This can either be a relative or absolute path.
-# If the directory does not exist, it will be created.
-
-from f3dasm import ExperimentData
-
-data = ExperimentData()
-data.set_project_dir("./example_project_dir")
-
-print(data.project_dir)
-
-###############################################################################
-# Storing the data
-# ^^^^^^^^^^^^^^^^^
-#
-# The :meth:`~f3dasm.ExperimentData.store` method is used to store the experiment data to disk.
-
-data.store()
-
-###############################################################################
-# The data is stored in several files in an 'experiment_data' subfolder in the provided project directory:
-#
-# .. code-block:: none
-# :caption: Directory Structure
-#
-# my_project/
-# βββ my_script.py
-# βββ experiment_data
-# βββ domain.pkl
-# βββ input_data.csv
-# βββ output_data.csv
-# βββ jobs.pkl
-#
-# In order to load the data, you can use the :meth:`~f3dasm.ExperimentData.from_file` method.
-
-data_loaded = ExperimentData.from_file(project_dir="./example_project_dir")
-
-print(data_loaded)
diff --git a/examples/002_experimentdata/README.rst b/examples/002_experimentdata/README.rst
deleted file mode 100644
index 4da7ded9..00000000
--- a/examples/002_experimentdata/README.rst
+++ /dev/null
@@ -1,7 +0,0 @@
-Managing experiments with the ExperimentData object
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The :class:`~f3dasm.ExperimentData` object is the main object used to store implementations of a design-of-experiments,
-keep track of results, perform optimization and extract data for machine learning purposes.
-
-All other processses of :mod:`f3dasm` use this object to manipulate and access data about your experiments.
diff --git a/examples/002_experimentdata/example_project_dir/experiment_data/domain.pkl b/examples/002_experimentdata/example_project_dir/experiment_data/domain.pkl
deleted file mode 100644
index 6b319cb7..00000000
Binary files a/examples/002_experimentdata/example_project_dir/experiment_data/domain.pkl and /dev/null differ
diff --git a/examples/002_experimentdata/example_project_dir/experiment_data/input.csv b/examples/002_experimentdata/example_project_dir/experiment_data/input.csv
deleted file mode 100644
index e16c76df..00000000
--- a/examples/002_experimentdata/example_project_dir/experiment_data/input.csv
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/examples/002_experimentdata/example_project_dir/experiment_data/jobs.pkl b/examples/002_experimentdata/example_project_dir/experiment_data/jobs.pkl
deleted file mode 100644
index 1884af77..00000000
Binary files a/examples/002_experimentdata/example_project_dir/experiment_data/jobs.pkl and /dev/null differ
diff --git a/examples/002_experimentdata/example_project_dir/experiment_data/output.csv b/examples/002_experimentdata/example_project_dir/experiment_data/output.csv
deleted file mode 100644
index e16c76df..00000000
--- a/examples/002_experimentdata/example_project_dir/experiment_data/output.csv
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/examples/003_datageneration/001_own_datagenerator.py b/examples/003_datageneration/001_own_datagenerator.py
deleted file mode 100644
index 0a004427..00000000
--- a/examples/003_datageneration/001_own_datagenerator.py
+++ /dev/null
@@ -1,194 +0,0 @@
-"""
-Implement your own datagenerator: car stopping distance problem
-===============================================================
-
-In this example, we will implement a custom data generator that generates output for a data-driven experiment.
-We will use the 'car stopping distance' problem as an example.
-"""
-
-import matplotlib.pyplot as plt
-import numpy as np
-from scipy.stats import norm
-
-from f3dasm import ExperimentData
-from f3dasm.datageneration import DataGenerator
-from f3dasm.design import Domain
-
-###############################################################################
-#
-# Car stopping distance problem
-# -----------------------------
-#
-# .. image:: ../../img/reaction-braking-stopping.png
-# :width: 70%
-# :align: center
-# :alt: Workflow
-#
-# Car stopping distance :math:`y` as a function of its velocity :math:`x` before it starts braking:
-#
-# .. math::
-#
-# y = z x + \frac{1}{2 \mu g} x^2 = z x + 0.1 x^2
-#
-#
-# - :math:`z` is the driver's reaction time (in seconds)
-# - :math:`\mu` is the road/tires coefficient of friction (we assume :math:`\mu=0.5`)
-# - :math:`g` is the acceleration of gravity (assume :math:`g=10 m/s^2`).
-#
-# .. math::
-#
-# y = d_r + d_{b}
-#
-# where :math:`d_r` is the reaction distance, and :math:`d_b` is the braking distance.
-#
-# Reaction distance :math:`d_r`
-#
-# .. math::
-#
-# d_r = z x
-#
-# with :math:`z` being the driver's reaction time, and :math:`x` being the velocity of the car at the start of braking.
-#
-# Kinetic energy of moving car:
-#
-# .. math::
-#
-# E = \frac{1}{2}m x^2
-#
-# where :math:`m` is the car mass.
-#
-# Work done by braking:
-#
-# .. math::
-#
-# W = \mu m g d_b
-#
-#
-# where :math:`\mu` is the coefficient of friction between the road and the tire, :math:`g` is the acceleration of gravity, and :math:`d_b` is the car braking distance.
-#
-# The braking distance follows from :math:`E=W`:
-#
-# .. math::
-#
-# d_b = \frac{1}{2\mu g}x^2
-#
-# Therefore, if we add the reacting distance :math:`d_r` to the braking distance :math:`d_b` we get the stopping distance :math:`y`:
-#
-# .. math::
-#
-# y = d_r + d_b = z x + \frac{1}{2\mu g} x^2
-#
-#
-# Every driver has its own reaction time :math:`z`
-# Assume the distribution associated to :math:`z` is Gaussian with mean :math:`\mu_z=1.5` seconds and variance :math:`\sigma_z^2=0.5^2`` seconds\ :sup:`2`:
-#
-# .. math::
-#
-# z \sim \mathcal{N}(\mu_z=1.5,\sigma_z^2=0.5^2)
-#
-#
-# We create a function that generates the stopping distance :math:`y` given the velocity :math:`x` and the reaction time :math:`z`:
-
-
-def y(x):
- z = norm.rvs(1.5, 0.5, size=1)
- y = z*x + 0.1*x**2
- return y
-
-
-###############################################################################
-# Implementing the data generator
-# -------------------------------
-#
-# Implementing this relationship in :mod:`f3dasm` can be done in two ways:
-#
-#
-# 1. Directly using a function
-# 2. Providing an object from a custom class that inherits from the :class:`~f3dasm.datageneration.DataGenerator` class.
-#
-# Using a function directly
-# ^^^^^^^^^^^^^^^^^^^^^^^^^
-#
-# We can use the function :func:`y(x)` directly as the data generator. We will demonstrate this in the following example code:
-#
-#
-# In order to create an :class:`~f3dasm.ExperimentData` object, we have to first create a domain
-domain = Domain()
-domain.add_float('x', low=0., high=100.)
-
-###############################################################################
-# For demonstration purposes, we will generate a dataset of stopping distances for velocities between 3 and 83 m/s.
-
-N = 33 # number of points to generate
-Data_x = np.linspace(3, 83, 100)
-
-###############################################################################
-# We can construct an :class:`~f3dasm.ExperimentData` object with the :class:`~f3dasm.design.Domain` and the numpy array:
-
-experiment_data = ExperimentData(input_data=Data_x, domain=domain)
-print(experiment_data)
-
-###############################################################################
-# As you can see, the ExperimentData object has been created successfully and the jobs have the label 'open'.
-# This means that the output has not been generated yet. We can now compute the stopping distance by calling the :meth:`~f3dasm.ExperimentData.evaluate` method:
-# We have to provide the function as the ``data_generator`` argument and provide name of the return value as the ``output_names`` argument:
-
-experiment_data.evaluate(data_generator=y, output_names=['y'])
-
-arr_in, arr_out = experiment_data.to_numpy()
-
-fig, ax = plt.subplots()
-ax.scatter(arr_in, arr_out.flatten(), s=2)
-_ = ax.set_xlabel('Car velocity ($m/s$)')
-_ = ax.set_ylabel('Stopping distance ($m$)')
-
-###############################################################################
-# The experiments have been evaluated and the jobs value has been set to 'finished'
-
-print(experiment_data)
-
-###############################################################################
-#
-# Using the DataGenerator class
-# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-#
-# We can also implement the data generator as a class that inherits from the :class:`~f3dasm.datageneration.DataGenerator` class.
-# This allows for more flexibility and control over the data generation process.
-
-experiment_data_class = ExperimentData(input_data=Data_x, domain=domain)
-
-###############################################################################
-# The custom data generator class should have an :meth:`~f3dasm.datageneration.DataGenerator.execute` method.
-# In this method, we can access the experiment using the :attr:`~f3dasm.datageneration.DataGenerator.experiment_sample` attribute.
-# We can store the output of the data generation process using the :meth:`~f3dasm.datageneration.DataGenerator.experiment_sample.store` method.
-
-
-class CarStoppingDistance(DataGenerator):
- def __init__(self, mu_z: float, sigma_z: float):
- self.mu_z = mu_z
- self.sigma_z = sigma_z
-
- def execute(self):
- x = self.experiment_sample.get('x')
- z = norm.rvs(self.mu_z, self.sigma_z, size=1)
- y = z*x + 0.1*x**2
- self.experiment_sample.store(object=y, name='y', to_disk=False)
-
-###############################################################################
-# We create an object of the :class:`~CarStoppingDistance` class and pass it to the :meth:`~f3dasm.ExperimentData.evaluate` method:
-
-
-car_stopping_distance = CarStoppingDistance(mu_z=1.5, sigma_z=0.5)
-experiment_data_class.evaluate(
- data_generator=car_stopping_distance, mode='sequential')
-
-print(experiment_data_class)
-
-###############################################################################
-#
-# There are three methods available of evaluating the experiments:
-#
-# * :code:`sequential`: regular for-loop over each of the experiments in order
-# * :code:`parallel`: utilizing the multiprocessing capabilities (with the `pathos `_ multiprocessing library), each experiment is run in a separate core
-# * :code:`cluster`: each experiment is run in a seperate node. This is especially useful on a high-performance computation cluster where you have multiple worker nodes and a commonly accessible resource folder. After completion of an experiment, the node will automatically pick the next available open experiment.
-# * :code:`cluster_parallel`: Combination of the :code:`cluster` and :code:`parallel` mode. Each node will run multiple samples in parallel.
diff --git a/examples/003_datageneration/002_builtin_benchmarkfunctions.py b/examples/003_datageneration/002_builtin_benchmarkfunctions.py
deleted file mode 100644
index 3d1d6b3d..00000000
--- a/examples/003_datageneration/002_builtin_benchmarkfunctions.py
+++ /dev/null
@@ -1,62 +0,0 @@
-"""
-Use the built-in benchmark functions
-====================================
-
-In this example, we will use the built-in benchmark functions provided by :mod:`f3dasm.datageneration.functions` to generate output for a data-driven experiment.
-"""
-
-import matplotlib.pyplot as plt
-
-from f3dasm import ExperimentData
-from f3dasm.design import make_nd_continuous_domain
-
-###############################################################################
-# :mod:`f3dasm` ships with a set of benchmark functions that can be used to test the performance of
-# optimization algorithms or to mock some expensive simulation in order to test the data-driven process.
-# These benchmark functions are taken and modified from the `Python Benchmark Test Optimization Function Single Objective `_ github repository.
-#
-# Let's start by creating a continuous domain
-# with 2 input variables, each ranging from -1.0 to 1.0
-
-domain = make_nd_continuous_domain([[-1., 1.], [-1., 1.]])
-
-###############################################################################
-# We generate the input data by sampling the domain equally spaced with the grid sampler and create the :class:`~f3dasm.ExperimentData` object:
-
-experiment_data = ExperimentData.from_sampling(
- 'grid', domain=domain, stepsize_continuous_parameters=0.1)
-
-print(experiment_data)
-
-###############################################################################
-# Evaluating a 2D version of the Ackley function is as simple as
-# calling the :meth:`~f3dasm.ExperimentData.evaluate` method with the function name as the ``data_generator`` argument.
-#
-# In addition, you can provide a dictionary (``kwargs``) with the followinging keywords to the :class:`~f3dasm.design.ExperimentData.evaluate` method:
-#
-# * ``scale_bounds``: A 2D list of floats that define the scaling lower and upper boundaries for each dimension. The normal benchmark function box-constraints will be scaled to these boundaries.
-# * ``noise``: A float that defines the standard deviation of the Gaussian noise that is added to the objective value.
-# * ``offset``: A boolean value. If ``True``, the benchmark function will be offset by a constant vector that will be randomly generated [1]_.
-# * ``seed``: Seed for the random number generator for the ``noise`` and ``offset`` calculations.
-#
-# .. [1] As benchmark functions usually have their minimum at the origin, the offset is used to test the robustness of the optimization algorithm.
-
-experiment_data.evaluate(data_generator='Ackley', kwargs={
- 'scale_bounds': domain.get_bounds(), 'offset': False})
-
-###############################################################################
-# The function values are stored in the ``y`` variable of the output data:
-
-print(experiment_data)
-
-###############################################################################
-
-arr_in, arr_out = experiment_data.to_numpy()
-fig, ax = plt.subplots(subplot_kw={'projection': '3d'})
-ax.scatter(arr_in[:, 0], arr_in[:, 1], arr_out.ravel())
-_ = ax.set_xlabel('$x_0$')
-_ = ax.set_ylabel('$x_1$')
-_ = ax.set_zlabel('$f(x)$')
-
-###############################################################################
-# A complete list of all the implemented benchmark functions can be found :ref:`here `
diff --git a/examples/003_datageneration/003_storing.py b/examples/003_datageneration/003_storing.py
deleted file mode 100644
index 3b2d0477..00000000
--- a/examples/003_datageneration/003_storing.py
+++ /dev/null
@@ -1,142 +0,0 @@
-"""
-Storing data generation output to disk
-======================================
-
-After running your simulation, you can store the result back into the :class:`~f3dasm.ExperimentSample` with the :meth:`~f3dasm.ExperimentSample.store` method.
-There are two ways of storing your output:
-
-* Singular values can be stored directly to the :attr:`~f3dasm.ExperimentData.output_data`
-* Large objects can be stored to disk and a reference path will be stored to the :attr:`~f3dasm.ExperimentData.output_data`.
-"""
-
-import numpy as np
-
-from f3dasm import ExperimentData, StoreProtocol
-from f3dasm.datageneration import DataGenerator
-from f3dasm.design import make_nd_continuous_domain
-
-###############################################################################
-# For this example we create a 3 dimensional continuous domain and generate 10 random samples.
-
-domain = make_nd_continuous_domain([[0., 1.], [0., 1.], [0., 1.]])
-experiment_data = ExperimentData.from_sampling(
- sampler='random', domain=domain, n_samples=10, seed=42)
-
-###############################################################################
-# Single values
-# -------------
-
-# Single values or small lists can be stored to the :class:`~f3dasm.ExperimentData` using the ``to_disk=False`` argument, with the name of the parameter as the key.
-# This will create a new output parameter if the parameter name is not found in :attr:`~f3dasm.ExperimentData.output_data` of the :class:`~f3dasm.ExperimentData` object:
-# This is especially useful if you want to get a quick overview of some loss or design metric of your sample.
-#
-# We create a custom datagenerator that sums the input features and stores the result back to the :class:`~f3dasm.ExperimentData` object:
-
-
-class MyDataGenerator_SumInput(DataGenerator):
- def execute(self):
- input_, _ = self.experiment_sample.to_numpy()
- y = float(sum(input_))
- self.experiment_sample.store(object=y, name='y', to_disk=False)
-
-###############################################################################
-# We pass the custom data generator to the :meth:`~f3dasm.ExperimentData.evaluate` method and inspect the experimentdata after completion:
-
-
-my_data_generator_single = MyDataGenerator_SumInput()
-
-experiment_data.evaluate(data_generator=my_data_generator_single)
-print(experiment_data)
-
-###############################################################################
-#
-# All built-in singular types are supported for storing to the :class:`~f3dasm.ExperimentData` this way. Array-like data such as numpy arrays and pandas dataframes are **not** supported and will raise an error.
-#
-# .. note::
-#
-# Outputs stored directly to the :attr:`~f3dasm.ExperimentData.output_data` will be stored within the :class:`~f3dasm.ExperimentData` object.
-# This means that the output will be loaded into memory everytime this object is accessed. For large outputs, it is recommended to store the output to disk.
-#
-# Large objects and array-like data
-# ---------------------------------
-#
-# In order to store large objects or array-like data, the :meth:`~f3dasm.ExperimentSample.store` method using the ``to_disk=True`` argument, can be used.
-# A reference (:code:`Path`) will be saved to the :attr:`~f3dasm.ExperimentData.output_data`.
-#
-# We create a another custom datagenerator that doubles the input features, but leaves them as an array:
-
-experiment_data = ExperimentData.from_sampling(
- sampler='random', domain=domain, n_samples=10, seed=42)
-
-
-class MyDataGenerator_DoubleInputs(DataGenerator):
- def execute(self):
- input_, output_ = self.experiment_sample.to_numpy()
- y = input_ * 2
- self.experiment_sample.store(
- object=y, name='output_numpy', to_disk=True)
-
-
-my_data_generator = MyDataGenerator_DoubleInputs()
-
-experiment_data.evaluate(data_generator=my_data_generator)
-print(experiment_data)
-
-###############################################################################
-# :mod:`f3dasm` will automatically create a new directory in the project directory for each output parameter and store the object with a generated filename referencing the :attr:`~f3dasm.design.ExperimentSample.job_number` of the design.
-#
-# .. code-block:: none
-# :caption: Directory Structure
-#
-# project_dir/
-# βββ output_numpy/
-# β βββ 0.npy
-# β βββ 1.npy
-# β βββ 2.npy
-# β βββ 3.npy
-# β
-# βββ experiment_data/
-# βββ domain.pkl
-# βββ input.csv
-# βββ output.csv
-# βββ jobs.pkl
-#
-#
-# In the output data of the :class:`~f3dasm.ExperimentData` object, a reference path (e.g. :code:`/output_numpy/0.npy`) to the stored object will be saved.
-#
-# Create a custom storage method
-# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-#
-# :mod:`f3dasm` has built-in storing functions for numpy :class:`~numpy.ndarray`, pandas :class:`~pandas.DataFrame` and xarray :class:`~xarray.DataArray` and :class:`~xarray.Dataset` objects.
-# For any other type of object, the object will be stored in the `pickle `_ format
-#
-# You can provide your own storing class to the :class:`~f3dasm.ExperimentSample.store` method call:
-#
-# * a ``store`` method should store an ``self.object`` to disk at the location of ``self.path``
-# * a ``load`` method should load the object from disk at the location of ``self.path`` and return it
-# * a class variable ``suffix`` should be defined, which is the file extension of the stored object as a string.
-# * the class should inherit from the :class:`~f3dasm.StoreProtocol` class
-#
-# You can take the following class for a :class:`~numpy.ndarray` object as an example:
-
-
-class NumpyStore(StoreProtocol):
- suffix: int = '.npy'
-
- def store(self) -> None:
- np.save(file=self.path.with_suffix(self.suffix), arr=self.object)
-
- def load(self) -> np.ndarray:
- return np.load(file=self.path.with_suffix(self.suffix))
-
-###############################################################################
-# After defining the storing function, it can be used as an additional argument in the :meth:`~f3dasm.ExperimentSample.store` method:
-
-
-class MyDataGenerator_DoubleInputs(DataGenerator):
- def execute(self):
- input_, output_ = self.experiment_sample.to_numpy()
- y = input_ * 2
- self.experiment_sample.store(
- object=y, name='output_numpy',
- to_disk=True, store_method=NumpyStore)
diff --git a/examples/003_datageneration/README.rst b/examples/003_datageneration/README.rst
deleted file mode 100644
index 8726d463..00000000
--- a/examples/003_datageneration/README.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-Generating output using the Data Generator
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The :class:`~f3dasm.datageneration.DataGenerator` class is the main class of the :mod:`~f3dasm.datageneration` module.
-It is used to generate :attr:`~f3dasm.ExperimentData.output_data` for the :class:`~f3dasm.ExperimentData`.
-
-The :class:`~f3dasm.datageneration.DataGenerator` can serve as the interface between the
-:class:`~f3dasm.ExperimentData` object and any third-party simulation software.
\ No newline at end of file
diff --git a/examples/003_datageneration/output_numpy/0.npy b/examples/003_datageneration/output_numpy/0.npy
deleted file mode 100644
index 3759655a..00000000
Binary files a/examples/003_datageneration/output_numpy/0.npy and /dev/null differ
diff --git a/examples/003_datageneration/output_numpy/1.npy b/examples/003_datageneration/output_numpy/1.npy
deleted file mode 100644
index 4a77a22a..00000000
Binary files a/examples/003_datageneration/output_numpy/1.npy and /dev/null differ
diff --git a/examples/003_datageneration/output_numpy/2.npy b/examples/003_datageneration/output_numpy/2.npy
deleted file mode 100644
index 0abee086..00000000
Binary files a/examples/003_datageneration/output_numpy/2.npy and /dev/null differ
diff --git a/examples/003_datageneration/output_numpy/3.npy b/examples/003_datageneration/output_numpy/3.npy
deleted file mode 100644
index 39c452a0..00000000
Binary files a/examples/003_datageneration/output_numpy/3.npy and /dev/null differ
diff --git a/examples/003_datageneration/output_numpy/4.npy b/examples/003_datageneration/output_numpy/4.npy
deleted file mode 100644
index c89c9782..00000000
Binary files a/examples/003_datageneration/output_numpy/4.npy and /dev/null differ
diff --git a/examples/003_datageneration/output_numpy/5.npy b/examples/003_datageneration/output_numpy/5.npy
deleted file mode 100644
index f7073b2a..00000000
Binary files a/examples/003_datageneration/output_numpy/5.npy and /dev/null differ
diff --git a/examples/003_datageneration/output_numpy/6.npy b/examples/003_datageneration/output_numpy/6.npy
deleted file mode 100644
index b2fa3491..00000000
Binary files a/examples/003_datageneration/output_numpy/6.npy and /dev/null differ
diff --git a/examples/003_datageneration/output_numpy/7.npy b/examples/003_datageneration/output_numpy/7.npy
deleted file mode 100644
index 8a2172a5..00000000
Binary files a/examples/003_datageneration/output_numpy/7.npy and /dev/null differ
diff --git a/examples/003_datageneration/output_numpy/8.npy b/examples/003_datageneration/output_numpy/8.npy
deleted file mode 100644
index 5246aa5d..00000000
Binary files a/examples/003_datageneration/output_numpy/8.npy and /dev/null differ
diff --git a/examples/003_datageneration/output_numpy/9.npy b/examples/003_datageneration/output_numpy/9.npy
deleted file mode 100644
index 47f2dcd4..00000000
Binary files a/examples/003_datageneration/output_numpy/9.npy and /dev/null differ
diff --git a/examples/004_optimization/001_builtin_optimizers.py b/examples/004_optimization/001_builtin_optimizers.py
deleted file mode 100644
index ec615dea..00000000
--- a/examples/004_optimization/001_builtin_optimizers.py
+++ /dev/null
@@ -1,62 +0,0 @@
-"""
-Use the built-in optimization algorithms
-========================================
-
-In this example, we will use the built-in optimization algorithms provided by the :mod:`f3dasm.optimization` submodule to optimize the Rosenbrock benchmark function.
-"""
-
-import matplotlib.pyplot as plt
-
-from f3dasm import ExperimentData
-from f3dasm.design import make_nd_continuous_domain
-from f3dasm.optimization import OPTIMIZERS
-
-###############################################################################
-# We create a 3D continous domain and sample one point from it.
-
-domain = make_nd_continuous_domain([[-1., 1.], [-1., 1.], [-1., 1.]])
-
-experimentdata = ExperimentData.from_sampling(
- domain=domain, sampler="random", seed=42, n_samples=1)
-
-print(experimentdata)
-
-###############################################################################
-# We evaluate the sample point on the Rosenbrock benchmark function:
-
-experimentdata.evaluate(data_generator='Rosenbrock', kwargs={
- 'scale_bounds': domain.get_bounds(), 'offset': False})
-
-print(experimentdata)
-
-###############################################################################
-# We call the :meth:`~f3dasm.ExperimentData.optimize` method with ``optimizer='CG'``
-# and ``data_generator='Rosenbrock'`` to optimize the Rosenbrock benchmark function with the
-# Conjugate Gradient Optimizer:
-
-experimentdata.optimize(optimizer='CG', data_generator='Rosenbrock', kwargs={
- 'scale_bounds': domain.get_bounds(), 'offset': False},
- iterations=50)
-
-print(experimentdata)
-
-###############################################################################
-# We plot the convergence of the optimization process:
-
-_, df_output = experimentdata.to_pandas()
-
-fig, ax = plt.subplots()
-ax.plot(df_output)
-_ = ax.set_xlabel('number of function evaluations')
-_ = ax.set_ylabel('$f(x)$')
-ax.set_yscale('log')
-
-###############################################################################
-# Hyper-parameters of the optimizer can be passed as dictionary to the :meth:`~f3dasm.ExperimentData.optimize` method.
-# If none are provided, default hyper-parameters are used. The hyper-parameters are specific to the optimizer used, and can be found in the corresponding documentation.
-#
-# An overview of the available optimizers can be found in :ref:`this section ` of the documentation
-# Access to more off-the-shelf optimizers requires the installation of the `f3dasm_optimize `_ , using the `TORQUE resource manager `_.
-# * The `DelftBlue: TU Delft supercomputer `_, using the `SLURM resource manager `_.
-# * The `OSCAR compute cluster from Brown University `_, using the `SLURM resource manager `_.
-
-from time import sleep
-
-import numpy as np
-
-from f3dasm import HPC_JOBID, ExperimentData
-from f3dasm.design import make_nd_continuous_domain
-
-###############################################################################
-# We will create the following data-driven process:
-#
-# * Create a 20D continuous :class:`~f3dasm.design.Domain`
-# * Sample from the domain using a the Latin-hypercube sampler
-# * With multiple nodes; use a data generation function, which will be the ``"Ackley"`` function a from the benchmark functions
-#
-#
-# .. image:: ../../img/f3dasm-workflow-example-cluster.png
-# :width: 70%
-# :align: center
-# :alt: Workflow
-
-###############################################################################
-# We want to make sure that the sampling is done only once, and that the data generation is done in parallel.
-# Therefore we can divide the different nodes into two categories:
-#
-# * The first node (:code:`f3dasm.HPC_JOBID == 0`) will be the **master** node, which will be responsible for creating the design-of-experiments and sampling (the ``create_experimentdata`` function).
-
-
-def create_experimentdata():
- """Design of Experiment"""
- # Create a domain object
- domain = make_nd_continuous_domain(
- bounds=np.tile([0.0, 1.0], (20, 1)), dimensionality=20)
-
- # Create the ExperimentData object
- data = ExperimentData(domain=domain)
-
- # Sampling from the domain
- data.sample(sampler='latin', n_samples=10)
-
- # Store the data to disk
- data.store()
-
-###############################################################################
-# * All the other nodes (:code:`f3dasm.HPC_JOBID > 0`) will be **process** nodes, which will retrieve the :class:`~f3dasm.ExperimentData` from disk and go straight to the data generation function.
-#
-# .. image:: ../../img/f3dasm-workflow-cluster-roles.png
-# :width: 100%
-# :align: center
-# :alt: Cluster roles
-
-
-def worker_node():
- # Extract the experimentdata from disk
- data = ExperimentData.from_file(project_dir='.')
-
- """Data Generation"""
- # Use the data-generator to evaluate the initial samples
- data.evaluate(data_generator='Ackley', mode='cluster')
-
-###############################################################################
-# The entrypoint of the script can now check the jobid of the current node and decide whether to create the experiment data or to run the data generation function:
-
-
-if __name__ == '__main__':
- # Check the jobid of the current node
- if HPC_JOBID is None:
- # If the jobid is none, we are not running anything now
- pass
-
- elif HPC_JOBID == 0:
- create_experimentdata()
- worker_node()
- elif HPC_JOBID > 0:
- # Asynchronize the jobs in order to omit racing conditions
- sleep(HPC_JOBID)
- worker_node()
-
-###############################################################################
-#
-# Running the program
-# -------------------
-#
-# You can run the workflow by submitting the bash script to the HPC queue:
-# Make sure you have `miniconda3 `_ installed on the cluster, and that you have created a conda environment (in this example named ``f3dasm_env``) with the necessary packages:
-#
-# .. tabs::
-#
-# .. group-tab:: TORQUE
-#
-# .. code-block:: bash
-#
-# #!/bin/bash
-# # Torque directives (#PBS) must always be at the start of a job script!
-# #PBS -N ExampleScript
-# #PBS -q mse
-# #PBS -l nodes=1:ppn=12,walltime=12:00:00
-#
-# # Make sure I'm the only one that can read my output
-# umask 0077
-#
-#
-# # The PBS_JOBID looks like 1234566[0].
-# # With the following line, we extract the PBS_ARRAYID, the part in the brackets []:
-# PBS_ARRAYID=$(echo "${PBS_JOBID}" | sed 's/\[[^][]*\]//g')
-#
-# module load use.own
-# module load miniconda3
-# cd $PBS_O_WORKDIR
-#
-# # Here is where the application is started on the node
-# # activating my conda environment:
-#
-# source activate f3dasm_env
-#
-# # limiting number of threads
-# OMP_NUM_THREADS=12
-# export OMP_NUM_THREADS=12
-#
-#
-# # If the PBS_ARRAYID is not set, set it to None
-# if ! [ -n "${PBS_ARRAYID+1}" ]; then
-# PBS_ARRAYID=None
-# fi
-#
-# # Executing my python program with the jobid flag
-# python main.py --jobid=${PBS_ARRAYID}
-#
-# .. group-tab:: SLURM
-#
-# .. code-block:: bash
-#
-# #!/bin/bash -l
-#
-# #SBATCH -J "ExmpleScript" # name of the job (can be change to whichever name you like)
-# #SBATCH --get-user-env # to set environment variables
-#
-# #SBATCH --partition=compute
-# #SBATCH --time=12:00:00
-# #SBATCH --nodes=1
-# #SBATCH --ntasks-per-node=12
-# #SBATCH --cpus-per-task=1
-# #SBATCH --mem=0
-# #SBATCH --account=research-eemcs-me
-# #SBATCH --array=0-2
-#
-# source activate f3dasm_env
-#
-# # Executing my python program with the jobid flag
-# python3 main.py --jobid=${SLURM_ARRAY_TASK_ID}
-#
-#
-# You can run the workflow by submitting the bash script to the HPC queue.
-# the following command submits an array job with 3 jobs with :code:`f3dasm.HPC_JOBID` of 0, 1 and 2.
-#
-# .. tabs::
-#
-# .. group-tab:: TORQUE
-#
-# .. code-block:: bash
-#
-# qsub pbsjob.sh -t 0-2
-#
-# .. group-tab:: SLURM
-#
-# .. code-block:: bash
-#
-# sbatch --array 0-2 pbsjob.sh
-#
diff --git a/examples/005_workflow/README.rst b/examples/005_workflow/README.rst
deleted file mode 100644
index 256635b3..00000000
--- a/examples/005_workflow/README.rst
+++ /dev/null
@@ -1,2 +0,0 @@
-Combining everything in a data-driven workflow
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
\ No newline at end of file
diff --git a/examples/006_hydra/001_hydra_usage.py b/examples/006_hydra/001_hydra_usage.py
deleted file mode 100644
index 7799bf7f..00000000
--- a/examples/006_hydra/001_hydra_usage.py
+++ /dev/null
@@ -1,165 +0,0 @@
-"""
-Combine hydra configurations with f3dasm
-========================================
-
-.. _hydra: https://hydra.cc/
-
-`hydra `_ installed on the cluster, and that you have created a conda environment (in this example named ``f3dasm_env``) with the necessary packages:
-#
-# .. tabs::
-#
-# .. group-tab:: TORQUE
-#
-# .. code-block:: bash
-#
-# #!/bin/bash
-# # Torque directives (#PBS) must always be at the start of a job script!
-# #PBS -N ExampleScript
-# #PBS -q mse
-# #PBS -l nodes=1:ppn=12,walltime=12:00:00
-#
-# # Make sure I'm the only one that can read my output
-# umask 0077
-#
-#
-# # The PBS_JOBID looks like 1234566[0].
-# # With the following line, we extract the PBS_ARRAYID, the part in the brackets []:
-# PBS_ARRAYID=$(echo "${PBS_JOBID}" | sed 's/\[[^][]*\]//g')
-#
-# module load use.own
-# module load miniconda3
-# cd $PBS_O_WORKDIR
-#
-# # Here is where the application is started on the node
-# # activating my conda environment:
-#
-# source activate f3dasm_env
-#
-# # limiting number of threads
-# OMP_NUM_THREADS=12
-# export OMP_NUM_THREADS=12
-#
-#
-# # If the PBS_ARRAYID is not set, set it to None
-# if ! [ -n "${PBS_ARRAYID+1}" ]; then
-# PBS_ARRAYID=None
-# fi
-#
-# # Executing my python program with the jobid flag
-# python main.py ++hpc.jobid=${PBS_ARRAYID} hydra.run.dir=outputs/${now:%Y-%m-%d}/${JOB_ID}
-#
-# .. group-tab:: SLURM
-#
-# .. code-block:: bash
-#
-# #!/bin/bash -l
-#
-# #SBATCH -J "ExmpleScript" # name of the job (can be change to whichever name you like)
-# #SBATCH --get-user-env # to set environment variables
-#
-# #SBATCH --partition=compute
-# #SBATCH --time=12:00:00
-# #SBATCH --nodes=1
-# #SBATCH --ntasks-per-node=12
-# #SBATCH --cpus-per-task=1
-# #SBATCH --mem=0
-# #SBATCH --account=research-eemcs-me
-# #SBATCH --array=0-2
-#
-# source activate f3dasm_env
-#
-# # Executing my python program with the jobid flag
-# python main.py ++hpc.jobid=${SLURM_ARRAY_TASK_ID} hydra.run.dir=/scratch/${USER}/${projectfolder}/${SLURM_ARRAY_JOB_ID}
-#
-# .. warning::
-# Make sure you set the ``hydra.run.dir`` argument in the jobscript to the location where you want to store the output of the hydra runs!
-#
-# You can run the workflow by submitting the bash script to the HPC queue.
-# the following command submits an array job with 3 jobs with :code:`f3dasm.HPC_JOBID` of 0, 1 and 2.
-#
-# .. tabs::
-#
-# .. group-tab:: TORQUE
-#
-# .. code-block:: bash
-#
-# qsub pbsjob.sh -t 0-2
-#
-# .. group-tab:: SLURM
-#
-# .. code-block:: bash
-#
-# sbatch --array 0-2 pbsjob.sh
-#
diff --git a/examples/006_hydra/README.rst b/examples/006_hydra/README.rst
deleted file mode 100644
index 07dfdd1c..00000000
--- a/examples/006_hydra/README.rst
+++ /dev/null
@@ -1,4 +0,0 @@
-Integration with hydra
-^^^^^^^^^^^^^^^^^^^^^^
-
-Examples that integrate the :mod:`f3dasm` package with the configuration manager `hydra :
- type:
-
- :
- type:
-
+ input:
+ :
+ type:
+
+ :
+ type:
+
+ output:
+ :
+ to_disk:
Parameters
@@ -183,91 +243,135 @@ def from_yaml(cls: Type[Domain], cfg: DictConfig) -> Domain:
Domain
Domain object
"""
+ def process_input(items):
+ for key, value in items.items():
+ _dict = OmegaConf.to_container(value, resolve=True)
+ domain.add(name=key, type=_dict.pop('type', None), **_dict)
+
+ def process_output(items):
+ for key, value in items.items():
+ _dict = OmegaConf.to_container(value, resolve=True)
+ domain.add_output(name=key, **_dict)
+
domain = cls()
- for key, value in cfg.items():
- _dict = OmegaConf.to_container(value, resolve=True)
- domain.add(name=key, type=_dict.pop('type'), **_dict)
+ if 'input' in cfg:
+ process_input(cfg.input)
+ else:
+ process_input(cfg)
+
+ if 'output' in cfg:
+ process_output(cfg.output)
return domain
@classmethod
- def from_dataframe(cls, df_input: pd.DataFrame,
- df_output: pd.DataFrame) -> Domain:
- """Initializes a Domain from a pandas DataFrame.
+ def from_data(cls, input_data: List[Dict[str, Any]],
+ output_data: List[Dict[str, Any]]
+ ) -> Domain:
+ """
+ Initialize a Domain from input and output data.
Parameters
----------
- df_input : pd.DataFrame
- DataFrame containing the input parameters.
- df_output : pd.DataFrame
- DataFrame containing the output parameters.
+ input_data : List[Dict[str, Any]]
+ List of dictionaries containing the input parameters.
+ output_data : List[Dict[str, Any]]
+ List of dictionaries containing the output parameters.
Returns
-------
Domain
- Domain object
+ Domain object containing the input and output parameter names.
"""
- input_space = {}
- for name, type in df_input.dtypes.items():
- if type == 'float64':
- if float(df_input[name].min()) == float(df_input[name].max()):
- input_space[name] = _ConstantParameter(
- value=float(df_input[name].min()))
- continue
-
- input_space[name] = _ContinuousParameter(lower_bound=float(
- df_input[name].min()),
- upper_bound=float(df_input[name].max()))
- elif type == 'int64':
- if int(df_input[name].min()) == int(df_input[name].max()):
- input_space[name] = _ConstantParameter(
- value=int(df_input[name].min()))
- continue
-
- input_space[name] = _DiscreteParameter(lower_bound=int(
- df_input[name].min()),
- upper_bound=int(df_input[name].max()))
- else:
- input_space[name] = _CategoricalParameter(
- df_input[name].unique().tolist())
+ all_input_parameters, all_output_parameters = set(), set()
+ for experiment_input, experiment_output in zip_longest(
+ input_data, output_data, fillvalue={}):
- output_space = {}
- for name in df_output.columns:
- output_space[name] = _OutputParameter(to_disk=False)
+ all_input_parameters.update(experiment_input.keys())
+ all_output_parameters.update(experiment_output.keys())
- return cls(space=input_space, output_space=output_space)
+ input_names = sorted(list(all_input_parameters))
+ output_names = sorted(list(all_output_parameters))
+
+ input_space = {name: Parameter() for name in input_names}
+ output_space = {name: Parameter() for name in output_names}
+
+ return cls(input_space=input_space, output_space=output_space)
# Export
# =============================================================================
- def store(self, filename: Path) -> None:
- """Stores the Domain in a pickle file.
+ def store(self, filename: Path | str) -> None:
+ """
+ Store the Domain object and its parameters as a JSON file.
Parameters
----------
- filename : str
- Name of the file.
- """
- with open(filename.with_suffix('.pkl'), 'wb') as f:
- pickle.dump(self, f)
+ filename : Path or str
+ Path of the JSON file to store the Domain object.
- def _cast_types_dataframe(self) -> dict:
- """Make a dictionary that provides the datatype of each parameter"""
- return {name: parameter._type for
- name, parameter in self.space.items()}
+ Examples
+ --------
+ >>> domain.to_json('domain.json')
+ """
+ domain_dict = {
+ 'input_space': {k: v.to_dict()
+ for k, v in self.input_space.items()},
+ 'output_space': {k: v.to_dict()
+ for k, v in self.output_space.items()}
+ }
+ with open(Path(filename).with_suffix('.json'), 'w') as f:
+ json.dump(domain_dict, f, indent=4)
# Append and remove parameters
# =============================================================================
- def _add(self, name: str, parameter: _Parameter):
+ def _add(self, name: str, parameter: Parameter):
+ """
+ Add a new input parameter to the domain.
+
+ Parameters
+ ----------
+ name : str
+ Name of the input parameter.
+ parameter : Parameter
+ Parameter object to be added to the domain.
+ """
# Check if parameter is already in the domain
- if name in self.space:
+ if name in self.input_space:
raise KeyError(
f"Parameter {name} already exists in the domain! \
Choose a different name.")
- self.space[name] = parameter
+ self.input_space[name] = parameter
+
+ def add_parameter(self, name: str,
+ to_disk=False,
+ store_function: Optional[StoreFunction] = None,
+ load_function: Optional[LoadFunction] = None):
+ """Add a new parameter to the domain.
+
+ Parameters
+ ----------
+ name : str
+ Name of the input parameter.
+ store_function : StoreFunction, optional
+ Function to store the parameter, by default None.
+ load_function : LoadFunction, optional
+ Function to load the parameter, by default None.
+
+ Example
+ -------
+ >>> domain = Domain()
+ >>> domain.add_parameter('param1', store_function, load_function)
+ >>> domain.input_space
+ {'param1': Parameter(store_function=store_function,
+ load_function=load_function)}
+ """
+ self._add(name, Parameter(store_function=store_function,
+ load_function=load_function,
+ to_disk=to_disk))
def add_int(self, name: str, low: int, high: int, step: int = 1):
"""Add a new discrete input parameter to the domain.
@@ -287,8 +391,8 @@ def add_int(self, name: str, low: int, high: int, step: int = 1):
-------
>>> domain = Domain()
>>> domain.add_int('param1', 0, 10, 2)
- >>> domain.space
- {'param1': _DiscreteParameter(lower_bound=0, upper_bound=10, step=2)}
+ >>> domain.input_space
+ {'param1': DiscreteParameter(lower_bound=0, upper_bound=10, step=2)}
Note
----
@@ -297,7 +401,8 @@ def add_int(self, name: str, low: int, high: int, step: int = 1):
"""
if low == high:
self.add_constant(name, low)
- self._add(name, _DiscreteParameter(low, high, step))
+ else:
+ self._add(name, DiscreteParameter(low, high, step))
def add_float(self, name: str, low: float = -np.inf, high: float = np.inf,
log: bool = False):
@@ -318,8 +423,8 @@ def add_float(self, name: str, low: float = -np.inf, high: float = np.inf,
-------
>>> domain = Domain()
>>> domain.add_float('param1', 0., 10., log=True)
- >>> domain.space
- {'param1': _ContinuousParameter(lower_bound=0.,
+ >>> domain.input_space
+ {'param1': ContinuousParameter(lower_bound=0.,
upper_bound=10., log=True)}
Note
@@ -330,7 +435,7 @@ def add_float(self, name: str, low: float = -np.inf, high: float = np.inf,
if math.isclose(low, high):
self.add_constant(name, low)
else:
- self._add(name, _ContinuousParameter(low, high, log))
+ self._add(name, ContinuousParameter(low, high, log))
def add_category(self, name: str, categories: Sequence[CategoricalType]):
"""Add a new categorical input parameter to the domain.
@@ -346,10 +451,10 @@ def add_category(self, name: str, categories: Sequence[CategoricalType]):
-------
>>> domain = Domain()
>>> domain.add_category('param1', [0, 1, 2])
- >>> domain.space
+ >>> domain.input_space
{'param1': CategoricalParameter(categories=[0, 1, 2])}
"""
- self._add(name, _CategoricalParameter(categories))
+ self._add(name, CategoricalParameter(categories))
def add_constant(self, name: str, value: Any):
"""Add a new constant input parameter to the domain.
@@ -365,10 +470,10 @@ def add_constant(self, name: str, value: Any):
-------
>>> domain = Domain()
>>> domain.add_constant('param1', 0)
- >>> domain.space
+ >>> domain.input_space
{'param1': ConstantParameter(value=0)}
"""
- self._add(name, _ConstantParameter(value))
+ self._add(name, ConstantParameter(value))
def add(self, name: str,
type: Literal['float', 'int', 'category', 'constant'],
@@ -394,8 +499,8 @@ def add(self, name: str,
-------
>>> domain = Domain()
>>> domain._new_add('param1', 'float', low=0., high=1.)
- >>> domain.space
- {'param1': _ContinuousParameter(lower_bound=0., upper_bound=1.)}
+ >>> domain.input_space
+ {'param1': ContinuousParameter(lower_bound=0., upper_bound=1.)}
"""
if type == 'float':
@@ -412,7 +517,9 @@ def add(self, name: str,
f"Possible types are: 'float', 'int', 'category', 'constant'.")
def add_output(self, name: str, to_disk: bool = False,
- exist_ok: bool = False):
+ exist_ok: bool = False,
+ store_function: Optional[StoreFunction] = None,
+ load_function: Optional[LoadFunction] = None):
"""Add a new output parameter to the domain.
Parameters
@@ -429,7 +536,7 @@ def add_output(self, name: str, to_disk: bool = False,
-------
>>> domain = Domain()
>>> domain.add_output('param1', True)
- >>> domain.space
+ >>> domain.input_space
{'param1': OutputParameter(to_disk=True)}
"""
if name in self.output_space:
@@ -439,7 +546,9 @@ def add_output(self, name: str, to_disk: bool = False,
Choose a different name.")
return
- self.output_space[name] = _OutputParameter(to_disk)
+ self.output_space[name] = Parameter(to_disk=to_disk,
+ store_function=store_function,
+ load_function=load_function)
# Getters
# =============================================================================
@@ -454,10 +563,10 @@ def get_bounds(self) -> np.ndarray:
Example
-------
>>> domain = Domain()
- >>> domain.space = {
- ... 'param1': _ContinuousParameter(lower_bound=0, upper_bound=1),
- ... 'param2': _ContinuousParameter(lower_bound=-1, upper_bound=1),
- ... 'param3': _ContinuousParameter(lower_bound=0, upper_bound=10)
+ >>> domain.input_space = {
+ ... 'param1': ContinuousParameter(lower_bound=0, upper_bound=1),
+ ... 'param2': ContinuousParameter(lower_bound=-1, upper_bound=1),
+ ... 'param3': ContinuousParameter(lower_bound=0, upper_bound=10)
... }
>>> bounds = domain.get_bounds()
>>> bounds
@@ -467,10 +576,10 @@ def get_bounds(self) -> np.ndarray:
"""
return np.array(
[[parameter.lower_bound, parameter.upper_bound]
- for _, parameter in self.continuous.space.items()]
+ for _, parameter in self.continuous.input_space.items()]
)
- def _filter(self, type: Type[_Parameter]) -> Domain:
+ def _filter(self, type: Type[Parameter]) -> Domain:
"""Filter the parameters of the domain by type
Parameters
@@ -486,119 +595,25 @@ def _filter(self, type: Type[_Parameter]) -> Domain:
Example
-------
>>> domain = Domain()
- >>> domain.space = {
- ... 'param1': _ContinuousParameter(lower_bound=0., upper_bound=1.),
- ... 'param2': _DiscreteParameter(lower_bound=0, upper_bound=8),
+ >>> domain.input_space = {
+ ... 'param1': ContinuousParameter(lower_bound=0., upper_bound=1.),
+ ... 'param2': DiscreteParameter(lower_bound=0, upper_bound=8),
... 'param3': CategoricalParameter(categories=['cat1', 'cat2'])
... }
- >>> filtered_domain = domain.filter_parameters(_ContinuousParameter)
- >>> filtered_domain.space
- {'param1': _ContinuousParameter(lower_bound=0, upper_bound=1)}
+ >>> filtered_domain = domain.filter_parameters(ContinuousParameter)
+ >>> filtered_domain.input_space
+ {'param1': ContinuousParameter(lower_bound=0, upper_bound=1)}
"""
return Domain(
- space={name: parameter for name, parameter in self.space.items()
- if isinstance(parameter, type)}
+ input_space={
+ name: parameter for name, parameter in self.input_space.items()
+ if isinstance(parameter, type)}
)
- def select(self, names: str | Iterable[str]) -> Domain:
- """Select a subset of parameters from the domain.
-
- Parameters
- ----------
-
- names : str or Iterable[str]
- The names of the parameters to select.
-
- Returns
- -------
- Domain
- A new domain with the selected parameters.
-
- Example
- -------
- >>> domain = Domain()
- >>> domain.space = {
- ... 'param1': _ContinuousParameter(lower_bound=0., upper_bound=1.),
- ... 'param2': _DiscreteParameter(lower_bound=0, upper_bound=8),
- ... 'param3': CategoricalParameter(categories=['cat1', 'cat2'])
- ... }
- >>> domain.select(['param1', 'param3'])
- Domain({'param1': _ContinuousParameter(lower_bound=0, upper_bound=1),
- 'param3': CategoricalParameter(categories=['cat1', 'cat2'])})
- """
-
- if isinstance(names, str):
- names = [names]
-
- return Domain(space={key: self.space[key] for key in names})
-
- def drop_output(self, names: str | Iterable[str]) -> Domain:
- """Drop a subset of output parameters from the domain.
-
- Parameters
- ----------
-
- names : str or Iterable[str]
- The names of the output parameters to drop.
-
- Returns
- -------
- Domain
- A new domain with the dropped output parameters.
-
- Example
- -------
- >>> domain = Domain()
- >>> domain.output_space = {
- ... 'param1': _OutputParameter(to_disk=True),
- ... 'param2': _OutputParameter(to_disk=True),
- ... 'param3': _OutputParameter(to_disk=True)
- ... }
- >>> domain.drop_output(['param1', 'param3'])
- Domain({'param2': _OutputParameter(to_disk=True)})
- """
-
- if isinstance(names, str):
- names = [names]
-
- return Domain(
- space=self.space,
- output_space={key: self.output_space[key]
- for key in self.output_space
- if key not in names})
-
# Miscellaneous
# =============================================================================
- def _all_input_continuous(self) -> bool:
- """Check if all input parameters are continuous"""
- return len(self) == len(self._filter(_ContinuousParameter))
-
- def is_in_output(self, output_name: str) -> bool:
- """Check if output is in the domain
-
- Parameters
- ----------
- output_name : str
- Name of the output
-
- Returns
- -------
- bool
- True if output is in the domain, False otherwise
-
- Example
- -------
- >>> domain = Domain()
- >>> domain.add_output('output1')
- >>> domain.is_in_output('output1')
- True
- >>> domain.is_in_output('output2')
- False
- """
- return output_name in self.output_space
-
def make_nd_continuous_domain(bounds: np.ndarray | List[List[float]],
dimensionality: Optional[int] = None) -> Domain:
@@ -635,7 +650,7 @@ def make_nd_continuous_domain(bounds: np.ndarray | List[List[float]],
>>> dimensionality = 2
>>> domain = make_nd_continuous_domain(bounds, dimensionality)
"""
- space = {}
+ input_space = {}
# bounds is a list of lists, convert to numpy array:
bounds = np.array(bounds)
@@ -643,31 +658,42 @@ def make_nd_continuous_domain(bounds: np.ndarray | List[List[float]],
dimensionality = bounds.shape[0]
for dim in range(dimensionality):
- space[f"x{dim}"] = _ContinuousParameter(
+ input_space[f"x{dim}"] = ContinuousParameter(
lower_bound=bounds[dim, 0], upper_bound=bounds[dim, 1])
- return Domain(space)
+ return Domain(input_space=input_space)
-def _domain_factory(domain: Domain | DictConfig | None,
- input_data: pd.DataFrame,
- output_data: pd.DataFrame) -> Domain:
+def _domain_factory(domain: Domain | DictConfig | Path | str) -> Domain:
+ """
+ Factory function to create a Domain object from various input types.
+
+ Parameters
+ ----------
+ domain : Domain | DictConfig | Path | str
+ The domain to be converted to a Domain object.
+
+ Returns
+ -------
+ Domain
+ Domain object
+ """
+ # If domain is already a Domain object, return it
if isinstance(domain, Domain):
return domain
+ # If domain is not given, return an empty Domain object
+ elif domain is None:
+ return Domain()
+
+ # If domain is a path, load the domain from the file
elif isinstance(domain, (Path, str)):
return Domain.from_file(Path(domain))
+ # If the domain is a hydra DictConfig, convert it to a Domain object
elif isinstance(domain, DictConfig):
return Domain.from_yaml(domain)
- elif (input_data.empty and output_data.empty and domain is None):
- return Domain()
-
- elif domain is None:
- return Domain.from_dataframe(
- input_data, output_data)
-
else:
raise TypeError(
f"Domain must be of type Domain, DictConfig "
diff --git a/src/f3dasm/_src/design/parameter.py b/src/f3dasm/_src/design/parameter.py
index 07b67e3f..311c99cf 100644
--- a/src/f3dasm/_src/design/parameter.py
+++ b/src/f3dasm/_src/design/parameter.py
@@ -1,4 +1,4 @@
-"""Parameters for constructing the feasible search space."""
+"""Parameters for constructing a feasible search space."""
# Modules
# =============================================================================
@@ -6,11 +6,8 @@
from __future__ import annotations
# Standard
-from dataclasses import dataclass, field
-from typing import Any, ClassVar, Sequence, Union
-
-# Third-party
-import numpy as np
+import pickle
+from typing import Any, ClassVar, Iterable, Optional, Protocol, Union
# Authorship & Credits
# =============================================================================
@@ -23,25 +20,236 @@
CategoricalType = Union[None, int, float, str]
+# =============================================================================
-@dataclass
-class _Parameter:
- """Interface class of a search space parameter
- Parameters
- ----------
- """
- _type: ClassVar[str] = field(init=False, default="object")
+class StoreFunction(Protocol):
+ """Base class for storing and loading output data from disk"""
+
+ def __call__(object: Any, path: str) -> str:
+ """
+ Protocol class for storing output data from disk.
+
+ Parameters
+ ----------
+ object : Any
+ The object to store.
+ path : str
+ The location to store the object to.
+
+ Notes
+ -----
+ The function should store the object to the location specified by the
+ path parameter. The suffix of the file should be determined by the
+ object type, and is not yet implemented in the path!
+ """
+ ...
+
+
+class LoadFunction(Protocol):
+ """Base class for storing and loading output data from disk"""
+
+ def __call__(path: str) -> Any:
+ """
+ Protocol class for loading output data from disk.
+
+ Parameters
+ ----------
+ path : str
+ The location to load the object from.
+
+ Returns
+ -------
+ Any
+ The loaded object.
+ """
+ ...
+
+
+# =============================================================================
+
+
+class Parameter:
+ """Interface class of a search space parameter."""
+ _type: ClassVar[str] = "object"
+
+ def __init__(self, to_disk: bool = False,
+ store_function: Optional[StoreFunction] = None,
+ load_function: Optional[LoadFunction] = None):
+ """
+ Initialize the Parameter.
+
+ Parameters
+ ----------
+ to_disk : bool, optional
+ Whether the parameter should be saved to disk. Defaults to False.
+ store_function : Optional[StoreFunction], optional
+ Function to store the parameter to disk. Defaults to None.
+ load_function : Optional[LoadFunction], optional
+ Function to load the parameter from disk. Defaults to None.
+
+ Raises
+ ------
+ ValueError
+ If `to_disk` is False but either `store_function` or
+ `load_function` is not None.
+
+ Notes
+ -----
+ The `store_function` and `load_function` parameters are used to store
+ the parameter to disk and load it from disk, respectively. f3dasm has
+ built-in support for some common datatypes (numpy array, pandas
+ DataFrame, xarray Dataarray and Dataset), for those data types the
+ `store_function` and `load_function` are automatically set. If the
+ parameter is not one of these types, the user must provide a custom
+ `store_function` and `load_function`.
+
+ Examples
+ --------
+ >>> param = Parameter(to_disk=True)
+ >>> print(param)
+ Parameter(type=object, to_disk=True)
+ """
+
+ if not to_disk and (
+ store_function is not None or load_function is not None):
+ raise ValueError(("If 'to_disk' is False, 'store_function' and"
+ "load_function' must be None.")
+ )
+
+ self.to_disk = to_disk
+ self.store_function = store_function
+ self.load_function = load_function
+
+ def __str__(self):
+ return f"Parameter(type={self._type}, to_disk={self.to_disk})"
+
+ def __repr__(self):
+ return f"{self.__class__.__name__}(to_disk={self.to_disk})"
+
+ def __eq__(self, __o: Parameter):
+ return self.to_disk == __o.to_disk
+
+ def __add__(self, __o: Parameter) -> Parameter:
+ """
+ Add two parameters together.
+ Parameters
+ ----------
+ __o : Parameter
+ The parameter to add to the current parameter.
-@dataclass
-class _OutputParameter(_Parameter):
- to_disk: bool = field(default=False)
+ Returns
+ -------
+ Parameter
+ The first parameter
+ Notes
+ -----
+ Adding two parameters together will return the first parameter. This
+ is because the parameters are not additive.
+ """
+ return self
-@dataclass
-class _ConstantParameter(_Parameter):
- """Create a search space parameter that is constant.
+ def to_dict(self) -> dict:
+ """
+ Convert the Parameter object to a dictionary.
+
+ Returns
+ -------
+ dict
+ Dictionary representation of the Parameter object.
+
+ Notes
+ -----
+ The dictionary representation of the Parameter object contains the
+ type of the parameter, whether it should be saved to disk, and the
+ store and load functions. The functions are stored as hex strings.
+
+ Examples
+ --------
+ >>> param = Parameter(to_disk=True)
+ >>> param_dict = param.to_dict()
+
+
+ """
+ param_dict = {
+ 'type': self._type,
+ 'to_disk': self.to_disk,
+ 'store_function': None,
+ 'load_function': None
+ }
+ if self.store_function:
+ param_dict['store_function'] = pickle.dumps(
+ self.store_function).hex()
+ if self.load_function:
+ param_dict['load_function'] = pickle.dumps(
+ self.load_function).hex()
+ return param_dict
+
+ @classmethod
+ def from_dict(cls, param_dict: dict) -> Parameter:
+ """
+ Create a Parameter object from a dictionary.
+
+ Parameters
+ ----------
+ param_dict : dict
+ Dictionary representation of the Parameter object.
+
+ Returns
+ -------
+ Parameter
+ Parameter object created from the dictionary.
+
+ Examples
+ --------
+ >>> param_dict = {'type': 'object', 'to_disk': False}
+ >>> param = Parameter.from_dict(param_dict)
+ """
+ param_type = param_dict['type']
+ store_function = None
+ load_function = None
+ if param_dict['store_function']:
+ store_function = pickle.loads(
+ bytes.fromhex(param_dict['store_function']))
+ if param_dict['load_function']:
+ load_function = pickle.loads(
+ bytes.fromhex(param_dict['load_function']))
+
+ if param_type == 'object':
+ return Parameter(to_disk=param_dict['to_disk'],
+ store_function=store_function,
+ load_function=load_function)
+ elif param_type == 'float':
+ return ContinuousParameter(
+ lower_bound=param_dict.get('lower_bound', float('-inf')),
+ upper_bound=param_dict.get('upper_bound', float('inf')),
+ log=param_dict.get('log', False)
+ )
+ elif param_type == 'int':
+ return DiscreteParameter(
+ lower_bound=param_dict.get('lower_bound', 0),
+ upper_bound=param_dict.get('upper_bound', 1),
+ step=param_dict.get('step', 1)
+ )
+ elif param_type == 'category':
+ return CategoricalParameter(
+ categories=param_dict.get('categories', [])
+ )
+ elif param_type == 'constant':
+ return ConstantParameter(
+ value=param_dict.get('value')
+ )
+ else:
+ raise ValueError(f"Unknown parameter type: {param_type}")
+
+# =============================================================================
+
+
+class ConstantParameter(Parameter):
+ """
+ Create a search space parameter that is constant.
Parameters
----------
@@ -58,269 +266,342 @@ class _ConstantParameter(_Parameter):
TypeError
If the value is not hashable.
+ Examples
+ --------
+ >>> param = ConstantParameter(value=5)
+ >>> print(param)
+ ConstantParameter(value=5)
"""
- value: Any
- _type: ClassVar[str] = field(init=False, default="object")
-
- def __post_init__(self):
- self._check_hashable()
+ def __init__(self, value: Any):
+ super().__init__()
+ self.value = value
+ self._validate_hashable()
- def __add__(self, __o: _Parameter
- ) -> _ConstantParameter | _CategoricalParameter:
- if isinstance(__o, _ConstantParameter):
- if self.value == __o.value:
+ def __add__(self, other: Parameter):
+ if isinstance(other, ConstantParameter):
+ if self.value == other.value:
return self
else:
- return _CategoricalParameter(
- categories=[self.value, __o.value])
+ return CategoricalParameter(
+ categories=[self.value, other.value])
- if isinstance(__o, _CategoricalParameter):
- return self.to_categorical() + __o
+ if isinstance(other, CategoricalParameter):
+ return self.to_categorical() + other
- if isinstance(__o, _DiscreteParameter):
- return self.to_categorical() + __o
+ if isinstance(other, DiscreteParameter):
+ return self.to_categorical() + other
- if isinstance(__o, _ContinuousParameter):
+ if isinstance(other, ContinuousParameter):
raise ValueError("Cannot add continuous parameter to constant!")
- def to_categorical(self) -> _CategoricalParameter:
- return _CategoricalParameter(categories=[self.value])
+ def to_categorical(self) -> CategoricalParameter:
+ """
+ Convert the constant parameter to a categorical parameter.
+
+ Returns
+ -------
+ CategoricalParameter
+ The converted categorical parameter.
+ """
+ return CategoricalParameter(categories=[self.value])
- def _check_hashable(self):
+ def to_dict(self):
+ param_dict = super().to_dict()
+ param_dict['type'] = 'constant'
+ param_dict['value'] = self.value
+ return param_dict
+
+ def _validate_hashable(self):
"""Check if the value is hashable."""
try:
hash(self.value)
except TypeError:
raise TypeError("The value must be hashable.")
+ def __str__(self):
+ return f"ConstantParameter(value={self.value})"
+
+ def __repr__(self):
+ return f"{self.__class__.__name__}(value={repr(self.value)})"
+
+ def __eq__(self, __o: Parameter) -> bool:
+ if not isinstance(__o, ConstantParameter):
+ return False
+
+ return self.value == __o.value
+
+# =============================================================================
-@dataclass
-class _ContinuousParameter(_Parameter):
+
+class ContinuousParameter(Parameter):
"""
A search space parameter that is continuous.
- Attributes
+ Parameters
----------
lower_bound : float, optional
- The lower bound of the continuous search space.
- Defaults to negative infinity.
+ The lower bound of the parameter. Defaults to -inf.
upper_bound : float, optional
- The upper bound of the continuous search space (exclusive).
- Defaults to infinity.
+ The upper bound of the parameter. Defaults to inf.
log : bool, optional
- Whether the search space is logarithmic. Defaults to False.
+ Whether the parameter should be on a log scale. Defaults to False.
Raises
------
- TypeError
- If the boundaries are not floats.
ValueError
- If the upper bound is less than the lower bound, or if the
- lower bound is equal to the upper bound.
-
- Note
- ----
- This class inherits from the `Parameter` class and adds the ability
- to specify a continuous search space.
+ If `log` is True and `lower_bound` is less than or equal to 0.
+ If `upper_bound` is less than or equal to `lower_bound`.
+
+ Examples
+ --------
+ >>> param = ContinuousParameter(lower_bound=0.0, upper_bound=1.0)
+ >>> print(param)
+ ContinuousParameter(lower_bound=0.0, upper_bound=1.0, log=False)
"""
+ _type: ClassVar[str] = "float"
- lower_bound: float = field(default=-np.inf)
- upper_bound: float = field(default=np.inf)
- log: bool = field(default=False)
- _type: ClassVar[str] = field(init=False, default="float")
-
- def __post_init__(self):
+ def __init__(self, lower_bound: float = float('-inf'),
+ upper_bound: float = float('inf'), log: bool = False):
+ super().__init__()
+ self.lower_bound = float(lower_bound)
+ self.upper_bound = float(upper_bound)
+ self.log = log
if self.log and self.lower_bound <= 0.0:
- raise ValueError(
- f"The `lower_bound` value must be larger than 0 for a \
- log distribution "
- f"(low={self.lower_bound}, high={self.upper_bound})."
- )
-
- self._check_types()
- self._check_range()
-
- def __add__(self, __o: _Parameter) -> _ContinuousParameter:
- if not isinstance(__o, _ContinuousParameter):
+ raise ValueError((
+ f"The `lower_bound` value must be larger than 0 for a "
+ f"log distribution (low={self.lower_bound}, "
+ f"high={self.upper_bound})."
+ ))
+ self._validate_range()
+
+ def __add__(self, other: Parameter) -> "ContinuousParameter":
+ if not isinstance(other, ContinuousParameter):
raise ValueError(
"Cannot add non-continuous parameter to continuous!")
-
- if self.log != __o.log:
+ if self.log != other.log:
raise ValueError(
"Cannot add continuous parameters with different log scales!")
-
- if self.lower_bound == __o.lower_bound \
- and self.upper_bound == __o.upper_bound:
- # If both lower and upper bounds are the same,
- # return the first object
- return self
-
- if self.lower_bound > __o.upper_bound \
- or __o.lower_bound > self.upper_bound:
- # If the ranges do not coincide, raise ValueError
+ if self.lower_bound > other.upper_bound or \
+ other.lower_bound > self.upper_bound:
raise ValueError("Ranges do not coincide, cannot add")
- # For other scenarios, join the ranges
- return _ContinuousParameter(
- lower_bound=min(self.lower_bound, __o.lower_bound),
- upper_bound=max(self.upper_bound, __o.upper_bound))
+ return ContinuousParameter(
+ lower_bound=min(self.lower_bound, other.lower_bound),
+ upper_bound=max(self.upper_bound, other.upper_bound)
+ )
+
+ def __str__(self):
+ return (f"ContinuousParameter(lower_bound={self.lower_bound}, "
+ f"upper_bound={self.upper_bound}, log={self.log})")
- def _check_types(self):
- """Check if the boundaries are actually floats"""
- if isinstance(self.lower_bound, int):
- self.lower_bound = float(self.lower_bound)
+ def __repr__(self):
+ return (f"{self.__class__.__name__}(lower_bound={self.lower_bound}, "
+ f"upper_bound={self.upper_bound}, log={self.log})")
- if isinstance(self.upper_bound, int):
- self.upper_bound = float(self.upper_bound)
+ def __eq__(self, __o: Parameter) -> bool:
+ if not isinstance(__o, ContinuousParameter):
+ return False
- if not isinstance(
- self.lower_bound, float) or not isinstance(
- self.upper_bound, float):
- raise TypeError(
- f"Expect float, got {type(self.lower_bound).__name__} \
- and {type(self.upper_bound).__name__}")
+ return (self.lower_bound == __o.lower_bound and self.upper_bound
+ == __o.upper_bound and self.log == __o.log)
- def _check_range(self):
- """Check if the lower boundary is lower than the higher boundary"""
+ def _validate_range(self):
if self.upper_bound <= self.lower_bound:
- raise ValueError(f"The `upper_bound` value must be larger than \
- the `lower_bound` value "
- f"(lower_bound={self.lower_bound}, \
- higher_bound={self.upper_bound}")
+ raise ValueError((
+ f"The `upper_bound` value must be larger than `lower_bound`. "
+ f"(lower_bound={self.lower_bound}, "
+ f"upper_bound={self.upper_bound})")
+ )
- def to_discrete(self, step: int = 1) -> _DiscreteParameter:
- """Convert the continuous parameter to a discrete parameter.
+ def to_discrete(self, step: int = 1) -> "DiscreteParameter":
+ """
+ Convert the continuous parameter to a discrete parameter.
Parameters
----------
- step : int
- The step size of the discrete search space, which defaults to 1.
+ step : int, optional
+ The step size for the discrete parameter. Defaults to 1.
Returns
-------
DiscreteParameter
- The discrete parameter.
+ The converted discrete parameter.
Raises
------
ValueError
If the step size is less than or equal to 0.
+ Examples
+ --------
+ >>> param = ContinuousParameter(lower_bound=0.0, upper_bound=1.0)
+ >>> discrete_param = param.to_discrete(step=0.1)
+ >>> print(discrete_param)
+ DiscreteParameter(lower_bound=0.0, upper_bound=1.0, step=0.1)
"""
if step <= 0:
raise ValueError("The step size must be larger than 0.")
-
- return _DiscreteParameter(
- lower_bound=int(self.lower_bound),
- upper_bound=int(self.upper_bound),
+ return DiscreteParameter(
+ lower_bound=self.lower_bound,
+ upper_bound=self.upper_bound,
step=step
)
+ def to_dict(self) -> dict:
+ param_dict = super().to_dict()
+ param_dict['type'] = 'float'
+ param_dict['lower_bound'] = self.lower_bound
+ param_dict['upper_bound'] = self.upper_bound
+ param_dict['log'] = self.log
+ return param_dict
+
+# =============================================================================
-@dataclass
-class _DiscreteParameter(_Parameter):
- """Create a search space parameter that is discrete
+
+class DiscreteParameter(Parameter):
+ """
+ Create a search space parameter that is discrete.
Parameters
----------
lower_bound : int, optional
- lower bound of discrete search space
+ The lower bound of the parameter. Defaults to 0.
upper_bound : int, optional
- upper bound of discrete search space (exclusive)
+ The upper bound of the parameter. Defaults to 1.
step : int, optional
- step size of discrete search space
- """
-
- lower_bound: int = field(default=0)
- upper_bound: int = field(default=1)
- step: int = field(default=1)
- _type: ClassVar[str] = field(init=False, default="int")
-
- def __post_init__(self):
-
- self._check_types()
- self._check_range()
+ The step size for the parameter. Defaults to 1.
- def __add__(self, __o: _Parameter) -> _DiscreteParameter:
- if isinstance(__o, _DiscreteParameter):
- if self.lower_bound == __o.lower_bound and \
- self.upper_bound == __o.upper_bound and \
- self.step == __o.step:
- return self
+ Raises
+ ------
+ ValueError
+ If `upper_bound` is less than or equal to `lower_bound`.
+ If `step` is less than or equal to 0.
+
+ Examples
+ --------
+ >>> param = DiscreteParameter(lower_bound=0, upper_bound=10, step=1)
+ >>> print(param)
+ DiscreteParameter(lower_bound=0, upper_bound=10, step=1)
+ """
- if isinstance(__o, _CategoricalParameter):
- return __o + self
+ def __init__(self, lower_bound: int = 0,
+ upper_bound: int = 1, step: int = 1):
+ super().__init__()
+ self.lower_bound = int(lower_bound)
+ self.upper_bound = int(upper_bound)
+ self.step = step
+ self._type = "int"
+
+ self._validate_range()
+
+ def __str__(self):
+ return (f"DiscreteParameter(lower_bound={self.lower_bound}, "
+ f"upper_bound={self.upper_bound}, step={self.step})")
+
+ def __repr__(self):
+ return (f"{self.__class__.__name__}(lower_bound={self.lower_bound}, "
+ f"upper_bound={self.upper_bound}, step={self.step})")
+
+ def __add__(self, other: Parameter) -> "DiscreteParameter":
+ if isinstance(other, CategoricalParameter):
+ return other + self
+ if isinstance(other, ConstantParameter):
+ return other.to_categorical() + self
+ if isinstance(other, ContinuousParameter):
+ raise ValueError("Cannot add continuous parameter to discrete!")
+ return self # Assuming the same discrete parameters are being added.
- if isinstance(__o, _ConstantParameter):
- return __o.to_categorical() + self
+ def __eq__(self, __o: Parameter) -> bool:
+ if not isinstance(__o, DiscreteParameter):
+ return False
- if isinstance(__o, _ContinuousParameter):
- raise ValueError("Cannot add continuous parameter to discrete!")
+ return (self.lower_bound == __o.lower_bound and self.upper_bound
+ == __o.upper_bound and self.step
+ == __o.step)
- def _check_types(self):
- """Check if the boundaries are actually ints"""
- if not isinstance(self.lower_bound, int) or not isinstance(
- self.upper_bound, int):
- raise TypeError(
- f"Expect integer, got {type(self.lower_bound).__name__} and \
- {type(self.upper_bound).__name__}")
+ def _validate_range(self):
+ if self.upper_bound <= self.lower_bound:
+ raise ValueError("Upper bound must be greater than lower bound.")
+ if self.step <= 0:
+ raise ValueError("Step size must be positive.")
- def _check_range(self):
- """Check if the lower boundary is lower than the higher boundary"""
- if self.upper_bound < self.lower_bound:
- raise ValueError("not the right range!")
+ def to_dict(self):
+ param_dict = super().to_dict()
+ param_dict['type'] = 'int'
+ param_dict['lower_bound'] = self.lower_bound
+ param_dict['upper_bound'] = self.upper_bound
+ param_dict['step'] = self.step
+ return param_dict
- if self.upper_bound == self.lower_bound:
- raise ValueError("same lower as upper bound!")
- if self.step <= 0:
- raise ValueError("step size must be larger than 0!")
+# =============================================================================
-@dataclass
-class _CategoricalParameter(_Parameter):
- """Create a search space parameter that is categorical
+class CategoricalParameter(Parameter):
+ """
+ Create a search space parameter that is categorical.
Parameters
----------
- categories
- list of strings that represent available categories
- """
+ categories : Iterable[Any]
+ The categories of the parameter.
- categories: Sequence[CategoricalType]
- _type: str = field(init=False, default="object")
-
- def __post_init__(self):
- self._check_duplicates()
-
- def __add__(self, __o: _Parameter) -> _CategoricalParameter:
- if isinstance(__o, _CategoricalParameter):
- # join unique categories
- joint_categories = list(set(self.categories + __o.categories))
+ Raises
+ ------
+ ValueError
+ If the categories contain duplicates.
- if isinstance(__o, _ConstantParameter):
- joint_categories = list(set(self.categories + [__o.value]))
+ Examples
+ --------
+ >>> param = CategoricalParameter(categories=['a', 'b', 'c'])
+ >>> print(param)
+ CategoricalParameter(categories=['a', 'b', 'c'])
+ """
+ _type: ClassVar[str] = "object"
- if isinstance(__o, _DiscreteParameter):
- roll_out_discrete = list(range(
- __o.lower_bound, __o.upper_bound, __o.step))
- joint_categories = list(set(self.categories + roll_out_discrete))
+ def __init__(self, categories: Iterable[Any]):
+ super().__init__()
+ self.categories = categories
+ self._check_duplicates()
- if isinstance(__o, _ContinuousParameter):
+ def __str__(self):
+ return f"CategoricalParameter(categories={self.categories})"
+
+ def __repr__(self):
+ return (f"{self.__class__.__name__}"
+ f"(categories={list(self.categories)})")
+
+ def __add__(self, other: Parameter) -> "CategoricalParameter":
+ if isinstance(other, CategoricalParameter):
+ joint_categories = list(set(self.categories + other.categories))
+ elif isinstance(other, ConstantParameter):
+ joint_categories = list(set(self.categories + [other.value]))
+ elif isinstance(other, DiscreteParameter):
+ joint_categories = list(set(self.categories + list(range(
+ other.lower_bound, other.upper_bound, other.step))))
+ elif isinstance(other, ContinuousParameter):
raise ValueError("Cannot add continuous parameter to categorical!")
+ else:
+ raise ValueError(
+ f"Cannot add parameter of type {type(other)} to categorical.")
+ return CategoricalParameter(joint_categories)
- return _CategoricalParameter(joint_categories)
-
- def __eq__(self, __o: _CategoricalParameter) -> bool:
- return set(self.categories) == set(__o.categories)
+ def __eq__(self, other: CategoricalParameter) -> bool:
+ return set(self.categories) == set(other.categories)
def _check_duplicates(self):
- """Check if there are duplicates in the categories list"""
if len(self.categories) != len(set(self.categories)):
raise ValueError("Categories contain duplicates!")
+ def to_dict(self) -> dict:
+ param_dict = super().to_dict()
+ param_dict['type'] = 'category'
+ param_dict['categories'] = self.categories
+ return param_dict
+# =============================================================================
+
-PARAMETERS = [_CategoricalParameter, _ConstantParameter,
- _ContinuousParameter, _DiscreteParameter]
+PARAMETERS = [CategoricalParameter, ConstantParameter,
+ ContinuousParameter, DiscreteParameter]
diff --git a/src/f3dasm/_src/design/samplers.py b/src/f3dasm/_src/design/samplers.py
new file mode 100644
index 00000000..b9562cc4
--- /dev/null
+++ b/src/f3dasm/_src/design/samplers.py
@@ -0,0 +1,631 @@
+"""Base class for sampling methods"""
+
+# Modules
+# =============================================================================
+
+from __future__ import annotations
+
+# Standard
+from itertools import product
+from typing import Dict, Literal, Optional
+
+# Third-party
+import numpy as np
+import pandas as pd
+from SALib.sample import latin as salib_latin
+from SALib.sample import sobol_sequence
+
+# Locals
+from ..core import Block, ExperimentData
+from .domain import Domain
+
+# Authorship & Credits
+# =============================================================================
+__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
+__credits__ = ['Martin van der Schelling']
+__status__ = 'Stable'
+# =============================================================================
+#
+# =============================================================================
+
+# Utility functions
+# =============================================================================
+
+
+def _stretch_samples(domain: Domain, samples: np.ndarray) -> np.ndarray:
+ """Stretch samples to their boundaries
+
+ Parameters
+ ----------
+ domain : Domain
+ domain object
+ samples : np.ndarray
+ samples to stretch
+
+ Returns
+ -------
+ np.ndarray
+ stretched samples
+ """
+ for dim, param in enumerate(domain.input_space.values()):
+ samples[:, dim] = (
+ samples[:, dim] * (
+ param.upper_bound - param.lower_bound
+ ) + param.lower_bound
+ )
+
+ # If param.log is True, take the 10** of the samples
+ if param.log:
+ samples[:, dim] = 10**samples[:, dim]
+
+ return samples
+
+
+def sample_constant(domain: Domain, n_samples: int) -> np.ndarray:
+ """
+ Sample the constant parameters.
+
+ Parameters
+ ----------
+ domain : Domain
+ The domain object containing the input space.
+ n_samples : int
+ The number of samples to generate.
+
+ Returns
+ -------
+ np.ndarray
+ The sampled data.
+ """
+ samples = np.array([param.value for param in domain.input_space.values()])
+ return np.tile(samples, (n_samples, 1))
+
+
+def sample_np_random_choice(
+ domain: Domain, n_samples: int,
+ seed: Optional[int] = None, **kwargs) -> np.ndarray:
+ """
+ Sample with numpy random choice.
+
+ Parameters
+ ----------
+ domain : Domain
+ The domain object containing the input space.
+ n_samples : int
+ The number of samples to generate.
+ seed : Optional[int], optional
+ The random seed, by default None
+ **kwargs : dict
+ Additional parameters for sampling.
+
+ Returns
+ -------
+ np.ndarray
+ The sampled data.
+ """
+ rng = np.random.default_rng(seed)
+ samples = np.empty(shape=(n_samples, len(domain)), dtype=object)
+ for dim, param in enumerate(domain.input_space.values()):
+ samples[:, dim] = rng.choice(
+ param.categories, size=n_samples)
+
+ return samples
+
+
+def sample_np_random_choice_range(
+ domain: Domain, n_samples: int,
+ seed: Optional[int] = None, **kwargs) -> np.ndarray:
+ """
+ Sample with numpy random choice within a range of values.
+
+ Parameters
+ ----------
+ domain : Domain
+ The domain object containing the input space.
+ n_samples : int
+ The number of samples to generate.
+ seed : Optional[int], optional
+ The random seed, by default None
+ **kwargs : dict
+ Additional parameters for sampling.
+
+ Returns
+ -------
+ np.ndarray
+ The sampled data.
+ """
+ samples = np.empty(shape=(n_samples, len(domain)), dtype=np.int32)
+ rng = np.random.default_rng(seed)
+ for dim, param in enumerate(domain.input_space.values()):
+ samples[:, dim] = rng.choice(
+ range(param.lower_bound,
+ param.upper_bound + 1, param.step),
+ size=n_samples,
+ )
+
+ return samples
+
+
+def sample_np_random_uniform(
+ domain: Domain, n_samples: int,
+ seed: Optional[int] = None, **kwargs) -> np.ndarray:
+ """
+ Sample with numpy random uniform distribution.
+
+ Parameters
+ ----------
+ domain : Domain
+ The domain object containing the input space.
+ n_samples : int
+ The number of samples to generate.
+ seed : Optional[int], optional
+ The random seed, by default None
+ **kwargs : dict
+ Additional parameters for sampling.
+
+ Returns
+ -------
+ np.ndarray
+ The sampled data.
+ """
+ rng = np.random.default_rng(seed)
+ samples = rng.uniform(low=0.0, high=1.0, size=(n_samples, len(domain)))
+
+ # stretch samples
+ samples = _stretch_samples(domain, samples)
+ return samples
+
+
+def sample_latin_hypercube(
+ domain: Domain, n_samples: int,
+ seed: Optional[int] = None, **kwargs) -> np.ndarray:
+ """
+ Sample with Latin Hypercube sampling.
+
+ Parameters
+ ----------
+ domain : Domain
+ The domain object containing the input space.
+ n_samples : int
+ The number of samples to generate.
+ seed : Optional[int], optional
+ The random seed, by default None
+ **kwargs : dict
+ Additional parameters for sampling.
+
+ Returns
+ -------
+ np.ndarray
+ The sampled data.
+ """
+ problem = {
+ "num_vars": len(domain),
+ "names": domain.input_names,
+ "bounds": [[s.lower_bound, s.upper_bound]
+ for s in domain.input_space.values()],
+ }
+
+ samples = salib_latin.sample(problem=problem, N=n_samples, seed=seed)
+ return samples
+
+
+def sample_sobol_sequence(
+ domain: Domain, n_samples: int, **kwargs) -> np.ndarray:
+ """
+ Sample with Sobol sequence sampling.
+
+ Parameters
+ ----------
+ domain : Domain
+ The domain object containing the input space.
+ n_samples : int
+ The number of samples to generate.
+ **kwargs : dict
+ Additional parameters for sampling.
+
+ Returns
+ -------
+ np.ndarray
+ The sampled data.
+ """
+ samples = sobol_sequence.sample(N=n_samples, D=len(domain))
+
+ # stretch samples
+ samples = _stretch_samples(domain, samples)
+ return samples
+
+
+# Built-in samplers
+# =============================================================================
+
+class RandomUniform(Block):
+ def __init__(self, seed: Optional[int], **parameters):
+ """
+ Initialize the RandomUniform sampler.
+
+ Parameters
+ ----------
+ seed : Optional[int]
+ The random seed.
+ **parameters : dict
+ Additional parameters for the sampler.
+ """
+ self.seed = seed
+ self.parameters = parameters
+
+ def call(self, data: ExperimentData, n_samples: int, **kwargs
+ ) -> ExperimentData:
+ """
+ Sample data using the RandomUniform method.
+
+ Parameters
+ ----------
+ n_samples : int
+ The number of samples to generate.
+ **kwargs : dict
+ Additional parameters for sampling.
+
+ Returns
+ -------
+ pd.DataFrame
+ The sampled data.
+ """
+ _continuous = sample_np_random_uniform(
+ domain=data.domain.continuous, n_samples=n_samples,
+ seed=self.seed)
+
+ _discrete = sample_np_random_choice_range(
+ domain=data.domain.discrete, n_samples=n_samples,
+ seed=self.seed)
+
+ _categorical = sample_np_random_choice(
+ domain=data.domain.categorical, n_samples=n_samples,
+ seed=self.seed)
+
+ _constant = sample_constant(data.domain.constant, n_samples)
+
+ df = pd.concat(
+ [pd.DataFrame(_continuous,
+ columns=data.domain.continuous.input_names),
+ pd.DataFrame(
+ _discrete, columns=data.domain.discrete.input_names),
+ pd.DataFrame(
+ _categorical,
+ columns=data.domain.categorical.input_names),
+ pd.DataFrame(_constant,
+ columns=data.domain.constant.input_names)],
+ axis=1
+ )[data.domain.input_names]
+
+ return type(data)(domain=data.domain,
+ input_data=df)
+
+
+def random(seed: Optional[int] = None, **kwargs) -> Block:
+ """
+ Create a RandomUniform sampler.
+
+ Parameters
+ ----------
+ seed : Optional[int], optional
+ The random seed, by default None
+ **kwargs : dict
+ Additional parameters for the sampler.
+
+ Returns
+ -------
+ Block
+ An Block instance of a random uniform sampler.
+ """
+ return RandomUniform(seed=seed, **kwargs)
+
+
+# =============================================================================
+
+class Grid(Block):
+ def __init__(self, **parameters):
+ """
+ Initialize the Grid sampler.
+
+ Parameters
+ ----------
+ **parameters : dict
+ Additional parameters for the sampler.
+ """
+ self.parameters = parameters
+
+ def call(self, data: ExperimentData,
+ stepsize_continuous_parameters:
+ Optional[Dict[str, float] | float] = None,
+ **kwargs) -> ExperimentData:
+ """
+ Sample data using the Grid method.
+
+ Parameters
+ ----------
+ stepsize_continuous_parameters : Optional[Dict[str, float] | float]
+ The step size for continuous parameters.
+ **kwargs : dict
+ Additional parameters for sampling.
+
+ Returns
+ -------
+ pd.DataFrame
+ The sampled data.
+ """
+ continuous = data.domain.continuous
+
+ if not continuous.input_space:
+ discrete_space = continuous.input_space
+
+ elif isinstance(stepsize_continuous_parameters, (float, int)):
+ discrete_space = {name: param.to_discrete(
+ step=stepsize_continuous_parameters)
+ for name, param in continuous.input_space.items()}
+
+ elif isinstance(stepsize_continuous_parameters, dict):
+ discrete_space = {key: continuous.input_space[key].to_discrete(
+ step=value) for key,
+ value in stepsize_continuous_parameters.items()}
+
+ if len(discrete_space) != len(data.domain.continuous):
+ raise ValueError(
+ "If you specify the stepsize for continuous parameters, \
+ the stepsize_continuous_parameters should \
+ contain all continuous parameters")
+
+ continuous_to_discrete = Domain(discrete_space)
+
+ _iterdict = {}
+
+ for k, v in data.domain.categorical.input_space.items():
+ _iterdict[k] = v.categories
+
+ for k, v, in data.domain.discrete.input_space.items():
+ _iterdict[k] = range(v.lower_bound, v.upper_bound+1, v.step)
+
+ for k, v, in continuous_to_discrete.input_space.items():
+ _iterdict[k] = np.arange(
+ start=v.lower_bound, stop=v.upper_bound, step=v.step)
+
+ for k, v, in data.domain.constant.input_space.items():
+ _iterdict[k] = [v.value]
+
+ df = pd.DataFrame(list(product(*_iterdict.values())),
+ columns=_iterdict, dtype=object
+ )[data.domain.input_names]
+
+ return type(data)(domain=data.domain,
+ input_data=df)
+
+
+def grid(**kwargs) -> Block:
+ """
+ Create a Grid sampler.
+
+ **kwargs : dict
+ Additional parameters for the sampler.
+
+ Returns
+ -------
+ Block
+ An Block instance of a grid sampler.
+ """
+ return Grid(**kwargs)
+
+# =============================================================================
+
+
+class Sobol(Block):
+ def __init__(self, seed: Optional[int], **parameters):
+ """
+ Initialize the Sobol sampler.
+
+ Parameters
+ ----------
+ n_samples : int
+ The number of samples to generate.
+ seed : Optional[int]
+ The random seed.
+ **parameters : dict
+ Additional parameters for the sampler.
+ """
+ self.seed = seed
+ self.parameters = parameters
+
+ def call(self, data: ExperimentData, n_samples: int, **kwargs
+ ) -> ExperimentData:
+ """
+ Sample data using the Sobol method.
+
+ Parameters
+ ----------
+ n_samples : int
+ The number of samples to generate.
+ **kwargs : dict
+ Additional parameters for sampling.
+
+ Returns
+ -------
+ pd.DataFrame
+ The sampled data.
+ """
+ _continuous = sample_sobol_sequence(
+ domain=data.domain.continuous, n_samples=n_samples)
+
+ _discrete = sample_np_random_choice_range(
+ domain=data.domain.discrete, n_samples=n_samples,
+ seed=self.seed)
+
+ _categorical = sample_np_random_choice(
+ domain=data.domain.categorical, n_samples=n_samples,
+ seed=self.seed)
+
+ _constant = sample_constant(
+ domain=data.domain.constant, n_samples=n_samples)
+
+ df = pd.concat(
+ [pd.DataFrame(_continuous,
+ columns=data.domain.continuous.input_names),
+ pd.DataFrame(
+ _discrete, columns=data.domain.discrete.input_names),
+ pd.DataFrame(
+ _categorical,
+ columns=data.domain.categorical.input_names),
+ pd.DataFrame(_constant,
+ columns=data.domain.constant.input_names)],
+ axis=1
+ )[data.domain.input_names]
+
+ return type(data)(domain=data.domain,
+ input_data=df)
+
+
+def sobol(seed: Optional[int] = None, **kwargs) -> Block:
+ """
+ Create a Sobol sampler.
+
+ Parameters
+ ----------
+ seed : Optional[int], optional
+ The random seed, by default None
+ **kwargs : dict
+ Additional parameters for the sampler.
+
+ Returns
+ -------
+ Block
+ A Block instance of a sobol sequence sampler.
+ """
+ return Sobol(seed=seed, **kwargs)
+
+
+# =============================================================================
+
+class Latin(Block):
+ def __init__(self, seed: Optional[int], **parameters):
+ """
+ Initialize the Latin sampler.
+
+ Parameters
+ ----------
+ seed : Optional[int]
+ The random seed.
+ **parameters : dict
+ Additional parameters for the sampler.
+ """
+ self.seed = seed
+ self.parameters = parameters
+
+ def call(self, data: ExperimentData, n_samples: int, **kwargs
+ ) -> ExperimentData:
+ """
+ Sample data using the Latin Hypercube method.
+
+ Parameters
+ ----------
+ n_samples : int
+ The number of samples to generate.
+ **kwargs : dict
+ Additional parameters for sampling.
+
+ Returns
+ -------
+ pd.DataFrame
+ The sampled data.
+ """
+ _continuous = sample_latin_hypercube(
+ domain=data.domain.continuous, n_samples=n_samples,
+ seed=self.seed)
+
+ _discrete = sample_np_random_choice_range(
+ domain=data.domain.discrete, n_samples=n_samples,
+ seed=self.seed)
+
+ _categorical = sample_np_random_choice(
+ domain=data.domain.categorical, n_samples=n_samples,
+ seed=self.seed)
+
+ _constant = sample_constant(
+ domain=data.domain.constant, n_samples=n_samples)
+
+ df = pd.concat(
+ [pd.DataFrame(_continuous,
+ columns=data.domain.continuous.input_names),
+ pd.DataFrame(
+ _discrete, columns=data.domain.discrete.input_names),
+ pd.DataFrame(
+ _categorical,
+ columns=data.domain.categorical.input_names),
+ pd.DataFrame(_constant,
+ columns=data.domain.constant.input_names)],
+ axis=1
+ )[data.domain.input_names]
+
+ return type(data)(domain=data.domain,
+ input_data=df)
+
+
+def latin(seed: Optional[int] = None, **kwargs) -> Block:
+ """
+ Create a lating hypercube sampler.
+
+ Parameters
+ ----------
+ seed : Optional[int], optional
+ The random seed, by default None
+ **kwargs : dict
+ Additional parameters for the sampler.
+
+ Returns
+ -------
+ Block
+ An Block instance of a latin hypercube sampler.
+ """
+ return Latin(seed=seed, **kwargs)
+
+# =============================================================================
+
+
+_SAMPLERS = [random, latin, sobol, grid]
+
+SAMPLER_MAPPING: Dict[str, Block] = {
+ sampler.__name__.lower(): sampler for sampler in _SAMPLERS}
+
+# Factory function
+# =============================================================================
+
+
+def _sampler_factory(sampler: str | Block, **parameters) -> Block:
+ """
+ Factory function for samplers
+
+ Parameters
+ ----------
+ sampler : str | Block
+ name of the sampler
+
+ Returns
+ -------
+ Block
+ sampler object
+ """
+
+ if isinstance(sampler, Block):
+ return sampler
+
+ elif isinstance(sampler, str):
+ filtered_name = sampler.lower().replace(
+ ' ', '').replace('-', '').replace('_', '')
+
+ if filtered_name in SAMPLER_MAPPING:
+ return SAMPLER_MAPPING[filtered_name](**parameters)
+
+ else:
+ raise KeyError(f"Unknown sampler name: {sampler}")
+
+ else:
+ raise TypeError(f"Unknown sampler type: {type(sampler)}")
+
+
+SamplerNames = Literal['random', 'latin', 'sobol', 'grid']
diff --git a/src/f3dasm/_src/experimentdata.py b/src/f3dasm/_src/experimentdata.py
new file mode 100644
index 00000000..ed0cf8f9
--- /dev/null
+++ b/src/f3dasm/_src/experimentdata.py
@@ -0,0 +1,1742 @@
+"""
+The ExperimentData object is the main object used to store implementations
+ of a design-of-experiments, keep track of results, perform optimization and
+ extract data for machine learning purposes.
+"""
+
+# Modules
+# =============================================================================
+
+from __future__ import annotations
+
+# Standard
+import functools
+from collections import defaultdict
+from copy import copy
+from functools import partial
+from itertools import zip_longest
+from pathlib import Path
+from time import sleep
+from typing import (Any, Callable, Dict, Iterable, Iterator, List, Literal,
+ Optional, Tuple, Type)
+
+# Third-party
+import numpy as np
+import pandas as pd
+import xarray as xr
+from filelock import FileLock
+from hydra.utils import get_original_cwd
+from omegaconf import DictConfig
+
+from ._io import (DOMAIN_FILENAME, EXPERIMENTDATA_SUBFOLDER,
+ INPUT_DATA_FILENAME, JOBS_FILENAME, LOCK_FILENAME, MAX_TRIES,
+ OUTPUT_DATA_FILENAME, _project_dir_factory, store_to_disk)
+# Local
+from .core import Block, DataGenerator
+from .datageneration import _datagenerator_factory
+from .design import Domain, _domain_factory, _sampler_factory
+from .experimentsample import ExperimentSample
+from .logger import logger
+from .optimization import _optimizer_factory
+
+# Authorship & Credits
+# =============================================================================
+__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
+__credits__ = ['Martin van der Schelling']
+__status__ = 'Stable'
+# =============================================================================
+#
+# =============================================================================
+
+
+class ExperimentData:
+ def __init__(
+ self,
+ domain: Optional[Domain] = None,
+ input_data: Optional[
+ pd.DataFrame | np.ndarray
+ | List[Dict[str, Any]] | str | Path] = None,
+ output_data: Optional[
+ pd.DataFrame | np.ndarray
+ | List[Dict[str, Any]] | str | Path] = None,
+ jobs: Optional[pd.Series] = None,
+ project_dir: Optional[Path] = None):
+ """
+ Main object to store implementations of a design-of-experiments, keep
+ track of results, perform optimization and extract data for machine
+ learning purposes.
+
+ Parameters
+ ----------
+ domain : Domain, optional
+ The domain of the experiment, by default None.
+ input_data : pd.DataFrame | np.ndarray | List[Dict[str, Any]] |
+ str | Path, optional
+ The input data of the experiment, by default None.
+ output_data : pd.DataFrame | np.ndarray | List[Dict[str, Any]] |
+ str | Path, optional
+ The output data of the experiment, by default None.
+ jobs : pd.Series, optional
+ The status of all the jobs, by default None.
+ project_dir : Path, optional
+ Directory of the project, by default None.
+
+ Examples
+ --------
+ >>> experiment_data = ExperimentData(
+ ... domain=domain_obj,
+ ... input_data=input_df,
+ ... output_data=output_df
+ ... )
+ """
+ _domain = _domain_factory(domain)
+ _project_dir = _project_dir_factory(project_dir)
+ _jobs = jobs_factory(jobs)
+
+ # If input_data is a numpy array, create pd.Dataframe to include column
+ # names from the domain
+ if isinstance(input_data, np.ndarray):
+ input_data = convert_numpy_to_dataframe_with_domain(
+ array=input_data,
+ names=_domain.input_names,
+ mode='input')
+
+ # Same with output data
+ if isinstance(output_data, np.ndarray):
+ output_data = convert_numpy_to_dataframe_with_domain(
+ array=output_data,
+ names=_domain.output_names,
+ mode='output')
+
+ _input_data = _dict_factory(data=input_data)
+ _output_data = _dict_factory(data=output_data)
+
+ # If the domain is empty, try to infer it from the input_data
+ # and output_data
+ if not _domain:
+ _domain = Domain.from_data(input_data=_input_data,
+ output_data=_output_data)
+
+ _data = data_factory(
+ input_data=_input_data, output_data=_output_data,
+ domain=_domain, jobs=_jobs, project_dir=_project_dir
+ )
+
+ self.data = _data
+ self.domain = _domain
+ self.project_dir = _project_dir
+
+ # Store to_disk objects so that the references are kept only
+ for id, experiment_sample in self:
+ self.store_experimentsample(experiment_sample, id)
+
+ def __len__(self):
+ """
+ Returns the number of experiments in the ExperimentData object.
+
+ Returns
+ -------
+ int
+ Number of experiments.
+
+ Examples
+ --------
+ >>> experimentdata = ExperimentData(input_data=np.array([1, 2, 3]),)
+ >>> len(experiment_data)
+ 3
+ """
+ return len(self.data)
+
+ def __iter__(self) -> Iterator[Tuple[int, ExperimentSample]]:
+ """
+ Returns an iterator over the ExperimentData object.
+
+ Returns
+ -------
+ Iterator[Tuple[int, ExperimentSample]]
+ Iterator over the ExperimentData object.
+
+ Examples
+ --------
+ >>> for id, sample in experiment_data:
+ ... print(id, sample)
+ 0 ExperimentSample(...)
+ """
+ return iter(self.data.items())
+
+ def __add__(self, __o: ExperimentData) -> ExperimentData:
+ """
+ Adds two ExperimentData objects.
+
+ Parameters
+ ----------
+ __o : ExperimentData
+ The other ExperimentData object to add.
+
+ Returns
+ -------
+ ExperimentData
+ The combined ExperimentData object.
+
+ Examples
+ --------
+ >>> combined_data = experiment_data1 + experiment_data2
+ """
+ copy_self = copy(self).reset_index()
+ copy_self._add(__o)
+ return copy_self
+
+ def __eq__(self, __o: ExperimentData) -> bool:
+ """
+ Checks if two ExperimentData objects are equal.
+
+ Parameters
+ ----------
+ __o : ExperimentData
+ The other ExperimentData object to compare.
+
+ Returns
+ -------
+ bool
+ True if the objects are equal, False otherwise.
+
+ Notes
+ -----
+ Two ExperimentData objects are considered equal if their data, domain
+ and project_dir are equal.
+
+ Examples
+ --------
+ >>> experiment_data1 == experiment_data2
+ True
+ """
+ return (self.data == __o.data and self.domain == __o.domain
+ and self.project_dir == __o.project_dir)
+
+ def __getitem__(self, key: int | Iterable[int]) -> ExperimentData:
+ """
+ Gets a subset of the ExperimentData object.
+
+ Parameters
+ ----------
+ key : int or Iterable[int]
+ The indices to select.
+
+ Returns
+ -------
+ ExperimentData
+ The selected subset of the ExperimentData object.
+
+ """
+ if isinstance(key, int):
+ key = [key]
+
+ return ExperimentData.from_data(
+ data={k: self.data[k] for k in self.index[key]},
+ domain=self.domain,
+ project_dir=self.project_dir)
+
+ def _repr_html_(self) -> str:
+ """
+ Returns an HTML representation of the ExperimentData object.
+
+ Returns
+ -------
+ str
+ HTML representation of the ExperimentData object.
+
+ Examples
+ --------
+ >>> experiment_data._repr_html_()
+ '
+ """
+ if status.upper() not in JobStatus.__members__:
+ raise ValueError(f"Invalid status: {status}")
+
+ self.job_status = JobStatus[status.upper()]
+
+ def replace_nan(self, replacement_value: Any):
+ """
+ Replace NaN values in input_data and output_data with a custom value.
+
+ Parameters
+ ----------
+ replacement_value : Any
+ The value to replace NaN values with.
+
+ Examples
+ --------
+ >>> sample = ExperimentSample(input_data={'param1': np.nan})
+ >>> sample.replace_nan(0)
+ >>> sample.input_data['param1']
+ 0
+ """
+ def replace_nan_in_dict(data: Dict[str, Any]) -> Dict[str, Any]:
+ return {k: (replacement_value if np.isnan(v) else v)
+ for k, v in data.items()}
+
+ self._input_data = replace_nan_in_dict(self._input_data)
+ self._output_data = replace_nan_in_dict(self._output_data)
+
+ def round(self, decimals: int):
+ """
+ Round the input and output data to a specified number
+ of decimal places.
+
+ Parameters
+ ----------
+ decimals : int
+ The number of decimal places to round to.
+
+ Examples
+ --------
+ >>> sample = ExperimentSample(input_data={'param1': 1.2345})
+ >>> sample.round(2)
+ >>> sample.input_data['param1']
+ 1.23
+ """
+ def round_dict(data: Dict[str, Any]) -> Dict[str, Any]:
+ return {k: round(v, decimals) if isinstance(v, (int, float))
+ else v for k, v in data.items()}
+
+ self._input_data = round_dict(self._input_data)
+ self._output_data = round_dict(self._output_data)
+
+ # Exporting
+ # =========================================================================
+
+ def to_multiindex(self) -> Dict[Tuple[str, str], Any]:
+ """
+ Convert the experiment sample to a multiindex dictionary.
+ Used to display the data prettily as a table in a Jupyter notebook.
+
+ Returns
+ -------
+ Dict[Tuple[str, str], Any]
+ A multiindex dictionary containing the job status, input,
+ and output data.
+
+ Examples
+ --------
+ >>> sample = ExperimentSample(input_data={'param1': 1.0})
+ >>> sample.to_multiindex()
+ {('jobs', ''): 'open', ('input', 'param1'): 1.0}
+ """
+ return {('jobs', ''): self.job_status.name.lower(),
+ **{('input', k): v for k, v in self._input_data.items()},
+ **{('output', k): v for k, v in self._output_data.items()},
+ }
+
+ def to_numpy(self) -> Tuple[np.ndarray, np.ndarray]:
+ """
+ Convert the experiment sample to numpy arrays.
+
+ Returns
+ -------
+ Tuple[np.ndarray, np.ndarray]
+ A tuple containing numpy arrays of input and output data.
+
+ Examples
+ --------
+ >>> sample = ExperimentSample(input_data={'param1': 1.0})
+ >>> sample.to_numpy()
+ (array([1.]), array([]))
+ """
+ return (np.array(list(self.input_data.values())),
+ np.array(list(self.output_data.values()))
+ )
+
+ def to_dict(self) -> Dict[str, Any]:
+ """
+ Convert the experiment sample to a dictionary.
+
+ Returns
+ -------
+ Dict[str, Any]
+ A dictionary containing both input and output data.
+
+ Examples
+ --------
+ >>> sample = ExperimentSample(input_data={'param1': 1.0})
+ >>> sample.to_dict()
+ {'param1': 1.0}
+ """
+ return {**self.input_data, **self.output_data}
+
+ # Storing
+ # =========================================================================
+
+ def store(self, name: str, object: Any, to_disk: bool = False,
+ store_function: Optional[Type[Callable]] = None,
+ load_function: Optional[Type[Callable]] = None):
+ """
+ Store an object in the experiment sample.
+
+ Parameters
+ ----------
+ name : str
+ The name of the object to store.
+ object : Any
+ The object to store.
+ to_disk : bool, optional
+ If True, the object will be stored on disk, by default False.
+ store_function : Optional[Type[Callable]], optional
+ The function to use for storing the object on disk
+ by default None.
+ load_function : Optional[Type[Callable]], optional
+ The function to use for loading the object from disk,
+ by default None.
+
+ Notes
+ -----
+ The object will be stored in the input data if the name is in the
+ input space of the domain. Otherwise, the object will be stored in
+ the output data if the name is in the output space of the domain.
+
+ If the object is stored on disk, the path to the stored object will
+ be stored in the input or output data, depending on where the object
+ is stored.
+
+ The store_function should have the following signature:
+
+ .. code-block:: python
+
+ def store_function(object: Any, path: str) -> Path:
+ ...
+
+ The load_function should have the following signature:
+
+ .. code-block:: python
+
+ def load_function(path: str) -> Any:
+ ...
+ """
+ if name not in self.domain.output_names:
+ self.domain.add_output(name=name, to_disk=to_disk,
+ store_function=store_function,
+ load_function=load_function)
+
+ self._output_data[name] = object
+
+ # Job status
+ # =========================================================================
+
+ def is_status(self, status: str) -> bool:
+ """
+ Check if the job's current status matches the given status.
+
+ Parameters
+ ----------
+ status : str
+ The status to check against the job's current status.
+
+ Returns
+ -------
+ bool
+ True if the job's current status matches the given status,
+ False otherwise.
+
+ Examples
+ --------
+ >>> sample = ExperimentSample()
+ >>> sample.is_status('open')
+ True
+ """
+ return self.job_status == JobStatus[status.upper()]
diff --git a/src/f3dasm/_src/hydra_utils.py b/src/f3dasm/_src/hydra_utils.py
index cb8ad947..832687e7 100644
--- a/src/f3dasm/_src/hydra_utils.py
+++ b/src/f3dasm/_src/hydra_utils.py
@@ -11,7 +11,7 @@
from omegaconf import OmegaConf
# Local
-from .experimentdata.experimentsample import ExperimentSample
+from .experimentsample import ExperimentSample
# Authorship & Credits
# =============================================================================
@@ -27,14 +27,14 @@ def update_config_with_experiment_sample(
config: OmegaConf, experiment_sample: ExperimentSample,
force_add: bool = False) -> OmegaConf:
"""
- Update the config with the values from the experiment sample
+ Update the config with the values from the experiment sample.
Parameters
----------
config : OmegaConf
- The configuration to update
+ The configuration to update.
experiment_sample : ExperimentSample
- The experiment sample to update the configuration with
+ The experiment sample to update the configuration with.
force_add : bool, optional
If True, the function will add keys that are not present in the
configuration. If False, the function will ignore keys that are not
@@ -43,7 +43,7 @@ def update_config_with_experiment_sample(
Returns
-------
OmegaConf
- The updated configuration
+ The updated configuration.
Notes
-----
@@ -56,6 +56,17 @@ def update_config_with_experiment_sample(
The function will return a new configuration object with the
updated values. The original configuration object will not be modified.
+
+ Examples
+ --------
+ >>> from omegaconf import OmegaConf
+ >>> from f3dasm._src.experimentdata.experimentsample
+ import ExperimentSample
+ >>> config = OmegaConf.create({'param1': 1, 'param2': 2})
+ >>> sample = ExperimentSample(input_data={'param1': 10})
+ >>> updated_config = update_config_with_experiment_sample(config, sample)
+ >>> print(updated_config)
+ {'param1': 10, 'param2': 2}
"""
cfg = deepcopy(config)
for key, value in experiment_sample.to_dict().items():
diff --git a/src/f3dasm/_src/logger.py b/src/f3dasm/_src/logger.py
index 7c6c336a..701dff78 100644
--- a/src/f3dasm/_src/logger.py
+++ b/src/f3dasm/_src/logger.py
@@ -44,13 +44,13 @@
class DistributedFileHandler(FileHandler):
- def __init__(self, filename):
+ def __init__(self, filename: str):
"""Distributed FileHandler class for handling logging to
one single file when multiple nodes access the same resource
Parameters
----------
- filename
+ filename : str
name of the logging file
"""
super().__init__(filename)
diff --git a/src/f3dasm/_src/optimization/__init__.py b/src/f3dasm/_src/optimization/__init__.py
index 6343b5d4..66545b94 100644
--- a/src/f3dasm/_src/optimization/__init__.py
+++ b/src/f3dasm/_src/optimization/__init__.py
@@ -5,12 +5,14 @@
# =============================================================================
# Standard
-from typing import List
+from typing import Callable, List
+
+from .numpy_implementations import random_search
+from .optimizer_factory import _optimizer_factory, available_optimizers
+from .scipy_implementations import cg, lbfgsb, nelder_mead
# Local
-from .numpy_implementations import RandomSearch
-from .optimizer import Optimizer
-from .scipy_implementations import CG, LBFGSB, NelderMead
+
# Authorship & Credits
# =============================================================================
@@ -21,35 +23,15 @@
#
# =============================================================================
-# List of available optimizers
-_OPTIMIZERS: List[Optimizer] = [RandomSearch, CG, LBFGSB, NelderMead]
+
+# =============================================================================
__all__ = [
- 'CG',
- 'LBFGSB',
- 'NelderMead',
- 'Optimizer',
- 'RandomSearch',
- '_OPTIMIZERS',
- 'find_optimizer',
+ '_optimizer_factory',
+ 'cg',
+ 'lbfgsb',
+ 'nelder_mead',
+ 'random_search',
+ 'available_optimizers',
]
-
-
-def find_optimizer(query: str) -> Optimizer:
- """Find a optimizer from the f3dasm.optimizer submodule
-
- Parameters
- ----------
- query
- string representation of the requested optimizer
-
- Returns
- -------
- class of the requested optimizer
- """
- try:
- return list(filter(
- lambda optimizer: optimizer.__name__ == query, _OPTIMIZERS))[0]
- except IndexError:
- return ValueError(f'Optimizer {query} not found!')
diff --git a/src/f3dasm/_src/optimization/adapters/scipy_implementations.py b/src/f3dasm/_src/optimization/adapters/scipy_implementations.py
index 1c412df5..a23e544d 100644
--- a/src/f3dasm/_src/optimization/adapters/scipy_implementations.py
+++ b/src/f3dasm/_src/optimization/adapters/scipy_implementations.py
@@ -1,18 +1,18 @@
# Modules
# =============================================================================
+from __future__ import annotations
# Standard
import warnings
+from copy import deepcopy
# Third-party core
import autograd.numpy as np
from scipy.optimize import minimize
# Locals
-from ...datageneration.datagenerator import DataGenerator
-from ...design.domain import Domain
-from ...experimentdata.experimentsample import ExperimentSample
-from ..optimizer import Optimizer
+from ...core import Block, DataGenerator, ExperimentData
+from ...experimentsample import ExperimentSample
# Authorship & Credits
# =============================================================================
@@ -27,54 +27,117 @@
"ignore", message="^OptimizeWarning: Unknown solver options.*")
-class _SciPyOptimizer(Optimizer):
+class ScipyOptimizer(Block):
+ require_gradients: bool = False
type: str = 'scipy'
- def __init__(self, domain: Domain, method: str, **hyperparameters):
- self.domain = domain
- self.method = method
- self.options = {**hyperparameters}
+ def __init__(self, algorithm, **hyperparameters):
+ self.algorithm = algorithm
+ self.hyperparameters = hyperparameters
def _callback(self, xk: np.ndarray, *args, **kwargs) -> None:
self.data.add_experiments(
- ExperimentSample.from_numpy(xk, domain=self.domain))
+ type(self.data)(domain=self.data.domain,
+ input_data=np.atleast_2d(xk),
+ project_dir=self.data.project_dir)
+ )
- def update_step(self):
+ def call(self, data: ExperimentData, **kwargs):
"""Update step function"""
raise ValueError(
'Scipy optimizers don\'t have an update steps. \
Multiple iterations are directly called \
througout scipy.minimize.')
- def run_algorithm(self, iterations: int, data_generator: DataGenerator):
+ def run_algorithm(self, data_generator: DataGenerator, iterations: int):
"""Run the algorithm for a number of iterations
Parameters
----------
iterations
number of iterations
- function
- function to be evaluated
"""
def fun(x):
- sample: ExperimentSample = data_generator._run(
- x, domain=self.domain)
+ x_ = ExperimentSample.from_numpy(input_array=x,
+ domain=self.data.domain)
+ sample = data_generator._run(
+ x_, domain=self.data.domain)
_, y = sample.to_numpy()
return float(y)
- self.options['maxiter'] = iterations
-
if not hasattr(data_generator, 'dfdx'):
data_generator.dfdx = None
+ self.hyperparameters['maxiter'] = iterations
+
minimize(
fun=fun,
- method=self.method,
+ method=self.algorithm,
jac=data_generator.dfdx,
x0=self.data.get_n_best_output(1).to_numpy()[0].ravel(),
callback=self._callback,
- options=self.options,
- bounds=self.domain.get_bounds(),
+ options=self.hyperparameters,
+ bounds=self.data.domain.get_bounds(),
tol=0.0,
)
+
+ def _iterate(self, data: ExperimentData, data_generator: DataGenerator,
+ iterations: int,
+ kwargs: dict, overwrite: bool):
+ """Internal represenation of the iteration process for scipy-minimize
+ optimizers.
+
+ Parameters
+ ----------
+ data_generator : DataGenerator
+ DataGenerator object
+ iterations : int
+ number of iterations
+ kwargs : Dict[str, Any]
+ any additional keyword arguments that will be passed to
+ the DataGenerator
+ overwrite: bool
+ If True, the optimizer will overwrite the current data.
+ """
+ self.data = data
+ n_data_before_iterate = deepcopy(len(data))
+ if len(data) < 1:
+ raise ValueError(
+ f'There are {len(data)} datapoints available, \
+ need 1 for initial \
+ population!'
+ )
+
+ self.run_algorithm(data_generator=data_generator,
+ iterations=iterations)
+
+ new_samples = self.data.select(self.data.index[1:])
+
+ new_samples.evaluate(data_generator=data_generator,
+ mode='sequential', **kwargs)
+
+ if overwrite:
+ self.data.add_experiments(
+ data.select([self.data.index[-1]]))
+
+ elif not overwrite:
+ # If x_new is empty, repeat best x0 to fill up total iteration
+ if len(self.data) == n_data_before_iterate:
+ repeated_sample = self.data.get_n_best_output(
+ n_samples=1)
+
+ for repetition in range(iterations):
+ self.data.add_experiments(repeated_sample)
+
+ # Repeat last iteration to fill up total iteration
+ if len(self.data) < n_data_before_iterate + iterations:
+ last_design = self.data.get_experiment_sample(len(self.data)-1)
+
+ while len(self.data) < n_data_before_iterate + iterations:
+ self.data.add_experiments(last_design)
+
+ self.data.evaluate(data_generator=data_generator,
+ mode='sequential', **kwargs)
+
+ return self.data
diff --git a/src/f3dasm/_src/optimization/numpy_implementations.py b/src/f3dasm/_src/optimization/numpy_implementations.py
index a79a4415..360c0c49 100644
--- a/src/f3dasm/_src/optimization/numpy_implementations.py
+++ b/src/f3dasm/_src/optimization/numpy_implementations.py
@@ -6,15 +6,13 @@
# =============================================================================
# Standard
-from typing import List, Optional, Tuple
+from typing import Optional
# Third-party core
import numpy as np
# Locals
-from ..datageneration.datagenerator import DataGenerator
-from ..design.domain import Domain
-from .optimizer import Optimizer
+from ..core import Block, ExperimentData
# Authorship & Credits
# =============================================================================
@@ -26,32 +24,46 @@
# =============================================================================
-class RandomSearch(Optimizer):
- """Naive random search"""
+class NumpyOptimizer(Block):
+ """Numpy optimizer class"""
require_gradients: bool = False
- def __init__(self, domain: Domain, seed: Optional[int] = None, **kwargs):
- self.domain = domain
+ def __init__(self, seed: Optional[int], **hyperparameters):
self.seed = seed
- self._set_algorithm()
+ self.hyperparameters = hyperparameters
+ self.algorithm = np.random.default_rng(seed)
- def _set_algorithm(self):
- self.algorithm = np.random.default_rng(self.seed)
-
- def update_step(
- self, data_generator: DataGenerator
- ) -> Tuple[np.ndarray, np.ndarray]:
+ def call(self, data: ExperimentData, **kwargs) -> ExperimentData:
x_new = np.atleast_2d(
[
self.algorithm.uniform(
- low=self.domain.get_bounds()[d, 0],
- high=self.domain.get_bounds()[d, 1])
- for d in range(len(self.domain))
+ low=data.domain.get_bounds()[d, 0],
+ high=data.domain.get_bounds()[d, 1])
+ for d in range(len(data.domain.input_space))
]
)
# return the data
- return x_new, None
+ return type(data)(domain=data.domain,
+ input_data=x_new,
+ )
+
+
+def random_search(seed: Optional[int] = None, **kwargs) -> Block:
+ """
+ Random search optimizer
+
+ Parameters
+ ----------
+ seed : int, optional
+ Random seed, by default None
- def _get_info(self) -> List[str]:
- return ['Fast', 'Single-Solution']
+ Returns
+ -------
+ Block
+ Optimizer object.
+ """
+ return NumpyOptimizer(
+ seed=seed,
+ **kwargs
+ )
diff --git a/src/f3dasm/_src/optimization/optimizer.py b/src/f3dasm/_src/optimization/optimizer.py
deleted file mode 100644
index adf5cb85..00000000
--- a/src/f3dasm/_src/optimization/optimizer.py
+++ /dev/null
@@ -1,235 +0,0 @@
-"""
-Module containing the interface class Optimizer
-"""
-
-# Modules
-# =============================================================================
-
-from __future__ import annotations
-
-# Standard
-from typing import ClassVar, Iterable, List, Protocol, Tuple
-
-# Third-party core
-import numpy as np
-import pandas as pd
-
-# Locals
-from ..datageneration.datagenerator import DataGenerator
-
-# Authorship & Credits
-# =============================================================================
-__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
-__credits__ = ['Martin van der Schelling']
-__status__ = 'Stable'
-# =============================================================================
-#
-# =============================================================================
-
-
-class ExperimentData(Protocol):
- @property
- def index(self, index) -> pd.Index:
- ...
-
- def get_n_best_output(self, n_samples: int) -> ExperimentData:
- ...
-
- def to_numpy() -> Tuple[np.ndarray, np.ndarray]:
- ...
-
- def select(self, indices: int | slice | Iterable[int]) -> ExperimentData:
- ...
-
-# =============================================================================
-
-
-class Optimizer:
- """
- Abstract class for optimization algorithms
- To implement a new optimizer, inherit from this class and implement the
- update_step method.
-
- Note
- ----
- The update_step method should have the following signature:
-
- '''
- def update_step(self, data_generator: DataGenerator)
- -> Tuple[np.ndarray, np.ndarray]:
- '''
-
- The method should return a tuple containing the new samples and the
- corresponding objective values. The new samples should be a numpy array.
-
- If the optimizer requires gradients, set the require_gradients attribute to
- True. This will ensure that the data_generator will calculate the gradients
- of the objective function from the DataGenerator.dfdx method.
-
- Hyperparameters can be set in the __init__ method of the child class.
- There are two hyperparameters that have special meaning:
- - population: the number of individuals in the population
- - seed: the seed of the random number generator
-
- You can create extra methods in your child class as you please, however
- it is advised not to create private methods (methods starting with an
- underscore) as these might be used in the base class.
- """
- type: ClassVar[str] = 'any'
- require_gradients: ClassVar[bool] = False
-
-# Private Properties
-# =============================================================================
-
- @property
- def _seed(self) -> int:
- """
- Property to return the seed of the optimizer
-
- Returns
- -------
- int | None
- Seed of the optimizer
-
- Note
- ----
- If the seed is not set, the property will return None
- This is done to prevent errors when the seed is not an available
- attribute in a custom optimizer class.
- """
- return self.seed if hasattr(self, 'seed') else None
-
- @property
- def _population(self) -> int:
- """
- Property to return the population size of the optimizer
-
- Returns
- -------
- int
- Number of individuals in the population
-
- Note
- ----
- If the population is not set, the property will return 1
- This is done to prevent errors when the population size is not an
- available attribute in a custom optimizer class.
- """
- return self.population if hasattr(self, 'population') else 1
-
-# Public Methods
-# =============================================================================
-
- def update_step(self, data_generator: DataGenerator) -> ExperimentData:
- """Update step of the optimizer. Needs to be implemented
- by the child class
-
- Parameters
- ----------
- data_generator : DataGenerator
- data generator object to calculate the objective value
-
- Returns
- -------
- ExperimentData
- ExperimentData object containing the new samples
-
- Raises
- ------
- NotImplementedError
- Raises when the method is not implemented by the child class
-
- Note
- ----
- You can access the data attribute of the optimizer to get the
- available data points. The data attribute is an
- f3dasm.ExperimentData object.
- """
- raise NotImplementedError(
- "You should implement an update step for your algorithm!")
-
-# Private Methods
-# =============================================================================
-
- def _set_algorithm(self):
- """
- Method that can be implemented to set the optimization algorithm.
- Whenever the reset method is called, this method will be called to
- reset the algorithm to its initial state."""
- ...
-
- def _construct_model(self, data_generator: DataGenerator):
- """
- Method that is called before the optimization starts. This method can
- be used to construct a model based on the available data or a specific
- data generator.
-
- Parameters
- ----------
- data_generator : DataGenerator
- DataGenerator object
-
- Note
- ----
- When this method is not implemented, the method will do nothing.
- """
- ...
-
- def _check_number_of_datapoints(self):
- """
- Check if the number of datapoints is sufficient for the
- initial population
-
- Raises
- ------
- ValueError
- Raises when the number of datapoints is insufficient
- """
- if len(self.data) < self._population:
- raise ValueError(
- f'There are {len(self.data)} datapoints available, \
- need {self._population} for initial \
- population!'
- )
-
- def _reset(self, data: ExperimentData):
- """Reset the optimizer to its initial state
-
- Parameters
- ----------
- data : ExperimentData
- Data to set the optimizer to its initial state
-
- Note
- ----
- This method should be called whenever the optimizer is reset
- to its initial state. This can be done when the optimizer is
- re-initialized or when the optimizer is re-used for a new
- optimization problem.
-
- The following steps are taken when the reset method is called:
- - The data attribute is set to the given data (self._set_data)
- - The algorithm is set to its initial state (self._set_algorithm)
- """
- self._set_data(data)
- self._set_algorithm()
-
- def _set_data(self, data: ExperimentData):
- """Set the data attribute to the given data
-
- Parameters
- ----------
- data : ExperimentData
- Data to set the optimizer to its initial state
- """
- self.data = data
-
- def _get_info(self) -> List[str]:
- """Give a list of characteristic features of this optimizer
-
- Returns
- -------
- List[str]
- List of characteristics of the optimizer
- """
- return []
diff --git a/src/f3dasm/_src/optimization/optimizer_factory.py b/src/f3dasm/_src/optimization/optimizer_factory.py
index 47ec1b68..07a6e7d5 100644
--- a/src/f3dasm/_src/optimization/optimizer_factory.py
+++ b/src/f3dasm/_src/optimization/optimizer_factory.py
@@ -4,13 +4,15 @@
# Modules
# =============================================================================
+from __future__ import annotations
+
# Standard
-from typing import Any, Dict, Optional
+from typing import Callable, Dict, List
# Local
-from ..design.domain import Domain
-from . import _OPTIMIZERS
-from .optimizer import Optimizer
+from ..core import Block
+from .numpy_implementations import random_search
+from .scipy_implementations import cg, lbfgsb, nelder_mead
# Authorship & Credits
# =============================================================================
@@ -21,25 +23,40 @@
#
# =============================================================================
-# Try importing f3dasm_optimize package
-try:
- import f3dasm_optimize # NOQA
- _OPTIMIZERS.extend(f3dasm_optimize._OPTIMIZERS)
-except ImportError:
- pass
+def available_optimizers():
+ """
+ Returns a list of all available built-in optimization algorithms.
-OPTIMIZER_MAPPING: Dict[str, Optimizer] = {
- opt.__name__.lower().replace(' ', '').replace('-', '').replace(
- '_', ''): opt for opt in _OPTIMIZERS}
+ Returns
+ -------
+ List[str]
+ List of all available optimization algorithms
+ """
+ return list(get_optimizer_mapping().keys())
-OPTIMIZERS = [opt.__name__ for opt in _OPTIMIZERS]
+def get_optimizer_mapping() -> Dict[str, Block]:
+ # List of available optimizers
+ _OPTIMIZERS: List[Callable] = [
+ cg, lbfgsb, nelder_mead, random_search]
+ # Try importing f3dasm_optimize package
+ try:
+ from f3dasm_optimize import optimizers_extension # NOQA
+ _OPTIMIZERS.extend(optimizers_extension())
+ except ImportError:
+ pass
-def _optimizer_factory(
- optimizer: str, domain: Domain,
- hyperparameters: Optional[Dict[str, Any]] = None) -> Optimizer:
+ OPTIMIZER_MAPPING: Dict[str, Block] = {
+ opt.__name__.lower().replace(' ', '').replace('-', '').replace(
+ '_', ''): opt for opt in _OPTIMIZERS}
+
+ return OPTIMIZER_MAPPING
+
+
+def _optimizer_factory(optimizer: str | Block, **hyperparameters
+ ) -> Block:
"""Factory function for optimizers
Parameters
@@ -47,10 +64,6 @@ def _optimizer_factory(
optimizer : str
Name of the optimizer to use
- domain : Domain
- Domain of the design space
- hyperparameters : dict, optional
- Hyperparameters for the optimizer
Returns
-------
@@ -64,16 +77,19 @@ def _optimizer_factory(
KeyError
If the optimizer is not found
"""
+ if isinstance(optimizer, Block):
+ return optimizer
+
+ elif isinstance(optimizer, str):
- if hyperparameters is None:
- hyperparameters = {}
+ filtered_name = optimizer.lower().replace(
+ ' ', '').replace('-', '').replace('_', '')
- filtered_name = optimizer.lower().replace(
- ' ', '').replace('-', '').replace('_', '')
+ OPTIMIZER_MAPPING = get_optimizer_mapping()
- if filtered_name in OPTIMIZER_MAPPING:
- return OPTIMIZER_MAPPING[filtered_name](
- domain=domain, **hyperparameters)
+ if filtered_name in OPTIMIZER_MAPPING:
+ return OPTIMIZER_MAPPING[filtered_name](
+ **hyperparameters)
else:
raise KeyError(f"Unknown optimizer: {optimizer}")
diff --git a/src/f3dasm/_src/optimization/scipy_implementations.py b/src/f3dasm/_src/optimization/scipy_implementations.py
index 42e1bc0a..53a8c810 100644
--- a/src/f3dasm/_src/optimization/scipy_implementations.py
+++ b/src/f3dasm/_src/optimization/scipy_implementations.py
@@ -5,12 +5,9 @@
# Modules
# =============================================================================
-# Standard
-from typing import List
-
# Locals
-from ..design.domain import Domain
-from .adapters.scipy_implementations import _SciPyOptimizer
+from ..core import Block
+from .adapters.scipy_implementations import ScipyOptimizer
# Authorship & Credits
# =============================================================================
@@ -22,51 +19,81 @@
# =============================================================================
-class CG(_SciPyOptimizer):
- """CG"""
- require_gradients: bool = True
+def cg(gtol: float = 0.0, **kwargs) -> Block:
+ """
+ Conjugate Gradient optimizer
+ Adapted from scipy.optimize.minimize
- def __init__(self, domain: Domain, gtol: float = 0.0, **kwargs):
- super().__init__(
- domain=domain, method='CG', gtol=gtol)
- self.gtol = gtol
+ Parameters
+ ----------
+ gtol : float, optional
+ Gradient norm tolerance, by default 0.0
- def _get_info(self) -> List[str]:
- return ['Stable', 'First-Order', 'Single-Solution']
+ Returns
+ -------
+ Optimizer
+ Optimizer
+ """
+ return ScipyOptimizer(
+ algorithm='CG',
+ gtol=gtol,
+ **kwargs
+ )
# =============================================================================
-class LBFGSB(_SciPyOptimizer):
- """L-BFGS-B"""
- require_gradients: bool = True
-
- def __init__(self, domain: Domain,
- ftol: float = 0.0, gtol: float = 0.0, **kwargs):
- super().__init__(
- domain=domain, method='L-BFGS-B', ftol=ftol, gtol=gtol)
- self.ftol = ftol
- self.gtol = gtol
-
- def _get_info(self) -> List[str]:
- return ['Stable', 'First-Order', 'Single-Solution']
+def lbfgsb(ftol: float = 0.0, gtol: float = 0.0, **kwargs) -> Block:
+ """
+ L-BFGS-B optimizer
+ Adapted from scipy.optimize.minimize
+
+ Parameters
+ ----------
+ ftol : float, optional
+ Function value tolerance, by default 0.0
+ gtol : float, optional
+ Gradient norm tolerance, by default 0.0
+
+ Returns
+ -------
+ Optimizer
+ Optimizer
+ """
+ return ScipyOptimizer(
+ algorithm='L-BFGS-B',
+ ftol=ftol,
+ gtol=gtol,
+ **kwargs
+ )
# =============================================================================
-class NelderMead(_SciPyOptimizer):
- """Nelder-Mead"""
- require_gradients: bool = False
-
- def __init__(self, domain: Domain,
- xatol: float = 0.0, fatol: float = 0.0,
- adaptive: bool = False, **kwargs):
- super().__init__(
- domain=domain, method='Nelder-Mead', xatol=xatol, fatol=fatol,
- adaptive=adaptive)
- self.xatol = xatol
- self.fatol = fatol
- self.adaptive = adaptive
-
- def _get_info(self) -> List[str]:
- return ['Fast', 'Global', 'First-Order', 'Single-Solution']
+def nelder_mead(xatol: float = 0.0, fatol: float = 0.0,
+ adaptive: bool = False, **kwargs) -> Block:
+ """
+ Nelder-Mead optimizer
+ Adapted from scipy.optimize.minimize
+
+ Parameters
+ ----------
+ xatol : float, optional
+ Absolute error in xopt between iterations, by default 0.0
+ fatol : float, optional
+ Absolute error in fun(xopt) between iterations, by default 0.0
+ adaptive : bool, optional
+ Adapt the algorithm, by default False
+
+ Returns
+ -------
+ Optimizer
+ Optimizer
+ """
+ return ScipyOptimizer(
+ algorithm='Nelder-Mead',
+ xatol=xatol,
+ fatol=fatol,
+ adaptive=adaptive,
+ **kwargs
+ )
diff --git a/src/f3dasm/datageneration/__init__.py b/src/f3dasm/datageneration/__init__.py
index 657e0a71..36c09a3a 100644
--- a/src/f3dasm/datageneration/__init__.py
+++ b/src/f3dasm/datageneration/__init__.py
@@ -4,7 +4,7 @@
# Modules
# =============================================================================
-from .._src.datageneration.datagenerator import DataGenerator
+from .._src.core import DataGenerator
# Authorship & Credits
# =============================================================================
diff --git a/src/f3dasm/datageneration/functions.py b/src/f3dasm/datageneration/functions.py
index 14c95ecf..f019b4b2 100644
--- a/src/f3dasm/datageneration/functions.py
+++ b/src/f3dasm/datageneration/functions.py
@@ -7,6 +7,40 @@
# Local
from .._src.datageneration.functions import (FUNCTIONS, FUNCTIONS_2D,
FUNCTIONS_7D, get_functions)
+from .._src.datageneration.functions.alias import (ackley, ackleyn2, ackleyn3,
+ ackleyn4, adjiman, bartels,
+ beale, bird, bohachevskyn1,
+ bohachevskyn2,
+ bohachevskyn3, booth,
+ branin, brent, brown,
+ bukinn6, colville,
+ crossintray, deckkersaarts,
+ dejongn5, dixonprice,
+ dropwave, easom, eggcrate,
+ eggholder, exponential,
+ goldsteinprice, griewank,
+ happycat, himmelblau,
+ holdertable, keane,
+ langermann, leon, levy,
+ levyn13, matyas, mccormick,
+ michalewicz, periodic,
+ powell, qing, quartic,
+ rastrigin, ridge,
+ rosenbrock,
+ rotatedhyperellipsoid,
+ salomon, schaffeln1,
+ schaffeln2, schaffeln3,
+ schaffeln4, schwefel,
+ schwefel2_20, schwefel2_21,
+ schwefel2_22, schwefel2_23,
+ shekel, shubert, shubertn3,
+ shubertn4, sphere,
+ styblinskitang, sumsquares,
+ thevenot, threehump, trid,
+ wolfe, xin_she_yang,
+ xin_she_yang2,
+ xin_she_yang3,
+ xin_she_yang4, zakharov)
# Authorship & Credits
# =============================================================================
@@ -22,4 +56,77 @@
'FUNCTIONS_2D',
'FUNCTIONS_7D',
'get_functions',
+ 'ackley',
+ 'ackleyn2',
+ 'ackleyn3',
+ 'ackleyn4',
+ 'adjiman',
+ 'bartels',
+ 'beale',
+ 'bird',
+ 'bohachevskyn1',
+ 'bohachevskyn2',
+ 'bohachevskyn3',
+ 'booth',
+ 'branin',
+ 'brent',
+ 'brown',
+ 'bukinn6',
+ 'colville',
+ 'crossintray',
+ 'deckkersaarts',
+ 'dejongn5',
+ 'dixonprice',
+ 'dropwave',
+ 'easom',
+ 'eggcrate',
+ 'eggholder',
+ 'exponential',
+ 'goldsteinprice',
+ 'griewank',
+ 'happycat',
+ 'himmelblau',
+ 'holdertable',
+ 'keane',
+ 'langermann',
+ 'leon',
+ 'levy',
+ 'levyn13',
+ 'matyas',
+ 'mccormick',
+ 'michalewicz',
+ 'periodic',
+ 'powell',
+ 'qing',
+ 'quartic',
+ 'rastrigin',
+ 'ridge',
+ 'rosenbrock',
+ 'rotatedhyperellipsoid',
+ 'salomon',
+ 'schaffeln1',
+ 'schaffeln2',
+ 'schaffeln3',
+ 'schaffeln4',
+ 'schwefel',
+ 'schwefel2_20',
+ 'schwefel2_21',
+ 'schwefel2_22',
+ 'schwefel2_23',
+ 'shekel',
+ 'shubert',
+ 'shubertn3',
+ 'shubertn4',
+ 'sphere',
+ 'styblinskitang',
+ 'sumsquares',
+ 'thevenot',
+ 'threehump',
+ 'trid',
+ 'wolfe',
+ 'xin_she_yang',
+ 'xin_she_yang2',
+ 'xin_she_yang3',
+ 'xin_she_yang4',
+ 'zakharov',
]
diff --git a/src/f3dasm/design.py b/src/f3dasm/design.py
index 47fe19fb..d805671b 100644
--- a/src/f3dasm/design.py
+++ b/src/f3dasm/design.py
@@ -6,7 +6,7 @@
# Local
from ._src.design.domain import Domain, make_nd_continuous_domain
-from ._src.experimentdata._jobqueue import NoOpenJobsError, Status
+from ._src.design.samplers import grid, latin, random, sobol
# Authorship & Credits
# =============================================================================
@@ -20,6 +20,8 @@
__all__ = [
'Domain',
'make_nd_continuous_domain',
- 'NoOpenJobsError',
- 'Status',
+ 'latin',
+ 'random',
+ 'grid',
+ 'sobol',
]
diff --git a/src/f3dasm/optimization.py b/src/f3dasm/optimization.py
index d5dfb49a..4198f18d 100644
--- a/src/f3dasm/optimization.py
+++ b/src/f3dasm/optimization.py
@@ -5,8 +5,8 @@
# =============================================================================
# Local
-from ._src.optimization.optimizer import Optimizer
-from ._src.optimization.optimizer_factory import OPTIMIZERS
+from ._src.optimization import cg, lbfgsb, nelder_mead, random_search
+from ._src.optimization.optimizer_factory import available_optimizers
# Authorship & Credits
# =============================================================================
@@ -18,6 +18,9 @@
# =============================================================================
__all__ = [
- 'Optimizer',
- 'OPTIMIZERS',
+ 'available_optimizers',
+ 'cg',
+ 'lbfgsb',
+ 'nelder_mead',
+ 'random_search'
]
diff --git a/studies/benchmark_optimizers/README.md b/studies/benchmark_optimizers/README.md
index 40f99200..3e558248 100644
--- a/studies/benchmark_optimizers/README.md
+++ b/studies/benchmark_optimizers/README.md
@@ -33,7 +33,7 @@ The benchmark function is optimized for a given number of iterations and repeate
### Before running the experiment
-1. Install `f3dasm_optimize` in your environment. See [here](https://bessagroup.github.io/f3dasm_optimize/rst_doc_files/getting_started.html) for instructions.
+1. Install `f3dasm_optimize` in your environment. See [here](https://f3dasm-optimize.readthedocs.io/en/latest/) for instructions.
3. Change the `config.yaml` file to your liking. See [here](#explanation-of-configyaml-parameters) for an explanation of the parameters.
### Running the experiment on your local machine
@@ -134,7 +134,7 @@ outputs/
| sampler_name | `str` | Name of the sampling strategy for the first iterations ([reference](https://f3dasm.readthedocs.io/en/latest/rst_doc_files/classes/sampling/sampling.html#id2)) |
| number_of_samples | `int` | Number of initial samples ($\vec{x}_0$) |
| realizations | `int` | Number of realizations with different initial conditions |
-| optimizers | `List[str]` | List of dictionaries. Each dictionary contains a key ``name`` with the optimizer name ([from `f3dasm`](https://f3dasm.readthedocs.io/en/latest/rst_doc_files/classes/optimization/optimizers.html#implemented-optimizers), [and `f3dasm_optimize`](https://bessagroup.github.io/f3dasm_optimize/rst_doc_files/optimizers.html#implemented-optimizers)) and a (optionally) a ``hyperparameters`` key to overwrite hyper-parameters of that specific optimzier. |
+| optimizers | `List[str]` | List of dictionaries. Each dictionary contains a key ``name`` with the optimizer name ([from `f3dasm`](https://f3dasm.readthedocs.io/en/latest/rst_doc_files/classes/optimization/optimizers.html#implemented-optimizers), [and `f3dasm_optimize`](https://f3dasm-optimize.readthedocs.io/en/latest/)) and a (optionally) a ``hyperparameters`` key to overwrite hyper-parameters of that specific optimzier. |
### HPC
diff --git a/studies/benchmark_optimizers/main.py b/studies/benchmark_optimizers/main.py
index c7294355..3e2ee4b8 100644
--- a/studies/benchmark_optimizers/main.py
+++ b/studies/benchmark_optimizers/main.py
@@ -29,7 +29,7 @@
import xarray as xr
# Local
-from f3dasm import ExperimentData
+from f3dasm import Block, ExperimentData
from f3dasm.datageneration import DataGenerator
from f3dasm.datageneration.functions import get_functions
from f3dasm.design import Domain, make_nd_continuous_domain
@@ -47,27 +47,36 @@
# Custom sampler method
# =============================================================================
-def sample_if_compatible_function(
- domain: Domain, n_samples: int, seed: int) -> pd.DataFrame:
- rng = np.random.default_rng(seed)
- samples = []
+class CustomSampler(Block):
+ def __init__(self, seed: int):
+ self.seed = seed
- for i in range(n_samples):
- dim = rng.choice(domain.space['dimensionality'].categories)
+ def call(self, data: ExperimentData, n_samples: int) -> ExperimentData:
+ rng = np.random.default_rng(self.seed)
+ samples = []
- available_functions = list(set(get_functions(d=int(dim))) & set(
- domain.space['function_name'].categories))
- function_name = rng.choice(available_functions)
+ for i in range(n_samples):
+ dim = rng.choice(
+ data.domain.input_space['dimensionality'].categories)
- noise = rng.choice(domain.space['noise'].categories)
- seed = rng.integers(
- low=domain.space['seed'].lower_bound,
- high=domain.space['seed'].upper_bound)
- budget = domain.space['budget'].value
+ available_functions = list(set(get_functions(d=int(dim))) & set(
+ data.domain.input_space['function_name'].categories))
+ function_name = rng.choice(available_functions)
- samples.append([function_name, dim, noise, seed, budget])
+ noise = rng.choice(data.domain.input_space['noise'].categories)
+ seed = rng.integers(
+ low=data.domain.input_space['seed'].lower_bound,
+ high=data.domain.input_space['seed'].upper_bound)
+ budget = data.domain.input_space['budget'].value
- return pd.DataFrame(samples, columns=domain.names)[domain.names]
+ samples.append([function_name, dim, noise, seed, budget])
+
+ df = pd.DataFrame(
+ samples, columns=data.domain.input_names)[data.domain.input_names]
+
+ return ExperimentData(
+ domain=data.domain, input_data=df,
+ project_dir=data.project_dir)
# Custom datagenerator
# =============================================================================
@@ -78,11 +87,11 @@ def __init__(self, config):
self.config = config
def optimize_function(self, optimizer: dict) -> xr.Dataset:
- seed = self.experiment_sample.get('seed')
- function_name = self.experiment_sample.get('function_name')
- dimensionality = self.experiment_sample.get('dimensionality')
- noise = self.experiment_sample.get('noise')
- budget = self.experiment_sample.get('budget')
+ seed = self.experiment_sample.input_data['seed']
+ function_name = self.experiment_sample.input_data['function_name']
+ dimensionality = self.experiment_sample.input_data['dimensionality']
+ noise = self.experiment_sample.input_data['noise']
+ budget = self.experiment_sample.input_data['budget']
hyperparameters = optimizer['hyperparameters'] \
if 'hyperparameters' in optimizer else {}
@@ -103,9 +112,8 @@ def optimize_function(self, optimizer: dict) -> xr.Dataset:
data.evaluate(
data_generator=function_name,
- kwargs={'scale_bounds': domain.get_bounds(), 'offset': True,
- 'noise': noise, 'seed': seed},
- mode='sequential')
+ scale_bounds=domain.get_bounds(), offset=True, noise=noise,
+ seed=seed, mode='sequential')
data.optimize(
optimizer=optimizer['name'], data_generator=function_name,
@@ -133,12 +141,15 @@ def execute(self):
def pre_processing(config):
+ custom_sampler = CustomSampler(
+ seed=config.experimentdata.from_sampling.seed)
+
if 'from_sampling' in config.experimentdata:
experimentdata = ExperimentData.from_sampling(
- sampler=sample_if_compatible_function,
+ sampler=custom_sampler,
domain=Domain.from_yaml(config.domain),
n_samples=config.experimentdata.from_sampling.n_samples,
- seed=config.experimentdata.from_sampling.seed)
+ )
else:
experimentdata = ExperimentData.from_yaml(config.experimentdata)
diff --git a/studies/fragile_becomes_supercompressible/example_design/experiment_data/domain.json b/studies/fragile_becomes_supercompressible/example_design/experiment_data/domain.json
new file mode 100644
index 00000000..fe4f5009
--- /dev/null
+++ b/studies/fragile_becomes_supercompressible/example_design/experiment_data/domain.json
@@ -0,0 +1,105 @@
+{
+ "input_space": {
+ "young_modulus": {
+ "type": "constant",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "value": 3500.0
+ },
+ "n_longerons": {
+ "type": "constant",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "value": 3
+ },
+ "bottom_diameter": {
+ "type": "constant",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "value": 100.0
+ },
+ "ratio_top_diameter": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 0.0,
+ "upper_bound": 0.8,
+ "log": false
+ },
+ "ratio_pitch": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 0.25,
+ "upper_bound": 1.5,
+ "log": false
+ },
+ "ratio_shear_modulus": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 0.035,
+ "upper_bound": 0.45,
+ "log": false
+ },
+ "ratio_area": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 1.17e-05,
+ "upper_bound": 0.0041,
+ "log": false
+ },
+ "ratio_Ixx": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 1.128e-11,
+ "upper_bound": 1.4e-06,
+ "log": false
+ },
+ "ratio_Iyy": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 1.128e-11,
+ "upper_bound": 1.4e-06,
+ "log": false
+ },
+ "ratio_J": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 1.353e-11,
+ "upper_bound": 7.77e-06,
+ "log": false
+ },
+ "circular": {
+ "type": "constant",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "value": false
+ },
+ "imperfection": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 0.0,
+ "upper_bound": 1.0,
+ "log": false
+ }
+ },
+ "output_space": {}
+}
\ No newline at end of file
diff --git a/studies/fragile_becomes_supercompressible/example_design/experiment_data/domain.pkl b/studies/fragile_becomes_supercompressible/example_design/experiment_data/domain.pkl
deleted file mode 100644
index 195a1995..00000000
Binary files a/studies/fragile_becomes_supercompressible/example_design/experiment_data/domain.pkl and /dev/null differ
diff --git a/studies/fragile_becomes_supercompressible/example_design/experiment_data/input.csv b/studies/fragile_becomes_supercompressible/example_design/experiment_data/input.csv
index 0878f0a3..a858a864 100644
--- a/studies/fragile_becomes_supercompressible/example_design/experiment_data/input.csv
+++ b/studies/fragile_becomes_supercompressible/example_design/experiment_data/input.csv
@@ -1,2 +1,2 @@
,bottom_diameter,circular,imperfection,n_longerons,ratio_Ixx,ratio_Iyy,ratio_J,ratio_area,ratio_pitch,ratio_shear_modulus,ratio_top_diameter,young_modulus
-0,100,0,0.2,3,0.0000001697758,0.0000003717950,1e-06,0.003624,0.75,0.367714286,0.4,3500.0
+0,100.0,0.0,0.2,3.0,1.697758e-07,3.71795e-07,1e-06,0.003624,0.75,0.367714286,0.4,3500.0
diff --git a/studies/fragile_becomes_supercompressible/example_design/experiment_data/jobs.csv b/studies/fragile_becomes_supercompressible/example_design/experiment_data/jobs.csv
new file mode 100644
index 00000000..ac944188
--- /dev/null
+++ b/studies/fragile_becomes_supercompressible/example_design/experiment_data/jobs.csv
@@ -0,0 +1,2 @@
+,0
+0,OPEN
diff --git a/studies/fragile_becomes_supercompressible/example_design/experiment_data/jobs.pkl b/studies/fragile_becomes_supercompressible/example_design/experiment_data/jobs.pkl
deleted file mode 100644
index 68654e40..00000000
Binary files a/studies/fragile_becomes_supercompressible/example_design/experiment_data/jobs.pkl and /dev/null differ
diff --git a/studies/fragile_becomes_supercompressible/main.py b/studies/fragile_becomes_supercompressible/main.py
index 2f608819..d78f3401 100644
--- a/studies/fragile_becomes_supercompressible/main.py
+++ b/studies/fragile_becomes_supercompressible/main.py
@@ -27,12 +27,12 @@
import hydra
import numpy as np
import pandas as pd
-from f3dasm import ExperimentData
+from abaqus2py import F3DASMAbaqusSimulator
+
+from f3dasm import Block, ExperimentData
from f3dasm import logger as f3dasm_logger
from f3dasm.design import Domain
-from abaqus2py import F3DASMAbaqusSimulator
-
# Authorship & Credits
# =============================================================================
__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
@@ -46,32 +46,33 @@
# Custom sampler method
# =============================================================================
-def log_normal_sampler(domain: Domain, n_samples: int,
- mean: float, sigma: float, seed: Optional[int] = None):
- """Sampler function for lognormal distribution
- Parameters
- ----------
- domain
- Domain object
- n_samples
- Number of samples to generate
- mean
- Mean of the lognormal distribution
- sigma
- Standard deviation of the lognormal distribution
- seed
- Seed for the random number generator
-
- Returns
- -------
- DataFrame
- pandas DataFrame with the samples
- """
- rng = np.random.default_rng(seed)
- sampled_imperfections = rng.lognormal(
- mean=mean, sigma=sigma, size=n_samples)
- return pd.DataFrame(sampled_imperfections, columns=domain.names)
+class LogNormalSampler(Block):
+ def __init__(self, mean: float, sigma: float, seed: Optional[int] = None):
+ """Sampler function for lognormal distribution
+
+ Parameters
+ ----------
+ mean
+ Mean of the lognormal distribution
+ sigma
+ Standard deviation of the lognormal distribution
+ seed
+ Seed for the random number generator
+ """
+ self.mean = mean
+ self.sigma = sigma
+ self.seed = seed
+
+ def call(self, data: ExperimentData, n_samples: int) -> ExperimentData:
+ rng = np.random.default_rng(self.seed)
+ sampled_imperfections = rng.lognormal(
+ mean=self.mean, sigma=self.sigma, size=n_samples)
+ df = pd.DataFrame(sampled_imperfections,
+ columns=self.domain.input_names)
+ return ExperimentData(domain=data.domain,
+ input_data=df,
+ project_dir=data.project_dir)
# =============================================================================
@@ -81,14 +82,16 @@ def pre_processing(config):
if 'from_sampling' in config.imperfection:
domain_imperfections = Domain.from_yaml(config.imperfection.domain)
+ log_normal_sampler = LogNormalSampler(
+ mean=config.imperfection.mean,
+ sigma=config.imperfection.sigma,
+ seed=config.experimentdata.from_sampling.seed)
imperfections = ExperimentData.from_sampling(
sampler=log_normal_sampler,
domain=domain_imperfections,
n_samples=config.experimentdata.from_sampling.n_samples,
- mean=config.imperfection.mean,
- sigma=config.imperfection.sigma,
- seed=config.experimentdata.from_sampling.seed)
+ )
experimentdata = experimentdata.join(imperfections)
diff --git a/tests/datageneration/test_datagenerator.py b/tests/datageneration/test_datagenerator.py
index 5a757ebe..a9a3f503 100644
--- a/tests/datageneration/test_datagenerator.py
+++ b/tests/datageneration/test_datagenerator.py
@@ -3,8 +3,9 @@
import pytest
from f3dasm import ExperimentData
-from f3dasm._src.datageneration.datagenerator import convert_function
+from f3dasm._src.datageneration.datagenerator_factory import convert_function
from f3dasm.datageneration import DataGenerator
+from f3dasm.design import make_nd_continuous_domain
pytestmark = pytest.mark.smoke
@@ -27,3 +28,32 @@ def test_convert_function2(
assert isinstance(data_generator, DataGenerator)
experiment_data.evaluate(data_generator)
+
+
+@pytest.mark.parametrize("mode", ['sequential', 'parallel'])
+def test_parallelization(mode, tmp_path):
+ domain = make_nd_continuous_domain([[0, 1], [0, 1]])
+ experiment_data = ExperimentData.from_sampling(
+ sampler='random',
+ domain=domain,
+ n_samples=10,
+ seed=42)
+
+ experiment_data.remove_lockfile()
+ experiment_data.set_project_dir(tmp_path)
+
+ experiment_data.evaluate(data_generator='ackley',
+ mode=mode)
+
+
+def test_invalid_parallelization_mode():
+ domain = make_nd_continuous_domain([[0, 1], [0, 1]])
+ experiment_data = ExperimentData.from_sampling(
+ sampler='random',
+ domain=domain,
+ n_samples=10,
+ seed=42)
+
+ with pytest.raises(ValueError):
+ experiment_data.evaluate(data_generator='ackley',
+ mode='invalid')
diff --git a/tests/design/conftest.py b/tests/design/conftest.py
index 4b749991..3733a9fe 100644
--- a/tests/design/conftest.py
+++ b/tests/design/conftest.py
@@ -1,23 +1,23 @@
import pandas as pd
import pytest
-from f3dasm._src.design.parameter import (_CategoricalParameter,
- _ContinuousParameter,
- _DiscreteParameter)
+from f3dasm._src.design.parameter import (CategoricalParameter,
+ ContinuousParameter,
+ DiscreteParameter)
from f3dasm.design import Domain
@pytest.fixture(scope="package")
def doe():
- x1 = _ContinuousParameter(lower_bound=2.4, upper_bound=10.3)
- x2 = _DiscreteParameter(lower_bound=5, upper_bound=80)
- x3 = _ContinuousParameter(lower_bound=10.0, upper_bound=380.3)
- x4 = _CategoricalParameter(categories=["test1", "test2", "test3"])
- x5 = _DiscreteParameter(lower_bound=2, upper_bound=3)
+ x1 = ContinuousParameter(lower_bound=2.4, upper_bound=10.3)
+ x2 = DiscreteParameter(lower_bound=5, upper_bound=80)
+ x3 = ContinuousParameter(lower_bound=10.0, upper_bound=380.3)
+ x4 = CategoricalParameter(categories=["test1", "test2", "test3"])
+ x5 = DiscreteParameter(lower_bound=2, upper_bound=3)
designspace = {'x1': x1, 'x2': x2, 'x3': x3, 'x4': x4, 'x5': x5}
- doe = Domain(space=designspace)
+ doe = Domain(input_space=designspace)
return doe
@@ -25,33 +25,33 @@ def doe():
def domain():
space = {
- 'x1': _ContinuousParameter(-5.12, 5.12),
- 'x2': _DiscreteParameter(-3, 3),
- 'x3': _CategoricalParameter(["red", "green", "blue"])
+ 'x1': ContinuousParameter(-5.12, 5.12),
+ 'x2': DiscreteParameter(-3, 3),
+ 'x3': CategoricalParameter(["red", "green", "blue"])
}
- return Domain(space=space)
+ return Domain(input_space=space)
@pytest.fixture(scope="package")
def continuous_parameter():
lower_bound = 3.3
upper_bound = 3.8
- return _ContinuousParameter(lower_bound=lower_bound,
- upper_bound=upper_bound)
+ return ContinuousParameter(lower_bound=lower_bound,
+ upper_bound=upper_bound)
@pytest.fixture(scope="package")
def discrete_parameter():
lower_bound = 3
upper_bound = 6
- return _DiscreteParameter(lower_bound=lower_bound, upper_bound=upper_bound)
+ return DiscreteParameter(lower_bound=lower_bound, upper_bound=upper_bound)
@pytest.fixture(scope="package")
def categorical_parameter():
categories = ["test1", "test2", "test3"]
- return _CategoricalParameter(categories=categories)
+ return CategoricalParameter(categories=categories)
@pytest.fixture(scope="package")
diff --git a/tests/design/test_data.py b/tests/design/test_data.py
deleted file mode 100644
index 0d546ccd..00000000
--- a/tests/design/test_data.py
+++ /dev/null
@@ -1,125 +0,0 @@
-
-import numpy as np
-import pandas as pd
-import pytest
-
-from f3dasm._src.experimentdata._data import _Data
-from f3dasm.design import Domain
-
-pytestmark = pytest.mark.smoke
-
-
-@pytest.fixture
-def sample_data():
- input_data = pd.DataFrame({'input1': [1, 2, 3], 'input2': [4, 5, 6]})
- return _Data(input_data)
-
-
-def test_data_initialization(sample_data: _Data):
- assert isinstance(sample_data.data, pd.DataFrame)
-
-
-def test_data_len(sample_data: _Data):
- assert len(sample_data) == len(sample_data.data)
-
-
-def test_data_repr_html(sample_data: _Data):
- assert isinstance(sample_data._repr_html_(), str)
-
-
-def test_data_from_design(domain: Domain):
- # Assuming you have a Domain object named "domain"
- data = _Data.from_domain(domain)
- assert isinstance(data, _Data)
- assert isinstance(data.data, pd.DataFrame)
-
-
-def test_data_reset(sample_data: _Data):
- # Assuming you have a Domain object named "domain"
- design = Domain()
- sample_data.reset(design)
- assert isinstance(sample_data.data, pd.DataFrame)
- assert len(sample_data) == 0
-
-
-def test_data_remove(sample_data: _Data):
- indices = [0, 2]
- sample_data.remove(indices)
- assert len(sample_data) == 1
-
-
-def test_data_add_numpy_arrays(sample_data: _Data):
- input_array = np.array([[1, 4], [2, 5]])
- df = pd.DataFrame(input_array, columns=sample_data.names)
- sample_data.add(df)
- assert len(sample_data) == 5
-
-
-def test_data_get_data(sample_data: _Data):
- input_data = sample_data.data
- assert isinstance(input_data, pd.DataFrame)
- assert input_data.equals(sample_data.data)
-
-
-def test_data_get_inputdata_dict(sample_data: _Data):
- index = 0
- input_dict = sample_data.get_data_dict(index)
- assert isinstance(input_dict, dict)
- assert input_dict == {'input1': 1, 'input2': 4}
-
-
-def test_data_set_data(sample_data: _Data):
- index = 0
- sample_data.set_data(index=index, value=15,
- column='output1')
- _column_index = sample_data.columns.iloc('output1')[0]
- assert sample_data.data.loc[index, _column_index] == 15
-
-
-def test_data_to_numpy(sample_data: _Data):
- input_array = sample_data.to_numpy()
- assert isinstance(input_array, np.ndarray)
- assert input_array.shape == (
- len(sample_data), len(sample_data.data.columns))
-
-
-def test_data_n_best_samples(sample_data: _Data):
- nosamples = 2
- output_names = 'input1'
- result = sample_data.n_best_samples(nosamples, output_names)
- assert isinstance(result, pd.DataFrame)
- assert len(result) == nosamples
-
-
-def test_compatible_columns_add():
- # create a 4 column dataframe with random numpy values
- df = pd.DataFrame(np.random.randn(100, 4), columns=list('ABCD'))
- dg = pd.DataFrame(np.random.randn(100, 4), columns=list('ABCD'))
-
- f = _Data(df)
- g = _Data(dg)
-
- _ = f + g
-
-
-def test_overwrite_data(sample_data: _Data):
- overwrite_data = _Data(pd.DataFrame(
- {'input1': [5, 6, 7], 'input2': [8, 9, 10]}))
-
- sample_data.overwrite(other=overwrite_data, indices=[0, 1, 2])
-
- pd.testing.assert_frame_equal(sample_data.data, overwrite_data.data,
- check_dtype=False, atol=1e-6)
-
-
-def test_overwrite_data2(sample_data: _Data):
- overwrite_data = _Data(pd.DataFrame(
- {'input1': [5, 6, ], 'input2': [8, 9]}))
-
- sample_data.overwrite(other=overwrite_data, indices=[1, 2])
-
- ground_truth = _Data(pd.DataFrame(
- {'input1': [1, 5, 6], 'input2': [4, 8, 9]}))
-
- pd.testing.assert_frame_equal(sample_data.data, ground_truth.data,
- check_dtype=False, atol=1e-6)
diff --git a/tests/design/test_designofexperiments.py b/tests/design/test_designofexperiments.py
index 29354121..85a71a07 100644
--- a/tests/design/test_designofexperiments.py
+++ b/tests/design/test_designofexperiments.py
@@ -1,10 +1,11 @@
import numpy as np
-import pandas as pd
import pytest
-from f3dasm._src.design.parameter import (_CategoricalParameter,
- _ContinuousParameter,
- _DiscreteParameter)
+from f3dasm._src.design.domain import _domain_factory
+from f3dasm._src.design.parameter import (CategoricalParameter,
+ ConstantParameter,
+ ContinuousParameter,
+ DiscreteParameter)
from f3dasm.design import Domain, make_nd_continuous_domain
pytestmark = pytest.mark.smoke
@@ -13,7 +14,7 @@
def test_empty_space_doe():
doe = Domain()
empty_dict = {}
- assert doe.space == empty_dict
+ assert doe.input_space == empty_dict
def test_correct_doe(doe):
@@ -21,85 +22,85 @@ def test_correct_doe(doe):
def test_get_continuous_parameters(doe: Domain):
- design = {'x1': _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- 'x3': _ContinuousParameter(lower_bound=10.0, upper_bound=380.3)}
- assert doe.continuous.space == design
+ design = {'x1': ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
+ 'x3': ContinuousParameter(lower_bound=10.0, upper_bound=380.3)}
+ assert doe.continuous.input_space == design
def test_get_discrete_parameters(doe: Domain):
- design = {'x2': _DiscreteParameter(lower_bound=5, upper_bound=80),
- 'x5': _DiscreteParameter(lower_bound=2, upper_bound=3)}
- assert doe.discrete.space == design
+ design = {'x2': DiscreteParameter(lower_bound=5, upper_bound=80),
+ 'x5': DiscreteParameter(lower_bound=2, upper_bound=3)}
+ assert doe.discrete.input_space == design
def test_get_categorical_parameters(doe: Domain):
- assert doe.categorical.space == {'x4': _CategoricalParameter(
+ assert doe.categorical.input_space == {'x4': CategoricalParameter(
categories=["test1", "test2", "test3"])}
def test_get_continuous_names(doe: Domain):
- assert doe.continuous.names == ["x1", "x3"]
+ assert doe.continuous.input_names == ["x1", "x3"]
def test_get_discrete_names(doe: Domain):
- assert doe.discrete.names == ["x2", "x5"]
+ assert doe.discrete.input_names == ["x2", "x5"]
def test_get_categorical_names(doe: Domain):
- assert doe.categorical.names == ["x4"]
+ assert doe.categorical.input_names == ["x4"]
def test_add_arbitrary_list_as_categorical_parameter():
arbitrary_list_1 = [3.1416, "pi", 42]
arbitrary_list_2 = np.linspace(start=142, stop=214, num=10)
- designspace = {'x1': _CategoricalParameter(categories=arbitrary_list_1),
- 'x2': _CategoricalParameter(categories=arbitrary_list_2)
+ designspace = {'x1': CategoricalParameter(categories=arbitrary_list_1),
+ 'x2': CategoricalParameter(categories=arbitrary_list_2)
}
- design = Domain(space=designspace)
+ design = Domain(input_space=designspace)
- assert design.space == designspace
+ assert design.input_space == designspace
def test_add_input_space():
designspace = {
- 'x1': _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- 'x2': _DiscreteParameter(lower_bound=5, upper_bound=80),
- 'x3': _ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
+ 'x1': ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
+ 'x2': DiscreteParameter(lower_bound=5, upper_bound=80),
+ 'x3': ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
}
- design = Domain(space=designspace)
+ design = Domain(input_space=designspace)
design.add('x4', type='category',
categories=["test1", "test2", "test3"])
design.add('x5', type='int', low=2, high=3)
- assert design.space == {
- 'x1': _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- 'x2': _DiscreteParameter(lower_bound=5, upper_bound=80),
- 'x3': _ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
- 'x4': _CategoricalParameter(categories=["test1", "test2", "test3"]),
- 'x5': _DiscreteParameter(lower_bound=2, upper_bound=3)
+ assert design.input_space == {
+ 'x1': ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
+ 'x2': DiscreteParameter(lower_bound=5, upper_bound=80),
+ 'x3': ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
+ 'x4': CategoricalParameter(categories=["test1", "test2", "test3"]),
+ 'x5': DiscreteParameter(lower_bound=2, upper_bound=3)
}
def test_add_space():
designspace = {
- 'x1': _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- 'x2': _DiscreteParameter(lower_bound=5, upper_bound=80),
- 'x3': _ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
+ 'x1': ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
+ 'x2': DiscreteParameter(lower_bound=5, upper_bound=80),
+ 'x3': ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
}
- domain = Domain(space=designspace)
+ domain = Domain(input_space=designspace)
domain.add('x4', type='category',
categories=["test1", "test2", "test3"])
domain.add('x5', type='int', low=2, high=3)
- assert domain.space == {
- 'x1': _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- 'x2': _DiscreteParameter(lower_bound=5, upper_bound=80),
- 'x3': _ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
- 'x4': _CategoricalParameter(categories=["test1", "test2", "test3"]),
- 'x5': _DiscreteParameter(lower_bound=2, upper_bound=3),
+ assert domain.input_space == {
+ 'x1': ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
+ 'x2': DiscreteParameter(lower_bound=5, upper_bound=80),
+ 'x3': ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
+ 'x4': CategoricalParameter(categories=["test1", "test2", "test3"]),
+ 'x5': DiscreteParameter(lower_bound=2, upper_bound=3),
}
@@ -107,60 +108,116 @@ def test_getNumberOfInputParameters(doe: Domain):
assert len(doe) == 5
-def test_all_input_continuous_False(doe: Domain):
- assert doe._all_input_continuous() is False
+def test_get_input_names(domain: Domain):
+ # Ensure that get_input_names returns the correct input parameter names
+ assert domain.input_names == ['x1', 'x2', 'x3']
-def test_all_input_continuous_True():
- designspace = {
- 'x1': _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- 'x3': _ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
- }
+def test_get_number_of_input_parameters(domain: Domain):
+ # Ensure that get_number_of_input_parameters returns the correct number of input parameters
+ assert len(domain) == 3
- doe = Domain(space=designspace)
- assert doe._all_input_continuous() is True
+def test_add_parameter_with_same_name_error():
+ domain = Domain()
+ domain.add('x1', type='float', low=0.0, high=1.0)
+ with pytest.raises(KeyError):
+ domain.add('x1', type='int', low=0, high=1)
-def test_cast_types_dataframe_input(doe: Domain):
- ground_truth = {
- "x1": "float",
- "x2": "int",
- "x3": "float",
- "x4": "object",
- "x5": "int",
- }
+def test_add_int_with_same_low_and_high():
+ domain = Domain()
+ domain.add_int('x1', low=1, high=1)
+ assert domain.input_space == {
+ 'x1': ConstantParameter(value=1)}
- assert doe._cast_types_dataframe() == ground_truth
+def test_add_float_with_same_low_and_high():
+ domain = Domain()
+ domain.add_float('x1', low=1.0, high=1.0)
+ assert domain.input_space == {
+ 'x1': ConstantParameter(value=1.0)}
-def test_get_input_names(domain: Domain):
- # Ensure that get_input_names returns the correct input parameter names
- assert domain.names == ['x1', 'x2', 'x3']
+def test_add_category_with_add_method():
+ domain = Domain()
+ domain.add('x1', type='category', categories=['a', 'b', 'c'])
+ assert domain.input_space == {
+ 'x1': CategoricalParameter(categories=['a', 'b', 'c'])}
-def test_get_number_of_input_parameters(domain: Domain):
- # Ensure that get_number_of_input_parameters returns the correct number of input parameters
- assert len(domain) == 3
+
+def test_add_constant_with_add_method():
+ domain = Domain()
+ domain.add('x1', type='constant', value=1)
+ assert domain.input_space == {
+ 'x1': ConstantParameter(value=1)}
+
+
+def test_add_output_that_exists_without_exist_ok():
+ domain = Domain()
+ domain.add_output('y')
+ with pytest.raises(KeyError):
+ domain.add_output('y', exist_ok=False)
+
+
+def test_add_output_that_exists_with_exist_ok():
+ domain = Domain()
+ domain.add_output('y')
+ domain.add_output('y', exist_ok=True)
+ assert domain.output_names == ['y']
+
+
+def test_domain_factory_with_invalid_input():
+ with pytest.raises(TypeError):
+ _domain_factory(domain=0)
+
+
+def test_eq_different_types():
+ domain = Domain()
+ with pytest.raises(TypeError):
+ domain == 0
+
+
+def test_add_different_types():
+ domain = Domain()
+ with pytest.raises(TypeError):
+ domain + 0
+
+
+def test_str_method():
+ domain = Domain()
+ assert str(
+ domain) == 'Domain(\n Input Space: { }\n Output Space: { }\n)'
+
+
+def test_add_two_constant_parameters():
+ c1 = ConstantParameter(value=1)
+ c2 = ConstantParameter(value=2)
+ assert CategoricalParameter(categories=[1, 2]) == c1 + c2
+
+
+def test_add_discrete_to_constant():
+ c = ConstantParameter(value=1)
+ disc = DiscreteParameter(lower_bound=2, upper_bound=4)
+ assert CategoricalParameter(categories=[1, 2, 3]) == c + disc
-def test_domain_from_dataframe(sample_dataframe: pd.DataFrame):
- domain = Domain.from_dataframe(
- df_input=sample_dataframe, df_output=pd.DataFrame())
- ground_truth = Domain(space={'feature1': _ContinuousParameter(lower_bound=1.0, upper_bound=3.0),
- 'feature2': _DiscreteParameter(lower_bound=4, upper_bound=6),
- 'feature3': _CategoricalParameter(['A', 'B', 'C'])})
- assert (domain.space == ground_truth.space)
+def test_add_continuous_to_constant_error():
+ c = ConstantParameter(value=1)
+ cont = ContinuousParameter(lower_bound=2, upper_bound=3)
+ with pytest.raises(ValueError):
+ c + cont
@pytest.mark.parametrize("bounds", [((0., 1.), (0., 1.), (0., 1.)), ([0., 1.], [0., 1.], [0., 1.]),
np.array([[0., 1.], [0., 1.], [0., 1.]]), np.tile([0., 1.], (3, 1))])
def test_make_nd_continuous_domain(bounds):
domain = make_nd_continuous_domain(bounds=bounds, dimensionality=3)
- ground_truth = Domain(space={'x0': _ContinuousParameter(lower_bound=0.0, upper_bound=1.0),
- 'x1': _ContinuousParameter(lower_bound=0.0, upper_bound=1.0),
- 'x2': _ContinuousParameter(lower_bound=0.0, upper_bound=1.0)})
- assert (domain.space == ground_truth.space)
+ ground_truth = Domain()
+ ground_truth.add_float('x0', low=0.0, high=1.0)
+ ground_truth.add_float('x1', low=0.0, high=1.0)
+ ground_truth.add_float('x2', low=0.0, high=1.0)
+ assert (domain.input_space == ground_truth.input_space)
if __name__ == "__main__": # pragma: no cover
diff --git a/tests/design/test_domain.py b/tests/design/test_domain.py
new file mode 100644
index 00000000..d1c7ff31
--- /dev/null
+++ b/tests/design/test_domain.py
@@ -0,0 +1,240 @@
+import json
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from f3dasm._src.design.domain import Domain
+from f3dasm._src.design.parameter import (CategoricalParameter,
+ ConstantParameter,
+ ContinuousParameter,
+ DiscreteParameter)
+
+pytestmark = pytest.mark.smoke
+
+
+# Continuous space tests
+
+
+def test_check_default_lower_bound():
+ continuous = ContinuousParameter()
+ assert continuous.lower_bound == -np.inf
+
+
+def test_check_default_upper_bound():
+ continuous = ContinuousParameter()
+ assert continuous.upper_bound == np.inf
+
+
+def test_correct_continuous_space():
+ lower_bound = 3.3
+ upper_bound = 3.8
+ _ = ContinuousParameter(lower_bound=lower_bound, upper_bound=upper_bound)
+
+
+def test_higher_upper_bound_than_lower_bound_continuous_space():
+ lower_bound = 2.0
+ upper_bound = 1.5
+ with pytest.raises(ValueError):
+ _ = ContinuousParameter(
+ lower_bound=lower_bound, upper_bound=upper_bound)
+
+
+def test_same_lower_and_upper_bound_continuous_space():
+ lower_bound = 1.5
+ upper_bound = 1.5
+ with pytest.raises(ValueError):
+ _ = ContinuousParameter(
+ lower_bound=lower_bound, upper_bound=upper_bound)
+
+
+# Discrete space tests
+
+
+def test_correct_discrete_space():
+ lower_bound = 1
+ upper_bound = 100
+ _ = DiscreteParameter(lower_bound=lower_bound, upper_bound=upper_bound)
+
+
+def test_higher_upper_bound_than_lower_bound_discrete_space():
+ lower_bound = 2
+ upper_bound = 1
+ with pytest.raises(ValueError):
+ _ = DiscreteParameter(lower_bound=lower_bound,
+ upper_bound=upper_bound)
+
+
+def test_same_lower_and_upper_bound_discrete_space():
+ lower_bound = 1
+ upper_bound = 1
+ with pytest.raises(ValueError):
+ _ = DiscreteParameter(lower_bound=lower_bound,
+ upper_bound=upper_bound)
+
+
+def test_integer_types_arg1_float_discrete_space():
+ lower_bound = 1 # float
+ upper_bound = 2.5
+ parameter = DiscreteParameter(lower_bound=lower_bound,
+ upper_bound=upper_bound)
+
+ assert isinstance(parameter.lower_bound, int)
+
+
+def test_float_types_arg2_float_discrete_space():
+ lower_bound = 1
+ upper_bound = 2.0 # float
+ parameter = DiscreteParameter(lower_bound=lower_bound,
+ upper_bound=upper_bound)
+ assert isinstance(parameter.upper_bound, int)
+
+
+# Categorical space tests
+
+
+def test_correct_categorical_space():
+ categories = ["test1", "test2", "test3", "test4"]
+ _ = CategoricalParameter(categories=categories)
+
+
+def test_invalid_types_in_categories_categorical_space():
+ categories = ["test1", "test2", [3, 4], "test4"]
+ with pytest.raises(TypeError):
+ _ = CategoricalParameter(categories=categories)
+
+
+def test_duplicates_categories_categorical_space():
+ categories = ["test1", "test2", "test1"]
+ with pytest.raises(ValueError):
+ _ = CategoricalParameter(categories=categories)
+
+
+@pytest.mark.parametrize("args", [((0., 5.), (-1., 3.), (-1., 5.),),
+ ((0., 5.), (1., 3.), (0., 5.),),
+ ((-1., 3.), (0., 5.), (-1., 5.),),
+ ((0., 5.), (0., 5.), (0., 5.),)])
+def test_add_continuous(args):
+ a, b, expected = args
+ param_a = ContinuousParameter(*a)
+ param_b = ContinuousParameter(*b)
+
+ assert param_a + param_b == ContinuousParameter(*expected)
+
+
+@pytest.mark.parametrize("args", [((0., 5.), (6., 10.)),])
+def test_faulty_continuous_ranges(args):
+ a, b = args
+ param_a = ContinuousParameter(*a)
+ param_b = ContinuousParameter(*b)
+ with pytest.raises(ValueError):
+ param_a + param_b
+
+
+def test_faulty_continous_log():
+ a = ContinuousParameter(1., 5., log=True)
+ b = ContinuousParameter(0., 5., log=False)
+ with pytest.raises(ValueError):
+ a + b
+
+
+@pytest.mark.parametrize("args", [(('test1', 'test2'), ('test3',), ('test1', 'test2', 'test3'),),
+ (('test1', 'test3'), ('test3',),
+ ('test1', 'test3'),)])
+def test_add_categorical(args):
+ a, b, expected = args
+ param_a = CategoricalParameter(list(a))
+ param_b = CategoricalParameter(list(b))
+
+ assert param_a + param_b == CategoricalParameter(list(expected))
+
+
+@pytest.mark.parametrize(
+ "args",
+ [(CategoricalParameter(['test1', 'test2']), ConstantParameter('test3'), CategoricalParameter(['test1', 'test2', 'test3']),),
+ (CategoricalParameter(['test1', 'test2']), DiscreteParameter(
+ 1, 3), CategoricalParameter(['test1', 'test2', 1, 2]),),
+ (CategoricalParameter(['test1', 'test2']), ConstantParameter(
+ 'test1'), CategoricalParameter(['test1', 'test2']),),
+ (CategoricalParameter(['test1', 'test2']), CategoricalParameter([
+ 'test1']), CategoricalParameter(['test1', 'test2']),),
+ (ConstantParameter('test3'), CategoricalParameter(
+ ['test1', 'test2']), CategoricalParameter(['test1', 'test2', 'test3']))
+
+
+ ])
+def test_add_combination(args):
+ a, b, expected = args
+ assert a + b == expected
+
+
+def test_to_discrete():
+ a = ContinuousParameter(0., 5.)
+ c = DiscreteParameter(0, 5, 0.2)
+ b = a.to_discrete(0.2)
+ assert isinstance(b, DiscreteParameter)
+ assert b.lower_bound == 0
+ assert b.upper_bound == 5
+ assert b.step == 0.2
+ assert b == c
+
+
+def test_to_discrete_negative_stepsize():
+ a = ContinuousParameter(0., 5.)
+ with pytest.raises(ValueError):
+ a.to_discrete(-0.2)
+
+
+def test_default_stepsize_to_discrete():
+ default_stepsize = 1
+ a = ContinuousParameter(0., 5.)
+ c = DiscreteParameter(0, 5, default_stepsize)
+ b = a.to_discrete()
+ assert isinstance(b, DiscreteParameter)
+ assert b.lower_bound == 0
+ assert b.upper_bound == 5
+ assert b.step == default_stepsize
+ assert b == c
+
+
+def test_domain_store(tmp_path):
+ domain = Domain()
+ domain.add_float('param1', 0.0, 1.0)
+ domain.add_int('param2', 0, 10)
+ domain.add_category('param3', ['a', 'b', 'c'])
+ domain.add_constant('param4', 42)
+
+ json_file = tmp_path / "domain.json"
+ domain.store(json_file)
+
+ with open(json_file, 'r') as f:
+ data = json.load(f)
+
+ assert 'input_space' in data
+ assert 'output_space' in data
+ assert 'param1' in data['input_space']
+ assert 'param2' in data['input_space']
+ assert 'param3' in data['input_space']
+ assert 'param4' in data['input_space']
+
+
+def test_domain_from_json(tmp_path):
+ domain = Domain()
+ domain.add_float('param1', 0.0, 1.0)
+ domain.add_int('param2', 0, 10)
+ domain.add_category('param3', ['a', 'b', 'c'])
+ domain.add_constant('param4', 42)
+
+ json_file = tmp_path / "domain.json"
+ domain.store(json_file)
+
+ loaded_domain = Domain.from_file(json_file)
+
+ assert loaded_domain.input_space['param1'] == domain.input_space['param1']
+ assert loaded_domain.input_space['param2'] == domain.input_space['param2']
+ assert loaded_domain.input_space['param3'] == domain.input_space['param3']
+ assert loaded_domain.input_space['param4'] == domain.input_space['param4']
+
+
+if __name__ == "__main__": # pragma: no cover
+ pytest.main()
diff --git a/tests/design/test_jobqueue.py b/tests/design/test_jobqueue.py
deleted file mode 100644
index efc4b8e3..00000000
--- a/tests/design/test_jobqueue.py
+++ /dev/null
@@ -1,93 +0,0 @@
-import pandas as pd
-import pytest
-
-from f3dasm._src.experimentdata._jobqueue import _JobQueue
-from f3dasm.design import NoOpenJobsError, Status
-
-pytestmark = pytest.mark.smoke
-
-
-@pytest.fixture
-def sample_job_queue():
- jobs = pd.Series(['open', 'open', 'in progress',
- 'finished'], dtype='string')
- job_queue = _JobQueue(jobs)
-
- yield job_queue
-
- # Reset the job queue to its original state after each test
- job_queue.reset()
-
-
-@pytest.fixture
-def empty_job_queue():
- return _JobQueue()
-
-
-def test_job_queue_initialization(sample_job_queue: _JobQueue):
- assert isinstance(sample_job_queue.jobs, pd.Series)
-
-
-def test_job_queue_repr_html(sample_job_queue: _JobQueue):
- assert isinstance(sample_job_queue._repr_html_(), str)
-
-
-def test_job_queue_remove(sample_job_queue: _JobQueue):
- sample_job_queue.remove([1, 3])
- expected_jobs = pd.Series(['open', 'in progress'], index=[
- 0, 2], dtype='string')
- assert sample_job_queue.jobs.equals(expected_jobs)
-
-
-def test_job_queue_add():
- job_queue = _JobQueue()
- job_queue.add(5, 'open')
- assert job_queue.jobs.equals(
- pd.Series(['open', 'open', 'open', 'open', 'open'], dtype='string'))
-
-
-def test_job_queue_reset(sample_job_queue: _JobQueue):
- sample_job_queue.reset()
- assert sample_job_queue.jobs.empty
-
-
-def test_job_queue_get_open_job(sample_job_queue: _JobQueue):
- open_job_index = sample_job_queue.get_open_job()
- assert isinstance(open_job_index, int)
- assert open_job_index in sample_job_queue.jobs.index
-
-
-def test_job_queue_get_open_job_no_jobs():
- jobs = pd.Series(['finished', 'finished', 'in progress',
- 'finished'], dtype='string')
- job_queue = _JobQueue(jobs)
- with pytest.raises(NoOpenJobsError):
- job_queue.get_open_job()
-
-
-def test_job_queue_mark_as_in_progress(sample_job_queue: _JobQueue):
- # sample_job_queue.mark_as_in_progress(0)
- sample_job_queue.mark(0, Status.IN_PROGRESS)
- assert sample_job_queue.jobs.loc[0] == 'in progress'
-
-
-def test_job_queue_mark_as_finished(sample_job_queue: _JobQueue):
- # sample_job_queue.mark_as_finished(1)
- sample_job_queue.mark(1, Status.FINISHED)
- assert sample_job_queue.jobs.loc[1] == 'finished'
-
-
-def test_job_queue_mark_as_error(sample_job_queue: _JobQueue):
- # sample_job_queue.mark_as_error(2)
- sample_job_queue.mark(2, Status.ERROR)
- assert sample_job_queue.jobs.loc[2] == 'error'
-
-
-def test_job_queue_mark_all_in_progress_open(sample_job_queue: _JobQueue):
- sample_job_queue.mark_all_in_progress_open()
- assert sample_job_queue.jobs.equals(
- pd.Series(['open', 'open', 'open', 'finished'], dtype='string'))
-
-
-def test_job_queue_is_all_finished(sample_job_queue: _JobQueue):
- assert not sample_job_queue.is_all_finished()
diff --git a/tests/design/test_parameters.py b/tests/design/test_parameters.py
new file mode 100644
index 00000000..197b7056
--- /dev/null
+++ b/tests/design/test_parameters.py
@@ -0,0 +1,283 @@
+import pickle
+
+import pytest
+
+from f3dasm._src.design.parameter import (CategoricalParameter,
+ ConstantParameter,
+ ContinuousParameter,
+ DiscreteParameter, Parameter)
+
+pytestmark = pytest.mark.smoke
+
+
+def store_function(obj, path):
+ with open(path, 'wb') as f:
+ pickle.dump(obj, f)
+ return path
+
+
+def load_function(path):
+ with open(path, 'rb') as f:
+ return pickle.load(f)
+
+# Test Parameter Base Class
+
+
+@pytest.mark.parametrize("to_disk, store_function, load_function, raises", [
+ (False, None, None, False),
+ (True, store_function, load_function, False),
+ (False, store_function, None, True),
+ (False, None, load_function, True),
+])
+def test_parameter_init(to_disk, store_function, load_function, raises):
+ if raises:
+ with pytest.raises(ValueError):
+ Parameter(to_disk, store_function, load_function)
+ else:
+ param = Parameter(to_disk, store_function, load_function)
+ assert param.to_disk == to_disk
+ assert param.store_function == store_function
+ assert param.load_function == load_function
+
+
+def test_parameter_str():
+ param = Parameter()
+ assert str(param) == "Parameter(type=object, to_disk=False)"
+
+
+def test_parameter_repr():
+ param = Parameter()
+ assert repr(param) == "Parameter(to_disk=False)"
+
+
+def test_parameter_eq():
+ param1 = Parameter()
+ param2 = Parameter()
+ assert param1 == param2
+
+
+def test_parameter_add():
+ param1 = Parameter()
+ param2 = Parameter()
+ result = param1 + param2
+ assert result == param1
+
+
+def test_parameter_to_dict():
+ param = Parameter(to_disk=True)
+ param_dict = param.to_dict()
+ assert param_dict['type'] == 'object'
+ assert param_dict['to_disk'] is True
+
+
+def test_parameter_from_dict():
+ param_dict = {'type': 'object', 'to_disk': True, 'store_function': None,
+ 'load_function': None}
+ param = Parameter.from_dict(param_dict)
+ assert param.to_disk is True
+
+
+def test_parameter_with_functions_to_dict():
+ param = Parameter(to_disk=True, store_function=store_function,
+ load_function=load_function)
+ param_dict = param.to_dict()
+ assert param_dict['store_function'] is not None
+ assert param_dict['load_function'] is not None
+
+
+def test_parameter_with_functions_from_dict():
+ param = Parameter(to_disk=True, store_function=store_function,
+ load_function=load_function)
+ param_dict = param.to_dict()
+ loaded_param = Parameter.from_dict(param_dict)
+ assert loaded_param.to_disk is True
+ assert pickle.dumps(
+ loaded_param.store_function) == pickle.dumps(store_function)
+ assert pickle.dumps(
+ loaded_param.load_function) == pickle.dumps(load_function)
+
+# Test ConstantParameter
+
+
+@pytest.mark.parametrize("value, raises", [
+ (5, False),
+ ("test", False),
+ ({"a": 1}, True),
+])
+def test_constant_parameter_init(value, raises):
+ if raises:
+ with pytest.raises(TypeError):
+ ConstantParameter(value)
+ else:
+ param = ConstantParameter(value)
+ assert param.value == value
+ assert param.to_disk is False
+
+
+def test_constant_parameter_to_categorical():
+ param = ConstantParameter(42)
+ cat_param = param.to_categorical()
+ assert isinstance(cat_param, CategoricalParameter)
+ assert cat_param.categories == [42]
+
+
+def test_constant_parameter_str():
+ param = ConstantParameter(42)
+ assert str(param) == "ConstantParameter(value=42)"
+
+
+def test_constant_parameter_repr():
+ param = ConstantParameter(42)
+ assert repr(param) == "ConstantParameter(value=42)"
+
+
+def test_constant_parameter_eq():
+ param1 = ConstantParameter(42)
+ param2 = ConstantParameter(42)
+ assert param1 == param2
+
+# Test ContinuousParameter
+
+
+@pytest.mark.parametrize("lower_bound, upper_bound, log, raises", [
+ (0.0, 10.0, False, False),
+ (0.0, 10.0, True, True),
+ (0.0, 0.0, False, True),
+ (10.0, 5.0, False, True),
+ (-1.0, 5.0, True, True),
+])
+def test_continuous_parameter_init(lower_bound, upper_bound, log, raises):
+ if raises:
+ with pytest.raises(ValueError):
+ ContinuousParameter(lower_bound, upper_bound, log)
+ else:
+ param = ContinuousParameter(lower_bound, upper_bound, log)
+ assert param.lower_bound == lower_bound
+ assert param.upper_bound == upper_bound
+ assert param.log == log
+
+
+def test_continuous_parameter_to_discrete():
+ param = ContinuousParameter(0.0, 10.0)
+ discrete_param = param.to_discrete(step=2)
+ assert isinstance(discrete_param, DiscreteParameter)
+ assert discrete_param.lower_bound == 0.0
+ assert discrete_param.upper_bound == 10.0
+ assert discrete_param.step == 2
+
+
+def test_continuous_parameter_str():
+ param = ContinuousParameter(0.0, 10.0, log=False)
+ assert str(
+ param) == "ContinuousParameter(lower_bound=0.0, upper_bound=10.0, log=False)"
+
+
+def test_continuous_parameter_repr():
+ param = ContinuousParameter(0.0, 10.0, log=False)
+ assert repr(
+ param) == "ContinuousParameter(lower_bound=0.0, upper_bound=10.0, log=False)"
+
+
+def test_continuous_parameter_eq():
+ param1 = ContinuousParameter(0.0, 10.0, log=False)
+ param2 = ContinuousParameter(0.0, 10.0, log=False)
+ assert param1 == param2
+
+# Test DiscreteParameter
+
+
+@pytest.mark.parametrize("lower_bound, upper_bound, step, raises", [
+ (0, 10, 1, False),
+ (10, 0, 1, True),
+ (0, 10, -1, True),
+])
+def test_discrete_parameter_init(lower_bound, upper_bound, step, raises):
+ if raises:
+ with pytest.raises(ValueError):
+ DiscreteParameter(lower_bound, upper_bound, step)
+ else:
+ param = DiscreteParameter(lower_bound, upper_bound, step)
+ assert param.lower_bound == lower_bound
+ assert param.upper_bound == upper_bound
+ assert param.step == step
+
+
+def test_discrete_parameter_str():
+ param = DiscreteParameter(0, 10, 2)
+ assert str(param) == "DiscreteParameter(lower_bound=0, upper_bound=10, step=2)"
+
+
+def test_discrete_parameter_repr():
+ param = DiscreteParameter(0, 10, 2)
+ assert repr(
+ param) == "DiscreteParameter(lower_bound=0, upper_bound=10, step=2)"
+
+
+def test_discrete_parameter_eq():
+ param1 = DiscreteParameter(0, 10, 2)
+ param2 = DiscreteParameter(0, 10, 2)
+ assert param1 == param2
+
+# Test CategoricalParameter
+
+
+@pytest.mark.parametrize("categories, raises", [
+ (["a", "b", "c"], False),
+ ([1, 2, 3], False),
+ (["a", "a", "b"], True),
+])
+def test_categorical_parameter_init(categories, raises):
+ if raises:
+ with pytest.raises(ValueError):
+ CategoricalParameter(categories)
+ else:
+ param = CategoricalParameter(categories)
+ assert set(param.categories) == set(categories)
+
+
+def test_categorical_parameter_str():
+ param = CategoricalParameter(["a", "b", "c"])
+ assert str(param) == "CategoricalParameter(categories=['a', 'b', 'c'])"
+
+
+def test_categorical_parameter_repr():
+ param = CategoricalParameter(["a", "b", "c"])
+ assert repr(param) == "CategoricalParameter(categories=['a', 'b', 'c'])"
+
+
+def test_categorical_parameter_eq():
+ param1 = CategoricalParameter(["a", "b", "c"])
+ param2 = CategoricalParameter(["c", "b", "a"])
+ assert param1 == param2
+
+
+def test_add_constant_to_constant():
+ param1 = ConstantParameter(5)
+ param2 = ConstantParameter(5)
+ result = param1 + param2
+ assert result == param1
+
+
+def test_add_constant_to_categorical():
+ const_param = ConstantParameter(5)
+ cat_param = CategoricalParameter([1, 2, 3])
+ result = const_param + cat_param
+ assert isinstance(result, CategoricalParameter)
+ assert set(result.categories) == {1, 2, 3, 5}
+
+
+def test_add_categorical_to_categorical():
+ cat_param1 = CategoricalParameter(["a", "b"])
+ cat_param2 = CategoricalParameter(["b", "c"])
+ result = cat_param1 + cat_param2
+ assert isinstance(result, CategoricalParameter)
+ assert set(result.categories) == {"a", "b", "c"}
+
+
+def test_add_continuous_to_continuous():
+ param1 = ContinuousParameter(0.0, 10.0)
+ param2 = ContinuousParameter(5.0, 15.0)
+ result = param1 + param2
+ assert isinstance(result, ContinuousParameter)
+ assert result.lower_bound == 0.0
+ assert result.upper_bound == 15.0
diff --git a/tests/design/test_space.py b/tests/design/test_space.py
deleted file mode 100644
index 5670fa77..00000000
--- a/tests/design/test_space.py
+++ /dev/null
@@ -1,212 +0,0 @@
-import numpy as np
-import pytest
-
-from f3dasm._src.design.parameter import (_CategoricalParameter,
- _ConstantParameter,
- _ContinuousParameter,
- _DiscreteParameter)
-
-pytestmark = pytest.mark.smoke
-
-
-# Continuous space tests
-
-
-def test_check_default_lower_bound():
- continuous = _ContinuousParameter()
- assert continuous.lower_bound == -np.inf
-
-
-def test_check_default_upper_bound():
- continuous = _ContinuousParameter()
- assert continuous.upper_bound == np.inf
-
-
-def test_correct_continuous_space():
- lower_bound = 3.3
- upper_bound = 3.8
- _ = _ContinuousParameter(lower_bound=lower_bound, upper_bound=upper_bound)
-
-
-def test_higher_upper_bound_than_lower_bound_continuous_space():
- lower_bound = 2.0
- upper_bound = 1.5
- with pytest.raises(ValueError):
- _ = _ContinuousParameter(
- lower_bound=lower_bound, upper_bound=upper_bound)
-
-
-def test_same_lower_and_upper_bound_continuous_space():
- lower_bound = 1.5
- upper_bound = 1.5
- with pytest.raises(ValueError):
- _ = _ContinuousParameter(
- lower_bound=lower_bound, upper_bound=upper_bound)
-
-
-def test_invalid_types_string_continuous_space():
- lower_bound = "1" # string
- upper_bound = 1.5
- with pytest.raises(TypeError):
- _ = _ContinuousParameter(
- lower_bound=lower_bound, upper_bound=upper_bound)
-
-
-# Discrete space tests
-
-
-def test_correct_discrete_space():
- lower_bound = 1
- upper_bound = 100
- _ = _DiscreteParameter(lower_bound=lower_bound, upper_bound=upper_bound)
-
-
-def test_higher_upper_bound_than_lower_bound_discrete_space():
- lower_bound = 2
- upper_bound = 1
- with pytest.raises(ValueError):
- _ = _DiscreteParameter(lower_bound=lower_bound,
- upper_bound=upper_bound)
-
-
-def test_same_lower_and_upper_bound_discrete_space():
- lower_bound = 1
- upper_bound = 1
- with pytest.raises(ValueError):
- _ = _DiscreteParameter(lower_bound=lower_bound,
- upper_bound=upper_bound)
-
-
-def test_invalid_types_arg1_float_discrete_space():
- lower_bound = 1 # float
- upper_bound = 1.5
- with pytest.raises(TypeError):
- _ = _DiscreteParameter(lower_bound=lower_bound,
- upper_bound=upper_bound)
-
-
-def test_invalid_types_arg2_float_discrete_space():
- lower_bound = 1
- upper_bound = 2.0 # float
- with pytest.raises(TypeError):
- _ = _DiscreteParameter(lower_bound=lower_bound,
- upper_bound=upper_bound)
-
-
-def test_invalid_types_string_discrete_space():
- lower_bound = "1" # string
- upper_bound = 1
- with pytest.raises(TypeError):
- _ = _DiscreteParameter(lower_bound=lower_bound,
- upper_bound=upper_bound)
-
-
-# Categorical space tests
-
-
-def test_correct_categorical_space():
- categories = ["test1", "test2", "test3", "test4"]
- _ = _CategoricalParameter(categories=categories)
-
-
-def test_invalid_types_in_categories_categorical_space():
- categories = ["test1", "test2", [3, 4], "test4"]
- with pytest.raises(TypeError):
- _ = _CategoricalParameter(categories=categories)
-
-
-def test_duplicates_categories_categorical_space():
- categories = ["test1", "test2", "test1"]
- with pytest.raises(ValueError):
- _ = _CategoricalParameter(categories=categories)
-
-
-@pytest.mark.parametrize("args", [((0., 5.), (-1., 3.), (-1., 5.),),
- ((0., 5.), (1., 3.), (0., 5.),),
- ((-1., 3.), (0., 5.), (-1., 5.),),
- ((0., 5.), (0., 5.), (0., 5.),)])
-def test_add_continuous(args):
- a, b, expected = args
- param_a = _ContinuousParameter(*a)
- param_b = _ContinuousParameter(*b)
-
- assert param_a + param_b == _ContinuousParameter(*expected)
-
-
-@pytest.mark.parametrize("args", [((0., 5.), (6., 10.)),])
-def test_faulty_continuous_ranges(args):
- a, b = args
- param_a = _ContinuousParameter(*a)
- param_b = _ContinuousParameter(*b)
- with pytest.raises(ValueError):
- param_a + param_b
-
-
-def test_faulty_continous_log():
- a = _ContinuousParameter(1., 5., log=True)
- b = _ContinuousParameter(0., 5., log=False)
- with pytest.raises(ValueError):
- a + b
-
-
-@pytest.mark.parametrize("args", [(('test1', 'test2'), ('test3',), ('test1', 'test2', 'test3'),),
- (('test1', 'test3'), ('test3',),
- ('test1', 'test3'),)])
-def test_add_categorical(args):
- a, b, expected = args
- param_a = _CategoricalParameter(list(a))
- param_b = _CategoricalParameter(list(b))
-
- assert param_a + param_b == _CategoricalParameter(list(expected))
-
-
-@pytest.mark.parametrize(
- "args",
- [(_CategoricalParameter(['test1', 'test2']), _ConstantParameter('test3'), _CategoricalParameter(['test1', 'test2', 'test3']),),
- (_CategoricalParameter(['test1', 'test2']), _DiscreteParameter(
- 1, 3), _CategoricalParameter(['test1', 'test2', 1, 2]),),
- (_CategoricalParameter(['test1', 'test2']), _ConstantParameter(
- 'test1'), _CategoricalParameter(['test1', 'test2']),),
- (_CategoricalParameter(['test1', 'test2']), _CategoricalParameter([
- 'test1']), _CategoricalParameter(['test1', 'test2']),),
- (_ConstantParameter('test3'), _CategoricalParameter(
- ['test1', 'test2']), _CategoricalParameter(['test1', 'test2', 'test3']))
-
-
- ])
-def test_add_combination(args):
- a, b, expected = args
- assert a + b == expected
-
-
-def test_to_discrete():
- a = _ContinuousParameter(0., 5.)
- c = _DiscreteParameter(0, 5, 0.2)
- b = a.to_discrete(0.2)
- assert isinstance(b, _DiscreteParameter)
- assert b.lower_bound == 0
- assert b.upper_bound == 5
- assert b.step == 0.2
- assert b == c
-
-
-def test_to_discrete_negative_stepsize():
- a = _ContinuousParameter(0., 5.)
- with pytest.raises(ValueError):
- a.to_discrete(-0.2)
-
-
-def test_default_stepsize_to_discrete():
- default_stepsize = 1
- a = _ContinuousParameter(0., 5.)
- c = _DiscreteParameter(0, 5, default_stepsize)
- b = a.to_discrete()
- assert isinstance(b, _DiscreteParameter)
- assert b.lower_bound == 0
- assert b.upper_bound == 5
- assert b.step == default_stepsize
- assert b == c
-
-
-if __name__ == "__main__": # pragma: no cover
- pytest.main()
diff --git a/tests/design/test_trial.py b/tests/design/test_trial.py
deleted file mode 100644
index ccbc7b85..00000000
--- a/tests/design/test_trial.py
+++ /dev/null
@@ -1,32 +0,0 @@
-import numpy as np
-import pytest
-
-from f3dasm import ExperimentSample
-
-pytestmark = pytest.mark.smoke
-
-
-def test_design_initialization(design_data):
- dict_input, dict_output, job_number = design_data
- design = ExperimentSample(dict_input, dict_output, job_number)
- assert design.input_data == dict_input
- assert design._dict_output == dict_output
- assert design.job_number == job_number
-
-
-def test_design_to_numpy(design_data):
- dict_input, dict_output, job_number = design_data
- design = ExperimentSample(dict_input, dict_output, job_number)
- input_array, output_array = design.to_numpy()
-
- check_output_array = np.array([v for v, _ in dict_output.values()])
- assert np.array_equal(output_array, check_output_array)
-
-
-def test_design_set(design_data):
- dict_input, dict_output, job_number = design_data
- design = ExperimentSample(dict_input, dict_output, job_number)
- design['output3'] = 5
-
- # Check if the output data is updated
- design.output_data['output3'] == 5
diff --git a/tests/experimentdata/conftest.py b/tests/experimentdata/conftest.py
index f2b70947..22abfa39 100644
--- a/tests/experimentdata/conftest.py
+++ b/tests/experimentdata/conftest.py
@@ -1,134 +1,162 @@
-from __future__ import annotations
+# from __future__ import annotations
-import numpy as np
-import pandas as pd
-import pytest
-import xarray as xr
+# import numpy as np
+# import pandas as pd
+# import pytest
+# import xarray as xr
-from f3dasm import ExperimentData
-from f3dasm._src.design.parameter import (_CategoricalParameter,
- _ContinuousParameter,
- _DiscreteParameter)
-from f3dasm.design import Domain, make_nd_continuous_domain
+# from f3dasm import ExperimentData
+# from f3dasm._src.design.parameter import (CategoricalParameter,
+# ContinuousParameter,
+# DiscreteParameter)
+# from f3dasm.design import Domain, make_nd_continuous_domain
-SEED = 42
+# SEED = 42
-@pytest.fixture(scope="package")
-def seed() -> int:
- return SEED
+# @pytest.fixture(scope="package")
+# def seed() -> int:
+# return SEED
-@pytest.fixture(scope="package")
-def domain() -> Domain:
+# @pytest.fixture(scope="package")
+# def domain() -> Domain:
- space = {
- 'x1': _ContinuousParameter(-5.12, 5.12),
- 'x2': _DiscreteParameter(-3, 3),
- 'x3': _CategoricalParameter(["red", "green", "blue"])
- }
+# space = {
+# 'x1': ContinuousParameter(-5.12, 5.12),
+# 'x2': DiscreteParameter(-3, 3),
+# 'x3': CategoricalParameter(["red", "green", "blue"])
+# }
- return Domain(space=space)
+# return Domain(input_space=space)
-@pytest.fixture(scope="package")
-def domain_continuous() -> Domain:
- return make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]), dimensionality=3)
+# @pytest.fixture(scope="package")
+# def domain_continuous() -> Domain:
+# return make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]), dimensionality=3)
-@pytest.fixture(scope="package")
-def experimentdata(domain: Domain) -> ExperimentData:
- e_data = ExperimentData(domain)
- e_data.sample(sampler='random', n_samples=10, seed=SEED)
- return e_data
-
-
-@pytest.fixture(scope="package")
-def experimentdata2(domain: Domain) -> ExperimentData:
- return ExperimentData.from_sampling(sampler='random', domain=domain, n_samples=10, seed=SEED)
-
-
-@pytest.fixture(scope="package")
-def experimentdata_continuous(domain_continuous: Domain) -> ExperimentData:
- return ExperimentData.from_sampling(sampler='random', domain=domain_continuous, n_samples=10, seed=SEED)
-
-
-@pytest.fixture(scope="package")
-def experimentdata_expected() -> ExperimentData:
- domain_continuous = make_nd_continuous_domain(
- bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]), dimensionality=3)
- data = ExperimentData.from_sampling(
- sampler='random', domain=domain_continuous, n_samples=10, seed=SEED)
- for es, output in zip(data, np.zeros((10, 1))):
- es.store(name='y', object=float(output))
- data._set_experiment_sample(es)
- data.add(input_data=np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]),
- output_data=np.array([[0.0], [0.0]]), domain=domain_continuous)
-
- data._input_data.round(6)
- # data._input_data.data = [[round(num, 6) if isinstance(
- # num, float) else num for num in sublist]
- # for sublist in data._input_data.data]
- return data
-
-
-@pytest.fixture(scope="package")
-def experimentdata_expected_no_output() -> ExperimentData:
- domain_continuous = make_nd_continuous_domain(
- bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]), dimensionality=3)
- data = ExperimentData.from_sampling(
- sampler='random', domain=domain_continuous, n_samples=10, seed=SEED)
- data.add(input_data=np.array(
- [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]), domain=domain_continuous)
-
- data._input_data.round(6)
- # data._input_data.data = [[round(num, 6) if isinstance(
- # num, float) else num for num in sublist]
- # for sublist in data._input_data.data]
- return data
-
-
-@pytest.fixture(scope="package")
-def experimentdata_expected_only_domain() -> ExperimentData:
- domain_continuous = make_nd_continuous_domain(
- bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]), dimensionality=3)
- return ExperimentData(domain=domain_continuous)
-
-
-@pytest.fixture(scope="package")
-def numpy_array(domain_continuous: Domain) -> np.ndarray:
- rng = np.random.default_rng(SEED)
- return rng.random((10, len(domain_continuous)))
-
-
-@pytest.fixture(scope="package")
-def numpy_output_array(domain_continuous: Domain) -> np.ndarray:
- return np.zeros((10, 1))
-
-
-@pytest.fixture(scope="package")
-def xarray_dataset(domain_continuous: Domain) -> xr.Dataset:
- rng = np.random.default_rng(SEED)
- # np.random.seed(SEED)
- input_data = rng.random((10, len(domain_continuous)))
- input_names = domain_continuous.names
-
- output_data = pd.DataFrame()
- output_names = output_data.columns.to_list()
-
- return xr.Dataset({'input': xr.DataArray(input_data, dims=['iterations', 'input_dim'], coords={
- 'iterations': range(len(input_data)), 'input_dim': input_names}),
- 'output': xr.DataArray(output_data, dims=['iterations', 'output_dim'], coords={
- 'iterations': range(len(output_data)), 'output_dim': output_names})})
-
-
-@pytest.fixture(scope="package")
-def pandas_dataframe(domain_continuous: Domain) -> pd.DataFrame:
- # np.random.seed(SEED)
- rng = np.random.default_rng(SEED)
- return pd.DataFrame(rng.random((10, len(domain_continuous))), columns=domain_continuous.names)
-
-
-@pytest.fixture(scope="package")
-def continuous_parameter() -> _ContinuousParameter:
- return _ContinuousParameter(lower_bound=0., upper_bound=1.)
+# @pytest.fixture(scope="package")
+# def experimentdata(domain: Domain) -> ExperimentData:
+# e_data = ExperimentData(domain)
+# e_data.sample(sampler='random', n_samples=10, seed=SEED)
+# return e_data
+
+
+# @pytest.fixture(scope="package")
+# def experimentdata2(domain: Domain) -> ExperimentData:
+# return ExperimentData.from_sampling(sampler='random', domain=domain, n_samples=10, seed=SEED)
+
+
+# @pytest.fixture(scope="package")
+# def experimentdata_continuous(domain_continuous: Domain) -> ExperimentData:
+# experiment_data = ExperimentData.from_sampling(
+# sampler='random', domain=domain_continuous, n_samples=10, seed=SEED)
+# experiment_data.round(3)
+# return experiment_data
+
+
+# @pytest.fixture(scope="package")
+# def experimentdata_expected() -> ExperimentData:
+# domain_continuous = make_nd_continuous_domain(
+# bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]), dimensionality=3)
+# data = ExperimentData.from_sampling(
+# sampler='random', domain=domain_continuous, n_samples=10, seed=SEED)
+# for (id, es), output in zip(data, np.zeros((10, 1))):
+# es.store(name='y', object=float(output))
+# data.store_experimentsample(experiment_sample=es,
+# id=id)
+# data.add(input_data=np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]),
+# output_data=np.array([[0.0], [0.0]]), domain=domain_continuous)
+
+# # data._input_data.round(6)
+# # data._input_data.data = [[round(num, 6) if isinstance(
+# # num, float) else num for num in sublist]
+# # for sublist in data._input_data.data]
+# data.round(3)
+# data.mark_all('finished')
+# return data
+
+
+# @pytest.fixture(scope="package")
+# def experimentdata_expected_no_output() -> ExperimentData:
+# domain_continuous = make_nd_continuous_domain(
+# bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]), dimensionality=3)
+# data = ExperimentData.from_sampling(
+# sampler='random', domain=domain_continuous, n_samples=10, seed=SEED)
+# data.add(input_data=np.array(
+# [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]), domain=domain_continuous)
+
+# data._input_data.round(6)
+# # data._input_data.data = [[round(num, 6) if isinstance(
+# # num, float) else num for num in sublist]
+# # for sublist in data._input_data.data]
+# return data
+
+
+# @pytest.fixture(scope="package")
+# def experimentdata_expected_only_domain() -> ExperimentData:
+# domain_continuous = make_nd_continuous_domain(
+# bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]), dimensionality=3)
+# return ExperimentData(domain=domain_continuous)
+
+
+# @pytest.fixture(scope="package")
+# def numpy_array(domain_continuous: Domain) -> np.ndarray:
+# rng = np.random.default_rng(SEED)
+# return rng.random((10, len(domain_continuous)))
+
+
+# @pytest.fixture(scope="package")
+# def numpy_output_array(domain_continuous: Domain) -> np.ndarray:
+# return np.zeros((10, 1))
+
+
+# @pytest.fixture(scope="package")
+# def xarray_dataset(domain_continuous: Domain) -> xr.Dataset:
+# rng = np.random.default_rng(SEED)
+# input_data = rng.random((10, len(domain_continuous))).round(3)
+# input_names = domain_continuous.input_names
+
+# output_data = pd.DataFrame()
+# output_names = output_data.columns.to_list()
+
+# iterations = np.arange(len(input_data)).astype(
+# np.int32) # Cast to desired dtype
+# # Ensure strings for input_dim
+# input_names = np.array(input_names, dtype=object)
+
+# return xr.Dataset(
+# {
+# 'input': xr.DataArray(
+# input_data,
+# dims=['iterations', 'input_dim'],
+# coords={
+# 'iterations': iterations,
+# 'input_dim': input_names,
+# }
+# ),
+# 'output': xr.DataArray(
+# output_data,
+# dims=['iterations', 'output_dim'],
+# coords={
+# 'iterations': iterations[:len(output_data)],
+# # Ensure strings for output_dim
+# 'output_dim': np.array(output_names, dtype=object),
+# }
+# )
+# }
+# )
+
+
+# @pytest.fixture(scope="package")
+# def pandas_dataframe(domain_continuous: Domain) -> pd.DataFrame:
+# # np.random.seed(SEED)
+# rng = np.random.default_rng(SEED)
+# return pd.DataFrame(rng.random((10, len(domain_continuous))).round(3),
+# columns=domain_continuous.input_names)
+
+
+# @pytest.fixture(scope="package")
+# def continuous_parameter() -> ContinuousParameter:
+# return ContinuousParameter(lower_bound=0., upper_bound=1.)
diff --git a/tests/experimentdata/test__jobqueue.py b/tests/experimentdata/test__jobqueue.py
deleted file mode 100644
index b38268bc..00000000
--- a/tests/experimentdata/test__jobqueue.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import pandas as pd
-
-from f3dasm._src.experimentdata._jobqueue import _JobQueue
-
-
-def test_select_all_with_matching_status():
- # Create a job queue with some jobs
- job_queue = _JobQueue()
- job_queue.jobs = pd.Series(['in progress', 'running', 'completed', 'in progress', 'failed'])
-
- # Select all jobs with status 'in progress'
- selected_jobs = job_queue.select_all('in progress')
-
- # Check if the selected jobs match the expected result
- assert (selected_jobs.jobs == ['in progress', 'in progress']).all()
-
-def test_select_all_with_no_matching_status():
- # Create a job queue with some jobs
- job_queue = _JobQueue()
- job_queue.jobs = pd.Series(['in progress', 'running', 'completed', 'in progress', 'failed'])
-
- # Select all jobs with status 'cancelled'
- selected_jobs = job_queue.select_all('cancelled')
-
- # Check if the selected jobs match the expected result
- assert selected_jobs.jobs.empty
-
-def test_select_all_with_empty_job_queue():
- # Create an empty job queue
- job_queue = _JobQueue()
-
- # Select all jobs with status 'in progress'
- selected_jobs = job_queue.select_all('in progress')
-
- # Check if the selected jobs match the expected result
- assert selected_jobs.jobs.empty
diff --git a/tests/experimentdata/test_experimentdata.py b/tests/experimentdata/test_experimentdata.py
index 4b682997..2aa2044d 100644
--- a/tests/experimentdata/test_experimentdata.py
+++ b/tests/experimentdata/test_experimentdata.py
@@ -1,734 +1,800 @@
-from __future__ import annotations
+# from __future__ import annotations
-import csv
-import pickle
-from pathlib import Path
-from typing import Iterable
+# import csv
+# import pickle
+# from pathlib import Path
+# from typing import Callable, Iterable, Union
-import numpy as np
-import pandas as pd
-import pytest
-import xarray as xr
+# import numpy as np
+# import pandas as pd
+# import pytest
+# import xarray as xr
-from f3dasm import ExperimentData, ExperimentSample
-from f3dasm._src.design.parameter import _ContinuousParameter
-from f3dasm._src.experimentdata._data import DataTypes, _Data
-from f3dasm._src.experimentdata._jobqueue import _JobQueue
-from f3dasm.design import Domain, Status, make_nd_continuous_domain
+# from f3dasm import ExperimentData, ExperimentSample
+# from f3dasm._src.design.parameter import ContinuousParameter
+# from f3dasm._src.experimentdata.utils import DataTypes
+# from f3dasm.design import Domain, make_nd_continuous_domain
-pytestmark = pytest.mark.smoke
+# pytestmark = pytest.mark.smoke
-SEED = 42
+# SEED = 42
-def test_check_experimentdata(experimentdata: ExperimentData):
- assert isinstance(experimentdata, ExperimentData)
+# def test_check_experimentdata(experimentdata: ExperimentData):
+# assert isinstance(experimentdata, ExperimentData)
-# Write test functions
+# # Write test functions
-def test_experiment_data_init(experimentdata: ExperimentData, domain: Domain):
- assert experimentdata.domain == domain
- assert experimentdata.project_dir == Path.cwd()
- # Add more assertions as needed
+# def test_experiment_data_init(experimentdata: ExperimentData, domain: Domain):
+# assert experimentdata.domain == domain
+# assert experimentdata.project_dir == Path.cwd()
+# # Add more assertions as needed
-def test_experiment_data_add(experimentdata: ExperimentData,
- experimentdata2: ExperimentData, domain: Domain):
- experimentdata_total = ExperimentData(domain)
- experimentdata_total.add_experiments(experimentdata)
- experimentdata_total.add_experiments(experimentdata2)
- assert experimentdata_total == experimentdata + experimentdata2
+# def test_experiment_data_add(experimentdata: ExperimentData,
+# experimentdata2: ExperimentData, domain: Domain):
+# experimentdata_total = ExperimentData(domain)
+# experimentdata_total.add_experiments(experimentdata)
+# experimentdata_total.add_experiments(experimentdata2)
+# assert experimentdata_total == experimentdata + experimentdata2
-def test_experiment_data_len_empty(domain: Domain):
- experiment_data = ExperimentData(domain)
- assert len(experiment_data) == 0 # Update with the expected length
+# def test_experiment_data_len_empty(domain: Domain):
+# experiment_data = ExperimentData(domain)
+# assert len(experiment_data) == 0 # Update with the expected length
-def test_experiment_data_len_equals_input_data(experimentdata: ExperimentData):
- assert len(experimentdata) == len(experimentdata._input_data)
+# def test_experiment_data_len_equals_input_data(experimentdata: ExperimentData):
+# assert len(experimentdata) == len(experimentdata.data)
-@pytest.mark.parametrize("slice_type", [3, [0, 1, 3]])
-def test_experiment_data_select(slice_type: int | Iterable[int], experimentdata: ExperimentData):
- input_data = experimentdata._input_data[slice_type]
- output_data = experimentdata._output_data[slice_type]
- jobs = experimentdata._jobs[slice_type]
- constructed_experimentdata = ExperimentData(
- input_data=input_data, output_data=output_data, jobs=jobs, domain=experimentdata.domain)
- assert constructed_experimentdata == experimentdata.select(slice_type)
+# @pytest.mark.parametrize("slice_type", [3, [0, 1, 3]])
+# def test_experiment_data_select(slice_type: int | Iterable[int], experimentdata: ExperimentData):
+# sliced_experimentdata = experimentdata.select(slice_type)
+# constructed_experimentdata = ExperimentData.from_data(data=sliced_experimentdata.data,
+# domain=experimentdata.domain)
+# assert sliced_experimentdata == constructed_experimentdata
-# Constructors
-# ======================================================================================
+# # Constructors
+# # ======================================================================================
-def test_from_file(experimentdata_continuous: ExperimentData, seed: int, tmp_path: Path):
- # experimentdata_continuous.filename = tmp_path / 'test001'
- experimentdata_continuous.store(tmp_path / 'experimentdata')
+# def test_from_file(experimentdata_continuous: ExperimentData, seed: int, tmp_path: Path):
+# # experimentdata_continuous.filename = tmp_path / 'test001'
+# experimentdata_continuous.store(tmp_path / 'experimentdata')
- experimentdata_from_file = ExperimentData.from_file(
- tmp_path / 'experimentdata')
+# experimentdata_from_file = ExperimentData.from_file(
+# tmp_path / 'experimentdata')
- # Check if the input_data attribute of ExperimentData matches the expected_data
- pd.testing.assert_frame_equal(
- experimentdata_continuous._input_data.to_dataframe(), experimentdata_from_file._input_data.to_dataframe(), check_dtype=False, atol=1e-6)
- pd.testing.assert_frame_equal(experimentdata_continuous._output_data.to_dataframe(),
- experimentdata_from_file._output_data.to_dataframe())
- pd.testing.assert_series_equal(
- experimentdata_continuous._jobs.jobs, experimentdata_from_file._jobs.jobs)
- # assert experimentdata_continuous.input_data == experimentdata_from_file.input_data
- assert experimentdata_continuous._output_data == experimentdata_from_file._output_data
- assert experimentdata_continuous.domain == experimentdata_from_file.domain
- assert experimentdata_continuous._jobs == experimentdata_from_file._jobs
+# experimentdata_from_file.round(3)
+# assert experimentdata_from_file == experimentdata_continuous
+# # # Check if the input_data attribute of ExperimentData matches the expected_data
+# # pd.testing.assert_frame_equal(
+# # experimentdata_continuous._input_data.to_dataframe(), experimentdata_from_file._input_data.to_dataframe(), check_dtype=False, atol=1e-6)
+# # pd.testing.assert_frame_equal(experimentdata_continuous._output_data.to_dataframe(),
+# # experimentdata_from_file._output_data.to_dataframe())
+# # pd.testing.assert_series_equal(
+# # experimentdata_continuous._jobs.jobs, experimentdata_from_file._jobs.jobs)
+# # # assert experimentdata_continuous.input_data == experimentdata_from_file.input_data
+# # assert experimentdata_continuous._output_data == experimentdata_from_file._output_data
+# # assert experimentdata_continuous.domain == experimentdata_from_file.domain
+# # assert experimentdata_continuous._jobs == experimentdata_from_file._jobs
-def test_from_file_wrong_name(experimentdata_continuous: ExperimentData, seed: int, tmp_path: Path):
- experimentdata_continuous.filename = tmp_path / 'test001'
- experimentdata_continuous.store()
- with pytest.raises(FileNotFoundError):
- _ = ExperimentData.from_file(tmp_path / 'experimentdata')
+# def test_from_file_wrong_name(experimentdata_continuous: ExperimentData, seed: int, tmp_path: Path):
+# experimentdata_continuous.set_project_dir(tmp_path / 'test001')
+# experimentdata_continuous.store()
+# with pytest.raises(FileNotFoundError):
+# _ = ExperimentData.from_file(tmp_path / 'experimentdata')
-def test_from_sampling(experimentdata_continuous: ExperimentData, seed: int):
- # sampler = RandomUniform(domain=experimentdata_continuous.domain, number_of_samples=10, seed=seed)
- experimentdata_from_sampling = ExperimentData.from_sampling(sampler='random',
- domain=experimentdata_continuous.domain,
- n_samples=10, seed=seed)
- assert experimentdata_from_sampling == experimentdata_continuous
+# def test_from_sampling(experimentdata_continuous: ExperimentData, seed: int):
+# # sampler = RandomUniform(domain=experimentdata_continuous.domain, number_of_samples=10, seed=seed)
+# experimentdata_from_sampling = ExperimentData.from_sampling(sampler='random',
+# domain=experimentdata_continuous.domain,
+# n_samples=10, seed=seed)
-@pytest.fixture
-def sample_csv_inputdata(tmp_path):
- # Create sample CSV files for testing
- input_csv_file = tmp_path / 'experimentdata_data.csv'
+# experimentdata_from_sampling.round(3)
+# assert experimentdata_from_sampling == experimentdata_continuous
- # Create sample input and output dataframes
- input_data = pd.DataFrame(
- {'input_col1': [1, 2, 3], 'input_col2': [4, 5, 6]})
- return input_csv_file, input_data
+# @pytest.fixture
+# def sample_csv_inputdata(tmp_path):
+# # Create sample CSV files for testing
+# input_csv_file = tmp_path / 'experimentdata_data.csv'
+# # Create sample input and output dataframes
+# input_data = pd.DataFrame(
+# {'input_col1': [1, 2, 3], 'input_col2': [4, 5, 6]})
-@pytest.fixture
-def sample_csv_outputdata(tmp_path):
- # Create sample CSV files for testing
- output_csv_file = tmp_path / 'experimentdata_output.csv'
+# return input_csv_file, input_data
- # Create sample input and output dataframes
- output_data = pd.DataFrame(
- {'output_col1': [7, 8, 9], 'output_col2': [10, 11, 12]})
- return output_csv_file, output_data
+# @pytest.fixture
+# def sample_csv_outputdata(tmp_path):
+# # Create sample CSV files for testing
+# output_csv_file = tmp_path / 'experimentdata_output.csv'
+# # Create sample input and output dataframes
+# output_data = pd.DataFrame(
+# {'output_col1': [7, 8, 9], 'output_col2': [10, 11, 12]})
-def test_from_object(experimentdata_continuous: ExperimentData):
- input_data = experimentdata_continuous._input_data
- output_data = experimentdata_continuous._output_data
- jobs = experimentdata_continuous._jobs
- domain = experimentdata_continuous.domain
- experiment_data = ExperimentData(
- input_data=input_data, output_data=output_data, jobs=jobs, domain=domain)
- assert experiment_data == ExperimentData(
- input_data=input_data, output_data=output_data, jobs=jobs, domain=domain)
- assert experiment_data == experimentdata_continuous
+# return output_csv_file, output_data
-# Exporters
-# ======================================================================================
+# def test_from_object(experimentdata_continuous: ExperimentData):
+# df_input, df_output = experimentdata_continuous.to_pandas()
-def test_to_numpy(experimentdata_continuous: ExperimentData, numpy_array: np.ndarray):
- x, y = experimentdata_continuous.to_numpy()
+# experiment_data = ExperimentData(
+# input_data=df_input,
+# output_data=df_output,
+# domain=experimentdata_continuous.domain,
+# project_dir=experimentdata_continuous.project_dir)
- # cast x to floats
- x = x.astype(float)
- # assert if x and numpy_array have all the same values
- assert np.allclose(x, numpy_array)
-
-
-def test_to_xarray(experimentdata_continuous: ExperimentData, xarray_dataset: xr.DataSet):
- exported_dataset = experimentdata_continuous.to_xarray()
- # assert if xr_dataset is equal to xarray
- assert exported_dataset.equals(xarray_dataset)
+# assert experimentdata_continuous == experiment_data
+# # input_data = experimentdata_continuous._input_data
+# # output_data = experimentdata_continuous._output_data
+# # jobs = experimentdata_continuous._jobs
+# # domain = experimentdata_continuous.domain
+# # experiment_data = ExperimentData(
+# # input_data=input_data, output_data=output_data, jobs=jobs, domain=domain)
+# # assert experiment_data == ExperimentData(
+# # input_data=input_data, output_data=output_data, jobs=jobs, domain=domain)
+# # assert experiment_data == experimentdata_continuous
-def test_to_pandas(experimentdata_continuous: ExperimentData, pandas_dataframe: pd.DataFrame):
- exported_dataframe, _ = experimentdata_continuous.to_pandas()
- # assert if pandas_dataframe is equal to exported_dataframe
- pd.testing.assert_frame_equal(
- exported_dataframe, pandas_dataframe, atol=1e-6, check_dtype=False)
-# Exporters
-# ======================================================================================
+# # Exporters
+# # ======================================================================================
-def test_add_new_input_column(experimentdata: ExperimentData,
- continuous_parameter: _ContinuousParameter):
- kwargs = {'low': continuous_parameter.lower_bound,
- 'high': continuous_parameter.upper_bound}
- experimentdata.add_input_parameter(
- name='test', type='float', **kwargs)
- assert 'test' in experimentdata._input_data.names
+# def test_to_numpy(experimentdata_continuous: ExperimentData, numpy_array: np.ndarray):
+# x, y = experimentdata_continuous.to_numpy()
+# # cast x to floats
+# x = x.astype(float)
-def test_add_new_output_column(experimentdata: ExperimentData):
- experimentdata.add_output_parameter(name='test', is_disk=False)
- assert 'test' in experimentdata._output_data.names
+# # assert if x and numpy_array have all the same values
+# assert np.allclose(x, numpy_array, rtol=1e-2)
-def test_set_error(experimentdata_continuous: ExperimentData):
- experimentdata_continuous._set_error(3)
- assert experimentdata_continuous._jobs.jobs[3] == Status.ERROR
+# def test_to_xarray(experimentdata_continuous: ExperimentData, xarray_dataset: xr.DataSet):
+# exported_dataset = experimentdata_continuous.to_xarray()
+# # assert if xr_dataset is equal to xarray
+# assert exported_dataset.equals(xarray_dataset)
-# Helper function to create a temporary CSV file with sample data
-def create_sample_csv_input(file_path):
- data = [
- ["x0", "x1", "x2"],
- [0.77395605, 0.43887844, 0.85859792],
- [0.69736803, 0.09417735, 0.97562235],
- [0.7611397, 0.78606431, 0.12811363],
- [0.45038594, 0.37079802, 0.92676499],
- [0.64386512, 0.82276161, 0.4434142],
- [0.22723872, 0.55458479, 0.06381726],
- [0.82763117, 0.6316644, 0.75808774],
- [0.35452597, 0.97069802, 0.89312112],
- [0.7783835, 0.19463871, 0.466721],
- [0.04380377, 0.15428949, 0.68304895],
- [0.000000, 0.000000, 0.000000],
- [1.000000, 1.000000, 1.000000],
- ]
- with open(file_path, mode='w', newline='') as file:
- writer = csv.writer(file)
- writer.writerows(data)
+# def test_to_pandas(experimentdata_continuous: ExperimentData, pandas_dataframe: pd.DataFrame):
+# exported_dataframe, _ = experimentdata_continuous.to_pandas()
+# # assert if pandas_dataframe is equal to exported_dataframe
+# pd.testing.assert_frame_equal(
+# exported_dataframe, pandas_dataframe, atol=1e-6, check_dtype=False)
+# # Exporters
+# # ======================================================================================
-def create_sample_csv_output(file_path):
- data = [
- ["y"],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
+# def test_set_error(experimentdata_continuous: ExperimentData):
+# experimentdata_continuous.mark(indices=3, status='error')
+# assert experimentdata_continuous.data[3].is_status('error')
- ]
- with open(file_path, mode='w', newline='') as file:
- writer = csv.writer(file)
- writer.writerows(data)
-# Pytest fixture to create a temporary CSV file
+# # Helper function to create a temporary CSV file with sample data
+# def create_sample_csv_input(file_path):
+# data = [
+# ["x0", "x1", "x2"],
+# [0.77395605, 0.43887844, 0.85859792],
+# [0.69736803, 0.09417735, 0.97562235],
+# [0.7611397, 0.78606431, 0.12811363],
+# [0.45038594, 0.37079802, 0.92676499],
+# [0.64386512, 0.82276161, 0.4434142],
+# [0.22723872, 0.55458479, 0.06381726],
+# [0.82763117, 0.6316644, 0.75808774],
+# [0.35452597, 0.97069802, 0.89312112],
+# [0.7783835, 0.19463871, 0.466721],
+# [0.04380377, 0.15428949, 0.68304895],
+# [0.000000, 0.000000, 0.000000],
+# [1.000000, 1.000000, 1.000000],
+# ]
+# with open(file_path, mode='w', newline='') as file:
+# writer = csv.writer(file)
+# writer.writerows(data)
-def create_domain_pickle(filepath):
- domain = make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
- dimensionality=3)
- domain.store(filepath)
+# def create_sample_csv_output(file_path):
+# data = [
+# ["y"],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# ]
+# with open(file_path, mode='w', newline='') as file:
+# writer = csv.writer(file)
+# writer.writerows(data)
-def create_jobs_pickle_finished(filepath):
- domain = make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
- dimensionality=3)
+# # Pytest fixture to create a temporary CSV file
- _data_input = _Data.from_dataframe(pd_input())
- _data_output = _Data.from_dataframe(pd_output())
- experimentdata = ExperimentData(
- domain=domain, input_data=_data_input, output_data=_data_output)
- experimentdata._jobs.store(filepath)
-
-
-def create_jobs_pickle_open(filepath):
- domain = make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
- dimensionality=3)
-
- _data_input = _Data.from_dataframe(pd_input())
- experimentdata = ExperimentData(domain=domain, input_data=_data_input)
- experimentdata._jobs.store(filepath)
+# def create_domain_pickle(filepath):
+# domain = make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
+# dimensionality=3)
+# domain.add_output('y', exist_ok=True)
+# domain.store(filepath)
-def path_domain(tmp_path):
- domain_file_path = tmp_path / "test_domain.pkl"
- create_domain_pickle(domain_file_path)
- return domain_file_path
-
-
-def str_domain(tmp_path):
- domain_file_path = tmp_path / "test_domain.pkl"
- create_domain_pickle(domain_file_path)
- return str(domain_file_path)
-
-
-def path_jobs_finished(tmp_path):
- jobs_file_path = tmp_path / "test_jobs.pkl"
- create_jobs_pickle_finished(jobs_file_path)
- return jobs_file_path
-
-
-def str_jobs_finished(tmp_path):
- jobs_file_path = tmp_path / "test_jobs.pkl"
- create_jobs_pickle_finished(jobs_file_path)
- return str(jobs_file_path)
-
-
-def path_jobs_open(tmp_path):
- jobs_file_path = tmp_path / "test_jobs.pkl"
- create_jobs_pickle_open(jobs_file_path)
- return jobs_file_path
-
-
-def str_jobs_open(tmp_path):
- jobs_file_path = tmp_path / "test_jobs.pkl"
- create_jobs_pickle_open(jobs_file_path)
- return str(jobs_file_path)
-
-
-def path_input(tmp_path):
- csv_file_path = tmp_path / "test_input.csv"
- create_sample_csv_input(csv_file_path)
- return csv_file_path
-
-
-def str_input(tmp_path):
- csv_file_path = tmp_path / "test_input.csv"
- create_sample_csv_input(csv_file_path)
- return str(csv_file_path)
-
-
-def path_output(tmp_path: Path):
- csv_file_path = tmp_path / "test_output.csv"
- create_sample_csv_output(csv_file_path)
- return csv_file_path
-
-
-def str_output(tmp_path: Path):
- csv_file_path = tmp_path / "test_output.csv"
- create_sample_csv_output(csv_file_path)
- return str(csv_file_path)
-
-# Pytest test function for reading and monkeypatching a CSV file
+# def create_jobs_csv_finished(filepath):
+# domain = make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
+# dimensionality=3)
-def numpy_input():
- return np.array([
- [0.77395605, 0.43887844, 0.85859792],
- [0.69736803, 0.09417735, 0.97562235],
- [0.7611397, 0.78606431, 0.12811363],
- [0.45038594, 0.37079802, 0.92676499],
- [0.64386512, 0.82276161, 0.4434142],
- [0.22723872, 0.55458479, 0.06381726],
- [0.82763117, 0.6316644, 0.75808774],
- [0.35452597, 0.97069802, 0.89312112],
- [0.7783835, 0.19463871, 0.466721],
- [0.04380377, 0.15428949, 0.68304895],
- [0.000000, 0.000000, 0.000000],
- [1.000000, 1.000000, 1.000000],
- ])
+# _data_input = pd_input()
+# _data_output = pd_output()
+# experimentdata = ExperimentData(
+# domain=domain, input_data=_data_input, output_data=_data_output)
+# experimentdata.jobs.to_csv(Path(filepath).with_suffix('.csv'))
-def numpy_output():
- return np.array([
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
+# def create_jobs_csv_open(filepath):
+# domain = make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
+# dimensionality=3)
- ])
+# _data_input = pd_input()
+# experimentdata = ExperimentData(domain=domain, input_data=_data_input)
+# experimentdata.jobs.to_csv(Path(filepath).with_suffix('.csv'))
-def pd_input():
- return pd.DataFrame([
- [0.77395605, 0.43887844, 0.85859792],
- [0.69736803, 0.09417735, 0.97562235],
- [0.7611397, 0.78606431, 0.12811363],
- [0.45038594, 0.37079802, 0.92676499],
- [0.64386512, 0.82276161, 0.4434142],
- [0.22723872, 0.55458479, 0.06381726],
- [0.82763117, 0.6316644, 0.75808774],
- [0.35452597, 0.97069802, 0.89312112],
- [0.7783835, 0.19463871, 0.466721],
- [0.04380377, 0.15428949, 0.68304895],
- [0.000000, 0.000000, 0.000000],
- [1.000000, 1.000000, 1.000000],
- ], columns=["x0", "x1", "x2"])
-
-
-def pd_output():
- return pd.DataFrame([
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
- [0.0],
-
- ], columns=["y"])
-
-
-def data_input():
- return _Data.from_dataframe(pd_input())
-
-
-def data_output():
- return _Data.from_dataframe(pd_output())
-
-
-@pytest.mark.parametrize("input_data", [path_input, str_input, pd_input(), data_input(), numpy_input()])
-@pytest.mark.parametrize("output_data", [path_output, str_output, pd_output(), data_output()])
-@pytest.mark.parametrize("domain", [make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
- dimensionality=3), None, path_domain, str_domain])
-@pytest.mark.parametrize("jobs", [None, path_jobs_finished, str_jobs_finished])
-def test_init_with_output(input_data: DataTypes, output_data: DataTypes, domain: Domain | str | Path | None,
- jobs: _JobQueue | str | Path | None,
- experimentdata_expected: ExperimentData, monkeypatch, tmp_path: Path):
-
- # if input_data is Callable
- if callable(input_data):
- input_data = input_data(tmp_path)
- expected_data_input = pd.read_csv(input_data)
-
- # if output_data is Callable
- if callable(output_data):
- output_data = output_data(tmp_path)
- expected_data_output = pd.read_csv(output_data)
-
- if callable(domain):
- domain = domain(tmp_path)
- expected_domain = Domain.from_file(domain)
-
- if callable(jobs):
- jobs = jobs(tmp_path)
- expected_jobs = _JobQueue.from_file(jobs).jobs
-
- # monkeypatch pd.read_csv to return the expected_data DataFrame
- def mock_read_csv(*args, **kwargs):
-
- path = args[0]
- if isinstance(args[0], str):
- path = Path(path)
-
- if path == tmp_path / "test_input.csv":
- return expected_data_input
-
- elif path == tmp_path / "test_output.csv":
- return expected_data_output
-
- else:
- raise ValueError("Unexpected file path")
-
- def mock_load_pickle(*args, **kwargs):
- return expected_domain
-
- def mock_pd_read_pickle(*args, **kwargs):
- path = args[0]
-
- if isinstance(path, str):
- path = Path(path)
-
- if path == tmp_path / "test_jobs.pkl":
- return expected_jobs
-
- else:
- raise ValueError("Unexpected jobs file path")
-
- monkeypatch.setattr(pd, "read_csv", mock_read_csv)
- monkeypatch.setattr(pickle, "load", mock_load_pickle)
- monkeypatch.setattr(pd, "read_pickle", mock_pd_read_pickle)
-
- if isinstance(input_data, np.ndarray) and domain is None:
- with pytest.raises(ValueError):
- ExperimentData(domain=domain, input_data=input_data,
- output_data=output_data, jobs=jobs)
- return
- # Initialize ExperimentData with the CSV file
- experiment_data = ExperimentData(domain=domain, input_data=input_data,
- output_data=output_data, jobs=jobs)
-
- # Check if the input_data attribute of ExperimentData matches the expected_data
- pd.testing.assert_frame_equal(
- experiment_data._input_data.to_dataframe(), experimentdata_expected._input_data.to_dataframe(), check_dtype=False, atol=1e-6)
- pd.testing.assert_frame_equal(experiment_data._output_data.to_dataframe(),
- experimentdata_expected._output_data.to_dataframe(), check_dtype=False)
-
-
-@pytest.mark.parametrize("input_data", [pd_input(), path_input, str_input, data_input(), numpy_input()])
-@pytest.mark.parametrize("output_data", [None])
-@pytest.mark.parametrize("domain", [make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
- dimensionality=3), None, path_domain, str_domain])
-@pytest.mark.parametrize("jobs", [None, path_jobs_open, str_jobs_open])
-def test_init_without_output(input_data: DataTypes, output_data: DataTypes, domain: Domain, jobs: _JobQueue,
- experimentdata_expected_no_output: ExperimentData, monkeypatch, tmp_path):
+# def path_domain(tmp_path):
+# domain_file_path = tmp_path / "test_domain.pkl"
+# create_domain_pickle(domain_file_path)
+# return domain_file_path
+
+
+# def str_domain(tmp_path):
+# domain_file_path = tmp_path / "test_domain.pkl"
+# create_domain_pickle(domain_file_path)
+# return str(domain_file_path)
+
+
+# def path_jobs_finished(tmp_path):
+# jobs_file_path = tmp_path / "test_jobs.csv"
+# create_jobs_csv_finished(jobs_file_path)
+# return jobs_file_path
+
+
+# def str_jobs_finished(tmp_path):
+# jobs_file_path = tmp_path / "test_jobs.csv"
+# create_jobs_csv_finished(jobs_file_path)
+# return str(jobs_file_path)
+
+
+# def path_jobs_open(tmp_path):
+# jobs_file_path = tmp_path / "test_jobs.pkl"
+# create_jobs_csv_open(jobs_file_path)
+# return jobs_file_path
+
+
+# def str_jobs_open(tmp_path):
+# jobs_file_path = tmp_path / "test_jobs.pkl"
+# create_jobs_csv_open(jobs_file_path)
+# return str(jobs_file_path)
+
+
+# def path_input(tmp_path):
+# csv_file_path = tmp_path / "test_input.csv"
+# create_sample_csv_input(csv_file_path)
+# return csv_file_path
+
+
+# def str_input(tmp_path):
+# csv_file_path = tmp_path / "test_input.csv"
+# create_sample_csv_input(csv_file_path)
+# return str(csv_file_path)
+
+
+# def path_output(tmp_path: Path):
+# csv_file_path = tmp_path / "test_output.csv"
+# create_sample_csv_output(csv_file_path)
+# return csv_file_path
+
+
+# def str_output(tmp_path: Path):
+# csv_file_path = tmp_path / "test_output.csv"
+# create_sample_csv_output(csv_file_path)
+# return str(csv_file_path)
+
+# # Pytest test function for reading and monkeypatching a CSV file
+
+
+# def numpy_input(*args, **kwargs):
+# return np.array([
+# [0.77395605, 0.43887844, 0.85859792],
+# [0.69736803, 0.09417735, 0.97562235],
+# [0.7611397, 0.78606431, 0.12811363],
+# [0.45038594, 0.37079802, 0.92676499],
+# [0.64386512, 0.82276161, 0.4434142],
+# [0.22723872, 0.55458479, 0.06381726],
+# [0.82763117, 0.6316644, 0.75808774],
+# [0.35452597, 0.97069802, 0.89312112],
+# [0.7783835, 0.19463871, 0.466721],
+# [0.04380377, 0.15428949, 0.68304895],
+# [0.000000, 0.000000, 0.000000],
+# [1.000000, 1.000000, 1.000000],
+# ])
+
+
+# def numpy_output(*args, **kwargs):
+# return np.array([
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+
+# ])
+
+
+# def pd_input(*args, **kwargs):
+# return pd.DataFrame([
+# [0.77395605, 0.43887844, 0.85859792],
+# [0.69736803, 0.09417735, 0.97562235],
+# [0.7611397, 0.78606431, 0.12811363],
+# [0.45038594, 0.37079802, 0.92676499],
+# [0.64386512, 0.82276161, 0.4434142],
+# [0.22723872, 0.55458479, 0.06381726],
+# [0.82763117, 0.6316644, 0.75808774],
+# [0.35452597, 0.97069802, 0.89312112],
+# [0.7783835, 0.19463871, 0.466721],
+# [0.04380377, 0.15428949, 0.68304895],
+# [0.000000, 0.000000, 0.000000],
+# [1.000000, 1.000000, 1.000000],
+# ], columns=["x0", "x1", "x2"])
+
+
+# def pd_output(*args, **kwargs):
+# return pd.DataFrame([
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+# [0.0],
+
+# ], columns=["y"])
+
+
+# # def data_input():
+# # return _Data.from_dataframe(pd_input())
+
+
+# # def data_output():
+# # return _Data.from_dataframe(pd_output())
+
+
+# @pytest.mark.parametrize("input_data", [path_input, str_input, pd_input, numpy_input])
+# @pytest.mark.parametrize("output_data", [path_output, str_output, pd_output])
+# @pytest.mark.parametrize("domain", [
+# make_nd_continuous_domain(bounds=np.array(
+# [[0., 1.], [0., 1.], [0., 1.]]), dimensionality=3),
+# None,
+# path_domain,
+# str_domain
+# ])
+# @pytest.mark.parametrize("jobs", [None, path_jobs_finished, str_jobs_finished])
+# def test_init_with_output(
+# input_data: Union[Callable[[Path], Union[str, Path]], DataTypes],
+# output_data: Union[Callable[[Path], Union[str, Path]], DataTypes],
+# domain: Union[Domain, str, Path, None],
+# jobs: Union[str, Path, None],
+# experimentdata_expected: ExperimentData,
+# monkeypatch,
+# tmp_path: Path,
+# ):
+# # Handle callable parameters
+# def resolve_param(param, tmp_path):
+# if callable(param):
+# return param(tmp_path)
+# return param
+
+# input_data = resolve_param(input_data, tmp_path)
+# output_data = resolve_param(output_data, tmp_path)
+# domain = resolve_param(domain, tmp_path)
+# jobs = resolve_param(jobs, tmp_path)
+
+# # Mock `pd.read_csv`
+# def mock_read_csv(file_path, *args, **kwargs):
+# path = Path(file_path)
+# if path == tmp_path / "test_input.csv":
+# return experimentdata_expected.to_pandas()[0]
+# elif path == tmp_path / "test_output.csv":
+# return experimentdata_expected.to_pandas()[1]
+# elif path == tmp_path / "test_jobs.csv":
+# return experimentdata_expected.jobs
+# raise ValueError(f"Unexpected file path: {file_path}")
+
+# # Mock `pickle.load`
+# def mock_load_pickle(file, *args, **kwargs):
+# if Path(file) == tmp_path / "test_domain.pkl":
+# return experimentdata_expected.domain
+# raise ValueError(f"Unexpected pickle file path: {file}")
+
+# monkeypatch.setattr(pd, "read_csv", mock_read_csv)
+# monkeypatch.setattr(pickle, "load", mock_load_pickle)
+
+# # # Validation logic for specific inputs
+# # if isinstance(input_data, np.ndarray) and domain is None:
+# # with pytest.raises(ValueError):
+# # ExperimentData(domain=domain, input_data=input_data,
+# # output_data=output_data, jobs=jobs)
+# # return
+
+# # Initialize ExperimentData and validate
+
+# experiment_data = ExperimentData(
+# domain=domain, input_data=input_data, output_data=output_data,
+# jobs=jobs)
+# experiment_data.domain.add_output('y', exist_ok=True)
+# experiment_data.round(3)
+
+# print(experiment_data)
+
+# print(experiment_data.domain)
+# print(experimentdata_expected)
+
+# print(experimentdata_expected.domain)
+
+# # Assertions
+# assert experiment_data == experimentdata_expected
+
+
+# # @pytest.mark.parametrize("input_data", [path_input, str_input, pd_input, numpy_input])
+# # @pytest.mark.parametrize("output_data", [path_output, str_output, pd_output])
+# # @pytest.mark.parametrize("domain", [make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
+# # dimensionality=3), None, path_domain, str_domain])
+# # @pytest.mark.parametrize("jobs", [None, path_jobs_finished, str_jobs_finished])
+# # def test_init_with_output(
+# # input_data: DataTypes, output_data: DataTypes,
+# # domain: Domain | str | Path | None,
+# # jobs: str | Path | None,
+# # experimentdata_expected: ExperimentData,
+# # monkeypatch, tmp_path: Path):
+
+# # # if input_data is Callable
+# # if callable(input_data):
+# # input_data = input_data(tmp_path)
+# # expected_data_input = pd.read_csv(input_data)
+
+# # # if output_data is Callable
+# # if callable(output_data):
+# # output_data = output_data(tmp_path)
+# # expected_data_output = pd.read_csv(output_data)
+
+# # if callable(domain):
+# # domain = domain(tmp_path)
+# # expected_domain = Domain.from_file(domain)
+
+# # if callable(jobs):
+# # jobs = jobs(tmp_path)
+# # expected_jobs = pd.read_csv(jobs)
+
+# # # monkeypatch pd.read_csv to return the expected_data DataFrame
+# # def mock_read_csv(*args, **kwargs):
+
+# # path = args[0]
+# # if isinstance(args[0], str):
+# # path = Path(path)
+
+# # if path == tmp_path / "test_input.csv":
+# # return expected_data_input
+
+# # elif path == tmp_path / "test_output.csv":
+# # return expected_data_output
+
+# # elif path == tmp_path / "test_jobs.csv":
+# # return expected_jobs
- # if input_data is Callable
- if callable(input_data):
- input_data = input_data(tmp_path)
- expected_data_input = pd.read_csv(input_data)
+# # else:
+# # raise ValueError("Unexpected file path")
- # if output_data is Callable
- if callable(output_data):
- output_data = output_data(tmp_path)
- expected_data_output = pd.read_csv(output_data)
+# # def mock_load_pickle(*args, **kwargs):
+# # return expected_domain
- if callable(domain):
- domain = domain(tmp_path)
- expected_domain = Domain.from_file(domain)
-
- if callable(jobs):
- jobs = jobs(tmp_path)
- expected_jobs = _JobQueue.from_file(jobs).jobs
-
- # monkeypatch pd.read_csv to return the expected_data DataFrame
- def mock_read_csv(*args, **kwargs):
+# # def mock_pd_read_pickle(*args, **kwargs):
+# # path = args[0]
+
+# # if isinstance(path, str):
+# # path = Path(path)
- path = args[0]
- if isinstance(args[0], str):
- path = Path(path)
-
- if path == tmp_path / "test_input.csv":
- return expected_data_input
-
- elif path == tmp_path / "test_output.csv":
- return expected_data_output
+# # if path == tmp_path / "test_jobs.pkl":
+# # return expected_jobs
- else:
- raise ValueError("Unexpected file path")
+# # else:
+# # raise ValueError("Unexpected jobs file path")
- def mock_load_pickle(*args, **kwargs):
- return expected_domain
+# # monkeypatch.setattr(pd, "read_csv", mock_read_csv)
+# # monkeypatch.setattr(pickle, "load", mock_load_pickle)
+# # monkeypatch.setattr(pd, "read_pickle", mock_pd_read_pickle)
- def mock_pd_read_pickle(*args, **kwargs):
- path = args[0]
+# # if isinstance(input_data, np.ndarray) and domain is None:
+# # with pytest.raises(ValueError):
+# # ExperimentData(domain=domain, input_data=input_data,
+# # output_data=output_data, jobs=jobs)
+# # return
+# # # Initialize ExperimentData with the CSV file
+# # experiment_data = ExperimentData(domain=domain, input_data=input_data,
+# # output_data=output_data, jobs=jobs)
- if isinstance(path, str):
- path = Path(path)
+# # experiment_data.round(3)
- if path == tmp_path / "test_jobs.pkl":
- return expected_jobs
+# # # Check if the input_data attribute of ExperimentData matches the expected_data
+# # # pd.testing.assert_frame_equal(
+# # # experiment_data._input_data.to_dataframe(), experimentdata_expected._input_data.to_dataframe(), check_dtype=False, atol=1e-6)
+# # # pd.testing.assert_frame_equal(experiment_data._output_data.to_dataframe(),
+# # # experimentdata_expected._output_data.to_dataframe(), check_dtype=False)
- monkeypatch.setattr(pd, "read_csv", mock_read_csv)
- monkeypatch.setattr(pickle, "load", mock_load_pickle)
- monkeypatch.setattr(pd, "read_pickle", mock_pd_read_pickle)
+# # assert experiment_data == experimentdata_expected
- if isinstance(input_data, np.ndarray) and domain is None:
- with pytest.raises(ValueError):
- ExperimentData(domain=domain, input_data=input_data,
- output_data=output_data, jobs=jobs)
- return
- # Initialize ExperimentData with the CSV file
- experiment_data = ExperimentData(domain=domain, input_data=input_data,
- output_data=output_data, jobs=jobs)
+# # @pytest.mark.parametrize("input_data", [pd_input(), path_input, str_input, numpy_input()])
+# # @pytest.mark.parametrize("output_data", [None])
+# # @pytest.mark.parametrize("domain", [make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
+# # dimensionality=3), None, path_domain, str_domain])
+# # @pytest.mark.parametrize("jobs", [None, path_jobs_open, str_jobs_open])
+# # def test_init_without_output(input_data: DataTypes, output_data: DataTypes, domain: Domain, jobs: _JobQueue,
+# # experimentdata_expected_no_output: ExperimentData, monkeypatch, tmp_path):
- # Check if the input_data attribute of ExperimentData matches the expected_data
- pd.testing.assert_frame_equal(
- experiment_data._input_data.to_dataframe(), experimentdata_expected_no_output._input_data.to_dataframe(), atol=1e-6, check_dtype=False)
- pd.testing.assert_frame_equal(experiment_data._output_data.to_dataframe(),
- experimentdata_expected_no_output._output_data.to_dataframe())
- pd.testing.assert_series_equal(
- experiment_data._jobs.jobs, experimentdata_expected_no_output._jobs.jobs)
- # assert experiment_data.domain == experimentdata_expected_no_output.domain
- assert experiment_data._jobs == experimentdata_expected_no_output._jobs
+# # # if input_data is Callable
+# # if callable(input_data):
+# # input_data = input_data(tmp_path)
+# # expected_data_input = pd.read_csv(input_data)
+
+# # # if output_data is Callable
+# # if callable(output_data):
+# # output_data = output_data(tmp_path)
+# # expected_data_output = pd.read_csv(output_data)
+# # if callable(domain):
+# # domain = domain(tmp_path)
+# # expected_domain = Domain.from_file(domain)
-@pytest.mark.parametrize("input_data", [None])
-@pytest.mark.parametrize("output_data", [None])
-@pytest.mark.parametrize("domain", [make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
- dimensionality=3), path_domain, str_domain])
-def test_init_only_domain(input_data: DataTypes, output_data: DataTypes, domain: Domain | str | Path,
- experimentdata_expected_only_domain: ExperimentData,
- monkeypatch, tmp_path):
+# # if callable(jobs):
+# # jobs = jobs(tmp_path)
+# # expected_jobs = _JobQueue.from_file(jobs).jobs
- # if input_data is Callable
- if callable(input_data):
- input_data = input_data(tmp_path)
- expected_data_input = pd.read_csv(input_data)
+# # # monkeypatch pd.read_csv to return the expected_data DataFrame
+# # def mock_read_csv(*args, **kwargs):
- # if output_data is Callable
- if callable(output_data):
- output_data = output_data(tmp_path)
- expected_data_output = pd.read_csv(output_data)
+# # path = args[0]
+# # if isinstance(args[0], str):
+# # path = Path(path)
- if callable(domain):
- domain = domain(tmp_path)
- expected_domain = Domain.from_file(domain)
+# # if path == tmp_path / "test_input.csv":
+# # return expected_data_input
- # monkeypatch pd.read_csv to return the expected_data DataFrame
- def mock_read_csv(*args, **kwargs):
+# # elif path == tmp_path / "test_output.csv":
+# # return expected_data_output
- path = args[0]
- if isinstance(args[0], str):
- path = Path(path)
+# # else:
+# # raise ValueError("Unexpected file path")
- if path == tmp_path / "test_input.csv":
- return expected_data_input
+# # def mock_load_pickle(*args, **kwargs):
+# # return expected_domain
- elif path == tmp_path / "test_output.csv":
- return expected_data_output
+# # def mock_pd_read_pickle(*args, **kwargs):
+# # path = args[0]
- else:
- raise ValueError("Unexpected file path")
+# # if isinstance(path, str):
+# # path = Path(path)
- def mock_load_pickle(*args, **kwargs):
- return expected_domain
+# # if path == tmp_path / "test_jobs.pkl":
+# # return expected_jobs
- monkeypatch.setattr(pd, "read_csv", mock_read_csv)
- monkeypatch.setattr(pickle, "load", mock_load_pickle)
+# # monkeypatch.setattr(pd, "read_csv", mock_read_csv)
+# # monkeypatch.setattr(pickle, "load", mock_load_pickle)
+# # monkeypatch.setattr(pd, "read_pickle", mock_pd_read_pickle)
- # Initialize ExperimentData with the CSV file
- experiment_data = ExperimentData(domain=domain, input_data=input_data,
- output_data=output_data)
+# # if isinstance(input_data, np.ndarray) and domain is None:
+# # with pytest.raises(ValueError):
+# # ExperimentData(domain=domain, input_data=input_data,
+# # output_data=output_data, jobs=jobs)
+# # return
- # Check if the input_data attribute of ExperimentData matches the expected_data
- pd.testing.assert_frame_equal(
- experiment_data._input_data.to_dataframe(), experimentdata_expected_only_domain._input_data.to_dataframe(), check_dtype=False)
- pd.testing.assert_frame_equal(experiment_data._output_data.to_dataframe(),
- experimentdata_expected_only_domain._output_data.to_dataframe(), check_dtype=False)
- assert experiment_data._input_data == experimentdata_expected_only_domain._input_data
- assert experiment_data._output_data == experimentdata_expected_only_domain._output_data
- assert experiment_data.domain == experimentdata_expected_only_domain.domain
- assert experiment_data._jobs == experimentdata_expected_only_domain._jobs
+# # # Initialize ExperimentData with the CSV file
+# # experiment_data = ExperimentData(domain=domain, input_data=input_data,
+# # output_data=output_data, jobs=jobs)
- assert experiment_data == experimentdata_expected_only_domain
+# # # Check if the input_data attribute of ExperimentData matches the expected_data
+# # pd.testing.assert_frame_equal(
+# # experiment_data._input_data.to_dataframe(), experimentdata_expected_no_output._input_data.to_dataframe(), atol=1e-6, check_dtype=False)
+# # pd.testing.assert_frame_equal(experiment_data._output_data.to_dataframe(),
+# # experimentdata_expected_no_output._output_data.to_dataframe())
+# # pd.testing.assert_series_equal(
+# # experiment_data._jobs.jobs, experimentdata_expected_no_output._jobs.jobs)
+# # # assert experiment_data.domain == experimentdata_expected_no_output.domain
+# # assert experiment_data._jobs == experimentdata_expected_no_output._jobs
-@pytest.mark.parametrize("input_data", [[0.1, 0.2], {"a": 0.1, "b": 0.2}, 0.2, 2])
-def test_invalid_type(input_data):
- with pytest.raises(TypeError):
- ExperimentData(input_data=input_data)
+# # @pytest.mark.parametrize("input_data", [None])
+# # @pytest.mark.parametrize("output_data", [None])
+# # @pytest.mark.parametrize("domain", [make_nd_continuous_domain(bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
+# # dimensionality=3), path_domain, str_domain])
+# # def test_init_only_domain(input_data: DataTypes, output_data: DataTypes, domain: Domain | str | Path,
+# # experimentdata_expected_only_domain: ExperimentData,
+# # monkeypatch, tmp_path):
+# # # if input_data is Callable
+# # if callable(input_data):
+# # input_data = input_data(tmp_path)
+# # expected_data_input = pd.read_csv(input_data)
-def test_add_invalid_type(experimentdata: ExperimentData):
- with pytest.raises(TypeError):
- experimentdata + 1
+# # # if output_data is Callable
+# # if callable(output_data):
+# # output_data = output_data(tmp_path)
+# # expected_data_output = pd.read_csv(output_data)
+# # if callable(domain):
+# # domain = domain(tmp_path)
+# # expected_domain = Domain.from_file(domain)
+
+# # # monkeypatch pd.read_csv to return the expected_data DataFrame
+# # def mock_read_csv(*args, **kwargs):
-def test_add_two_different_domains(experimentdata: ExperimentData, experimentdata_continuous: ExperimentData):
- with pytest.raises(ValueError):
- experimentdata + experimentdata_continuous
+# # path = args[0]
+# # if isinstance(args[0], str):
+# # path = Path(path)
+# # if path == tmp_path / "test_input.csv":
+# # return expected_data_input
-def test_repr_html(experimentdata: ExperimentData, monkeypatch):
- assert isinstance(experimentdata._repr_html_(), str)
+# # elif path == tmp_path / "test_output.csv":
+# # return expected_data_output
+# # else:
+# # raise ValueError("Unexpected file path")
-def test_store(experimentdata: ExperimentData, tmp_path: Path):
- experimentdata.store(tmp_path / "test")
- assert (tmp_path / "test" / "experiment_data" / "input.csv").exists()
- assert (tmp_path / "test" / "experiment_data" / "output.csv").exists()
- assert (tmp_path / "test" / "experiment_data" / "domain.pkl").exists()
- assert (tmp_path / "test" / "experiment_data" / "jobs.pkl").exists()
+# # def mock_load_pickle(*args, **kwargs):
+# # return expected_domain
+# # monkeypatch.setattr(pd, "read_csv", mock_read_csv)
+# # monkeypatch.setattr(pickle, "load", mock_load_pickle)
-def test_store_give_no_filename(experimentdata: ExperimentData, tmp_path: Path):
- experimentdata.set_project_dir(tmp_path / 'test2')
- experimentdata.store()
- assert (tmp_path / "test2" / "experiment_data" / "input.csv").exists()
- assert (tmp_path / "test2" / "experiment_data" / "output.csv").exists()
- assert (tmp_path / "test2" / "experiment_data" / "domain.pkl").exists()
- assert (tmp_path / "test2" / "experiment_data" / "jobs.pkl").exists()
+# # # Initialize ExperimentData with the CSV file
+# # experiment_data = ExperimentData(domain=domain, input_data=input_data,
+# # output_data=output_data)
+# # # Check if the input_data attribute of ExperimentData matches the expected_data
+# # pd.testing.assert_frame_equal(
+# # experiment_data._input_data.to_dataframe(), experimentdata_expected_only_domain._input_data.to_dataframe(), check_dtype=False)
+# # pd.testing.assert_frame_equal(experiment_data._output_data.to_dataframe(),
+# # experimentdata_expected_only_domain._output_data.to_dataframe(), check_dtype=False)
+# # assert experiment_data._input_data == experimentdata_expected_only_domain._input_data
+# # assert experiment_data._output_data == experimentdata_expected_only_domain._output_data
+# # assert experiment_data.domain == experimentdata_expected_only_domain.domain
+# # assert experiment_data._jobs == experimentdata_expected_only_domain._jobs
-@pytest.mark.parametrize("mode", ["sequential", "parallel", "typo"])
-def test_evaluate_mode(mode: str, experimentdata_continuous: ExperimentData, tmp_path: Path):
- experimentdata_continuous.filename = tmp_path / 'test009'
+# # assert experiment_data == experimentdata_expected_only_domain
- if mode == "typo":
- with pytest.raises(ValueError):
- experimentdata_continuous.evaluate("ackley", mode=mode, kwargs={
- "scale_bounds": np.array([[0., 1.], [0., 1.], [0., 1.]]), 'seed': SEED})
- else:
- experimentdata_continuous.evaluate("ackley", mode=mode, kwargs={
- "scale_bounds": np.array([[0., 1.], [0., 1.], [0., 1.]]), 'seed': SEED})
+# @pytest.mark.parametrize("input_data", [[0.1, 0.2], {"a": 0.1, "b": 0.2}, 0.2, 2])
+# def test_invalid_type(input_data):
+# with pytest.raises(TypeError):
+# ExperimentData(input_data=input_data)
-def test_get_input_data(experimentdata_expected_no_output: ExperimentData):
- input_data = experimentdata_expected_no_output.get_input_data()
- df, _ = input_data.to_pandas()
- pd.testing.assert_frame_equal(df, pd_input(), check_dtype=False, atol=1e-6)
- assert experimentdata_expected_no_output._input_data == input_data._input_data
+# def test_add_invalid_type(experimentdata: ExperimentData):
+# with pytest.raises(TypeError):
+# experimentdata + 1
-@pytest.mark.parametrize("selection", ["x0", ["x0"], ["x0", "x2"]])
-def test_get_input_data_selection(experimentdata_expected_no_output: ExperimentData, selection: Iterable[str] | str):
- input_data = experimentdata_expected_no_output.get_input_data(selection)
- df, _ = input_data.to_pandas()
- if isinstance(selection, str):
- selection = [selection]
- selected_pd = pd_input()[selection]
- pd.testing.assert_frame_equal(
- df, selected_pd, check_dtype=False, atol=1e-6)
+# def test_add_two_different_domains(experimentdata: ExperimentData, experimentdata_continuous: ExperimentData):
+# with pytest.raises(ValueError):
+# experimentdata + experimentdata_continuous
-def test_get_output_data(experimentdata_expected: ExperimentData):
- output_data = experimentdata_expected.get_output_data()
- _, df = output_data.to_pandas()
- pd.testing.assert_frame_equal(df, pd_output(), check_dtype=False)
- assert experimentdata_expected._output_data == output_data._output_data
+# def test_repr_html(experimentdata: ExperimentData, monkeypatch):
+# assert isinstance(experimentdata._repr_html_(), str)
-@pytest.mark.parametrize("selection", ["y", ["y"]])
-def test_get_output_data_selection(experimentdata_expected: ExperimentData, selection: Iterable[str] | str):
- output_data = experimentdata_expected.get_output_data(selection)
- _, df = output_data.to_pandas()
- if isinstance(selection, str):
- selection = [selection]
- selected_pd = pd_output()[selection]
- pd.testing.assert_frame_equal(df, selected_pd, check_dtype=False)
+# def test_store(experimentdata: ExperimentData, tmp_path: Path):
+# experimentdata.store(tmp_path / "test")
+# assert (tmp_path / "test" / "experiment_data" / "input.csv").exists()
+# assert (tmp_path / "test" / "experiment_data" / "output.csv").exists()
+# assert (tmp_path / "test" / "experiment_data" / "domain.pkl").exists()
+# assert (tmp_path / "test" / "experiment_data" / "jobs.pkl").exists()
-def test_iter_behaviour(experimentdata_continuous: ExperimentData):
- for i in experimentdata_continuous:
- assert isinstance(i, ExperimentSample)
- selected_experimentdata = experimentdata_continuous.select([0, 2, 4])
- for i in selected_experimentdata:
- assert isinstance(i, ExperimentSample)
+# def test_store_give_no_filename(experimentdata: ExperimentData, tmp_path: Path):
+# experimentdata.set_project_dir(tmp_path / 'test2')
+# experimentdata.store()
+# assert (tmp_path / "test2" / "experiment_data" / "input.csv").exists()
+# assert (tmp_path / "test2" / "experiment_data" / "output.csv").exists()
+# assert (tmp_path / "test2" / "experiment_data" / "domain.pkl").exists()
+# assert (tmp_path / "test2" / "experiment_data" / "jobs.pkl").exists()
-def test_select_with_status_open(experimentdata: ExperimentData):
- selected_data = experimentdata.select_with_status('open')
- assert all(job == Status.OPEN for job in selected_data._jobs.jobs)
+# @pytest.mark.parametrize("mode", ["sequential", "parallel", "typo"])
+# def test_evaluate_mode(mode: str, experimentdata_continuous: ExperimentData, tmp_path: Path):
+# experimentdata_continuous.filename = tmp_path / 'test009'
+# if mode == "typo":
+# with pytest.raises(ValueError):
+# experimentdata_continuous.evaluate(
+# data_generator="ackley", mode=mode,
+# scale_bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
+# seed=SEED)
+# else:
+# experimentdata_continuous.evaluate(
+# data_generator="ackley", mode=mode,
+# scale_bounds=np.array([[0., 1.], [0., 1.], [0., 1.]]),
+# seed=SEED)
-def test_select_with_status_in_progress(experimentdata: ExperimentData):
- selected_data = experimentdata.select_with_status('in progress')
- assert all(job == Status.IN_PROGRESS for job in selected_data._jobs.jobs)
+# @pytest.mark.parametrize("selection", ["x0", ["x0"], ["x0", "x2"]])
+# def test_get_input_data_selection(experimentdata_expected_no_output: ExperimentData, selection: Iterable[str] | str):
+# input_data = experimentdata_expected_no_output.get_input_data(selection)
+# df, _ = input_data.to_pandas()
+# if isinstance(selection, str):
+# selection = [selection]
+# selected_pd = pd_input()[selection]
+# pd.testing.assert_frame_equal(
+# df, selected_pd, check_dtype=False, atol=1e-6)
-def test_select_with_status_finished(experimentdata: ExperimentData):
- selected_data = experimentdata.select_with_status('finished')
- assert all(job == Status.FINISHED for job in selected_data._jobs.jobs)
+# def test_iter_behaviour(experimentdata_continuous: ExperimentData):
+# for i in experimentdata_continuous:
+# assert isinstance(i, ExperimentSample)
-def test_select_with_status_error(experimentdata: ExperimentData):
- selected_data = experimentdata.select_with_status('error')
- assert all(job == Status.ERROR for job in selected_data._jobs.jobs)
+# selected_experimentdata = experimentdata_continuous.select([0, 2, 4])
+# for i in selected_experimentdata:
+# assert isinstance(i, ExperimentSample)
-def test_select_with_status_invalid_status(experimentdata: ExperimentData):
- with pytest.raises(ValueError):
- _ = experimentdata.select_with_status('invalid_status')
+# def test_select_with_status_open(experimentdata: ExperimentData):
+# selected_data = experimentdata.select_with_status('open')
+# assert all(es.is_status('open') for _, es in selected_data)
-if __name__ == "__main__": # pragma: no cover
- pytest.main()
+# def test_select_with_status_in_progress(experimentdata: ExperimentData):
+# selected_data = experimentdata.select_with_status('in progress')
+# assert all(es.is_status('in progress') for _, es in selected_data)
+
+
+# def test_select_with_status_finished(experimentdata: ExperimentData):
+# selected_data = experimentdata.select_with_status('finished')
+# assert all(es.is_status('finished') for _, es in selected_data)
+
+
+# def test_select_with_status_error(experimentdata: ExperimentData):
+# selected_data = experimentdata.select_with_status('error')
+# assert all(es.is_status('error') for _, es in selected_data)
+
+
+# def test_select_with_status_invalid_status(experimentdata: ExperimentData):
+# with pytest.raises(ValueError):
+# _ = experimentdata.select_with_status('invalid_status')
+
+
+# if __name__ == "__main__": # pragma: no cover
+# pytest.main()
diff --git a/tests/experimentdata/test_experimentdata2.py b/tests/experimentdata/test_experimentdata2.py
new file mode 100644
index 00000000..4fecc56b
--- /dev/null
+++ b/tests/experimentdata/test_experimentdata2.py
@@ -0,0 +1,315 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+from omegaconf import DictConfig
+
+from f3dasm import ExperimentData
+from f3dasm.design import Domain, make_nd_continuous_domain
+
+SEED = 42
+
+pytestmark = pytest.mark.smoke
+
+
+def domain_dictconfig_with_output():
+ config_dict = {"input": {"x0": {"type": "float", "low": 0.0, "high": 1.0},
+ "x1": {"type": "float", "low": 0.0, "high": 1.0},
+ "x2": {"type": "float", "low": 0.0, "high": 1.0}},
+
+ "output": {'y': {}}
+ }
+
+ return DictConfig(config_dict)
+
+
+def domain_dictconfig_without_output():
+ config_dict = {"input": {"x0": {"type": "float", "low": 0.0, "high": 1.0},
+ "x1": {"type": "float", "low": 0.0, "high": 1.0},
+ "x2": {"type": "float", "low": 0.0, "high": 1.0}},
+ }
+
+ return DictConfig(config_dict)
+
+
+def edata_domain_with_output() -> Domain:
+ return experiment_data_with_output().domain
+
+
+def edata_domain_without_output() -> Domain:
+ return experiment_data_without_output().domain
+
+# =============================================================================
+
+
+def test_project_dir_false_data():
+ with pytest.raises(TypeError):
+ ExperimentData(project_dir=0)
+
+# =============================================================================
+
+
+def experiment_data_with_output() -> ExperimentData:
+ domain = make_nd_continuous_domain(
+ bounds=[[0., 1.], [0., 1.], [0., 1.]])
+
+ data = ExperimentData.from_sampling(
+ sampler='random', domain=domain, n_samples=10, seed=SEED
+ )
+
+ data += ExperimentData(
+ input_data=np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]),
+ domain=data.domain)
+
+ def f(*args, **kwargs):
+ return 0.0
+
+ data.evaluate(data_generator=f, output_names=['y'])
+ data.round(3)
+
+ data.set_project_dir('./test_project')
+ return data
+
+
+def experiment_data_without_output() -> ExperimentData:
+ domain = make_nd_continuous_domain(
+ bounds=[[0., 1.], [0., 1.], [0., 1.]])
+
+ data = ExperimentData.from_sampling(
+ sampler='random', domain=domain, n_samples=10, seed=SEED
+ )
+
+ data += ExperimentData(
+ input_data=np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]),
+ domain=data.domain)
+
+ data.round(3)
+
+ data.set_project_dir('./test_project')
+ return data
+
+
+# =============================================================================
+
+@ pytest.fixture(scope="package")
+def edata_expected_with_output() -> ExperimentData:
+ domain = make_nd_continuous_domain(
+ bounds=[[0., 1.], [0., 1.], [0., 1.]])
+
+ data = ExperimentData.from_sampling(
+ sampler='random', domain=domain, n_samples=10, seed=SEED
+ )
+
+ data += ExperimentData(
+ input_data=np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]),
+ domain=data.domain)
+
+ def f(*args, **kwargs):
+ return 0.0
+
+ data.evaluate(data_generator=f, output_names=['y'])
+ data.round(3)
+
+ data.set_project_dir('./test_project')
+
+ return data
+
+
+@ pytest.fixture(scope="package")
+def edata_expected_without_output() -> ExperimentData:
+ domain = make_nd_continuous_domain(
+ bounds=[[0., 1.], [0., 1.], [0., 1.]])
+
+ data = ExperimentData.from_sampling(
+ sampler='random', domain=domain, n_samples=10, seed=SEED
+ )
+
+ data += ExperimentData(
+ input_data=np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]),
+ domain=data.domain)
+
+ data.round(3)
+
+ data.set_project_dir('./test_project')
+
+ return data
+
+
+# =============================================================================
+
+
+def edata_jobs_with_output() -> pd.Series:
+ return experiment_data_with_output().jobs
+
+
+def edata_jobs_without_output() -> pd.Series:
+ return experiment_data_without_output().jobs
+
+# =============================================================================
+
+
+def arr_input():
+ return np.array([
+ [0.77395605, 0.43887844, 0.85859792],
+ [0.69736803, 0.09417735, 0.97562235],
+ [0.7611397, 0.78606431, 0.12811363],
+ [0.45038594, 0.37079802, 0.92676499],
+ [0.64386512, 0.82276161, 0.4434142],
+ [0.22723872, 0.55458479, 0.06381726],
+ [0.82763117, 0.6316644, 0.75808774],
+ [0.35452597, 0.97069802, 0.89312112],
+ [0.7783835, 0.19463871, 0.466721],
+ [0.04380377, 0.15428949, 0.68304895],
+ [0.000000, 0.000000, 0.000000],
+ [1.000000, 1.000000, 1.000000],
+ ]).round(3)
+
+
+def list_of_dicts_input():
+ return [
+ {'x0': 0.77395605, 'x1': 0.43887844, 'x2': 0.85859792},
+ {'x0': 0.69736803, 'x1': 0.09417735, 'x2': 0.97562235},
+ {'x0': 0.7611397, 'x1': 0.78606431, 'x2': 0.12811363},
+ {'x0': 0.45038594, 'x1': 0.37079802, 'x2': 0.92676499},
+ {'x0': 0.64386512, 'x1': 0.82276161, 'x2': 0.4434142},
+ {'x0': 0.22723872, 'x1': 0.55458479, 'x2': 0.06381726},
+ {'x0': 0.82763117, 'x1': 0.6316644, 'x2': 0.75808774},
+ {'x0': 0.35452597, 'x1': 0.97069802, 'x2': 0.89312112},
+ {'x0': 0.7783835, 'x1': 0.19463871, 'x2': 0.466721},
+ {'x0': 0.04380377, 'x1': 0.15428949, 'x2': 0.68304895},
+ {'x0': 0.000000, 'x1': 0.000000, 'x2': 0.000000},
+ {'x0': 1.000000, 'x1': 1.000000, 'x2': 1.000000},
+ ]
+
+
+def list_of_dicts_output():
+ return [
+ {'y': 0.0},
+ {'y': 0.0},
+ {'y': 0.0},
+ {'y': 0.0},
+ {'y': 0.0},
+ {'y': 0.0},
+ {'y': 0.0},
+ {'y': 0.0},
+ {'y': 0.0},
+ {'y': 0.0},
+ {'y': 0.0},
+ {'y': 0.0},
+ ]
+
+
+def pd_input():
+ return pd.DataFrame(arr_input(), columns=['x0', 'x1', 'x2'])
+
+
+def arr_output():
+ return np.array([[0.],
+ [0.],
+ [0.],
+ [0.],
+ [0.],
+ [0.],
+ [0.],
+ [0.],
+ [0.],
+ [0.],
+ [0.],
+ [0.]])
+
+
+def pd_output():
+ return pd.DataFrame(arr_output(), columns=['y'])
+
+
+@ pytest.mark.parametrize("input_data", ["test_input.csv", pd_input(), arr_input(), list_of_dicts_input()])
+@ pytest.mark.parametrize("output_data", ["test_output.csv", pd_output(), arr_output(), list_of_dicts_output()])
+@ pytest.mark.parametrize("domain", ["test_domain.json", edata_domain_with_output(), None, domain_dictconfig_with_output()])
+@ pytest.mark.parametrize("jobs", [edata_jobs_with_output(), "test_jobs.csv", None])
+@ pytest.mark.parametrize("project_dir", ["./test_project", Path("./test_project")])
+def test_experimentdata_creation_with_output(
+ input_data, output_data, domain, jobs, project_dir, edata_expected_with_output, monkeypatch):
+
+ def mock_read_csv(path, *args, **kwargs):
+ if str(path) == "test_input.csv":
+ return pd_input()
+ elif str(path) == "test_output.csv":
+ return pd_output()
+ elif str(path) == "test_jobs.csv":
+ return edata_jobs_with_output()
+ raise ValueError(f"Unexpected file path: {path}")
+
+ def mock_domain_from_file(path, *args, **kwargs):
+ return edata_domain_with_output()
+
+ monkeypatch.setattr(pd, 'read_csv', mock_read_csv)
+ monkeypatch.setattr(Domain, 'from_file', mock_domain_from_file)
+
+ experiment_data = ExperimentData(domain=domain, input_data=input_data,
+ output_data=output_data, jobs=jobs,
+ project_dir=project_dir)
+
+ if domain is None:
+ experiment_data.domain = edata_domain_with_output()
+
+ experiment_data.round(3)
+ assert experiment_data == edata_expected_with_output
+
+
+# =============================================================================
+
+@ pytest.mark.parametrize("input_data", ["test_input.csv", pd_input(), arr_input(), list_of_dicts_input()])
+@ pytest.mark.parametrize("domain", ["test_domain.json", edata_domain_without_output(), domain_dictconfig_without_output()])
+@ pytest.mark.parametrize("jobs", [edata_jobs_without_output(), "test_jobs.csv", None])
+@ pytest.mark.parametrize("project_dir", ["./test_project", Path("./test_project")])
+def test_experimentdata_creation_without_output(
+ input_data, domain, jobs, project_dir, edata_expected_without_output, monkeypatch):
+
+ def mock_read_csv(path, *args, **kwargs):
+ if str(path) == "test_input.csv":
+ return pd_input()
+ elif str(path) == "test_output.csv":
+ return pd_output()
+ elif str(path) == "test_jobs.csv":
+ return edata_jobs_without_output()
+ raise ValueError(f"Unexpected file path: {path}")
+
+ def mock_domain_from_file(path, *args, **kwargs):
+ return edata_domain_without_output()
+
+ monkeypatch.setattr(pd, 'read_csv', mock_read_csv)
+ monkeypatch.setattr(Domain, 'from_file', mock_domain_from_file)
+
+ experiment_data = ExperimentData(domain=domain, input_data=input_data,
+ jobs=jobs,
+ project_dir=project_dir)
+
+ if domain is None:
+ experiment_data.domain = edata_domain_without_output()
+
+ experiment_data.round(3)
+ assert experiment_data == edata_expected_without_output
+
+
+def test_experiment_data_from_yaml_sampling():
+ domain = make_nd_continuous_domain(
+ bounds=[[0., 1.], [0., 1.], [0., 1.]])
+
+ data_expected = ExperimentData.from_sampling(
+ sampler='random', domain=domain, n_samples=10, seed=SEED
+ )
+
+ dict_config = DictConfig({'from_sampling': {
+ 'sampler': 'random',
+ 'domain': {"x0": {"type": "float", "low": 0.0, "high": 1.0},
+ "x1": {"type": "float", "low": 0.0, "high": 1.0},
+ "x2": {"type": "float", "low": 0.0, "high": 1.0},
+ },
+ 'n_samples': 10,
+ 'seed': SEED
+ }})
+
+ data = ExperimentData.from_yaml(dict_config)
+
+ assert data.domain == data_expected.domain
diff --git a/tests/experimentdata/test_experimentdata_to_disk.py b/tests/experimentdata/test_experimentdata_to_disk.py
new file mode 100644
index 00000000..bb145b6c
--- /dev/null
+++ b/tests/experimentdata/test_experimentdata_to_disk.py
@@ -0,0 +1,150 @@
+from f3dasm.design import Domain
+from f3dasm import ExperimentData
+import xarray as xr
+import pytest
+import pandas as pd
+import numpy as np
+from pathlib import Path
+
+pytestmark = pytest.mark.smoke
+
+
+class CustomObject:
+ @classmethod
+ def load(cls, _path):
+ return CustomObject()
+
+ def save(self, _path):
+ ...
+
+
+def custom_object_store(object: CustomObject, path: str) -> str:
+ _path = Path(path).with_suffix(".xxx")
+ object.save(_path)
+ return str(_path)
+
+
+def custom_object_load(path: str) -> CustomObject:
+ _path = Path(path).with_suffix(".xxx")
+ return CustomObject.load(_path)
+
+
+@pytest.fixture
+def domain_with_custom_object() -> Domain:
+ domain = Domain()
+ domain.add_float(name="x1", low=0, high=1)
+ domain.add_parameter(name="custom_in", store_function=custom_object_store,
+ load_function=custom_object_load, to_disk=True)
+ domain.add_output(name="y")
+ domain.add_output(name="custom_out", store_function=custom_object_store,
+ load_function=custom_object_load, to_disk=True)
+ return domain
+
+
+def test_custom_object(domain_with_custom_object, tmp_path):
+ input_data = [{'custom_in': CustomObject(), 'x1': 0.5}]
+ output_data = [{'y': 1, 'custom_out': CustomObject()}]
+ data = ExperimentData(domain=domain_with_custom_object, input_data=input_data,
+ output_data=output_data, project_dir=tmp_path)
+
+ assert isinstance(data.data[0].input_data['custom_in'], CustomObject)
+ assert isinstance(data.data[0].output_data['custom_out'], CustomObject)
+ assert isinstance(data.data[0]._input_data['custom_in'], Path)
+
+
+def test_numpy_array_object(tmp_path):
+ domain = Domain()
+ domain.add_parameter('x', to_disk=True)
+ x = np.array([1, 2, 3])
+ input_data = [{'x': x}]
+ data = ExperimentData(
+ domain=domain, input_data=input_data, project_dir=tmp_path)
+
+ assert isinstance(data.data[0].input_data['x'], np.ndarray)
+ assert isinstance(data.data[0]._input_data['x'], Path)
+ assert np.allclose(data.data[0].input_data['x'], x)
+
+
+def test_pandas_dataframe_object(tmp_path):
+ domain = Domain()
+ domain.add_parameter('x', to_disk=True)
+ x = pd.DataFrame([{f'u{i}': 3.2 for i in range(10)} for _ in range(10)])
+ input_data = [{'x': x}]
+ data = ExperimentData(
+ domain=domain, input_data=input_data, project_dir=tmp_path)
+
+ assert isinstance(data.data[0].input_data['x'], pd.DataFrame)
+ assert isinstance(data.data[0]._input_data['x'], Path)
+ pd.testing.assert_frame_equal(data.data[0].input_data['x'], x)
+
+
+def test_xarray_object(tmp_path):
+ domain = Domain()
+ domain.add_parameter('x', to_disk=True)
+ x = pd.DataFrame([{f'u{i}': 3.2 for i in range(10)} for _ in range(10)])
+ input_data = [{'x': x}]
+ data = ExperimentData(
+ domain=domain, input_data=input_data, project_dir=tmp_path)
+
+ assert isinstance(data.data[0].input_data['x'], pd.DataFrame)
+ assert isinstance(data.data[0]._input_data['x'], Path)
+ pd.testing.assert_frame_equal(data.data[0].input_data['x'], x)
+
+
+def test_xarray_dataarray_object(tmp_path):
+ domain = Domain()
+ domain.add_parameter('x', to_disk=True)
+
+ # Create an xarray.DataArray
+ x = xr.DataArray(
+ data=[[3.2 for i in range(10)] for _ in range(10)],
+ dims=["row", "col"],
+ coords={"row": range(10), "col": [f'u{i}' for i in range(10)]},
+ name="x_data"
+ )
+
+ input_data = [{'x': x}]
+ data = ExperimentData(
+ domain=domain, input_data=input_data, project_dir=tmp_path)
+
+ # Assertions
+ assert isinstance(data.data[0].input_data['x'], xr.DataArray)
+ assert isinstance(data.data[0]._input_data['x'], Path)
+ xr.testing.assert_equal(data.data[0].input_data['x'], x)
+
+
+def test_xarray_dataset_object(tmp_path):
+ domain = Domain()
+ domain.add_parameter('x', to_disk=True)
+
+ # Create an xarray.DataArray
+ _x = xr.DataArray(
+ data=[[3.2 for i in range(10)] for _ in range(10)],
+ dims=["row", "col"],
+ coords={"row": range(10), "col": [f'u{i}' for i in range(10)]},
+ )
+
+ x = xr.Dataset({'x': _x})
+ input_data = [{'x': x}]
+ data = ExperimentData(
+ domain=domain, input_data=input_data, project_dir=tmp_path)
+
+ # Assertions
+ assert isinstance(data.data[0].input_data['x'], xr.Dataset)
+ assert isinstance(data.data[0]._input_data['x'], Path)
+ xr.testing.assert_equal(data.data[0].input_data['x'], x)
+
+
+def test_xarray_pickle_object(tmp_path):
+ domain = Domain()
+ domain.add_parameter('x', to_disk=True)
+
+ # Create an xarray.DataArray
+ x = CustomObject()
+ input_data = [{'x': x}]
+ data = ExperimentData(
+ domain=domain, input_data=input_data, project_dir=tmp_path)
+
+ # Assertions
+ assert isinstance(data.data[0].input_data['x'], CustomObject)
+ assert isinstance(data.data[0]._input_data['x'], Path)
diff --git a/tests/experimentdata/test_experimentsample.py b/tests/experimentdata/test_experimentsample.py
new file mode 100644
index 00000000..23f599b5
--- /dev/null
+++ b/tests/experimentdata/test_experimentsample.py
@@ -0,0 +1,206 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from f3dasm import ExperimentSample
+from f3dasm._src.experimentsample import JobStatus
+from f3dasm.design import Domain
+
+pytestmark = pytest.mark.smoke
+
+
+@pytest.fixture
+def sample_domain() -> Domain:
+ domain = Domain()
+ domain.add_float(name='x1')
+ domain.add_float(name='x2')
+ domain.add_output(name='y1')
+
+ return domain
+
+
+def test_initialization(sample_domain):
+ sample = ExperimentSample(
+ input_data={'x1': 1, 'x2': 2},
+ output_data={'y1': 3},
+ domain=sample_domain,
+ job_status='FINISHED',
+ project_dir=Path("/tmp")
+ )
+
+ assert sample.input_data == {'x1': 1, 'x2': 2}
+ assert sample.output_data == {'y1': 3}
+ assert sample.job_status == JobStatus.FINISHED
+ assert sample.project_dir == Path("/tmp")
+
+
+def test_default_initialization(sample_domain):
+ sample = ExperimentSample(domain=sample_domain)
+ assert sample.input_data == {}
+ assert sample.output_data == {}
+ assert sample.job_status == JobStatus.OPEN
+ assert sample.project_dir == Path.cwd()
+
+
+def test_from_numpy(sample_domain):
+ array = np.array([1.0, 2.0])
+ sample = ExperimentSample.from_numpy(array, domain=sample_domain)
+ assert sample.input_data == {'x1': 1.0, 'x2': 2.0}
+ assert sample.output_data == {}
+
+
+def test_from_numpy_no_domain():
+ array = np.array([1.0, 2.0])
+ sample = ExperimentSample.from_numpy(array)
+ assert sample.input_data == {'x0': 1.0, 'x1': 2.0}
+ assert sample.output_data == {}
+ expected_domain = Domain()
+ expected_domain.add_float(name='x0')
+ expected_domain.add_float(name='x1')
+ assert sample.domain == expected_domain
+
+
+def test_addition(sample_domain):
+ sample1 = ExperimentSample(input_data={'x1': 1}, output_data={
+ 'y1': 3}, domain=sample_domain)
+ sample2 = ExperimentSample(
+ input_data={'x2': 2}, output_data={}, domain=sample_domain)
+ combined = sample1 + sample2
+ assert combined.input_data == {'x1': 1, 'x2': 2}
+ assert combined.output_data == {'y1': 3}
+
+
+def test_equality(sample_domain):
+ sample1 = ExperimentSample(input_data={'x1': 1}, output_data={
+ 'y1': 3}, domain=sample_domain)
+ sample2 = ExperimentSample(input_data={'x1': 1}, output_data={
+ 'y1': 3}, domain=sample_domain)
+ assert sample1 == sample2
+
+
+def test_replace_nan(sample_domain):
+ sample = ExperimentSample(input_data={'x1': float('nan')}, output_data={
+ 'y1': 3}, domain=sample_domain)
+ sample.replace_nan(0)
+ assert sample.input_data == {'x1': 0}
+
+
+def test_round(sample_domain):
+ sample = ExperimentSample(input_data={'x1': 1.2345}, output_data={
+ 'y1': 3.6789}, domain=sample_domain)
+ sample.round(2)
+ assert sample.input_data == {'x1': 1.23}
+ assert sample.output_data == {'y1': 3.68}
+
+
+def test_store(sample_domain):
+ sample = ExperimentSample(domain=sample_domain)
+ sample.store('y2', 42, to_disk=False)
+ assert sample.output_data['y2'] == 42
+
+
+def test_mark(sample_domain):
+ sample = ExperimentSample(domain=sample_domain)
+ sample.mark('in_progress')
+ assert sample.job_status == JobStatus.IN_PROGRESS
+
+
+def test_to_multiindex(sample_domain):
+ sample = ExperimentSample(input_data={'x1': 1}, output_data={
+ 'y1': 3}, domain=sample_domain)
+ multiindex = sample.to_multiindex()
+ assert multiindex == {
+ ('jobs', ''): 'finished',
+ ('input', 'x1'): 1,
+ ('output', 'y1'): 3
+ }
+
+
+def test_to_numpy(sample_domain):
+ sample = ExperimentSample(input_data={'x1': 1, 'x2': 2}, output_data={
+ 'y1': 3}, domain=sample_domain)
+ input_array, output_array = sample.to_numpy()
+ np.testing.assert_array_equal(input_array, [1, 2])
+ np.testing.assert_array_equal(output_array, [3])
+
+
+def test_to_dict(sample_domain):
+ sample = ExperimentSample(input_data={'x1': 1, 'x2': 2}, output_data={
+ 'y1': 3}, domain=sample_domain)
+ dictionary = sample.to_dict()
+ assert dictionary == {'x1': 1, 'x2': 2, 'y1': 3}
+
+
+def test_invalid_status(sample_domain):
+ sample = ExperimentSample(domain=sample_domain)
+ with pytest.raises(ValueError):
+ sample.mark('invalid_status')
+
+
+def test_get(sample_domain):
+ sample = ExperimentSample(input_data={'x1': 1}, output_data={
+ 'y1': 3}, domain=sample_domain)
+ assert sample.get('x1') == 1
+ assert sample.get('y1') == 3
+ with pytest.raises(KeyError):
+ sample.get('nonexistent')
+
+
+def test_is_status(sample_domain):
+ """
+ Test the is_status method of the ExperimentSample class.
+
+ Parameters
+ ----------
+ sample_domain : Domain
+ The domain fixture for the experiment sample.
+ """
+ sample = ExperimentSample(domain=sample_domain, job_status='OPEN')
+ assert sample.is_status('open')
+ assert not sample.is_status('finished')
+
+
+def test_store_to_disk(sample_domain, tmp_path):
+ """
+ Test the store method of the ExperimentSample class with to_disk=True.
+
+ Parameters
+ ----------
+ sample_domain : Domain
+ The domain fixture for the experiment sample.
+ tmp_path : Path
+ Temporary directory for storing the object.
+ """
+ def dummy_store_function(obj, path):
+ with open(path, 'w') as f:
+ f.write(str(obj))
+ return path
+
+ def dummy_load_function(path):
+ with open(path, 'r') as f:
+ return f.read()
+
+ sample = ExperimentSample(domain=sample_domain, project_dir=tmp_path)
+ sample.store('y2', 42, to_disk=True, store_function=dummy_store_function,
+ load_function=dummy_load_function)
+ assert sample._output_data['y2'] == 42
+ assert sample.domain.output_space['y2'].to_disk
+ assert sample.domain.output_space['y2'].store_function == dummy_store_function
+ assert sample.domain.output_space['y2'].load_function == dummy_load_function
+
+
+def test_to_numpy_with_nan(sample_domain):
+ """
+ Test the to_numpy method of the ExperimentSample class with NaN values.
+
+ Parameters
+ ----------
+ sample_domain : Domain
+ The domain fixture for the experiment sample.
+ """
+ sample = ExperimentSample(input_data={'x1': float('nan'), 'x2': 2}, output_data={
+ 'y1': 3}, domain=sample_domain)
+ input_array, output_array = sample.to_numpy()
+ np.testing.assert_array_equal(input_array, [np.nan, 2])
+ np.testing.assert_array_equal(output_array, [3])
diff --git a/tests/functions/test_function.py b/tests/functions/test_function.py
index 108647d7..53d88f6c 100644
--- a/tests/functions/test_function.py
+++ b/tests/functions/test_function.py
@@ -1,18 +1,22 @@
import numpy as np
import pytest
+from f3dasm import ExperimentData
from f3dasm._src.datageneration.functions.pybenchfunction import Ackley
+from f3dasm.design import make_nd_continuous_domain
pytestmark = pytest.mark.smoke
+
def test_create_mesh_returns_correct_mesh_shape():
# Arrange
px = 10
- domain = np.array([[-5.0, 5.0], [-5.0, 5.0]])
- instance = Ackley(dimensionality=2)
-
+ arr = np.array([[-5.0, 5.0], [-5.0, 5.0]])
+ domain = make_nd_continuous_domain(bounds=arr)
+ instance = Ackley()
+ instance.arm(data=ExperimentData(domain=domain))
# Act
- xv, yv, Y = instance._create_mesh(px, domain)
+ xv, yv, Y = instance._create_mesh(px, arr)
# Assert
assert xv.shape == (px, px)
@@ -23,23 +27,15 @@ def test_create_mesh_returns_correct_mesh_shape():
def test_create_mesh_raises_value_error_with_invalid_px():
# Arrange
px = -10
- domain = np.array([[-5.0, 5.0], [-5.0, 5.0]])
- instance = Ackley(dimensionality=2)
+ arr = np.array([[-5.0, 5.0], [-5.0, 5.0]])
+ domain = make_nd_continuous_domain(bounds=arr)
+ instance = Ackley()
+
+ instance.arm(data=ExperimentData(domain=domain))
# Act / Assert
with pytest.raises(ValueError):
- instance._create_mesh(px, domain)
-
-
-# def test_create_mesh_raises_value_error_with_invalid_domain_shape():
-# # Arrange
-# px = 10
-# domain = np.array([[-5.0, 5.0], [-5.0, 5.0], [-5.0, 5.0]])
-# instance = Ackley(dimensionality=2)
-
-# # Act / Assert
-# with pytest.raises(ValueError):
-# instance._create_mesh(px, domain)
+ instance._create_mesh(px, arr)
if __name__ == "__main__": # pragma: no cover
diff --git a/tests/functions/test_scaling_and_offset.py b/tests/functions/test_scaling_and_offset.py
index 15011e50..b9968f82 100644
--- a/tests/functions/test_scaling_and_offset.py
+++ b/tests/functions/test_scaling_and_offset.py
@@ -3,10 +3,11 @@
import numpy as np
import pytest
+from f3dasm import ExperimentData
+from f3dasm._src.datageneration.datagenerator_factory import \
+ _datagenerator_factory
from f3dasm._src.datageneration.functions import (FUNCTIONS, Function,
get_function_classes)
-from f3dasm._src.datageneration.functions.function_factory import (
- _datagenerator_factory, is_dim_compatible)
from f3dasm.design import make_nd_continuous_domain
pytestmark = pytest.mark.smoke
@@ -17,72 +18,82 @@
def test_offset(function: Function, seed: int):
dim = 2
- bounds = np.tile([0.0, 1.0], (dim, 1))
+ domain = make_nd_continuous_domain(bounds=np.tile([0.0, 1.0], (dim, 1)))
func: Function = function(
seed=seed,
- dimensionality=dim,
- scale_bounds=bounds,
+ scale_bounds=domain.get_bounds(),
)
+ func.arm(data=ExperimentData(domain=domain))
+
xmin = func._get_global_minimum_for_offset_calculation()
- assert func.check_if_within_bounds(xmin, bounds=bounds)
+ assert func.check_if_within_bounds(xmin, bounds=domain.get_bounds())
@pytest.mark.parametrize("function", FUNCTIONS)
def test_check_global_minimum(function: str):
+ _func = _datagenerator_factory(
+ data_generator=function)
+
dim = 6
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(function, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 4
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(function, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 3
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(function, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 2
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
seed = 42
func = _datagenerator_factory(
- function, domain=domain, kwargs={'seed': seed})
+ data_generator=function, seed=seed)
+ func.arm(data=ExperimentData(domain=domain))
_ = func.get_global_minimum(dim)
@pytest.mark.parametrize("function", FUNCTIONS)
-@pytest.mark.parametrize("scale_bounds_list", ([-1.0, 0.0], [-1.0, 1.0], [0.0, 1.0], [-3.0, 1.0]))
+@pytest.mark.parametrize("scale_bounds_list",
+ ([-1.0, 0.0], [-1.0, 1.0], [0.0, 1.0], [-3.0, 1.0]))
def test_scaling_1(function: str, scale_bounds_list: List[float]):
+ _func = _datagenerator_factory(
+ data_generator=function)
+
dim = 6
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(function, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 4
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(function, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 3
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(function, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 2
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
seed = np.random.randint(low=0, high=1e5)
scale_bounds = np.tile(scale_bounds_list, (dim, 1))
- # func: Function = function(seed=seed, scale_bounds=scale_bounds, dimensionality=dim)
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- func = _datagenerator_factory(function, domain=domain, kwargs={
- 'seed': seed, 'scale_bounds': scale_bounds})
+ func = _datagenerator_factory(
+ data_generator=function, seed=seed, scale_bounds=scale_bounds)
+ func.arm(data=ExperimentData(domain=domain))
x = np.random.uniform(
- low=scale_bounds[0, 0], high=scale_bounds[0, 1], size=(1, func.dimensionality))
+ low=scale_bounds[0, 0], high=scale_bounds[0, 1],
+ size=(1, func.dimensionality))
assert func._retrieve_original_input(
func.augmentor.augment_input(x)) == pytest.approx(x)
diff --git a/tests/newdata/conftest.py b/tests/newdata/conftest.py
deleted file mode 100644
index be072701..00000000
--- a/tests/newdata/conftest.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import numpy as np
-import pytest
-
-from f3dasm._src.experimentdata._columns import _Columns
-from f3dasm._src.experimentdata._newdata import _Index
-from f3dasm.design import Domain
-
-
-@pytest.fixture(scope="package")
-def list_1():
- return [[np.array([0.3, 5.0, 0.34]), 'd', 3], [np.array(
- [0.23, 5.0, 0.0]), 'f', 4], [np.array([0.3, 5.0, 0.2]), 'c', 0]]
-
-
-@pytest.fixture(scope="package")
-def columns_1():
- return _Columns({'a': None, 'b': None, 'c': None})
-
-
-@pytest.fixture(scope="package")
-def indices_1():
- return _Index([3, 5, 6])
-
-
-@pytest.fixture(scope="package")
-def list_2():
- return [[np.array([0.3, 0.2])], [np.array([0.4, 0.3])], [np.array([0.0, 1.0])]]
-
-
-@pytest.fixture(scope="package")
-def columns_2():
- return _Columns({'a': None})
-
-
-@pytest.fixture(scope="package")
-def list_3():
- return [[np.array([1.1, 0.2])], [np.array([8.9, 0.3])], [np.array([0.0, 0.87])]]
-
-
-@pytest.fixture(scope="package")
-def domain():
- domain = Domain()
- domain.add_float('a', 0.0, 1.0)
- domain.add_float('b', 0.0, 1.0)
- domain.add_float('c', 0.0, 1.0)
- domain.add_category('d', ['a', 'b', 'c'])
- domain.add_int('e', 0, 10)
- return domain
diff --git a/tests/newdata/test_data.py b/tests/newdata/test_data.py
deleted file mode 100644
index 38b1b0ce..00000000
--- a/tests/newdata/test_data.py
+++ /dev/null
@@ -1,292 +0,0 @@
-from copy import deepcopy
-from typing import Any, List
-
-import numpy as np
-import pandas as pd
-import pytest
-
-from f3dasm._src.experimentdata._columns import _Columns
-from f3dasm._src.experimentdata._newdata import _Data, _Index
-from f3dasm.design import Domain
-
-pytestmark = pytest.mark.smoke
-
-DataType = List[List[Any]]
-
-
-def test_init(list_1: DataType):
- data = _Data(list_1)
- assert data.data == list_1
- assert data.columns.names == [0, 1, 2]
- assert data.indices.equals(pd.Index([0, 1, 2]))
-
-
-def test_init_with_columns(list_1: DataType, columns_1: _Columns):
- data = _Data(list_1, columns_1)
- assert data.data == list_1
- assert data.names == ['a', 'b', 'c']
-
-
-def test_init_with_columns_and_indices(
- list_1: DataType, columns_1: _Columns, indices_1: _Index):
- data = _Data(list_1, columns_1, indices_1)
- assert data.data == list_1
- assert data.names == ['a', 'b', 'c']
- assert data.indices.equals(pd.Index([3, 5, 6]))
-
-
-def test__len__(list_1: DataType):
- data = _Data(list_1)
- assert len(data) == 3
-
-
-def test__iter__(list_1: DataType):
- data = _Data(list_1)
- for i, row in enumerate(data):
- assert row == list_1[i]
-
-
-def test__getitem__(list_1: DataType):
- data = _Data(list_1)
- assert data[0].data[0] == list_1[0]
- assert data[1].data[0] == list_1[1]
- assert data[2].data[0] == list_1[2]
-
-
-def test__getitem__list(list_1: DataType):
- data = _Data(data=[[1, 2, 3], [4, 5, 6]], columns=_Columns(
- {'a': None, 'b': None, 'c': None}), index=_Index([3, 45]))
- assert data[[3, 45]].data == data.data
-
-
-def test__add__(list_1: DataType, list_3: DataType):
- data_1 = _Data(list_1)
- data_2 = _Data(list_3)
- data_3 = data_1 + data_2
- assert data_3.data == list_1 + list_3
- assert data_3.columns.names == [0, 1, 2]
-
-
-def test__add__empty(list_3: DataType):
- data_1 = _Data(columns=_Columns({0: None, 1: None, 2: None}))
- data_2 = _Data(list_3)
- data_3 = data_1 + data_2
- assert data_3.data == list_3
- assert data_3.columns.names == [0, 1, 2]
-
-
-def test__eq__(list_1: DataType):
- data_1 = _Data(list_1)
- data_2 = _Data(list_1)
- assert data_1 == data_2
-
-
-def test_repr_html(list_1: DataType):
- data = _Data(list_1)
- assert data._repr_html_() == data.to_dataframe()._repr_html_()
-
-# Properties
-# =============================================================================
-
-
-def test_names(list_1: DataType, columns_1: _Columns):
- data = _Data(list_1, columns=columns_1)
- assert data.names == ['a', 'b', 'c']
-
-
-def test_names_default(list_1: DataType):
- data = _Data(list_1)
- assert data.names == [0, 1, 2]
-
-
-def test_indices(list_1: DataType, indices_1: _Index):
- data = _Data(list_1, index=indices_1)
- assert data.indices.equals(pd.Index([3, 5, 6]))
-
-
-def test_indices_default(list_1: DataType):
- data = _Data(list_1)
- assert data.indices.equals(pd.Index([0, 1, 2]))
-
-# Alternative constructors
-# =============================================================================
-
-
-def test_from_indices():
- data = _Data.from_indices(pd.Index([0, 1]))
- assert data.indices.equals(pd.Index(([0, 1])))
- assert not data.names
- assert data.is_empty()
-
-
-def test_from_domain(domain: Domain):
- data = _Data.from_domain(domain)
- assert data.indices.equals(pd.Index([]))
- assert data.names == ['a', 'b', 'c', 'd', 'e']
- assert data.is_empty()
-
-
-def test_from_numpy():
- data = _Data.from_numpy(np.array([[1, 2, 3], [4, 5, 6]]))
- assert data.data == [[1, 2, 3], [4, 5, 6]]
- assert data.names == [0, 1, 2]
- assert data.indices.equals(pd.Index([0, 1]))
-
-
-def test_from_dataframe():
- data = _Data.from_dataframe(pd.DataFrame([[1, 2, 3], [4, 5, 6]]))
- assert data.data == [[1, 2, 3], [4, 5, 6]]
- assert data.names == [0, 1, 2]
- assert data.indices.equals(pd.Index([0, 1]))
-
-
-def test_reset():
- data = _Data.from_numpy(np.array([[1, 2, 3], [4, 5, 6]]))
- data.reset()
- assert data.data == []
- assert not data.names
- assert data.indices.equals(pd.Index([]))
-
-
-def test_reset_with_domain(domain: Domain):
- data = _Data.from_numpy(np.array([[1, 2, 3], [4, 5, 6]]))
- data.reset(domain)
- assert data.data == []
- assert data.names == domain.names
- assert data.indices.equals(pd.Index([]))
-
-# Export
-# =============================================================================
-
-
-def test_to_numpy(list_1: DataType):
- data = _Data(list_1)
- data.to_numpy()
-
-
-def to_dataframe(list_1: DataType):
- data = _Data(list_1)
- data.to_dataframe()
- assert data.to_dataframe().equals(pd.DataFrame(list_1))
-
-
-def test_select_columns(list_1: DataType, columns_1: _Columns):
- data = _Data(data=[[1, 2, 3], [4, 5, 6]], columns=columns_1)
- new_data = data.select_columns(['a', 'c'])
- assert new_data.names == ['a', 'c']
- assert new_data.data == [[1, 3], [4, 6]]
-
-
-def test_select_column(list_1: DataType, columns_1: _Columns):
- data = _Data(data=[[1, 2, 3], [4, 5, 6]], columns=columns_1)
- new_data = data.select_columns('a')
- assert new_data.names == ['a']
- assert new_data.data == [[1], [4]]
-
-
-def test_add(list_2: DataType, list_3: DataType):
- data_0 = _Data(deepcopy(list_2))
- data_1 = _Data(deepcopy(list_2))
- data_2 = _Data(list_3)
- data_1.add(data_2.to_dataframe())
- assert data_1 == (data_0 + data_2)
-
-
-def test_add_empty_rows():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]])
- data.add_empty_rows(2)
- assert data.data == [[1, 2, 3], [4, 5, 6], [
- np.nan, np.nan, np.nan], [np.nan, np.nan, np.nan]]
-
-
-def test_add_column():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]])
- data.add_column('a')
- assert data.data == [[1, 2, 3, np.nan], [4, 5, 6, np.nan]]
- assert data.names == [0, 1, 2, 'a']
-
-
-def test_remove():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]])
- data.remove(0)
- assert data.data == [[4, 5, 6]]
- assert data.names == [0, 1, 2]
-
-
-def test_remove_list():
- data = _Data(data=[[1, 2, 3], [4, 5, 6], [7, 8, 9]])
- data.remove([0, 2])
- assert data.data == [[4, 5, 6]]
- assert data.names == [0, 1, 2]
-
-
-def test_get_data_dict():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]])
- assert data.get_data_dict(0) == {0: 1, 1: 2, 2: 3}
-
-
-def test_set_data_all_columns():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]])
- data.set_data(index=0, value=[4, 5, 6])
- assert data.data == [[4, 5, 6], [4, 5, 6]]
-
-
-def test_set_data():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]], columns=_Columns(
- {'a': None, 'b': None, 'c': None}))
- data.set_data(index=0, value=99, column='b')
- assert data.data == [[1, 99, 3], [4, 5, 6]]
-
-
-def test_set_data_no_valid_index():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]], columns=_Columns(
- {'a': None, 'b': None, 'c': None}))
- with pytest.raises(IndexError):
- data.set_data(index=2, value=99, column='b')
-
-
-def test_set_data_unknown_column():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]], columns=_Columns(
- {'a': None, 'b': None, 'c': None}))
-
- data.set_data(index=0, value=99, column='d')
- assert data.names == ['a', 'b', 'c', 'd']
- assert data.data == [[1, 2, 3, 99], [4, 5, 6, np.nan]]
-
-
-def test_reset_index():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]], columns=_Columns(
- {'a': None, 'b': None, 'c': None}), index=_Index([3, 45]))
- data.reset_index()
- assert data.indices.equals(pd.Index([0, 1]))
-
-
-def test_is_empty():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]], columns=_Columns(
- {'a': None, 'b': None, 'c': None}), index=_Index([3, 45]))
- assert not data.is_empty()
- data.reset()
- assert data.is_empty()
-
-
-def test_has_columnnames():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]], columns=_Columns(
- {'a': None, 'b': None, 'c': None}), index=_Index([3, 45]))
- assert not data.has_columnnames('d')
- assert data.has_columnnames('c')
- data.add_column('d')
- assert data.has_columnnames('d')
-
-
-def test_set_columnnames():
- data = _Data(data=[[1, 2, 3], [4, 5, 6]], columns=_Columns(
- {'a': None, 'b': None, 'c': None}), index=_Index([3, 45]))
- data.set_columnnames(['d', 'f', 'g'])
- assert data.names == ['d', 'f', 'g']
-
-
-if __name__ == "__main__": # pragma: no cover
- pytest.main()
-
- # return [[np.array([0.3, 5.0, 0.34]), 'd', 3], [np.array(
- # [0.23, 5.0, 0.0]), 'f', 4], [np.array([0.3, 5.0, 0.2]), 'c', 0]]
diff --git a/tests/optimization/conftest.py b/tests/optimization/conftest.py
index 17884367..c955e570 100644
--- a/tests/optimization/conftest.py
+++ b/tests/optimization/conftest.py
@@ -1,7 +1,7 @@
import pytest
from f3dasm import ExperimentData
-from f3dasm._src.design.parameter import _ContinuousParameter
+from f3dasm._src.design.parameter import ContinuousParameter
from f3dasm.design import Domain
@@ -12,13 +12,14 @@ def data():
# Define the parameters
input_parameters = {
- "x1": _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- "x2": _ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
- "x3": _ContinuousParameter(lower_bound=0.6, upper_bound=7.3),
+ "x1": ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
+ "x2": ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
+ "x3": ContinuousParameter(lower_bound=0.6, upper_bound=7.3),
}
# Create the design space
- design = Domain(space=input_parameters)
+ design = Domain(input_space=input_parameters)
# Set the lower_bound and upper_bound of 'y' to None, indicating it has no bounds
- return ExperimentData.from_sampling(sampler='random', domain=design, n_samples=N, seed=seed)
+ return ExperimentData.from_sampling(sampler='random',
+ domain=design, n_samples=N, seed=seed)
diff --git a/tests/optimization/test_all_optimizers.py b/tests/optimization/test_all_optimizers.py
index b8005aa3..cb1d89e1 100644
--- a/tests/optimization/test_all_optimizers.py
+++ b/tests/optimization/test_all_optimizers.py
@@ -1,46 +1,39 @@
from __future__ import annotations
-from typing import List
-
import numpy as np
import pytest
from f3dasm import ExperimentData
-from f3dasm._src.datageneration.functions.function_factory import \
- is_dim_compatible
+from f3dasm._src.datageneration.datagenerator_factory import \
+ _datagenerator_factory
from f3dasm._src.optimization.optimizer_factory import _optimizer_factory
from f3dasm.datageneration import DataGenerator
from f3dasm.datageneration.functions import FUNCTIONS
from f3dasm.design import make_nd_continuous_domain
-from f3dasm.optimization import OPTIMIZERS, Optimizer
-
-
-@pytest.mark.smoke
-@pytest.mark.parametrize("optimizer", OPTIMIZERS)
-def test_get_info(data: ExperimentData, optimizer: str):
- opt: Optimizer = _optimizer_factory(optimizer, data.domain)
- characteristics = opt._get_info()
- assert isinstance(characteristics, List)
+from f3dasm.optimization import available_optimizers
@pytest.mark.parametrize("seed", [42])
-@pytest.mark.parametrize("optimizer", OPTIMIZERS)
+@pytest.mark.parametrize("optimizer", available_optimizers())
@pytest.mark.parametrize("data_generator", FUNCTIONS)
def test_all_optimizers_and_functions(seed: int, data_generator: str, optimizer: str):
i = 10 # iterations
+ _func = _datagenerator_factory(
+ data_generator=data_generator, seed=seed)
+
dim = 6
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(data_generator, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 4
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(data_generator, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 3
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(data_generator, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 2
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
@@ -52,10 +45,10 @@ def test_all_optimizers_and_functions(seed: int, data_generator: str, optimizer:
data2 = ExperimentData.from_sampling(
sampler='random', domain=domain, n_samples=30, seed=seed)
- data1.evaluate(data_generator, kwargs={'noise': None, 'seed': seed,
- 'scale_bounds': np.tile([-1.0, 1.0], (dim, 1))})
- data2.evaluate(data_generator, kwargs={'noise': None, 'seed': seed,
- 'scale_bounds': np.tile([-1.0, 1.0], (dim, 1))})
+ data1.evaluate(data_generator=data_generator, noise=None, seed=seed,
+ scale_bounds=np.tile([-1.0, 1.0], (dim, 1)))
+ data2.evaluate(data_generator=data_generator, noise=None, seed=seed,
+ scale_bounds=np.tile([-1.0, 1.0], (dim, 1)))
data1.optimize(optimizer=optimizer, data_generator=data_generator,
iterations=i, kwargs={'noise': None, 'seed': seed,
@@ -66,62 +59,74 @@ def test_all_optimizers_and_functions(seed: int, data_generator: str, optimizer:
'scale_bounds': np.tile([-1.0, 1.0], (dim, 1))},
hyperparameters={'seed': seed})
+ data1.replace_nan(None)
+ data2.replace_nan(None)
+
assert (data1 == data2)
-@pytest.mark.smoke
-@pytest.mark.parametrize("seed", [42])
-@pytest.mark.parametrize("optimizer", OPTIMIZERS)
-@pytest.mark.parametrize("data_generator", ['levy', 'ackley', 'sphere'])
+@ pytest.mark.smoke
+@ pytest.mark.parametrize("seed", [42])
+@ pytest.mark.parametrize("optimizer", available_optimizers())
+@ pytest.mark.parametrize("data_generator", ['levy', 'ackley', 'sphere'])
def test_all_optimizers_3_functions(seed: int, data_generator: DataGenerator, optimizer: str):
test_all_optimizers_and_functions(seed, data_generator, optimizer)
# TODO: Use stored data to assess this property (maybe hypothesis ?)
-@pytest.mark.smoke
-@pytest.mark.parametrize("iterations", [10, 23, 66, 86])
-@pytest.mark.parametrize("optimizer", OPTIMIZERS)
-@pytest.mark.parametrize("data_generator", ["sphere"])
-@pytest.mark.parametrize("x0_selection", ["best", "new"])
+@ pytest.mark.smoke
+@ pytest.mark.parametrize("iterations", [10, 23, 66, 86])
+@ pytest.mark.parametrize("optimizer", available_optimizers())
+@ pytest.mark.parametrize("data_generator", ["sphere"])
+@ pytest.mark.parametrize("x0_selection", ["best", "new"])
def test_optimizer_iterations(iterations: int, data_generator: str,
optimizer: str, x0_selection: str):
numsamples = 40 # initial samples
seed = 42
+ _func = _datagenerator_factory(
+ data_generator=data_generator)
+
dim = 6
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(data_generator, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 4
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(data_generator, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 3
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
- if not is_dim_compatible(data_generator, domain):
+ if not _func.is_dim_compatible(d=dim):
dim = 2
domain = make_nd_continuous_domain(bounds=np.tile(
[-1.0, 1.0], (dim, 1)), dimensionality=dim)
-
data = ExperimentData.from_sampling(
sampler='random', domain=domain, n_samples=numsamples, seed=seed)
# func = data_generator(noise=None, seed=seed, scale_bounds=np.tile([-1.0, 1.0], (dim, 1)), dimensionality=dim)
# Evaluate the initial samples
- data.evaluate(data_generator, mode='sequential', kwargs={'seed': seed, 'noise': None,
- 'scale_bounds': np.tile([-1.0, 1.0], (dim, 1)), })
+ data.evaluate(data_generator, mode='sequential', seed=seed, noise=None,
+ scale_bounds=np.tile([-1.0, 1.0], (dim, 1)))
- _optimizer = _optimizer_factory(optimizer, domain=domain)
+ _data_generator = _datagenerator_factory(
+ data_generator=data_generator,
+ scale_bounds=np.tile([-1.0, 1.0], (dim, 1)), seed=seed)
- if x0_selection == "new" and iterations < _optimizer._population:
+ _optimizer = _optimizer_factory(optimizer)
+ population = _optimizer._population if hasattr(
+ _optimizer, '_population') else 1
+ if x0_selection == "new" and iterations < population:
with pytest.raises(ValueError):
- data.optimize(optimizer=optimizer, data_generator=data_generator,
- iterations=iterations, kwargs={'seed': seed, 'noise': None,
- 'scale_bounds': np.tile([-1.0, 1.0], (dim, 1)), },
- hyperparameters={'seed': seed},
- x0_selection=x0_selection)
+ data.optimize(
+ optimizer=optimizer, data_generator=data_generator,
+ iterations=iterations,
+ kwargs={'seed': seed, 'noise': None,
+ 'scale_bounds': np.tile([-1.0, 1.0], (dim, 1)), },
+ hyperparameters={'seed': seed},
+ x0_selection=x0_selection)
else:
data.optimize(optimizer=optimizer, data_generator=data_generator,
diff --git a/tests/optimization/test_run_optimization.py b/tests/optimization/test_run_optimization.py
index 3aa3639e..e047a3ff 100644
--- a/tests/optimization/test_run_optimization.py
+++ b/tests/optimization/test_run_optimization.py
@@ -12,18 +12,18 @@
from pathos.helpers import mp
# Locals
-from f3dasm import ExperimentData, logger
-from f3dasm._src.datageneration.functions.function_factory import \
+from f3dasm import Block, ExperimentData, logger
+from f3dasm._src.datageneration.datagenerator_factory import \
_datagenerator_factory
from f3dasm._src.optimization.optimizer_factory import _optimizer_factory
from f3dasm.datageneration import DataGenerator
from f3dasm.datageneration.functions import FUNCTIONS_2D, FUNCTIONS_7D
from f3dasm.design import Domain, make_nd_continuous_domain
-from f3dasm.optimization import OPTIMIZERS, Optimizer
+from f3dasm.optimization import available_optimizers
class OptimizationResult:
- def __init__(self, data: List[ExperimentData], optimizer: Optimizer,
+ def __init__(self, data: List[ExperimentData], optimizer: Block,
kwargs: Optional[Dict[str, Any]],
data_generator: DataGenerator,
number_of_samples: int, seeds: List[int],
@@ -48,8 +48,6 @@ def __init__(self, data: List[ExperimentData], optimizer: Optimizer,
total optimization time
"""
self.data = data
- self.optimizer = _optimizer_factory(
- optimizer=optimizer, domain=self.data[0].domain)
self.data_generator = data_generator
self.kwargs = kwargs,
self.number_of_samples = number_of_samples
@@ -57,8 +55,8 @@ def __init__(self, data: List[ExperimentData], optimizer: Optimizer,
self.opt_time = opt_time
self.func = _datagenerator_factory(
- data_generator=self.data_generator,
- domain=self.data[0].domain, kwargs=kwargs)
+ data_generator=self.data_generator, **kwargs)
+ self.optimizer = _optimizer_factory(optimizer=optimizer)
self._log()
def _log(self):
@@ -96,7 +94,7 @@ def to_xarray(self) -> xr.Dataset:
def run_optimization(
- optimizer: Optimizer | str,
+ optimizer: Block | str,
data_generator: DataGenerator | str,
sampler: Callable | str,
domain: Domain,
@@ -140,14 +138,16 @@ def run_optimization(
hyperparameters = {}
# Set function seed
- optimizer = _optimizer_factory(
- optimizer=optimizer, domain=domain, hyperparameters=hyperparameters)
+ data_generator = _datagenerator_factory(
+ data_generator=data_generator, **kwargs)
+
+ optimizer = _optimizer_factory(optimizer=optimizer, **hyperparameters)
# Sample
data = ExperimentData.from_sampling(
sampler=sampler, domain=domain, n_samples=number_of_samples, seed=seed)
- data.evaluate(data_generator, mode='sequential', kwargs=kwargs)
+ data.evaluate(data_generator, mode='sequential', **kwargs)
data.optimize(optimizer=optimizer, data_generator=data_generator,
iterations=iterations, kwargs=kwargs,
hyperparameters=hyperparameters)
@@ -156,7 +156,7 @@ def run_optimization(
def run_multiple_realizations(
- optimizer: Optimizer,
+ optimizer: Block,
data_generator: DataGenerator | str,
sampler: Callable | str,
domain: Domain,
@@ -245,7 +245,7 @@ def run_multiple_realizations(
@pytest.mark.smoke
-@pytest.mark.parametrize("optimizer", OPTIMIZERS)
+@pytest.mark.parametrize("optimizer", available_optimizers())
@pytest.mark.parametrize("data_generator", ['Levy', 'Ackley', 'Sphere'])
@pytest.mark.parametrize("dimensionality", [2])
def test_run_multiple_realizations_3_functions(data_generator: str,
@@ -253,7 +253,7 @@ def test_run_multiple_realizations_3_functions(data_generator: str,
test_run_multiple_realizations(data_generator, optimizer, dimensionality)
-@pytest.mark.parametrize("optimizer", OPTIMIZERS)
+@pytest.mark.parametrize("optimizer", available_optimizers())
@pytest.mark.parametrize("data_generator", FUNCTIONS_2D)
@pytest.mark.parametrize("dimensionality", [2])
def test_run_multiple_realizations(data_generator: str, optimizer: str, dimensionality: int):
@@ -273,7 +273,12 @@ def test_run_multiple_realizations(data_generator: str, optimizer: str, dimensio
else:
PARALLELIZATION = True
- if optimizer in ['EvoSaxCMAES', 'EvoSaxSimAnneal', 'EvoSaxPSO', 'EvoSaxDE']:
+ data_generator_ = _datagenerator_factory(
+ data_generator=data_generator, **kwargs)
+ optimizer_ = _optimizer_factory(optimizer=optimizer)
+
+ opt_type = optimizer_.type if hasattr(optimizer_, 'type') else None
+ if opt_type == 'evosax':
PARALLELIZATION = False
_ = run_multiple_realizations(
@@ -288,14 +293,14 @@ def test_run_multiple_realizations(data_generator: str, optimizer: str, dimensio
)
-@pytest.mark.parametrize("optimizer", OPTIMIZERS)
+@pytest.mark.parametrize("optimizer", available_optimizers())
@pytest.mark.parametrize("data_generator", FUNCTIONS_7D)
@pytest.mark.parametrize("dimensionality", [7])
def test_run_multiple_realizations_7D(data_generator: str, optimizer: str, dimensionality: int):
test_run_multiple_realizations(data_generator, optimizer, dimensionality)
-@pytest.mark.parametrize("optimizer", OPTIMIZERS)
+@pytest.mark.parametrize("optimizer", available_optimizers())
@pytest.mark.parametrize("data_generator", ['griewank'])
@pytest.mark.parametrize("dimensionality", [2])
def test_run_multiple_realizations_fast(data_generator: str, optimizer: str, dimensionality: int):
diff --git a/tests/sampling/conftest.py b/tests/sampling/conftest.py
index dc14fcd6..214506ac 100644
--- a/tests/sampling/conftest.py
+++ b/tests/sampling/conftest.py
@@ -1,8 +1,8 @@
import pytest
-from f3dasm._src.design.parameter import (_CategoricalParameter,
- _ContinuousParameter,
- _DiscreteParameter)
+from f3dasm._src.design.parameter import (CategoricalParameter,
+ ContinuousParameter,
+ DiscreteParameter)
from f3dasm.design import Domain
@@ -10,16 +10,16 @@
def design():
# Define the parameters
parameters = {
- "x1": _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- "x2": _DiscreteParameter(lower_bound=5, upper_bound=80),
- "x3": _ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
- "x4": _CategoricalParameter(categories=["test1", "test2", "test3"]),
- "x5": _DiscreteParameter(lower_bound=3, upper_bound=6),
- "x6": _CategoricalParameter(categories=["material1", "material2", "material3"]),
+ "x1": ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
+ "x2": DiscreteParameter(lower_bound=5, upper_bound=80),
+ "x3": ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
+ "x4": CategoricalParameter(categories=["test1", "test2", "test3"]),
+ "x5": DiscreteParameter(lower_bound=3, upper_bound=6),
+ "x6": CategoricalParameter(categories=["material1", "material2", "material3"]),
}
# Create the design space
- design = Domain(parameters)
+ design = Domain(input_space=parameters)
return design
@@ -27,16 +27,16 @@ def design():
def design2():
# Define the parameters
parameters = {
- "x1": _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- "x2": _CategoricalParameter(categories=["main"]),
- "x3": _ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
- "x4": _CategoricalParameter(categories=["test" + str(i) for i in range(80)]),
- "x5": _DiscreteParameter(lower_bound=3, upper_bound=6),
- "x6": _CategoricalParameter(categories=["material" + str(i) for i in range(20)]),
+ "x1": ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
+ "x2": CategoricalParameter(categories=["main"]),
+ "x3": ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
+ "x4": CategoricalParameter(categories=["test" + str(i) for i in range(80)]),
+ "x5": DiscreteParameter(lower_bound=3, upper_bound=6),
+ "x6": CategoricalParameter(categories=["material" + str(i) for i in range(20)]),
}
# Create the design space
- design = Domain(parameters)
+ design = Domain(input_space=parameters)
return design
@@ -44,15 +44,15 @@ def design2():
def design3():
# Define the parameters
parameters = {
- "x1": _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- "x2": _DiscreteParameter(lower_bound=5, upper_bound=80),
- "x3": _ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
- "x4": _CategoricalParameter(categories=["test1", "test2", "test3"]),
- "x5": _ContinuousParameter(lower_bound=0.6, upper_bound=7.3),
+ "x1": ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
+ "x2": DiscreteParameter(lower_bound=5, upper_bound=80),
+ "x3": ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
+ "x4": CategoricalParameter(categories=["test1", "test2", "test3"]),
+ "x5": ContinuousParameter(lower_bound=0.6, upper_bound=7.3),
}
# Create the design space
- design = Domain(parameters)
+ design = Domain(input_space=parameters)
return design
@@ -60,15 +60,15 @@ def design3():
def design4():
# Define the parameters
parameters = {
- "x1": _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- "x2": _DiscreteParameter(lower_bound=5, upper_bound=80),
- "x3": _ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
- "x4": _CategoricalParameter(categories=["test1", "test2", "test3"]),
- "x5": _DiscreteParameter(lower_bound=3, upper_bound=6),
+ "x1": ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
+ "x2": DiscreteParameter(lower_bound=5, upper_bound=80),
+ "x3": ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
+ "x4": CategoricalParameter(categories=["test1", "test2", "test3"]),
+ "x5": DiscreteParameter(lower_bound=3, upper_bound=6),
}
# Create the design space
- design = Domain(parameters)
+ design = Domain(input_space=parameters)
return design
@@ -76,14 +76,14 @@ def design4():
def design5():
# Define the parameters
parameters = {
- "x1": _ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
- "x2": _DiscreteParameter(lower_bound=5, upper_bound=80),
- "x3": _ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
- "x4": _CategoricalParameter(categories=["test1", "test2", "test3"]),
- "x5": _DiscreteParameter(lower_bound=3, upper_bound=6),
- "x6": _DiscreteParameter(lower_bound=500, upper_bound=532),
+ "x1": ContinuousParameter(lower_bound=2.4, upper_bound=10.3),
+ "x2": DiscreteParameter(lower_bound=5, upper_bound=80),
+ "x3": ContinuousParameter(lower_bound=10.0, upper_bound=380.3),
+ "x4": CategoricalParameter(categories=["test1", "test2", "test3"]),
+ "x5": DiscreteParameter(lower_bound=3, upper_bound=6),
+ "x6": DiscreteParameter(lower_bound=500, upper_bound=532),
}
# Create the design space
- design = Domain(parameters)
+ design = Domain(input_space=parameters)
return design
diff --git a/tests/sampling/test_hypothesis.py b/tests/sampling/test_hypothesis.py
index 821a1fd9..c9828716 100644
--- a/tests/sampling/test_hypothesis.py
+++ b/tests/sampling/test_hypothesis.py
@@ -6,9 +6,9 @@
from hypothesis.strategies import (SearchStrategy, composite, floats, integers,
text)
-from f3dasm._src.design.parameter import (_CategoricalParameter,
- _ContinuousParameter,
- _DiscreteParameter, _Parameter)
+from f3dasm._src.design.parameter import (CategoricalParameter,
+ ContinuousParameter,
+ DiscreteParameter, Parameter)
from f3dasm.design import Domain
pytestmark = pytest.mark.smoke
@@ -20,14 +20,14 @@ def design_space(draw: Callable[[SearchStrategy[int]], int], min_value: int = 1,
_name = text(alphabet="abcdefghijklmnopqrstuvwxyz",
min_size=10, max_size=10)
- def get_space(number_of_parameters: int) -> Dict[str, _Parameter]:
+ def get_space(number_of_parameters: int) -> Dict[str, Parameter]:
space = {}
names = []
for _ in range(number_of_parameters):
names.append(_name.filter(lambda x: x not in names))
for i in range(number_of_parameters):
- parameter: _Parameter = np.random.choice(
+ parameter: Parameter = np.random.choice(
a=["ContinuousSpace", "DiscreteSpace", "CategoricalSpace"]
)
name = names[i]
@@ -38,7 +38,7 @@ def get_space(number_of_parameters: int) -> Dict[str, _Parameter]:
draw(floats(min_value=0.1)),
)
- space[name] = _ContinuousParameter(
+ space[name] = ContinuousParameter(
lower_bound=lower_bound, upper_bound=upper_bound)
elif parameter == "DiscreteSpace":
@@ -47,16 +47,16 @@ def get_space(number_of_parameters: int) -> Dict[str, _Parameter]:
draw(integers(min_value=1)),
)
- space[name] = _DiscreteParameter(
+ space[name] = DiscreteParameter(
lower_bound=lower_bound, upper_bound=upper_bound)
elif parameter == "CategoricalSpace":
categories = ["test1", "test2"]
- space[name] = _CategoricalParameter(categories=categories)
+ space[name] = CategoricalParameter(categories=categories)
return space
design_space = Domain(
- space=get_space(number_of_input_parameters),
+ input_space=get_space(number_of_input_parameters),
)
return design_space
@@ -64,11 +64,11 @@ def get_space(number_of_parameters: int) -> Dict[str, _Parameter]:
@given(design_space())
@settings(max_examples=10)
def test_check_length_input_when_adding_parameter(design: Domain):
- length_input_space = len(design.space)
- parameter = _DiscreteParameter()
+ length_input_space = len(design.input_space)
+ parameter = DiscreteParameter()
kwargs = {'low': parameter.lower_bound, 'high': parameter.upper_bound}
design.add(name="test", type='int', **kwargs)
- assert length_input_space + 1 == (len(design.space))
+ assert length_input_space + 1 == (len(design.input_space))
if __name__ == "__main__": # pragma: no cover
diff --git a/tests/sampling/test_sampling.py b/tests/sampling/test_sampling.py
index b542840b..c8348254 100644
--- a/tests/sampling/test_sampling.py
+++ b/tests/sampling/test_sampling.py
@@ -4,7 +4,7 @@
from pandas.testing import assert_frame_equal
from f3dasm import ExperimentData
-from f3dasm._src.design.parameter import _ContinuousParameter
+from f3dasm._src.design.parameter import ContinuousParameter
from f3dasm.design import Domain
pytestmark = pytest.mark.smoke
@@ -14,7 +14,7 @@ def test_sampling_interface_not_implemented_error():
seed = 42
# Define the parameters
- x1 = _ContinuousParameter(lower_bound=2.4, upper_bound=10.3)
+ x1 = ContinuousParameter(lower_bound=2.4, upper_bound=10.3)
space = {'x1': x1}
design = Domain(space)
@@ -49,8 +49,6 @@ def test_correct_sampling_ran(design3: Domain):
samples = ExperimentData(domain=design3)
samples.sample(sampler='random', n_samples=numsamples, seed=seed)
- samples._input_data.round(6)
-
df_input, _ = samples.to_pandas()
df_input.columns = df_ground_truth.columns
diff --git a/tests/sampling/test_sampling_grid.py b/tests/sampling/test_sampling_grid.py
new file mode 100644
index 00000000..f135ea81
--- /dev/null
+++ b/tests/sampling/test_sampling_grid.py
@@ -0,0 +1,149 @@
+from itertools import product
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from f3dasm import ExperimentData
+from f3dasm._src.design.samplers import Grid
+from f3dasm.design import Domain
+
+pytestmark = pytest.mark.smoke
+
+
+@pytest.fixture
+def sample_domain() -> Domain:
+ """Fixture to provide a sample domain."""
+
+ domain = Domain()
+
+ domain.add_float(name='x1', low=0, high=1)
+ domain.add_float(name='x2', low=2, high=4)
+ domain.add_int(name='d1', low=1, high=3)
+ domain.add_category(name='cat1', categories=["A", "B", "C"])
+ domain.add_constant(name='const1', value=42)
+ return domain
+
+
+@pytest.fixture
+def sample_domain_no_continuous() -> Domain:
+ """Fixture to provide a sample domain."""
+
+ domain = Domain()
+ domain.add_int(name='d1', low=1, high=3)
+ domain.add_category(name='cat1', categories=["A", "B", "C"])
+ domain.add_constant(name='const1', value=42)
+ return domain
+
+
+def test_grid_sample_with_default_steps(sample_domain):
+ """Test Grid sampler with default step size."""
+ grid_sampler = Grid()
+ experiment_data = ExperimentData(domain=sample_domain)
+ grid_sampler.arm(experiment_data)
+
+ stepsize = 0.5
+ samples = grid_sampler.call(data=experiment_data,
+ stepsize_continuous_parameters=stepsize)
+ df, _ = samples.to_pandas()
+ # Expected continuous values
+ x1_values = np.arange(0, 1, stepsize)
+ x2_values = np.arange(2, 4, stepsize)
+
+ # Expected discrete values
+ d1_values = [1, 2, 3]
+
+ # Expected categorical values
+ cat1_values = ["A", "B", "C"]
+
+ # Generate all combinations
+ expected_combinations = list(
+ product(x1_values, x2_values, d1_values, cat1_values, [42]))
+
+ # Convert to DataFrame
+ expected_df = pd.DataFrame(
+ expected_combinations,
+ columns=["x1", "x2", "d1", "cat1", "const1"],
+ )
+
+ df.sort_values(by=['x1', 'x2', 'd1', 'cat1', 'const1'],
+ inplace=True, ignore_index=True)
+ expected_df.sort_values(
+ ["x1", "x2", "d1", "cat1", "const1"], inplace=True, ignore_index=True)
+
+ # Assert equality
+ pd.testing.assert_frame_equal(df, expected_df, check_dtype=False)
+
+
+def test_grid_sample_with_custom_steps(sample_domain):
+ """Test Grid sampler with custom step sizes for continuous parameters."""
+ grid_sampler = Grid()
+ experiment_data = ExperimentData(domain=sample_domain)
+ grid_sampler.arm(experiment_data)
+
+ custom_steps = {"x1": 0.25, "x2": 0.5}
+ samples = grid_sampler.call(data=experiment_data,
+ stepsize_continuous_parameters=custom_steps)
+ df, _ = samples.to_pandas()
+
+ # Expected continuous values
+ x1_values = np.arange(0, 1, custom_steps["x1"])
+ x2_values = np.arange(2, 4, custom_steps["x2"])
+
+ # Expected discrete values
+ d1_values = [1, 2, 3]
+
+ # Expected categorical values
+ cat1_values = ["A", "B", "C"]
+
+ # Generate all combinations
+ expected_combinations = list(
+ product(x1_values, x2_values, d1_values, cat1_values, [42]))
+
+ # Convert to DataFrame
+ expected_df = pd.DataFrame(
+ expected_combinations,
+ columns=["x1", "x2", "d1", "cat1", "const1"],
+ )
+
+ df.sort_values(by=['x1', 'x2', 'd1', 'cat1', 'const1'],
+ inplace=True, ignore_index=True)
+ expected_df.sort_values(
+ ["x1", "x2", "d1", "cat1", "const1"], inplace=True, ignore_index=True)
+
+ # Assert equality
+ pd.testing.assert_frame_equal(df, expected_df, check_dtype=False)
+
+
+def test_grid_sample_with_no_continuous(sample_domain_no_continuous):
+ """Test Grid sampler with no continuous parameters."""
+ grid_sampler = Grid()
+ experiment_data = ExperimentData(domain=sample_domain_no_continuous)
+ grid_sampler.arm(experiment_data)
+
+ samples = grid_sampler.call(data=experiment_data,
+ stepsize_continuous_parameters=None)
+ df, _ = samples.to_pandas()
+
+ # Expected discrete values
+ d1_values = [1, 2, 3]
+
+ # Expected categorical values
+ cat1_values = ["A", "B", "C"]
+
+ # Generate all combinations
+ expected_combinations = list(product(d1_values, cat1_values, [42]))
+
+ # Convert to DataFrame
+ expected_df = pd.DataFrame(
+ expected_combinations,
+ columns=["d1", "cat1", "const1"],
+ )
+
+ df.sort_values(by=['d1', 'cat1', 'const1'],
+ inplace=True, ignore_index=True)
+ expected_df.sort_values(
+ ["d1", "cat1", "const1"], inplace=True, ignore_index=True)
+
+ # Assert equality
+ pd.testing.assert_frame_equal(df, expected_df, check_dtype=False)
diff --git a/tests/test_hydra_utils.py b/tests/test_hydra_utils.py
new file mode 100644
index 00000000..88b11baa
--- /dev/null
+++ b/tests/test_hydra_utils.py
@@ -0,0 +1,42 @@
+import pytest
+from omegaconf import OmegaConf
+
+from f3dasm._src.experimentsample import ExperimentSample
+from f3dasm._src.hydra_utils import update_config_with_experiment_sample
+from f3dasm.design import Domain
+
+pytestmark = pytest.mark.smoke
+
+
+@pytest.fixture
+def sample_config():
+ return OmegaConf.create({
+ 'parameter1': 1,
+ 'parameter2': 2,
+ 'nested': {
+ 'parameter3': 3
+ }
+ })
+
+
+@pytest.fixture
+def experiment_sample():
+
+ domain = Domain()
+ domain.add_parameter('parameter1')
+ domain.add_parameter('nested.parameter3')
+ domain.add_output('parameter2')
+ return ExperimentSample(
+ input_data={'parameter1': 10, 'nested.parameter3': 30},
+ output_data={'parameter2': 20},
+ domain=domain
+ )
+
+
+def test_update_config_with_experiment_sample(sample_config, experiment_sample):
+ updated_config = update_config_with_experiment_sample(
+ sample_config, experiment_sample)
+
+ assert updated_config.parameter1 == 10
+ assert updated_config.parameter2 == 20
+ assert updated_config.nested.parameter3 == 30
\n",
+ " ![\"Block\"](\"block.png\" "\\"Block\\"")
\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```python\n",
+ "class CustomBlock(Block)\n",
+ " def call(self):\n",
+ " ...\n",
+ " # Any method that manipulates dthe experiments\n",
+ " ...\n",
+ " return self.data\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "In order to start the data-driven process, you need to create an `ExperimentData` instance and call the `run()` method of experiment data instance with the block object(s) you want to run."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```pyton\n",
+ "custom_block = CustomBlock()\n",
+ "\n",
+ "experiment_data.run(block=custom_block)\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Multiple blocks can be chained together by passing a list of blocks to the `run` method.\n",
+ "\n",
+ "```python\n",
+ "experiment_data.run(block=[custom_block, another_custom_block])\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ " ![\"Blocks\"](\"blocks.png\" "\\"Blocks\\"")
\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "A single block or a list of blocks can be 'looped' over by passing them through the `f3dasm.loop` function. This function will return a new block that will run the original block(s) multiple times.\n",
+ "\n",
+ "```python\n",
+ "\n",
+ "from f3dasm import loop\n",
+ "\n",
+ "looped_block = loop(custom_block, n_loops=10)\n",
+ "\n",
+ "experiment_data.run(block=looped_block)\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ " ![\"Block](\"blocks_loop.png\" "\\"Block")
\n",
+ "
"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "f3dasm_env3",
+ "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.17"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/source/notebooks/data-driven/blocks.png b/docs/source/notebooks/data-driven/blocks.png
new file mode 100644
index 00000000..27f06379
Binary files /dev/null and b/docs/source/notebooks/data-driven/blocks.png differ
diff --git a/docs/source/notebooks/data-driven/blocks.svg b/docs/source/notebooks/data-driven/blocks.svg
new file mode 100644
index 00000000..d6a0c985
--- /dev/null
+++ b/docs/source/notebooks/data-driven/blocks.svg
@@ -0,0 +1,246 @@
+
+
+
+
diff --git a/docs/source/notebooks/data-driven/blocks_loop.png b/docs/source/notebooks/data-driven/blocks_loop.png
new file mode 100644
index 00000000..f89b1466
Binary files /dev/null and b/docs/source/notebooks/data-driven/blocks_loop.png differ
diff --git a/docs/source/notebooks/data-driven/blocks_loop.svg b/docs/source/notebooks/data-driven/blocks_loop.svg
new file mode 100644
index 00000000..e43ddb9a
--- /dev/null
+++ b/docs/source/notebooks/data-driven/blocks_loop.svg
@@ -0,0 +1,265 @@
+
+
+
+
diff --git a/docs/source/notebooks/data-driven/carstoppingdistance.ipynb b/docs/source/notebooks/data-driven/carstoppingdistance.ipynb
new file mode 100644
index 00000000..30e89e04
--- /dev/null
+++ b/docs/source/notebooks/data-driven/carstoppingdistance.ipynb
@@ -0,0 +1,801 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Car stopping distance problem\n",
+ "\n",
+ "In this example, we will implement a data-driven process that generates output for a data-driven experiment. We will use the βcar stopping distanceβ problem as an example."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ " ![\"car](\"reaction-braking-stopping.png\" "\\"car")
\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Defining the problem\n",
+ "\n",
+ "Car stopping distance $y$ as a function of its velocity $x$ before it starts braking:\n",
+ "\n",
+ "$y = z x + \\frac{1}{2 \\mu g} x^2 = z x + 0.1 x^2$\n",
+ "- $z$ is the driver's reaction time (in seconds)\n",
+ "- $\\mu$ is the road/tires coefficient of friction (we assume $\\mu=0.5$)\n",
+ "- $g$ is the acceleration of gravity (assume $g=10 m/s^2$).\n",
+ "\n",
+ "$y = d_r + d_{b}$\n",
+ "- where $d_r$ is the reaction distance, and $d_b$ is the braking distance.\n",
+ "\n",
+ "Reaction distance $d_r$:\n",
+ "\n",
+ "$d_r = z x$\n",
+ "- with $z$ being the driver's reaction time, $x$ being the velocity of the car at the start of braking.\n",
+ "\n",
+ "Kinetic energy of moving car:\n",
+ "\n",
+ "$E = \\frac{1}{2}m x^2$\n",
+ "- where $m$ is the car mass.\n",
+ "\n",
+ "Work done by braking:\n",
+ "\n",
+ "$W = \\mu m g d_b$\n",
+ "- where $\\mu$ is the coefficient of friction between the road and the tire, $g$ is the acceleration of gravity, and $d_b$ is the car braking distance.\n",
+ "\n",
+ "The braking distance follows from $E=W$:\n",
+ "\n",
+ "$d_b = \\frac{1}{2\\mu g}x^2$\n",
+ "\n",
+ "Therefore, if we add the reacting distance $d_r$ to the braking distance $d_b$ we get the stopping distance $y$:\n",
+ "\n",
+ "$y = d_r + d_b = z x + \\frac{1}{2\\mu g} x^2$\n",
+ "\n",
+ "Every driver has its own reaction time $z$. Assume the distribution associated to $z$ is Gaussian with mean $\\mu_z=1.5$ seconds and variance $\\sigma_z^2=0.5^2$ seconds $^2$:\n",
+ "\n",
+ "$z \\sim \\mathcal{N}(\\mu_z=1.5,\\sigma_z^2=0.5^2)$\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We create a function that generates the stopping distance $y$ given the velocity $x$ and the reaction time $z$:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from scipy.stats import norm\n",
+ "\n",
+ "def y(x):\n",
+ " z = norm.rvs(1.5, 0.5, size=1)\n",
+ " y = float(z*x + 0.1*x**2)\n",
+ " return y"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Next, we create a design-of-experiments by creating a Domain object with $x$ as the car velocity:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from f3dasm.design import Domain\n",
+ "\n",
+ "domain = Domain()\n",
+ "domain.add_float('x', low=0., high=100.)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "For demonstration purposes, we will generate a dataset of stopping distances for velocities between 3 and 83 m/s."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input\n",
+ " x\n",
+ "0 open 3.000000\n",
+ "1 open 3.808081\n",
+ "2 open 4.616162\n",
+ "3 open 5.424242\n",
+ "4 open 6.232323\n",
+ ".. ... ...\n",
+ "95 open 79.767677\n",
+ "96 open 80.575758\n",
+ "97 open 81.383838\n",
+ "98 open 82.191919\n",
+ "99 open 83.000000\n",
+ "\n",
+ "[100 rows x 2 columns]"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "from f3dasm import ExperimentData\n",
+ "\n",
+ "N = 33 # number of points to generate\n",
+ "Data_x = np.linspace(3, 83, 100)\n",
+ "\n",
+ "experiment_data = ExperimentData(input_data=Data_x, domain=domain)\n",
+ "experiment_data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "As you can see, the `ExperimentData` object has been created successfully and the jobs have the label `βopenβ`. This means that the output has not been generated yet. Now, we want to compute the stopping distance for each velocity in the design-of-experiments. There are several ways to approach this with `f3dasm`:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Method 1: Use the `Block` abstraction directly:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We create a new class `CarStoppingDistance` that inherits from `Block` and implements the `call` method accordingly:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from f3dasm import Block\n",
+ "\n",
+ "class CarStoppingDistance(Block):\n",
+ " def call(self):\n",
+ " for id, experiment_sample in self.data:\n",
+ "\n",
+ " # Extract the car velocity x from the experiment sample\n",
+ " x = experiment_sample.input_data['x']\n",
+ "\n",
+ " # Evaluate the stopping distance y(x)\n",
+ " distance = y(x)\n",
+ "\n",
+ " # Store the stopping distance back in the experiment sample\n",
+ " experiment_sample.store(name='distance', object=distance)\n",
+ "\n",
+ " # Mark the experiment as finished\n",
+ " experiment_sample.mark('finished')\n",
+ "\n",
+ " # After all experiments are finished, return the data\n",
+ " return self.data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We create a new instance of `CarStoppingDistance` and run it on our experiments:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "
|---|---|---|
| \n", + " | \n", + " | x | \n", + "
| 0 | \n", + "open | \n", + "3.000000 | \n", + "
| 1 | \n", + "open | \n", + "3.808081 | \n", + "
| 2 | \n", + "open | \n", + "4.616162 | \n", + "
| 3 | \n", + "open | \n", + "5.424242 | \n", + "
| 4 | \n", + "open | \n", + "6.232323 | \n", + "
| ... | \n", + "... | \n", + "... | \n", + "
| 95 | \n", + "open | \n", + "79.767677 | \n", + "
| 96 | \n", + "open | \n", + "80.575758 | \n", + "
| 97 | \n", + "open | \n", + "81.383838 | \n", + "
| 98 | \n", + "open | \n", + "82.191919 | \n", + "
| 99 | \n", + "open | \n", + "83.000000 | \n", + "
100 rows Γ 2 columns
\n", + "\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input output\n",
+ " x distance\n",
+ "0 finished 3.000000 7.318851\n",
+ "1 finished 3.808081 5.617512\n",
+ "2 finished 4.616162 13.960788\n",
+ "3 finished 5.424242 7.987772\n",
+ "4 finished 6.232323 16.914891\n",
+ ".. ... ... ...\n",
+ "95 finished 79.767677 777.219006\n",
+ "96 finished 80.575758 750.739983\n",
+ "97 finished 81.383838 809.754817\n",
+ "98 finished 82.191919 809.877997\n",
+ "99 finished 83.000000 825.231563\n",
+ "\n",
+ "[100 rows x 3 columns]"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "car_stopping_distance = CarStoppingDistance()\n",
+ "experiment_data.run(car_stopping_distance)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Method 2: Using the `DataGenerator` class:\n",
+ "\n",
+ "The `DataGenerator` class is a wrapper around the `Block` class that simplifies the process of running a function on every experiment. Instead of implementing the `call()` method of this block and operating on the whole `ExperimentData`, we implement an `execute()` method that operates on each `ExperimentSample` iteratively. The currently processed `ExperimentSample` is stored in the `experiment_sample` attribute of the `DataGenerator` class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from f3dasm.datageneration import DataGenerator\n",
+ "\n",
+ "class CarStoppingDistanceDataGenerator(DataGenerator):\n",
+ " def execute(self):\n",
+ " # Extract the car velocity x from the experiment sample\n",
+ " x = self.experiment_sample.input_data['x']\n",
+ "\n",
+ " # Evaluate the stopping distance y(x)\n",
+ " distance = y(x)\n",
+ "\n",
+ " # Store the stopping distance back in the experiment sample\n",
+ " self.experiment_sample.store(name='distance', object=distance)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "car_stopping_distance_datagenerator = CarStoppingDistanceDataGenerator()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "output | \n", + "
|---|---|---|---|
| \n", + " | \n", + " | x | \n", + "distance | \n", + "
| 0 | \n", + "finished | \n", + "3.000000 | \n", + "7.318851 | \n", + "
| 1 | \n", + "finished | \n", + "3.808081 | \n", + "5.617512 | \n", + "
| 2 | \n", + "finished | \n", + "4.616162 | \n", + "13.960788 | \n", + "
| 3 | \n", + "finished | \n", + "5.424242 | \n", + "7.987772 | \n", + "
| 4 | \n", + "finished | \n", + "6.232323 | \n", + "16.914891 | \n", + "
| ... | \n", + "... | \n", + "... | \n", + "... | \n", + "
| 95 | \n", + "finished | \n", + "79.767677 | \n", + "777.219006 | \n", + "
| 96 | \n", + "finished | \n", + "80.575758 | \n", + "750.739983 | \n", + "
| 97 | \n", + "finished | \n", + "81.383838 | \n", + "809.754817 | \n", + "
| 98 | \n", + "finished | \n", + "82.191919 | \n", + "809.877997 | \n", + "
| 99 | \n", + "finished | \n", + "83.000000 | \n", + "825.231563 | \n", + "
100 rows Γ 3 columns
\n", + "\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input output\n",
+ " x distance\n",
+ "0 finished 3.000000 4.133655\n",
+ "1 finished 3.808081 9.113758\n",
+ "2 finished 4.616162 7.694777\n",
+ "3 finished 5.424242 11.401391\n",
+ "4 finished 6.232323 13.355383\n",
+ ".. ... ... ...\n",
+ "95 finished 79.767677 752.353654\n",
+ "96 finished 80.575758 803.593101\n",
+ "97 finished 81.383838 748.149040\n",
+ "98 finished 82.191919 720.842429\n",
+ "99 finished 83.000000 813.449692\n",
+ "\n",
+ "[100 rows x 3 columns]"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Recreate the experiment data\n",
+ "experiment_data = ExperimentData(input_data=Data_x, domain=domain)\n",
+ "\n",
+ "# Evaluate the experiment data on the DataGenerator\n",
+ "experiment_data.evaluate(car_stopping_distance_datagenerator, mode='sequential')\n",
+ "\n",
+ "experiment_data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "There are three methods available of evaluating the experiments:\n",
+ "\n",
+ "- `'sequential'`: regular for-loop over each of the experiments in order\n",
+ "- `'parallel'`: utilizing the multiprocessing capabilities (with the pathos multiprocessing library), each experiment is run in a separate core\n",
+ "- `'cluster'`: each experiment is run in a seperate node. This is especially useful on a high-performance computation cluster where you have multiple worker nodes and a commonly accessible resource folder. After completion of an experiment, the node will automatically pick the next available open experiment.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Method 3: Using the function directly\n",
+ "\n",
+ "The function `y(x)` can be called directly on the `ExperimentData.evaluate` method. This is the simplest way to run a function on every experiment in the design-of-experiments.\n",
+ "In order to use this method, we need to specify the `output_names` of the return values of the function `y(x)` in the method call:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "output | \n", + "
|---|---|---|---|
| \n", + " | \n", + " | x | \n", + "distance | \n", + "
| 0 | \n", + "finished | \n", + "3.000000 | \n", + "4.133655 | \n", + "
| 1 | \n", + "finished | \n", + "3.808081 | \n", + "9.113758 | \n", + "
| 2 | \n", + "finished | \n", + "4.616162 | \n", + "7.694777 | \n", + "
| 3 | \n", + "finished | \n", + "5.424242 | \n", + "11.401391 | \n", + "
| 4 | \n", + "finished | \n", + "6.232323 | \n", + "13.355383 | \n", + "
| ... | \n", + "... | \n", + "... | \n", + "... | \n", + "
| 95 | \n", + "finished | \n", + "79.767677 | \n", + "752.353654 | \n", + "
| 96 | \n", + "finished | \n", + "80.575758 | \n", + "803.593101 | \n", + "
| 97 | \n", + "finished | \n", + "81.383838 | \n", + "748.149040 | \n", + "
| 98 | \n", + "finished | \n", + "82.191919 | \n", + "720.842429 | \n", + "
| 99 | \n", + "finished | \n", + "83.000000 | \n", + "813.449692 | \n", + "
100 rows Γ 3 columns
\n", + "\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input output\n",
+ " x distance\n",
+ "0 finished 3.000000 6.865499\n",
+ "1 finished 3.808081 8.001959\n",
+ "2 finished 4.616162 12.034931\n",
+ "3 finished 5.424242 7.698961\n",
+ "4 finished 6.232323 18.099358\n",
+ ".. ... ... ...\n",
+ "95 finished 79.767677 705.504497\n",
+ "96 finished 80.575758 718.290648\n",
+ "97 finished 81.383838 732.702359\n",
+ "98 finished 82.191919 776.652027\n",
+ "99 finished 83.000000 716.987663\n",
+ "\n",
+ "[100 rows x 3 columns]"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Recreate the experiment data\n",
+ "experiment_data = ExperimentData(input_data=Data_x, domain=domain)\n",
+ "\n",
+ "# Evaluate the experiment data on the DataGenerator\n",
+ "experiment_data.evaluate(y, output_names=['distance'], mode='sequential')\n",
+ "\n",
+ "experiment_data"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "f3dasm_env3",
+ "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.17"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/source/notebooks/data-driven/cluster.ipynb b/docs/source/notebooks/data-driven/cluster.ipynb
new file mode 100644
index 00000000..2c503195
--- /dev/null
+++ b/docs/source/notebooks/data-driven/cluster.ipynb
@@ -0,0 +1,259 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Using `f3dasm` on a High-Performance Cluster Computer\n",
+ "\n",
+ "Your `f3dasm` workflow can be seamlessly translated to a high-performance computing cluster. \n",
+ "The advantage is that you can parallelize the total number of experiments among the nodes of the cluster. \n",
+ "This is especially useful when you have a large number of experiments to run.\n",
+ "\n",
+ "> This example has been tested on the following high-performance computing cluster systems:\n",
+ "> \n",
+ "> - The [hpc06 cluster of Delft University of Technology](https://hpcwiki.tudelft.nl/index.php/Main_Page), using the [TORQUE resource manager](https://en.wikipedia.org/wiki/TORQUE).\n",
+ "> - The [DelftBlue: TU Delft supercomputer](https://www.tudelft.nl/dhpc/system), using the [SLURM resource manager](https://slurm.schedmd.com/documentation.html).\n",
+ "> - The [OSCAR compute cluster from Brown University](https://docs.ccv.brown.edu/oscar/getting-started), using the [SLURM resource manager](https://slurm.schedmd.com/documentation.html).\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from time import sleep\n",
+ "\n",
+ "import numpy as np\n",
+ "\n",
+ "from f3dasm import HPC_JOBID, ExperimentData\n",
+ "from f3dasm.design import make_nd_continuous_domain"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We will create the following data-driven process:\n",
+ "\n",
+ "- Create a 20D continuous `Domain`.\n",
+ "- Sample from the domain using a Latin-hypercube sampler.\n",
+ "- With multiple nodes, use a data generation function, which will be the `\"Ackley\"` function from the benchmark functions.\n",
+ "\n",
+ "| \n", + " | jobs | \n", + "input | \n", + "output | \n", + "
|---|---|---|---|
| \n", + " | \n", + " | x | \n", + "distance | \n", + "
| 0 | \n", + "finished | \n", + "3.000000 | \n", + "6.865499 | \n", + "
| 1 | \n", + "finished | \n", + "3.808081 | \n", + "8.001959 | \n", + "
| 2 | \n", + "finished | \n", + "4.616162 | \n", + "12.034931 | \n", + "
| 3 | \n", + "finished | \n", + "5.424242 | \n", + "7.698961 | \n", + "
| 4 | \n", + "finished | \n", + "6.232323 | \n", + "18.099358 | \n", + "
| ... | \n", + "... | \n", + "... | \n", + "... | \n", + "
| 95 | \n", + "finished | \n", + "79.767677 | \n", + "705.504497 | \n", + "
| 96 | \n", + "finished | \n", + "80.575758 | \n", + "718.290648 | \n", + "
| 97 | \n", + "finished | \n", + "81.383838 | \n", + "732.702359 | \n", + "
| 98 | \n", + "finished | \n", + "82.191919 | \n", + "776.652027 | \n", + "
| 99 | \n", + "finished | \n", + "83.000000 | \n", + "716.987663 | \n", + "
100 rows Γ 3 columns
\n", + "\n",
+ " ![\"Block\"](\"../../img/f3dasm-workflow-example-cluster.png\" "\\"Block\\"")
\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We want to ensure that the sampling is done only once, and that the data generation is performed in parallel. \n",
+ "Therefore, we can divide the different nodes into two categories:\n",
+ "\n",
+ "- The first node (`f3dasm.HPC_JOBID == 0`) will be the **master** node, responsible for creating the design-of-experiments and sampling (the `create_experimentdata` function).\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def create_experimentdata():\n",
+ " \"\"\"Design of Experiment\"\"\"\n",
+ " # Create a domain object\n",
+ " domain = make_nd_continuous_domain(\n",
+ " bounds=np.tile([0.0, 1.0], (20, 1)), dimensionality=20)\n",
+ "\n",
+ " # Create the ExperimentData object\n",
+ " data = ExperimentData(domain=domain)\n",
+ "\n",
+ " # Sampling from the domain\n",
+ " data.sample(sampler='latin', n_samples=10)\n",
+ "\n",
+ " # Store the data to disk\n",
+ " data.store()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- All the other nodes (`f3dasm.HPC_JOBID > 0`) will be **process** nodes, which will retrieve the `ExperimentData` from disk and proceed directly to the data generation function.\n",
+ "\n",
+ "\n",
+ "\n",
+ " ![\"Block\"](\"../../img/f3dasm-workflow-cluster-roles.png\" "\\"Block\\"")
\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def worker_node():\n",
+ " # Extract the experimentdata from disk\n",
+ " data = ExperimentData.from_file(project_dir='.')\n",
+ "\n",
+ " \"\"\"Data Generation\"\"\"\n",
+ " # Use the data-generator to evaluate the initial samples\n",
+ " data.evaluate(data_generator='Ackley', mode='cluster')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The entrypoint of the script can now check the jobid of the current node and decide whether to create the experiment data or to run the data generation function:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if __name__ == '__main__':\n",
+ " # Check the jobid of the current node\n",
+ " if HPC_JOBID is None:\n",
+ " # If the jobid is none, we are not running anything now\n",
+ " pass\n",
+ "\n",
+ " elif HPC_JOBID == 0:\n",
+ " create_experimentdata()\n",
+ " worker_node()\n",
+ " elif HPC_JOBID > 0:\n",
+ " # Asynchronize the jobs in order to omit racing conditions\n",
+ " sleep(HPC_JOBID)\n",
+ " worker_node()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Running the Program\n",
+ "\n",
+ "You can run the workflow by submitting the bash script to the HPC queue. \n",
+ "Make sure you have [miniconda3](https://docs.anaconda.com/free/miniconda/index.html) installed on the cluster and that you have created a conda environment (in this example named `f3dasm_env`) with the necessary packages.\n",
+ "\n",
+ "### TORQUE Example\n",
+ "\n",
+ "---\n",
+ "\n",
+ "```bash\n",
+ "#!/bin/bash\n",
+ "# Torque directives (#PBS) must always be at the start of a job script!\n",
+ "#PBS -N ExampleScript\n",
+ "#PBS -q mse\n",
+ "#PBS -l nodes=1:ppn=12,walltime=12:00:00\n",
+ "\n",
+ "# Make sure I'm the only one that can read my output\n",
+ "umask 0077\n",
+ "\n",
+ "# The PBS_JOBID looks like 1234566[0].\n",
+ "# With the following line, we extract the PBS_ARRAYID, the part in the brackets []:\n",
+ "PBS_ARRAYID=$(echo \"${PBS_JOBID}\" | sed 's/\\[[^][]*\\]//g')\n",
+ "\n",
+ "module load use.own\n",
+ "module load miniconda3\n",
+ "cd $PBS_O_WORKDIR\n",
+ "\n",
+ "# Activate my conda environment:\n",
+ "source activate f3dasm_env\n",
+ "\n",
+ "# Limit the number of threads\n",
+ "OMP_NUM_THREADS=12\n",
+ "export OMP_NUM_THREADS=12\n",
+ "\n",
+ "# If the PBS_ARRAYID is not set, set it to None\n",
+ "if ! [ -n \"${PBS_ARRAYID+1}\" ]; then\n",
+ " PBS_ARRAYID=None\n",
+ "fi\n",
+ "\n",
+ "# Execute my Python program with the jobid flag\n",
+ "python main.py --jobid=${PBS_ARRAYID}\n",
+ "```\n",
+ "\n",
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### SLURM Example\n",
+ "\n",
+ "---\n",
+ "\n",
+ "```bash\n",
+ "#!/bin/bash -l\n",
+ "\n",
+ "#SBATCH -J \"ExampleScript\" # Name of the job\n",
+ "#SBATCH --get-user-env # Set environment variables\n",
+ "\n",
+ "#SBATCH --partition=compute\n",
+ "#SBATCH --time=12:00:00\n",
+ "#SBATCH --nodes=1\n",
+ "#SBATCH --ntasks-per-node=12\n",
+ "#SBATCH --cpus-per-task=1\n",
+ "#SBATCH --mem=0\n",
+ "#SBATCH --account=research-eemcs-me\n",
+ "#SBATCH --array=0-2\n",
+ "\n",
+ "source activate f3dasm_env\n",
+ "\n",
+ "# Execute my Python program with the jobid flag\n",
+ "python3 main.py --jobid=${SLURM_ARRAY_TASK_ID}\n",
+ "```\n",
+ "\n",
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can run the workflow by submitting the bash script to the HPC queue. \n",
+ "The following command submits an array job with 3 jobs where `f3dasm.HPC_JOBID` takes values of 0, 1, and 2.\n",
+ "\n",
+ "### TORQUE Example\n",
+ "\n",
+ "```bash\n",
+ "qsub pbsjob.sh -t 0-2\n",
+ "```\n",
+ "\n",
+ "### SLURM Example\n",
+ "\n",
+ "```bash\n",
+ "sbatch --array 0-2 pbsjob.sh\n",
+ "```"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "f3dasm_env3",
+ "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.17"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/source/notebooks/data-driven/gridsampler.ipynb b/docs/source/notebooks/data-driven/gridsampler.ipynb
new file mode 100644
index 00000000..8e8c1b17
--- /dev/null
+++ b/docs/source/notebooks/data-driven/gridsampler.ipynb
@@ -0,0 +1,311 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Implementing a grid search sampler from scratch\n",
+ "\n",
+ "In this example, we will implement a [grid search sampler](https://en.wikipedia.org/wiki/Hyperparameter_optimization) from scratch. The grid search sampler is a simple sampler that evaluates all possible combinations of the parameters in the domain. This is useful for small domains, but it can become computationally expensive for larger domains. We will show how to create this sampler and use it in a `f3dasm` data-driven experiment."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from __future__ import annotations\n",
+ "\n",
+ "from itertools import product\n",
+ "from typing import Dict, Optional\n",
+ "\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "\n",
+ "from f3dasm import ExperimentData, Block\n",
+ "from f3dasm.design import Domain"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "When integrating your sampling strategy into the data-driven process, you have to create a new class that inherits from the `Block` base class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class GridSampler(Block):\n",
+ " def call(self, stepsize_continuous_parameters: Optional[Dict[str, float]] = None) -> ExperimentData:\n",
+ "\n",
+ " # Extract only the continuous variables\n",
+ " continuous = self.data.domain.continuous\n",
+ " discrete = self.data.domain.discrete\n",
+ " categorical = self.data.domain.categorical\n",
+ " constant = self.data.domain.constant\n",
+ "\n",
+ " _iterdict = {}\n",
+ "\n",
+ " if continuous.input_space:\n",
+ "\n",
+ " discrete_space = {key: continuous.input_space[key].to_discrete(\n",
+ " step=value) for key,\n",
+ " value in stepsize_continuous_parameters.items()}\n",
+ "\n",
+ " continuous = Domain(input_space=discrete_space)\n",
+ "\n",
+ " for k, v in categorical.input_space.items():\n",
+ " _iterdict[k] = v.categories\n",
+ "\n",
+ " for k, v, in discrete.input_space.items():\n",
+ " _iterdict[k] = range(v.lower_bound, v.upper_bound+1, v.step)\n",
+ "\n",
+ " for k, v, in continuous.input_space.items():\n",
+ " _iterdict[k] = np.arange(\n",
+ " start=v.lower_bound, stop=v.upper_bound, step=v.step)\n",
+ "\n",
+ " for k, v, in constant.input_space.items():\n",
+ " _iterdict[k] = [v.value]\n",
+ "\n",
+ " df = pd.DataFrame(list(product(*_iterdict.values())),\n",
+ " columns=_iterdict, dtype=object\n",
+ " )[self.data.domain.input_names]\n",
+ "\n",
+ " return ExperimentData(domain=self.data.domain,\n",
+ " input_data=df)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We will now sample the domain using the grid sampler we implemented.\n",
+ "- First, we will create a domain with a mix of continuous, discrete, and categorical parameters to test our implementation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "domain = Domain()\n",
+ "domain.add_float(\"param_1\", -1.0, 1.0)\n",
+ "domain.add_int(\"param_2\", 1, 5)\n",
+ "domain.add_category(\"param_3\", [\"red\", \"blue\", \"green\", \"yellow\", \"purple\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- We create an `ExperimentData` object with the domain:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "experiment_data = ExperimentData(domain=domain)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Then, we can create a `GridSampler` block object:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "grid_sampler = GridSampler()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Lastly, we call the `run()` method on the created `ExperimentData`, providing the grid sampler:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input \n",
+ " param_1 param_2 param_3\n",
+ "0 open -1.0 1 red\n",
+ "1 open -0.9 1 red\n",
+ "2 open -0.8 1 red\n",
+ "3 open -0.7 1 red\n",
+ "4 open -0.6 1 red\n",
+ ".. ... ... ... ...\n",
+ "495 open 0.5 5 purple\n",
+ "496 open 0.6 5 purple\n",
+ "497 open 0.7 5 purple\n",
+ "498 open 0.8 5 purple\n",
+ "499 open 0.9 5 purple\n",
+ "\n",
+ "[500 rows x 4 columns]"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "experiment_data.run(grid_sampler, stepsize_continuous_parameters={\"param_1\": 0.1})"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "f3dasm_env3",
+ "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.17"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/source/notebooks/data-driven/reaction-braking-stopping.png b/docs/source/notebooks/data-driven/reaction-braking-stopping.png
new file mode 100644
index 00000000..915c20db
Binary files /dev/null and b/docs/source/notebooks/data-driven/reaction-braking-stopping.png differ
diff --git a/docs/source/notebooks/design/domain_creation.ipynb b/docs/source/notebooks/design/domain_creation.ipynb
new file mode 100644
index 00000000..230fc604
--- /dev/null
+++ b/docs/source/notebooks/design/domain_creation.ipynb
@@ -0,0 +1,495 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Introduction to domain and parameters\n",
+ "\n",
+ "This section will give you information on how to set up your search space with the `Domain` class and the paramaters\n",
+ "The `Domain` contains a dictionary of parameter instances for both the `input_space` and `output_space` that make up the feasible search space.\n",
+ "This notebook demonstrates how to use the `Domain` class effectively, from initialization to advanced use cases.\n",
+ "\n",
+ "The `Domain` class can be imported from the `f3dasm.design` module:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from f3dasm.design import Domain"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "A domain object can be created as follows"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Creating a Domain Object\n",
+ "\n",
+ "To start, we create an empty domain object:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "domain = Domain()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### Input Parameters\n",
+ "\n",
+ "Now we will add some input parameters. You can use the `add_parameter` method to add an input parameter:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "domain.add_parameter(name='x0')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Parameters can be of any type. `f3dasm` has built-in support for the following types:\n",
+ "\n",
+ "- floating point parameters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "domain.add_float(name='x1', low=0.0, high=100.0)\n",
+ "domain.add_float(name='x2', low=0.0, high=4.0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- discrete integer parameters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "domain.add_int(name='x3', low=2, high=4)\n",
+ "domain.add_int(name='x4', low=74, high=99)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- categorical parameters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "domain.add_category(name='x5', categories=['test1', 'test2', 'test3', 'test4'])\n",
+ "domain.add_category(name='x6', categories=[0.9, 0.2, 0.1, -2])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- constant parameters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "domain.add_constant(name='x7', value=0.9)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can print the domain object to see the parameters that have been added:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Domain(\n",
+ " Input Space: { x0: Parameter(type=object, to_disk=False), x1: ContinuousParameter(lower_bound=0.0, upper_bound=100.0, log=False), x2: ContinuousParameter(lower_bound=0.0, upper_bound=4.0, log=False), x3: DiscreteParameter(lower_bound=2, upper_bound=4, step=1), x4: DiscreteParameter(lower_bound=74, upper_bound=99, step=1), x5: CategoricalParameter(categories=['test1', 'test2', 'test3', 'test4']), x6: CategoricalParameter(categories=[0.9, 0.2, 0.1, -2]), x7: ConstantParameter(value=0.9) }\n",
+ " Output Space: { }\n",
+ ")\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(domain)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Output Parameters\n",
+ "\n",
+ "Output parameters are the results of evaluating the input design with a data generation model. Output parameters can hold any type of data, e.g., a scalar value, a vector, a matrix, etc. Normally, you would not need to define output parameters, as they are created automatically when you store a variable to the `ExperimentData` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "domain.add_output(name='y', to_disk=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Storing parameters on disk\n",
+ "\n",
+ "As you will see in the next section, ?the `ExperimentData` object stores data associated with parameters. The data is stored in a tabular format, where each row corresponds to a single evaluation of the designspace. The columns of the table correspond to the input parameters and the output values.\n",
+ "\n",
+ "Sometimes it is wise to store the data associated with a parameter separately outside this table:\n",
+ "- when the data associated with a parameter is very large (e.g., large arrays or matrices), it allows you to lazy-load the data when needed\n",
+ "- when the data should not or cannot be casted to a `.csv` file (e.g., a custom object)\n",
+ "\n",
+ "You can choose to only store a reference in the `ExperimentData` object and store the data on disk. This can be done by setting the `to_disk` parameter to `True` when adding the parameter to the domain.\n",
+ "\n",
+ "`f3dasm` supports storing and loading data for a few commonly used data types:\n",
+ "\n",
+ "- numpy arrays\n",
+ "- pandas dataframes\n",
+ "- xarray datasets and data arrays\n",
+ "\n",
+ "For any other data types, you have to define custom functions to store and load data. These functions should take the data as input and return a string that can be used to identify the data when loading it. You can define these functions using the `store_function` and `load_function` parameters when adding the parameter to the domain.\n",
+ "\n",
+ "The following example demonstrates how to store and load a numpy array to and from disk. We will use a custom store and load function for this example, but these functions are not necessary for numpy arrays, as `f3dasm` provides built-in support for storing and loading numpy arrays:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from pathlib import Path\n",
+ "import numpy as np\n",
+ "\n",
+ "def numpy_store(object: np.ndarray, path: str) -> str:\n",
+ " \"\"\"\n",
+ " Store a numpy array.\n",
+ "\n",
+ " Parameters\n",
+ " ----------\n",
+ " object : np.ndarray\n",
+ " The numpy array to store.\n",
+ " path : str\n",
+ " The path where the array will be stored.\n",
+ "\n",
+ " Returns\n",
+ " -------\n",
+ " str\n",
+ " The path to the stored array.\n",
+ " \"\"\"\n",
+ " _path = Path(path).with_suffix('.npy')\n",
+ " np.save(file=_path, arr=object)\n",
+ " return str(_path)\n",
+ "\n",
+ "\n",
+ "def numpy_load(path: str) -> np.ndarray:\n",
+ " \"\"\"\n",
+ " Load a numpy array.\n",
+ "\n",
+ " Parameters\n",
+ " ----------\n",
+ " path : str\n",
+ " The path to the array to load.\n",
+ "\n",
+ " Returns\n",
+ " -------\n",
+ " np.ndarray\n",
+ " The loaded array.\n",
+ " \"\"\"\n",
+ " _path = Path(path).with_suffix('.npy')\n",
+ " return np.load(file=_path)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "With these functions defined, we can add the parameter to the input of the domain:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "domain.add_parameter(name='array_input', to_disk=True,\n",
+ " store_function=numpy_store, load_function=numpy_load)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In the same fashion, we can add an output parameter to the domain:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "domain.add_output(name='array_output', to_disk=True,\n",
+ " store_function=numpy_store, load_function=numpy_load)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## Filtering the Domain\n",
+ "\n",
+ "The domain object can be filtered to only include certain types of parameters. This might be useful when you want to create a design of experiments with only continuous parameters, for example.\n",
+ "\n",
+ "The attributes `Domain.continuous`, `Domain.discrete`, `Domain.categorical`, and `Domain.constant` can be used to filter the domain object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Continuous domain: Domain(\n",
+ " Input Space: { x1: ContinuousParameter(lower_bound=0.0, upper_bound=100.0, log=False), x2: ContinuousParameter(lower_bound=0.0, upper_bound=4.0, log=False) }\n",
+ " Output Space: { }\n",
+ ")\n",
+ "Discrete domain: Domain(\n",
+ " Input Space: { x3: DiscreteParameter(lower_bound=2, upper_bound=4, step=1), x4: DiscreteParameter(lower_bound=74, upper_bound=99, step=1) }\n",
+ " Output Space: { }\n",
+ ")\n",
+ "Categorical domain: Domain(\n",
+ " Input Space: { x5: CategoricalParameter(categories=['test1', 'test2', 'test3', 'test4']), x6: CategoricalParameter(categories=[0.9, 0.2, 0.1, -2]) }\n",
+ " Output Space: { }\n",
+ ")\n",
+ "Constant domain: Domain(\n",
+ " Input Space: { x7: ConstantParameter(value=0.9) }\n",
+ " Output Space: { }\n",
+ ")\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(f\"Continuous domain: {domain.continuous}\")\n",
+ "print(f\"Discrete domain: {domain.discrete}\")\n",
+ "print(f\"Categorical domain: {domain.categorical}\")\n",
+ "print(f\"Constant domain: {domain.constant}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Storing the `Domain` object\n",
+ "\n",
+ "The `Domain` object can be stored to disk using the `store` method. This method saves the domain object to a JSON file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "domain.store('my_domain.json')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The `Domain` object can be loaded from disk using the `Domain.from_file` method:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Domain(input_space={'x0': Parameter(to_disk=False), 'x1': ContinuousParameter(lower_bound=0.0, upper_bound=100.0, log=False), 'x2': ContinuousParameter(lower_bound=0.0, upper_bound=4.0, log=False), 'x3': DiscreteParameter(lower_bound=2, upper_bound=4, step=1), 'x4': DiscreteParameter(lower_bound=74, upper_bound=99, step=1), 'x5': CategoricalParameter(categories=['test1', 'test2', 'test3', 'test4']), 'x6': CategoricalParameter(categories=[0.9, 0.2, 0.1, -2]), 'x7': ConstantParameter(value=0.9), 'array_input': Parameter(to_disk=True)}, output_space={'y': Parameter(to_disk=False), 'array_output': Parameter(to_disk=True)})"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Domain.from_file('my_domain.json')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "> Custom storing and loading functions will be encoded with `pickle` and converted to hexadecimal strings. This allows you to store and load custom functions without having to define them again."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## Helper Function for Single-Objective, N-Dimensional Continuous Domains\n",
+ "\n",
+ "We can easily create an $n$-dimensional continuous domain with the helper function `make_nd_continuous_domain`. We have to specify the boundaries (bounds) for each of the dimensions with a list of lists or a NumPy `numpy.ndarray`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from f3dasm.design import make_nd_continuous_domain"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Domain(\n",
+ " Input Space: { x0: ContinuousParameter(lower_bound=-1.0, upper_bound=1.0, log=False), x1: ContinuousParameter(lower_bound=-1.0, upper_bound=1.0, log=False) }\n",
+ " Output Space: { }\n",
+ ")\n"
+ ]
+ }
+ ],
+ "source": [
+ "bounds = [[-1.0, 1.0], [-1.0, 1.0]]\n",
+ "domain = make_nd_continuous_domain(bounds=bounds)\n",
+ "\n",
+ "print(domain)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "f3dasm_env3",
+ "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.17"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/source/notebooks/design/my_domain.json b/docs/source/notebooks/design/my_domain.json
new file mode 100644
index 00000000..8e861606
--- /dev/null
+++ b/docs/source/notebooks/design/my_domain.json
@@ -0,0 +1,97 @@
+{
+ "input_space": {
+ "x0": {
+ "type": "object",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null
+ },
+ "x1": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 0.0,
+ "upper_bound": 100.0,
+ "log": false
+ },
+ "x2": {
+ "type": "float",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 0.0,
+ "upper_bound": 4.0,
+ "log": false
+ },
+ "x3": {
+ "type": "int",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 2,
+ "upper_bound": 4,
+ "step": 1
+ },
+ "x4": {
+ "type": "int",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "lower_bound": 74,
+ "upper_bound": 99,
+ "step": 1
+ },
+ "x5": {
+ "type": "category",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "categories": [
+ "test1",
+ "test2",
+ "test3",
+ "test4"
+ ]
+ },
+ "x6": {
+ "type": "category",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "categories": [
+ 0.9,
+ 0.2,
+ 0.1,
+ -2
+ ]
+ },
+ "x7": {
+ "type": "constant",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null,
+ "value": 0.9
+ },
+ "array_input": {
+ "type": "object",
+ "to_disk": true,
+ "store_function": "8004951c000000000000008c085f5f6d61696e5f5f948c0b6e756d70795f73746f72659493942e",
+ "load_function": "8004951b000000000000008c085f5f6d61696e5f5f948c0a6e756d70795f6c6f61649493942e"
+ }
+ },
+ "output_space": {
+ "y": {
+ "type": "object",
+ "to_disk": false,
+ "store_function": null,
+ "load_function": null
+ },
+ "array_output": {
+ "type": "object",
+ "to_disk": true,
+ "store_function": "8004951c000000000000008c085f5f6d61696e5f5f948c0b6e756d70795f73746f72659493942e",
+ "load_function": "8004951b000000000000008c085f5f6d61696e5f5f948c0a6e756d70795f6c6f61649493942e"
+ }
+ }
+}
\ No newline at end of file
diff --git a/docs/source/notebooks/experimentdata/experimentdata.ipynb b/docs/source/notebooks/experimentdata/experimentdata.ipynb
new file mode 100644
index 00000000..57ad72e2
--- /dev/null
+++ b/docs/source/notebooks/experimentdata/experimentdata.ipynb
@@ -0,0 +1,1403 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# The `ExperimentData` object\n",
+ "\n",
+ "We define an experiment as a single set of input parameters that are used to run a simulation or an experiment. `f3dasm` uses a custom `ExperimentSample` object to keep track of these inputs and outputs of the experiments.\n",
+ "\n",
+ "Each `ExperimentSample` is effectively an individual experiment. \n",
+ "- It contains a dictionary `input_data` with key-value pairs of the input variables and a dictionary `output_data` with key-value pairs of the resulted output variables.\n",
+ "- The property `job_status` is used to keep track of the status of the experiment. It can be one of the following values: `open`, `in progress`, `finished`, or `error`.\n",
+ "\n",
+ "All of these individual experiments are bundled together in the custom `ExperimentData` object. The `ExperimentData` object is the main object used to keep track of results, perform optimization and extract data for machine learning purposes. All other processses of `f3dasm` use this object to manipulate and access data about your experiments.\n",
+ "\n",
+ "The ExperimentData object consists of the following attributes:\n",
+ "\n",
+ "- `domain`: The `Domain` of the Experiment. This is used for keeping track of the input and output variables of the experiments\n",
+ "- `data`: A dictionary containing the data of the experiments. The keys of the dictionary are numerical identifiers (starting from $0$) of the experiments and the values are `ExperimentSample` objects. \n",
+ "- `project_dir`: A user-defined project directory where all data related to your data-driven process will be stored."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Creating the `ExperimentData` object\n",
+ "\n",
+ "The `ExperimentData` object can be constructed in several ways:\n",
+ "\n",
+ "You can construct a ExperimentData object by providing it `input data`, `output data`, a `Domain` object and a project directory:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from f3dasm import ExperimentData"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The `domain` object needs to be constructed before creating the `ExperimentData` object. The `Domain` object is used to keep track of the input and output variables of the experiments:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from f3dasm.design import Domain\n",
+ "\n",
+ "domain = Domain()\n",
+ "domain.add_float(name='x0', low=0., high=1.)\n",
+ "domain.add_float(name='x1', low=0., high=1.)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The `input_data` and `output_data` can be provided in a tabular matter and in one of the following formats:\n",
+ "- a 2D numpy array. The first dimension corresponds to the number of experiments and the second dimension corresponds to the input/output variables.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "||
|---|---|---|---|---|
| \n", + " | \n", + " | param_1 | \n", + "param_2 | \n", + "param_3 | \n", + "
| 0 | \n", + "open | \n", + "-1.0 | \n", + "1 | \n", + "red | \n", + "
| 1 | \n", + "open | \n", + "-0.9 | \n", + "1 | \n", + "red | \n", + "
| 2 | \n", + "open | \n", + "-0.8 | \n", + "1 | \n", + "red | \n", + "
| 3 | \n", + "open | \n", + "-0.7 | \n", + "1 | \n", + "red | \n", + "
| 4 | \n", + "open | \n", + "-0.6 | \n", + "1 | \n", + "red | \n", + "
| ... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "
| 495 | \n", + "open | \n", + "0.5 | \n", + "5 | \n", + "purple | \n", + "
| 496 | \n", + "open | \n", + "0.6 | \n", + "5 | \n", + "purple | \n", + "
| 497 | \n", + "open | \n", + "0.7 | \n", + "5 | \n", + "purple | \n", + "
| 498 | \n", + "open | \n", + "0.8 | \n", + "5 | \n", + "purple | \n", + "
| 499 | \n", + "open | \n", + "0.9 | \n", + "5 | \n", + "purple | \n", + "
500 rows Γ 4 columns
\n", + "\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input \n",
+ " x0 x1\n",
+ "0 open 0.1 0.4\n",
+ "1 open 0.2 0.5\n",
+ "2 open 0.3 0.6"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "input_data = np.array([\n",
+ " [0.1, 0.4],\n",
+ " [0.2, 0.5],\n",
+ " [0.3, 0.6]\n",
+ "])\n",
+ "\n",
+ "experimentdata = ExperimentData(domain=domain, input_data=input_data)\n",
+ "experimentdata"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- a pandas DataFrame. The columns of the DataFrame correspond to the input/output variables and the rows correspond to the experiments."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "|
|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "
| 0 | \n", + "open | \n", + "0.1 | \n", + "0.4 | \n", + "
| 1 | \n", + "open | \n", + "0.2 | \n", + "0.5 | \n", + "
| 2 | \n", + "open | \n", + "0.3 | \n", + "0.6 | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input \n",
+ " x0 x1\n",
+ "0 open 0.1 0.4\n",
+ "1 open 0.2 0.5\n",
+ "2 open 0.3 0.6"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import pandas as pd\n",
+ "\n",
+ "input_data = pd.DataFrame({\n",
+ " 'x0': [0.1, 0.2, 0.3],\n",
+ " 'x1': [0.4, 0.5, 0.6]\n",
+ "})\n",
+ "\n",
+ "\n",
+ "experimentdata = ExperimentData(domain=domain, input_data=input_data)\n",
+ "experimentdata"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "- a list of dictionaries. Each dictionary corresponds to an experiment and the keys of the dictionary correspond to the input/output variables."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "|
|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "
| 0 | \n", + "open | \n", + "0.1 | \n", + "0.4 | \n", + "
| 1 | \n", + "open | \n", + "0.2 | \n", + "0.5 | \n", + "
| 2 | \n", + "open | \n", + "0.3 | \n", + "0.6 | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input \n",
+ " x0 x1\n",
+ "0 open 0.1 0.4\n",
+ "1 open 0.2 0.5\n",
+ "2 open 0.3 0.6"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "input_data = [{'x0': 0.1, 'x1': 0.4}, \n",
+ " {'x0': 0.2, 'x1': 0.5}, \n",
+ " {'x0': 0.3, 'x1': 0.6}]\n",
+ "\n",
+ "experimentdata = ExperimentData(domain=domain, input_data=input_data)\n",
+ "experimentdata"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "> It is also possible to infer the parameter names from the input and output data. This will automatically infer the names of the input and output variables from the input and output data. For numpy arrays, there is no way to infer the names of the variables, so default names (e.g. `x0`, `x1`, `y0`, `y1`) will be used. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- a path to a `.csv` file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "|
|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "
| 0 | \n", + "open | \n", + "0.1 | \n", + "0.4 | \n", + "
| 1 | \n", + "open | \n", + "0.2 | \n", + "0.5 | \n", + "
| 2 | \n", + "open | \n", + "0.3 | \n", + "0.6 | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input \n",
+ " x0 x1\n",
+ "0 open 0.1 0.4\n",
+ "1 open 0.2 0.5\n",
+ "2 open 0.3 0.6"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "input_data = pd.DataFrame({\n",
+ " 'x0': [0.1, 0.2, 0.3],\n",
+ " 'x1': [0.4, 0.5, 0.6]\n",
+ "})\n",
+ "\n",
+ "# For the sake of this example, we store the input_data in a file:\n",
+ "input_data.to_csv('input_data.csv')\n",
+ "\n",
+ "# Now we can load the input_data from the file:\n",
+ "experimentdata = ExperimentData(domain=domain, input_data='input_data.csv')\n",
+ "experimentdata"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We demonstrated how to use various datatypes for the `input_data` but the same applies to the `output_data` of the `ExperimentData` object:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "|
|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "
| 0 | \n", + "open | \n", + "0.1 | \n", + "0.4 | \n", + "
| 1 | \n", + "open | \n", + "0.2 | \n", + "0.5 | \n", + "
| 2 | \n", + "open | \n", + "0.3 | \n", + "0.6 | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input output\n",
+ " x0 x1 y\n",
+ "0 finished 0.1 0.4 0.5\n",
+ "1 finished 0.2 0.5 0.6\n",
+ "2 open 0.3 0.6 NaN"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "domain.add_output(name='y')\n",
+ "\n",
+ "input_data = [{'x0': 0.1, 'x1': 0.4}, \n",
+ " {'x0': 0.2, 'x1': 0.5}, \n",
+ " {'x0': 0.3, 'x1': 0.6}]\n",
+ "\n",
+ "output_data = [{'y': 0.5},\n",
+ " {'y': 0.6}]\n",
+ "\n",
+ "experimentdata = ExperimentData(domain=domain, input_data=input_data, output_data=output_data)\n",
+ "experimentdata"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "For experiments where the output data is given upon creation, the `job_status` will be set to `finished`, indicating that these experiments do not need to be run again.\n",
+ "For experiments where the output data is not given upon creation, the `job_status` will be set to `open`, indicating that these experiments are open to be evaluated.\n",
+ "\n",
+ "The status of a job can be manually set by using the `mark` method of the `ExperimentData` object:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "output | \n", + "|
|---|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "y | \n", + "
| 0 | \n", + "finished | \n", + "0.1 | \n", + "0.4 | \n", + "0.5 | \n", + "
| 1 | \n", + "finished | \n", + "0.2 | \n", + "0.5 | \n", + "0.6 | \n", + "
| 2 | \n", + "open | \n", + "0.3 | \n", + "0.6 | \n", + "NaN | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input output\n",
+ " x0 x1 y\n",
+ "0 finished 0.1 0.4 0.5\n",
+ "1 open 0.2 0.5 0.6\n",
+ "2 open 0.3 0.6 NaN"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "experimentdata.mark(indices=1, status='open')\n",
+ "experimentdata"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Upon inspecting the `ExperimentData` object, you will see that the `data` attribute is a dictionary with numerical identifiers as keys and `ExperimentSample` objects as values:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "defaultdict(f3dasm._src.experimentsample.ExperimentSample,\n",
+ " {0: ExperimentSample(input_data={'x0': 0.1, 'x1': 0.4}, output_data={'y': 0.5}, job_status=JobStatus.FINISHED),\n",
+ " 1: ExperimentSample(input_data={'x0': 0.2, 'x1': 0.5}, output_data={'y': 0.6}, job_status=JobStatus.OPEN),\n",
+ " 2: ExperimentSample(input_data={'x0': 0.3, 'x1': 0.6}, output_data={}, job_status=JobStatus.OPEN)})"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "experimentdata.data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Manipulating the `ExperimentData` object"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Multiple `ExperimentData` objects can be combined using the `+` operator. This will create a new `ExperimentData` object that contains all the experiments from the two original `ExperimentData` objects.\n",
+ "If applicable, the `ExperimentData` objects are combined as well."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "output | \n", + "|
|---|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "y | \n", + "
| 0 | \n", + "finished | \n", + "0.1 | \n", + "0.4 | \n", + "0.5 | \n", + "
| 1 | \n", + "open | \n", + "0.2 | \n", + "0.5 | \n", + "0.6 | \n", + "
| 2 | \n", + "open | \n", + "0.3 | \n", + "0.6 | \n", + "NaN | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " jobs input \n",
+ " x0 x1\n",
+ "0 open 0.1 0.4\n",
+ "1 open 0.2 0.5\n",
+ "2 open 0.3 0.6\n",
+ "3 open 0.7 0.3\n",
+ "4 open 0.8 0.2\n",
+ "5 open 0.9 0.1"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "experimentdata_1 = ExperimentData(domain=domain, input_data=np.array([\n",
+ " [0.1, 0.4],\n",
+ " [0.2, 0.5],\n",
+ " [0.3, 0.6]\n",
+ "]))\n",
+ "\n",
+ "experimentdata_2 = ExperimentData(domain=domain, input_data=pd.DataFrame({\n",
+ " 'x0': [0.7, 0.8, 0.9],\n",
+ " 'x1': [0.3, 0.2, 0.1]\n",
+ "}))\n",
+ "\n",
+ "experimentdata_1 + experimentdata_2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Storing the `ExperimentData` object\n",
+ "\n",
+ "The `ExperimentData` object can be stored to a series of files using the `store()` method. In this example, we will show how to store the `ExperimentData` to disk using the `store()` method and how to load the stored data using the `from_file()` method.\n",
+ "\n",
+ "- The `project_dir` argument of the is used to store the `ExperimentData` to disk. You can provide a string or a path to a directory. This can either be a relative or absolute path. If the directory does not exist, it will be created.\n",
+ "- The `store()` method is used to store the experiment data to the directory provided."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "experimentdata.set_project_dir('./my_project')\n",
+ "\n",
+ "experimentdata.store()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The data is stored in several files in an `/experiment_data` subfolder in the provided project directory:\n",
+ "\n",
+ "```\n",
+ "my_project/\n",
+ "βββ my_script.py\n",
+ "βββ experiment_data\n",
+ " βββ domain.json\n",
+ " βββ input_data.csv\n",
+ " βββ output_data.csv\n",
+ " βββ jobs.csv\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In order to load the data, you can use `ExperimentData.from_file()`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data_loaded = ExperimentData.from_file(project_dir=\"./my_project\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Exporting the `ExperimentData` object\n",
+ "\n",
+ "The `ExperimentData` object can be exported to several common data formats:\n",
+ "\n",
+ "- To two numpy arrays (one for the input data and one for the output data) using the `to_numpy()` method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(array([[0.1, 0.4],\n",
+ " [0.2, 0.5],\n",
+ " [0.3, 0.6]]),\n",
+ " array([[0.5],\n",
+ " [0.6],\n",
+ " [nan]]))"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "experimentdata.to_numpy()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- To two pandas DataFrames (one for the input data and one for the output data) using the `to_pandas()` method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | jobs | \n", + "input | \n", + "|
|---|---|---|---|
| \n", + " | \n", + " | x0 | \n", + "x1 | \n", + "
| 0 | \n", + "open | \n", + "0.1 | \n", + "0.4 | \n", + "
| 1 | \n", + "open | \n", + "0.2 | \n", + "0.5 | \n", + "
| 2 | \n", + "open | \n", + "0.3 | \n", + "0.6 | \n", + "
| 3 | \n", + "open | \n", + "0.7 | \n", + "0.3 | \n", + "
| 4 | \n", + "open | \n", + "0.8 | \n", + "0.2 | \n", + "
| 5 | \n", + "open | \n", + "0.9 | \n", + "0.1 | \n", + "
\n",
+ "\n",
+ "\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " x0 x1\n",
+ "0 0.1 0.4\n",
+ "1 0.2 0.5\n",
+ "2 0.3 0.6"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df_input, df_output = experimentdata.to_pandas()\n",
+ "df_input"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- to an `xarray.Dataset` object using the `to_xarray()` method:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | x0 | \n", + "x1 | \n", + "
|---|---|---|
| 0 | \n", + "0.1 | \n", + "0.4 | \n", + "
| 1 | \n", + "0.2 | \n", + "0.5 | \n", + "
| 2 | \n", + "0.3 | \n", + "0.6 | \n", + "
\n",
+ "
"
+ ],
+ "text/plain": [
+ "<xarray.Dataset>\n", + "Dimensions: (iterations: 3, input_dim: 2, output_dim: 1)\n", + "Coordinates:\n", + " * iterations (iterations) int64 0 1 2\n", + " * input_dim (input_dim) object 'x0' 'x1'\n", + " * output_dim (output_dim) object 'y'\n", + "Data variables:\n", + " input (iterations, input_dim) float64 0.1 0.4 0.2 0.5 0.3 0.6\n", + " output (iterations, output_dim) float64 0.5 0.6 nan
...
'
+ """
+ return self.to_multiindex()._repr_html_()
+
+ def __repr__(self) -> str:
+ """
+ Returns a string representation of the ExperimentData object.
+
+ Returns
+ -------
+ str
+ String representation of the ExperimentData object.
+
+ Examples
+ --------
+ >>> repr(experiment_data)
+ 'ExperimentData(...)'
+ """
+ return self.to_multiindex().__repr__()
+
+ def access_file(self, operation: Callable) -> Callable:
+ """
+ Wrapper for accessing a single resource with a file lock.
+
+ Parameters
+ ----------
+ operation : Callable
+ The operation to be performed on the resource.
+
+ Returns
+ -------
+ Callable
+ The wrapped operation.
+
+ Examples
+ --------
+ >>> @experiment_data.access_file
+ ... def read_data(project_dir):
+ ... # read data from file
+ ... pass
+ """
+ @functools.wraps(operation)
+ def wrapper_func(project_dir: Path, *args, **kwargs) -> None:
+ lock = FileLock(
+ (project_dir / EXPERIMENTDATA_SUBFOLDER / LOCK_FILENAME
+ ).with_suffix('.lock'))
+
+ # If the lock has been acquired:
+ with lock:
+ tries = 0
+ while tries < MAX_TRIES:
+ # try:
+ # print(f"{args=}, {kwargs=}")
+ # self = ExperimentData.from_file(project_dir)
+ # value = operation(*args, **kwargs)
+ # self.store()
+ # break
+ try:
+ # Load a fresh instance of ExperimentData from file
+ loaded_self = ExperimentData.from_file(
+ self.project_dir)
+
+ # Call the operation with the loaded instance
+ # Replace the self in args with the loaded instance
+ # Modify the first argument
+ args = (loaded_self,) + args[1:]
+ value = operation(*args, **kwargs)
+ loaded_self.store()
+ break
+
+ # Racing conditions can occur when the file is empty
+ # and the file is being read at the same time
+ except pd.errors.EmptyDataError:
+ tries += 1
+ logger.debug((
+ f"EmptyDataError occurred, retrying"
+ f" {tries+1}/{MAX_TRIES}"))
+ sleep(1)
+
+ raise pd.errors.EmptyDataError()
+
+ return value
+
+ return partial(wrapper_func, project_dir=self.project_dir)
+
+ # Properties
+ # =========================================================================
+
+ @property
+ def index(self) -> pd.Index:
+ """
+ Returns an iterable of the job number of the experiments.
+
+ Returns
+ -------
+ pd.Index
+ The job number of all the experiments in pandas Index format.
+
+ Examples
+ --------
+ >>> experiment_data.index
+ Int64Index([0, 1, 2], dtype='int64')
+ """
+ return pd.Index(self.data.keys())
+
+ @property
+ def jobs(self) -> pd.Series:
+ """
+ Returns the status of all the jobs.
+
+ Returns
+ -------
+ pd.Series
+ The status of all the jobs.
+
+ Examples
+ --------
+ >>> experiment_data.jobs
+ 0 open
+ 1 finished
+ dtype: object
+ """
+ return pd.Series({id: es.job_status.name for id, es in self})
+
+ # Alternative constructors
+ # =========================================================================
+
+ @classmethod
+ def from_file(cls: Type[ExperimentData],
+ project_dir: Path | str) -> ExperimentData:
+ """
+ Create an ExperimentData object from .csv and .json files.
+
+ Parameters
+ ----------
+ project_dir : Path or str
+ User defined path of the experimentdata directory.
+
+ Returns
+ -------
+ ExperimentData
+ ExperimentData object containing the loaded data.
+
+ Examples
+ --------
+ >>> experiment_data = ExperimentData.from_file('path/to/project_dir')
+ """
+ if isinstance(project_dir, str):
+ project_dir = Path(project_dir)
+
+ try:
+ return _from_file_attempt(project_dir)
+ except FileNotFoundError:
+ try:
+ filename_with_path = Path(get_original_cwd()) / project_dir
+ except ValueError: # get_original_cwd() hydra initialization error
+ raise FileNotFoundError(
+ f"Cannot find the folder {project_dir} !")
+
+ return _from_file_attempt(filename_with_path)
+
+ @classmethod
+ def from_sampling(cls, sampler: Block | str,
+ domain: Domain | DictConfig | str | Path,
+ **kwargs):
+ """
+ Create an ExperimentData object from a sampler.
+
+ Parameters
+ ----------
+ sampler : Block or str
+ Sampler object containing the sampling strategy or one of the
+ built-in sampler names.
+ domain : Domain or DictConfig
+ Domain object containing the domain of the experiment or hydra
+ DictConfig object containing the configuration.
+ **kwargs
+ Additional keyword arguments passed to the sampler.
+
+ Returns
+ -------
+ ExperimentData
+ ExperimentData object containing the sampled data.
+
+ Examples
+ --------
+ >>> experiment_data = ExperimentData.from_sampling('random', domain)
+ """
+ data = cls(domain=domain)
+ data.sample(sampler=sampler, **kwargs)
+ return data
+
+ @classmethod
+ def from_yaml(cls, config: DictConfig) -> ExperimentData:
+ """
+ Create an ExperimentData object from a YAML configuration.
+
+ Parameters
+ ----------
+ config : DictConfig
+ Hydra DictConfig object containing the configuration.
+
+ Returns
+ -------
+ ExperimentData
+ ExperimentData object containing the loaded data.
+
+ Examples
+ --------
+ >>> experiment_data = ExperimentData.from_yaml(config)
+ """
+ # Option 0: Both existing and sampling
+ if 'from_file' in config and 'from_sampling' in config:
+ return cls.from_file(config.from_file) + cls.from_sampling(
+ **config.from_sampling)
+
+ # Option 1: From exisiting ExperimentData files
+ if 'from_file' in config:
+ return cls.from_file(config.from_file)
+
+ # Option 2: Sample from the domain
+ if 'from_sampling' in config:
+ return cls.from_sampling(**config.from_sampling)
+
+ else:
+ return cls(**config)
+
+ @classmethod
+ def from_data(cls, data: Optional[Dict[int, ExperimentSample]] = None,
+ domain: Optional[Domain] = None,
+ project_dir: Optional[Path] = None) -> ExperimentData:
+ """
+ Create an ExperimentData object from existing data.
+
+ Parameters
+ ----------
+ data : dict of int to ExperimentSample, optional
+ The existing data, by default None.
+ domain : Domain, optional
+ The domain of the data, by default None.
+ project_dir : Path, optional
+ The project directory, by default None.
+
+ Returns
+ -------
+ ExperimentData
+ ExperimentData object containing the loaded data.
+
+ Examples
+ --------
+ >>> experiment_data = ExperimentData.from_data(data, domain)
+ """
+ if data is None:
+ data = {}
+
+ if domain is None:
+ domain = Domain()
+
+ experiment_data = cls()
+
+ experiment_data.data = defaultdict(ExperimentSample, data)
+ experiment_data.domain = domain
+ experiment_data.project_dir = _project_dir_factory(project_dir)
+ return experiment_data
+
+ # Selecting subsets
+ # =========================================================================
+
+ def select(self, indices: int | Iterable[int]) -> ExperimentData:
+ """
+ Select a subset of the ExperimentData object.
+
+ Parameters
+ ----------
+ indices : int or Iterable[int]
+ The indices to select.
+
+ Returns
+ -------
+ ExperimentData
+ The selected subset of the ExperimentData object.
+
+ Examples
+ --------
+ >>> subset = experiment_data.select([0, 1, 2])
+ """
+ return self[indices]
+
+ def select_with_status(
+ self,
+ status: Literal['open', 'in_progress', 'finished', 'error']
+ ) -> ExperimentData:
+ """
+ Select a subset of the ExperimentData object with a given status.
+
+ Parameters
+ ----------
+ status : {'open', 'in_progress', 'finished', 'error'}
+ The status to select.
+
+ Returns
+ -------
+ ExperimentData
+ The selected subset of the ExperimentData object with the given
+ status.
+
+ Examples
+ --------
+ >>> subset = experiment_data.select_with_status('finished')
+ """
+ idx = [i for i, es in self if es.is_status(status)]
+ return self[idx]
+
+ # Export
+ # =========================================================================
+
+ def store(self, project_dir: Optional[Path | str] = None):
+ """
+ Write the ExperimentData to disk in the project directory.
+
+ Parameters
+ ----------
+ project_dir : Optional[Path | str], optional
+ The f3dasm project directory to store the
+ ExperimentData object to, by default None.
+
+ Note
+ ----
+ If no project directory is provided, the ExperimentData object is
+ stored in the directory provided by the `.project_dir` attribute that
+ is set upon creation of the object.
+
+ The ExperimentData object is stored in a subfolder 'experiment_data'.
+
+ The ExperimentData object is stored in four files:
+
+ * the input data (`input.csv`)
+ * the output data (`output.csv`)
+ * the jobs (`jobs.csv`)
+ * the domain (`domain.json`)
+
+ To avoid the ExperimentData to be written simultaneously by multiple
+ processes, a '.lock' file is automatically created
+ in the project directory. Concurrent process can only sequentially
+ access the lock file. This lock file is removed after the
+ ExperimentData object is written to disk.
+ """
+ if project_dir is not None:
+ self.set_project_dir(project_dir)
+
+ subdirectory = self.project_dir / EXPERIMENTDATA_SUBFOLDER
+
+ # Create the experimentdata subfolder if it does not exist
+ subdirectory.mkdir(parents=True, exist_ok=True)
+
+ df_input, df_output = self.to_pandas(keep_references=True)
+
+ df_input.to_csv(
+ (subdirectory / INPUT_DATA_FILENAME).with_suffix('.csv'))
+ df_output.to_csv(
+ (subdirectory / OUTPUT_DATA_FILENAME).with_suffix('.csv'))
+ self.domain.store(subdirectory / DOMAIN_FILENAME)
+ self.jobs.to_csv((subdirectory / JOBS_FILENAME).with_suffix('.csv'))
+
+ def to_numpy(self) -> Tuple[np.ndarray, np.ndarray]:
+ """
+ Convert the ExperimentData object to a tuple of numpy arrays.
+
+ Returns
+ -------
+ tuple of np.ndarray
+ A tuple containing two numpy arrays, the first one for input
+ columns, and the second for output columns.
+
+ Examples
+ --------
+ >>> input_array, output_array = experiment_data.to_numpy()
+ """
+ df_input, df_output = self.to_pandas(keep_references=False)
+ return df_input.to_numpy(), df_output.to_numpy()
+
+ def to_pandas(self, keep_references: bool = False
+ ) -> Tuple[pd.DataFrame, pd.DataFrame]:
+ """
+ Convert the ExperimentData object to pandas DataFrames.
+
+ Parameters
+ ----------
+ keep_references : bool, optional
+ If True, the references to the output data are kept, by default
+ False.
+
+ Returns
+ -------
+ tuple of pd.DataFrame
+ A tuple containing two pandas DataFrames, the first one for input
+ columns, and the second for output columns.
+
+ Examples
+ --------
+ >>> df_input, df_output = experiment_data.to_pandas()
+ """
+ if keep_references:
+ return (
+ pd.DataFrame([es._input_data for _, es in self],
+ index=self.index),
+ pd.DataFrame([es._output_data for _, es in self],
+ index=self.index)
+ )
+ else:
+ return (
+ pd.DataFrame([es.input_data for _, es in self],
+ index=self.index),
+ pd.DataFrame([es.output_data for _, es in self],
+ index=self.index)
+ )
+
+ def to_xarray(self, keep_references: bool = False) -> xr.Dataset:
+ """
+ Convert the ExperimentData object to an xarray Dataset.
+
+ Parameters
+ ----------
+ keep_references : bool, optional
+ If True, the references to the output data are kept, by default
+ False.
+
+ Returns
+ -------
+ xr.Dataset
+ An xarray Dataset containing the data.
+
+ Examples
+ --------
+ >>> dataset = experiment_data.to_xarray()
+ """
+ df_input, df_output = self.to_pandas(keep_references=keep_references)
+
+ da_input = xr.DataArray(df_input, dims=['iterations', 'input_dim'],
+ coords={'iterations': self.index,
+ 'input_dim': df_input.columns})
+
+ da_output = xr.DataArray(df_output, dims=['iterations', 'output_dim'],
+ coords={'iterations': self.index,
+ 'output_dim': df_output.columns})
+
+ return xr.Dataset({'input': da_input, 'output': da_output})
+
+ # TODO: Implement this
+ def get_n_best_output(self, n_samples: int,
+ output_name: Optional[str] = 'y') -> ExperimentData:
+ """
+ Get the n best samples from the output data. Lower values are better.
+
+ Parameters
+ ----------
+ n_samples : int
+ Number of samples to select.
+ output_name : str, optional
+ The name of the output column to sort by, by default 'y'.
+
+ Returns
+ -------
+ ExperimentData
+ New ExperimentData object with a selection of the n best samples.
+
+ Examples
+ --------
+ >>> best_samples = experiment_data.get_n_best_output(5)
+ """
+ _, df_out = self.to_pandas()
+ indices = df_out.nsmallest(n=n_samples, columns=output_name).index
+ return self[indices]
+
+ def to_multiindex(self) -> pd.DataFrame:
+ """
+ Convert the ExperimentData object to a pandas DataFrame with a
+ MultiIndex. This is used for visualization purposes in a Jupyter
+ notebook environment.
+
+ Returns
+ -------
+ pd.DataFrame
+ A pandas DataFrame with a MultiIndex.
+
+ Examples
+ --------
+ >>> df_multiindex = experiment_data.to_multiindex()
+ """
+ list_of_dicts = [sample.to_multiindex() for _, sample in self]
+ return pd.DataFrame(merge_dicts(list_of_dicts), index=self.index)
+
+ # Append or remove data
+ # =========================================================================
+
+ def add_experiments(self,
+ data: ExperimentSample | ExperimentData
+ ) -> None:
+ """
+ Add an ExperimentSample or ExperimentData to the ExperimentData
+ attribute.
+
+ Parameters
+ ----------
+ data : ExperimentSample or ExperimentData
+ Experiment(s) to add.
+
+ Raises
+ ------
+ ValueError
+ If the input is not an ExperimentSample or ExperimentData object.
+
+ Examples
+ --------
+ >>> experiment_data.add_experiments(new_sample)
+ >>> experiment_data.add_experiments(new_data)
+ """
+ if isinstance(data, ExperimentSample):
+ self._add_experiment_sample(data)
+
+ elif isinstance(data, ExperimentData):
+ self._add(data)
+
+ else:
+ raise ValueError((
+ f"The input to this function should be an ExperimentSample or "
+ f"ExperimentData object, not {type(data)} ")
+ )
+
+ # Not used
+ def overwrite(
+ self, indices: Iterable[int],
+ domain: Optional[Domain] = None,
+ input_data: Optional[
+ pd.DataFrame | np.ndarray
+ | List[Dict[str, Any]] | str | Path] = None,
+ output_data: Optional[
+ pd.DataFrame | np.ndarray
+ | List[Dict[str, Any]] | str | Path] = None,
+ jobs: Optional[Path | str] = None,
+ add_if_not_exist: bool = False
+ ) -> None:
+ """Overwrite the ExperimentData object.
+
+ Parameters
+ ----------
+ indices : Iterable[int]
+ The indices to overwrite.
+ domain : Optional[Domain], optional
+ Domain of the new object, by default None
+ input_data : Optional[DataTypes], optional
+ input parameters of the new object, by default None
+ output_data : Optional[DataTypes], optional
+ output parameters of the new object, by default None
+ jobs : Optional[Path | str], optional
+ jobs off the new object, by default None
+ add_if_not_exist : bool, optional
+ If True, the new objects are added if the requested indices
+ do not exist in the current ExperimentData object, by default False
+ """
+ raise NotImplementedError()
+
+ # Not used
+ def _overwrite_experiments(
+ self, indices: Iterable[int],
+ experiment_sample: ExperimentSample | ExperimentData,
+ add_if_not_exist: bool) -> None:
+ """
+ Overwrite the ExperimentData object at the given indices.
+
+ Parameters
+ ----------
+ indices : Iterable[int]
+ The indices to overwrite.
+ experimentdata : ExperimentData | ExperimentSample
+ The new ExperimentData object to overwrite with.
+ add_if_not_exist : bool
+ If True, the new objects are added if the requested indices
+ do not exist in the current ExperimentData object.
+ """
+ raise NotImplementedError()
+
+ # Used in parallel mode
+ def overwrite_disk(
+ self, indices: Iterable[int],
+ domain: Optional[Domain] = None,
+ input_data: Optional[
+ pd.DataFrame | np.ndarray
+ | List[Dict[str, Any]] | str | Path] = None,
+ output_data: Optional[
+ pd.DataFrame | np.ndarray
+ | List[Dict[str, Any]] | str | Path] = None,
+ jobs: Optional[Path | str] = None,
+ add_if_not_exist: bool = False
+ ) -> None:
+ """
+ Overwrite experiments on disk with new data.
+
+ Parameters
+ ----------
+ indices : Iterable[int]
+ The indices of the experiments to overwrite.
+ domain : Domain, optional
+ The new domain, by default None.
+ input_data : pd.DataFrame | np.ndarray | List[Dict[str, Any]] |
+ str | Path, optional
+ The new input data, by default None.
+ output_data : pd.DataFrame | np.ndarray | List[Dict[str, Any]] |
+ str | Path, optional
+ The new output data, by default None.
+ jobs : Path | str, optional
+ The new jobs data, by default None.
+ add_if_not_exist : bool, optional
+ If True, add experiments if the indices do not exist,
+ by default False.
+ """
+ raise NotImplementedError()
+
+ def remove_rows_bottom(self, number_of_rows: int):
+ """
+ Remove a number of rows from the end of the ExperimentData object.
+
+ Parameters
+ ----------
+ number_of_rows : int
+ Number of rows to remove from the bottom.
+
+ Examples
+ --------
+ >>> experiment_data.remove_rows_bottom(3)
+ """
+ # remove the last n rows
+ for i in range(number_of_rows):
+ self.data.pop(self.index[-1])
+
+ def reset_index(self) -> ExperimentData:
+ """
+ Reset the index of the ExperimentData object.
+ The index will be reset to a range from 0 to the number of experiments.
+
+ Returns
+ -------
+ ExperimentData
+ ExperimentData object with a reset index.
+
+ Examples
+ --------
+ >>> reset_data = experiment_data.reset_index()
+ """
+ return ExperimentData.from_data(
+ data={i: v for i, v in enumerate(self.data.values())},
+ domain=self.domain,
+ project_dir=self.project_dir)
+
+ def join(self, experiment_data: ExperimentData) -> ExperimentData:
+ """
+ Join two ExperimentData objects.
+
+ Parameters
+ ----------
+ experiment_data : ExperimentData
+ The other ExperimentData object to join with.
+
+ Returns
+ -------
+ ExperimentData
+ The joined ExperimentData object.
+
+ Examples
+ --------
+ >>> joined_data = experiment_data1.join(experiment_data2)
+ """
+ copy_self = self.reset_index()
+ # TODO: Reset isnt necessary, only copy
+ copy_other = experiment_data.reset_index()
+
+ for (i, es_self), (_, es_other) in zip(copy_self, copy_other):
+ copy_self.data[i] = es_self + es_other
+
+ copy_self.domain += copy_other.domain
+
+ return copy_self
+
+ def _add(self, experiment_data: ExperimentData):
+ # copy and reset self
+ copy_other = experiment_data.reset_index()
+
+ # Find the last key in my_dict
+ last_key = max(self.index) if self else -1
+
+ # Update keys of other dict
+ other_updated_data = {
+ last_key + 1 + i: v for i, v in enumerate(
+ copy_other.data.values())}
+
+ self.data.update(other_updated_data)
+ self.domain += copy_other.domain
+
+ def _add_experiment_sample(self, experiment_sample: ExperimentSample):
+ last_key = max(self.index) if self else -1
+ self.data[last_key + 1] = experiment_sample
+
+ def _overwrite(self, experiment_data: ExperimentData,
+ indices: Iterable[int],
+ add_if_not_exist: bool = False):
+ if len(indices) != len(experiment_data):
+ raise ValueError((
+ f"The number of indices ({len(indices)}) must match the number"
+ f"of experiments ({len(experiment_data)}).")
+ )
+ copy_other = experiment_data.reset_index()
+
+ for (_, es), id in zip(copy_other, indices):
+ self.data[id] = es
+
+ self.domain += copy_other.domain
+
+ def replace_nan(self, value: Any):
+ """
+ Replace all NaN values in the output data with the given value.
+
+ Parameters
+ ----------
+ value : Any
+ The value to replace NaNs with.
+
+ Examples
+ --------
+ >>> experiment_data.replace_nan(0)
+ """
+ for _, es in self:
+ es.replace_nan(value)
+
+ def round(self, decimals: int):
+ """
+ Round all output data to the given number of decimals.
+
+ Parameters
+ ----------
+ decimals : int
+ Number of decimals to round to.
+
+ Examples
+ --------
+ >>> experiment_data.round(2)
+ """
+ for _, es in self:
+ es.round(decimals)
+
+ def sort(self, criterion: Callable[[ExperimentSample], Any],
+ reverse: bool = False) -> ExperimentData:
+ """
+ Sort the ExperimentData object based on a criterion.
+
+ Parameters
+ ----------
+ criterion : Callable[[ExperimentSample], Any]
+ The criterion to sort on. This should be a function that takes an
+ ExperimentSample object and returns a value to sort on.
+ reverse : bool, optional
+ If True, sort in descending order, by default False.
+
+ Returns
+ -------
+ ExperimentData
+ The sorted ExperimentData object.
+
+ Examples
+ --------
+ >>> sorted_data = experiment_data.sort(lambda x: x.output_data['y'])
+ """
+
+ sorted_data = dict(
+ sorted(self.data.items(), key=lambda item: criterion(
+ item[1]), reverse=reverse)
+ )
+ return ExperimentData.from_data(
+ data=sorted_data,
+ domain=self.domain,
+ project_dir=self.project_dir
+ )
+
+ # ExperimentSample
+ # =========================================================================
+
+ def get_experiment_sample(self, id: int) -> ExperimentSample:
+ """
+ Gets the experiment_sample at the given index.
+
+ Parameters
+ ----------
+ id : int
+ The index of the experiment_sample to retrieve.
+
+ Returns
+ -------
+ ExperimentSample
+ The ExperimentSample at the given index.
+
+ Examples
+ --------
+ >>> sample = experiment_data.get_experiment_sample(0)
+ """
+ return self.data[id]
+
+ def store_experimentsample(
+ self, experiment_sample: ExperimentSample, id: int):
+ """
+ Store an ExperimentSample object in the ExperimentData object.
+
+ Parameters
+ ----------
+ experiment_sample : ExperimentSample
+ The ExperimentSample object to store.
+ id : int
+ The index of the ExperimentSample object.
+
+ Examples
+ --------
+ >>> experiment_data.store_experimentsample(sample, 0)
+ """
+ self.domain += experiment_sample.domain
+
+ for name, value in experiment_sample._output_data.items():
+
+ # # If the output parameter is not in the domain, add it
+ # if name not in self.domain.output_names:
+ # self.domain.add_output(name=name, to_disk=True)
+
+ parameter = self.domain.output_space[name]
+
+ # If the parameter is to be stored on disk, store it
+ # Also check if the value is not already a reference!
+ if parameter.to_disk and not isinstance(value, (Path, str)):
+ storage_location = store_to_disk(
+ project_dir=self.project_dir, object=value, name=name,
+ id=id, store_function=parameter.store_function)
+
+ experiment_sample._output_data[name] = Path(storage_location)
+
+ for name, value in experiment_sample._input_data.items():
+ parameter = self.domain.input_space[name]
+
+ # If the parameter is to be stored on disk, store it
+ # Also check if the value is not already a reference!
+ if parameter.to_disk and not isinstance(value, (Path, str)):
+ storage_location = store_to_disk(
+ project_dir=self.project_dir, object=value, name=name,
+ id=id, store_function=parameter.store_function)
+
+ experiment_sample._input_data[name] = Path(storage_location)
+
+ # Set the experiment sample in the ExperimentData object
+ self.data[id] = experiment_sample
+
+ # Used in parallel mode
+
+ def get_open_job(self) -> Tuple[int, ExperimentSample]:
+ """
+ Get the first open job in the ExperimentData object.
+
+ Returns
+ -------
+ tuple of int and ExperimentSample
+ The index and ExperimentSample of the first open job.
+
+ Notes
+ -----
+ This function iterates over the ExperimentData object and returns the
+ first open job. If no open jobs are found, it returns None.
+
+ The returned open job is marked as 'in_progress'.
+
+ Examples
+ --------
+ >>> job_id, job_sample = experiment_data.get_open_job()
+ """
+ for id, es in self:
+ if es.is_status('open'):
+ es.mark('in_progress')
+ return id, es
+
+ return None, ExperimentSample()
+
+ # Jobs
+ # =========================================================================
+
+ def is_all_finished(self) -> bool:
+ """
+ Check if all jobs are finished.
+
+ Returns
+ -------
+ bool
+ True if all jobs are finished, False otherwise.
+
+ Examples
+ --------
+ >>> experiment_data.is_all_finished()
+ True
+ """
+ return all(es.is_status('finished') for _, es in self)
+
+ def mark(self, indices: int | Iterable[int],
+ status: Literal['open', 'in_progress', 'finished', 'error']):
+ """
+ Mark the jobs at the given indices with the given status.
+
+ Parameters
+ ----------
+ indices : int or Iterable[int]
+ Indices of the jobs to mark.
+ status : {'open', 'in_progress', 'finished', 'error'}
+ Status to mark the jobs with.
+
+ Raises
+ ------
+ ValueError
+ If the given status is not valid.
+
+ Examples
+ --------
+ >>> experiment_data.mark([0, 1], 'finished')
+ """
+ if isinstance(indices, int):
+ indices = [indices]
+ for i in indices:
+ self.data[i].mark(status)
+
+ def mark_all(self,
+ status: Literal['open', 'in_progress', 'finished', 'error']):
+ """
+ Mark all the experiments with the given status.
+
+ Parameters
+ ----------
+ status : {'open', 'in_progress', 'finished', 'error'}
+ Status to mark the jobs with.
+
+ Raises
+ ------
+ ValueError
+ If the given status is not valid.
+
+ Examples
+ --------
+ >>> experiment_data.mark_all('finished')
+ """
+ for _, es in self:
+ es.mark(status)
+
+ def run(self, block: Block | Iterable[Block], **kwargs) -> ExperimentData:
+ """
+ Run a block over the entire ExperimentData object.
+
+ Parameters
+ ----------
+ block : Block
+ The block(s) to run.
+ **kwargs
+ Additional keyword arguments passed to the block.
+
+ Returns
+ -------
+ ExperimentData
+ The ExperimentData object after running the block.
+
+ Examples
+ --------
+ >>> experiment_data.run(block)
+ """
+ if isinstance(block, Block):
+ block = [block]
+
+ for b in block:
+ b.arm(data=self)
+ self = b.call(data=self, **kwargs)
+
+ return self
+
+ # Datageneration
+ # =========================================================================
+
+ def evaluate(self, data_generator: Block | str,
+ mode: Literal['sequential', 'parallel',
+ 'cluster', 'cluster_parallel'] = 'sequential',
+ output_names: Optional[List[str]] = None,
+ **kwargs) -> None:
+ """
+ Run any function over the entirety of the experiments.
+
+ Parameters
+ ----------
+ data_generator : DataGenerator
+ Data generator to use.
+ mode : {'sequential', 'parallel', 'cluster', 'cluster_parallel'},
+ optional
+ Operational mode, by default 'sequential'.
+ output_names : list of str, optional
+ Names of the output parameters, by default None.
+ **kwargs
+ Additional keyword arguments passed to the data generator.
+
+ Raises
+ ------
+ ValueError
+ If an invalid parallelization mode is specified.
+
+ Examples
+ --------
+ >>> experiment_data.evaluate(data_generator, mode='parallel')
+ """
+ # Create
+ data_generator = _datagenerator_factory(
+ data_generator=data_generator, output_names=output_names, **kwargs)
+
+ self = self.run(block=data_generator, mode=mode, **kwargs)
+
+ # Optimization
+ # =========================================================================
+
+ def optimize(self, optimizer: Block | str,
+ data_generator: DataGenerator | str,
+ iterations: int,
+ kwargs: Optional[Dict[str, Any]] = None,
+ hyperparameters: Optional[Dict[str, Any]] = None,
+ x0_selection: Literal['best', 'random',
+ 'last',
+ 'new'] | ExperimentData = 'best',
+ sampler: Optional[Block | str] = 'random',
+ overwrite: bool = False) -> None:
+ """
+ Optimize the ExperimentData object.
+
+ Parameters
+ ----------
+ optimizer : Block or str or Callable
+ Optimizer object.
+ data_generator : DataGenerator or str
+ DataGenerator object.
+ iterations : int
+ Number of iterations.
+ kwargs : dict, optional
+ Additional keyword arguments passed to the DataGenerator.
+ hyperparameters : dict, optional
+ Additional keyword arguments passed to the optimizer.
+ x0_selection : {'best', 'random', 'last', 'new'} or ExperimentData
+ How to select the initial design, by default 'best'.
+ sampler : Block or str, optional
+ Sampler to use if x0_selection is 'new', by default 'random'.
+ overwrite : bool, optional
+ If True, the optimizer will overwrite the current data, by default
+ False.
+
+ Raises
+ ------
+ ValueError
+ If an invalid x0_selection is specified.
+
+ Examples
+ --------
+ >>> experiment_data.optimize(optimizer, data_generator, iterations=10)
+ """
+ if kwargs is None:
+ kwargs = {}
+
+ # Create the data generator object if a string reference is passed
+ if isinstance(data_generator, str):
+ data_generator = _datagenerator_factory(
+ data_generator=data_generator, **kwargs)
+
+ if hyperparameters is None:
+ hyperparameters = {}
+
+ # Create the optimizer object if a string reference is passed
+ if isinstance(optimizer, str):
+ optimizer = _optimizer_factory(
+ optimizer=optimizer, **hyperparameters)
+
+ # Create the sampler object if a string reference is passed
+ if isinstance(sampler, str):
+ sampler = _sampler_factory(sampler=sampler)
+
+ population = optimizer.population if hasattr(
+ optimizer, 'population') else 1
+
+ opt_type = optimizer.type if hasattr(optimizer, 'type') else None
+
+ if iterations < population and x0_selection == 'new':
+ raise ValueError(
+ f'For creating new samples, the total number of '
+ f'requested iterations ({iterations}) cannot be '
+ f'smaller than the population size '
+ f'({population})')
+
+ x0 = x0_factory(experiment_data=self, mode=x0_selection,
+ n_samples=population, sampler=sampler)
+
+ x0.evaluate(data_generator=data_generator, mode='sequential',
+ **kwargs)
+
+ if len(x0) < population:
+ raise ValueError((
+ f"There are {len(self.data)} samples available, "
+ f"need {population} for initial population!"
+ ))
+
+ optimizer.arm(data=x0)
+ data_generator.arm(data=x0)
+
+ x = x0
+
+ n_updates = range(
+ iterations // population + (iterations % population > 0))
+
+ if opt_type == 'scipy':
+ # Scipy optimizers work differently since they are not
+ # able to output a single update step
+ optimizer._iterate(data=x, data_generator=data_generator,
+ iterations=iterations, kwargs=kwargs,
+ overwrite=overwrite)
+ else:
+ for _ in n_updates:
+ if overwrite:
+ x = optimizer.call(data=x,
+ grad_fn=data_generator.dfdx)
+ else:
+ x += optimizer.call(data=x,
+ grad_fn=data_generator.dfdx)
+ x = data_generator.call(data=x, mode='sequential',
+ **kwargs)
+
+ if not overwrite:
+ x.remove_rows_bottom(
+ number_of_rows=population * n_updates.stop - iterations)
+ self._add(experiment_data=x[population:])
+
+ else:
+ self._add(experiment_data=x)
+
+ # Sampling
+ # =========================================================================
+
+ def sample(self, sampler: Block | str, **kwargs) -> None:
+ """
+ Sample data from the domain providing the sampler strategy
+
+ Parameters
+ ----------
+ sampler: BlockAbstract | str
+ Sampler callable or string of built-in sampler
+ If a string is passed, it should be one of the built-in samplers:
+
+ * 'random' : Random sampling
+ * 'latin' : Latin Hypercube Sampling
+ * 'sobol' : Sobol Sequence Sampling
+ * 'grid' : Grid Search Sampling
+
+ Note
+ ----
+ When using the 'grid' sampler, an optional argument
+ 'stepsize_continuous_parameters' can be passed to specify the stepsize
+ to cast continuous parameters to discrete parameters.
+
+ - The stepsize should be a dictionary with the parameter names as keys\
+ and the stepsize as values.
+ - Alternatively, a single stepsize can be passed for all continuous\
+ parameters.
+
+ Raises
+ ------
+ ValueError
+ Raised when invalid sampler type is specified
+ """
+
+ # Creation
+ sampler = _sampler_factory(sampler=sampler, **kwargs)
+
+ samples = self.run(block=sampler, **kwargs)
+
+ self._add(samples)
+
+ # Project directory
+ # =========================================================================
+
+ def set_project_dir(self, project_dir: Path | str):
+ """Set the directory of the f3dasm project folder.
+
+ Parameters
+ ----------
+ project_dir : Path or str
+ Path to the project directory
+ """
+ self.project_dir = _project_dir_factory(project_dir)
+
+ def remove_lockfile(self):
+ """
+ Remove the lock file from the project directory
+
+ Note
+ ----
+ The lock file is automatically created when the ExperimentData object
+ is written to disk. Concurrent processes can only sequentially access
+ the lock file. This lock file is removed after the ExperimentData
+ object is written to disk.
+
+ Examples
+ --------
+ >>> experiment_data.remove_lockfile()
+ """
+ (self.project_dir / EXPERIMENTDATA_SUBFOLDER / LOCK_FILENAME
+ ).with_suffix('.lock').unlink(missing_ok=True)
+
+
+# =============================================================================
+
+
+def x0_factory(experiment_data: ExperimentData,
+ mode: str | ExperimentData, n_samples: int,
+ sampler: Block) -> ExperimentData:
+ """Set the initial population to the best n samples of the given data
+
+ Parameters
+ ----------
+ experiment_data : ExperimentData
+ Data to be used for the initial population
+ mode : str
+ Mode of selecting the initial population, by default 'best'
+ The following modes are available:
+
+ - best: select the best n samples
+ - new: create n new samples
+ - random: select n random samples
+ - last: select the last n samples
+ n_samples : int
+ Number of samples to select
+ sampler : Block or str
+ Sampler object containing the sampling strategy or one of the
+ built-in sampler names. Used if mode is 'new'
+
+ Returns
+ -------
+ ExperimentData
+ Initial population of the optimization
+
+ Raises
+ ------
+ ValueError
+ Raises when the mode is not recognized
+ """
+ if isinstance(mode, ExperimentData):
+ x0 = mode
+
+ if mode == 'new':
+ x0 = ExperimentData.from_sampling(
+ sampler=sampler,
+ domain=experiment_data.domain,
+ n_samples=n_samples
+ )
+
+ elif mode == 'best':
+ x0 = experiment_data.get_n_best_output(n_samples)
+
+ elif mode == 'random':
+ x0 = experiment_data.select(
+ np.random.choice(
+ experiment_data.index,
+ size=n_samples, replace=False))
+
+ elif mode == 'last':
+ x0 = experiment_data.select(
+ experiment_data.index[-n_samples:])
+
+ else:
+ raise ValueError(
+ f'Unknown selection mode {mode}, use best, random or last')
+
+ return x0.reset_index()
+
+
+def _from_file_attempt(project_dir: Path) -> ExperimentData:
+ """Attempt to create an ExperimentData object
+ from .csv and .pkl files.
+
+ Parameters
+ ----------
+ path : Path
+ Name of the user-defined directory where the files are stored.
+
+ Returns
+ -------
+ ExperimentData
+ ExperimentData object containing the loaded data.
+
+ Raises
+ ------
+ FileNotFoundError
+ If the files cannot be found.
+ """
+ subdirectory = project_dir / EXPERIMENTDATA_SUBFOLDER
+
+ try:
+ return ExperimentData(domain=subdirectory / DOMAIN_FILENAME,
+ input_data=subdirectory / INPUT_DATA_FILENAME,
+ output_data=subdirectory / OUTPUT_DATA_FILENAME,
+ jobs=subdirectory / JOBS_FILENAME,
+ project_dir=project_dir)
+
+ except FileNotFoundError:
+ raise FileNotFoundError(
+ f"Cannot find the files from {subdirectory}.")
+
+
+def convert_numpy_to_dataframe_with_domain(
+ array: np.ndarray, names: Optional[List[str]],
+ mode: Literal['input', 'output']
+) -> pd.DataFrame:
+ """
+ Convert a numpy array to a pandas DataFrame with the domain names
+
+ Parameters
+ ----------
+ array : np.ndarray
+ The numpy array to be converted
+ names : List[str], optional
+ The names of the columns, by default None
+ mode : str
+ The mode of the data, either 'input' or 'output'
+
+ Returns
+ -------
+ pd.DataFrame
+ The converted data as a pandas DataFrame
+ """
+ if not names:
+ if mode == 'input':
+ names = [f'x{i}' for i in range(array.shape[1])]
+ elif mode == 'output':
+ if array.shape[1] == 1:
+ names = ['y']
+ else:
+ names = [f'y{i}' for i in range(array.shape[1])]
+
+ else:
+ raise ValueError(
+ f"Unknown mode {mode}, use 'input' or 'output'")
+
+ return pd.DataFrame(array, columns=names)
+
+
+def merge_dicts(list_of_dicts):
+ merged_dict = defaultdict(list)
+
+ # Get all unique keys from all dictionaries
+ all_keys = sorted({key for d in list_of_dicts for key in d})
+
+ # Define the desired order for the first element of the tuple
+ order = {'jobs': 0, 'input': 1, 'output': 2}
+
+ # Sort the keys first by the defined order then alphabetically within
+ # each group
+ sorted_keys = sorted(all_keys, key=lambda k: (
+ order.get(k[0], float('inf')), k))
+
+ # Iterate over each dictionary and insert None for missing keys
+ for d in list_of_dicts:
+ for key in sorted_keys:
+ # Use None for missing keys
+ merged_dict[key].append(d.get(key, None))
+
+ return dict(merged_dict)
+
+
+def _dict_factory(data: pd.DataFrame | List[Dict[str, Any]] | None | Path | str
+ ) -> List[Dict[str, Any]]:
+ """
+ Convert the DataTypes to a list of dictionaries
+
+ Parameters
+ ----------
+ data : pd.DataFrame | List[Dict[str, Any]] | None | Path | str
+ The data to be converted
+
+ Returns
+ -------
+ List[Dict[str, Any]]
+ The converted data as a list of dictionaries
+
+ Raises
+ ------
+ ValueError
+ Raised when the data type is not supported
+
+ Notes
+ -----
+ If the data is None, an empty list is returned.
+ """
+ if data is None:
+ return []
+
+ elif isinstance(data, (Path, str)):
+ return _dict_factory(pd.read_csv(
+ Path(data).with_suffix('.csv'),
+ header=0, index_col=0))
+
+ # check if data is already a list of dicts
+ elif isinstance(data, list) and all(isinstance(d, dict) for d in data):
+ return data
+
+ # If the data is a pandas DataFrame, convert it to a list of dictionaries
+ # Note : itertuples() is faster but renames the column names
+ elif isinstance(data, pd.DataFrame):
+ return [row.to_dict() for _, row in data.iterrows()]
+
+ raise ValueError(f"Data type {type(data)} not supported")
+
+
+def data_factory(input_data: List[Dict[str, Any]],
+ output_data: List[Dict[str, Any]],
+ domain: Domain,
+ jobs: pd.Series,
+ project_dir: Path,
+ ) -> Dict[int, ExperimentSample]:
+ """
+ Convert the input and output data to a defaultdictionary
+ of ExperimentSamples
+
+ Parameters
+ ----------
+ input_data : List[Dict[str, Any]]
+ The input data of the experiments
+ output_data : List[Dict[str, Any]]
+ The output data of the experiments
+ domain : Domain
+ The domain of the data
+ jobs : pd.Series
+ The status of all the jobs
+ project_dir : Path
+ The project directory of the data
+
+
+ Returns
+ -------
+ Dict[int, ExperimentSample]
+ The converted data as a defaultdict of ExperimentSamples
+
+ """
+ # remove all key-value pairs that have a None or np.nan value
+ input_data = remove_nan_and_none_keys_inplace(input_data)
+ output_data = remove_nan_and_none_keys_inplace(output_data)
+ # Combine the two lists into a dictionary of ExperimentSamples
+ data = {index: ExperimentSample(input_data=experiment_input,
+ output_data=experiment_output,
+ domain=domain,
+ job_status=job_status,
+ project_dir=project_dir)
+ for index, (experiment_input, experiment_output, job_status) in
+ enumerate(zip_longest(input_data, output_data, jobs))}
+
+ return defaultdict(ExperimentSample, data)
+
+
+def remove_nan_and_none_keys_inplace(data_list: List[Dict[str, Any]]) -> None:
+ for data in data_list:
+ keys_to_remove = [k for k, v in data.items() if v is None or (
+ isinstance(v, float) and np.isnan(v))]
+ for k in keys_to_remove:
+ del data[k]
+
+ return data_list
+
+
+def jobs_factory(jobs: pd.Series | str | Path | None) -> pd.Series:
+ if isinstance(jobs, pd.Series):
+ return jobs
+
+ elif jobs is None:
+ return pd.Series()
+
+ elif isinstance(jobs, (Path, str)):
+ df = pd.read_csv(
+ Path(jobs).with_suffix('.csv'),
+ header=0, index_col=0).squeeze()
+ # If the jobs is jut one value, it is parsed as a string
+ # So, make sure that we return a pd.Series either way!
+ if not isinstance(df, pd.Series):
+ df = pd.Series(df)
+
+ return df
+
+ else:
+ raise ValueError(f"Jobs type {type(jobs)} not supported")
diff --git a/src/f3dasm/_src/experimentdata/__init__.py b/src/f3dasm/_src/experimentdata/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/f3dasm/_src/experimentdata/_columns.py b/src/f3dasm/_src/experimentdata/_columns.py
deleted file mode 100644
index 76a3f474..00000000
--- a/src/f3dasm/_src/experimentdata/_columns.py
+++ /dev/null
@@ -1,125 +0,0 @@
-"""
-The _Columns class is used to order and track the parameter names of the data
-columns. This class is not intended to be used directly by the user.
-It is used by the _Data class to provide an interface to datatypes that do not
-have a column structure, such as numpy arrays.
-
-Note
-----
-
-For the default back-end of _Data, this class is obsolete since pandas
-DataFrames have a column structure. However, this class is intended to be a
-uniform interface to data that does not have a column structure.
-"""
-
-# Modules
-# =============================================================================
-
-from __future__ import annotations
-
-# Standard
-from typing import Dict, List, Optional
-
-# Authorship & Credits
-# =============================================================================
-__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
-__credits__ = ['Martin van der Schelling']
-__status__ = 'Stable'
-# =============================================================================
-#
-# =============================================================================
-
-
-class _Columns:
- def __init__(self, columns: Optional[Dict[str, None]] = None):
- """Class that keeps track of the names and order of parameters
- in the raw data.
-
- Parameters
- ----------
- columns: Dict[str, None], optional
- dictionary with names as column names and None as values
- , by default None
-
- Note
- ----
- The datatype of a dict with nonsensical values is used to prevent
- duplicate keys. This is because the dict is used as a set.
- """
- if columns is None:
- columns = {}
-
- self.columns: Dict[str, None] = columns
-
- def __repr__(self) -> str:
- """Representation of the _Columns object."""
- return self.columns.keys().__repr__()
-
- def __add__(self, __o: _Columns) -> _Columns:
- """Add two _Columns objects.
-
- Parameters
- ----------
- __o: _Columns
- _Columns object to add
-
- Returns
- -------
- _Columns
- _Columns object with the columns of both _Columns objects
- """
- return _Columns({**self.columns, **__o.columns})
-
- @property
- def names(self) -> List[str]:
- """List of the names of the columns.
-
- Returns
- -------
- List[str]
- list of the names of the columns
- """
- return list(self.columns.keys())
-
- def add(self, name: str):
- """Add a column to the _Columns object.
-
- Parameters
- ----------
- name: str
- name of the column to add
- """
- self.columns[name] = None
-
- def iloc(self, name: str | List[str]) -> List[int]:
- """Get the index of a column.
-
- Parameters
- ----------
- name: str | List[str]
- name of the column(s) to get the index of
-
- Returns
- -------
- List[int]
- list of the indices of the columns
- """
- if isinstance(name, str):
- name = [name]
-
- _indices = []
- for n in name:
- _indices.append(self.names.index(n))
- return _indices
-
- def rename(self, old_name: str, new_name: str):
- """Replace the name of a column.
-
- Parameters
- ----------
- old_name: str
- name of the column to replace
- new_name: str
- name of the column to replace with
- """
- self.columns[new_name] = self.columns.pop(old_name)
diff --git a/src/f3dasm/_src/experimentdata/_data.py b/src/f3dasm/_src/experimentdata/_data.py
deleted file mode 100644
index 3ca3c5b2..00000000
--- a/src/f3dasm/_src/experimentdata/_data.py
+++ /dev/null
@@ -1,585 +0,0 @@
-# Modules
-# =============================================================================
-
-from __future__ import annotations
-
-# Standard
-from copy import deepcopy
-from pathlib import Path
-from typing import (Any, Dict, Iterable, Iterator, List, Optional, Tuple, Type,
- Union)
-
-# Third-party
-import numpy as np
-import pandas as pd
-import xarray as xr
-
-# Local
-from ..design.domain import Domain
-from ._columns import _Columns
-
-# Authorship & Credits
-# =============================================================================
-__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
-__credits__ = ['Martin van der Schelling']
-__status__ = 'Stable'
-# =============================================================================
-#
-# =============================================================================
-
-
-class _Data:
- def __init__(self, data: Optional[pd.DataFrame] = None,
- columns: Optional[_Columns] = None):
- if data is None:
- data = pd.DataFrame()
-
- if columns is None:
- columns = _Columns({col: None for col in data.columns})
-
- self.columns: _Columns = columns
- self.data = data.rename(
- columns={name: i for i, name in enumerate(data.columns)})
-
- def __len__(self):
- """The len() method returns the number of datapoints"""
- return len(self.data)
-
- def __iter__(self) -> Iterator[Tuple[Dict[str, Any]]]:
- self.current_index = 0
- return self
-
- def __next__(self):
- if self.current_index >= len(self):
- raise StopIteration
- else:
- index = self.data.index[self.current_index]
- current_value = self.get_data_dict(index)
- self.current_index += 1
- return current_value
-
- def __getitem__(self, index: int | Iterable[int]) -> _Data:
- """Get a subset of the data.
-
- Parameters
- ----------
- index : int, list
- The index of the data to get.
-
- Returns
- -------
- A subset of the data.
- """
- # If the object is empty, return itself
- if self.is_empty():
- return self
-
- if isinstance(index, int):
- index = [index]
- return _Data(data=self.data.loc[index].copy(),
- columns=self.columns)
-
- def __add__(self, other: _Data | Dict[str, Any]) -> _Data:
- """Add two Data objects together.
-
- Parameters
- ----------
- other : Data
- The Data object to add.
-
- Returns
- -------
- The sum of the two Data objects.
- """
- # If other is a dictionary, convert it to a _Data object
- if isinstance(other, Dict):
- other = _convert_dict_to_data(other)
-
- try:
- last_index = self.data.index[-1]
- except IndexError: # Empty DataFrame
- # Make a copy of other.data
- return _Data(data=other.data.copy(), columns=other.columns)
-
- # Make a copy of other.data and modify its index
- other_data_copy = other.data.copy()
- other_data_copy.index = other_data_copy.index + last_index + 1
- return _Data(pd.concat(
- [self.data, other_data_copy]), columns=self.columns)
-
- def __eq__(self, __o: _Data) -> bool:
- try:
- pd.testing.assert_frame_equal(self.data, __o.data)
- except AssertionError:
- return False
-
- return True
-
- def _repr_html_(self) -> str:
- return self.to_dataframe()._repr_html_()
-
-# Properties
-# =============================================================================
-
- @property
- def indices(self) -> pd.Index:
- return self.data.index
-
- @property
- def names(self) -> List[str]:
- return self.columns.names
-
-# Alternative constructors
-# =============================================================================
-
- @classmethod
- def from_indices(cls, indices: pd.Index) -> _Data:
- """Create a Data object from a list of indices.
-
- Parameters
- ----------
- indices : pd.Index
- The indices of the data.
-
- Returns
- -------
- Empty data object with indices
- """
- return cls(pd.DataFrame(index=indices))
-
- @classmethod
- def from_domain(cls, domain: Domain) -> _Data:
- """Create a Data object from a domain.
-
- Parameters
- ----------
- design
- _description_
-
- Returns
- -------
- _description_
- """
- _dtypes = {index: parameter._type for index,
- (_, parameter) in enumerate(domain.space.items())}
-
- df = pd.DataFrame(columns=range(len(domain))).astype(_dtypes)
-
- # Set the categories tot the categorical parameters
- for index, (name, categorical_input) in enumerate(
- domain.categorical.space.items()):
- df[index] = pd.Categorical(
- df[index], categories=categorical_input.categories)
-
- _columns = {name: None for name in domain.names}
- return cls(df, columns=_Columns(_columns))
-
- @classmethod
- def from_file(cls, filename: Path | str) -> _Data:
- """Loads the data from a file.
-
- Parameters
- ----------
- filename : Path
- The filename to load the data from.
- """
- file = Path(filename).with_suffix('.csv')
- df = pd.read_csv(file, header=0, index_col=0)
- _columns = {name: False for name in df.columns.to_list()}
- # Reset the columns to be consistent
- df.columns = range(df.columns.size)
- return cls(df, columns=_Columns(_columns))
-
- @classmethod
- def from_numpy(cls: Type[_Data], array: np.ndarray) -> _Data:
- """Loads the data from a numpy array.
-
- Parameters
- ----------
- array : np.ndarray
- The numpy array to load the data from.
- data_type : str
- """
- return cls(pd.DataFrame(array))
-
- @classmethod
- def from_dataframe(cls, dataframe: pd.DataFrame) -> _Data:
- """Loads the data from a dataframe.
-
- Parameters
- ----------
- dataframe : pd.DataFrame
- The dataframe to load the data from.
- """
- _columns = {name: None for name in dataframe.columns.to_list()}
- return cls(dataframe, columns=_Columns(_columns))
-
- def reset(self, domain: Optional[Domain] = None):
- """Resets the data to the initial state.
-
- Parameters
- ----------
- domain : Domain, optional
- The domain of the experiment.
-
- Note
- ----
- If the domain is None, the data will be reset to an empty dataframe.
- """
-
- if domain is None:
- self.data = pd.DataFrame()
- self.columns = _Columns()
- else:
- self.data = self.from_domain(domain).data
- self.columns = self.from_domain(domain).columns
-
-# Export
-# =============================================================================
-
- def to_numpy(self) -> np.ndarray:
- """Export the _Data object to a numpy array.
-
- Returns
- -------
- np.ndarray
- numpy array with the data.
- """
- return self.data.to_numpy(dtype=np.float32)
-
- def to_xarray(self, label: str) -> xr.DataArray:
- """Export the _Data object to a xarray DataArray.
-
- Parameters
- ----------
- label : str
- The name of the data.
-
- Returns
- -------
- xr.DataArray
- xarray DataArray with the data.
- """
- return xr.DataArray(self.data, dims=['iterations', label], coords={
- 'iterations': self.indices, label: self.names})
-
- def to_dataframe(self) -> pd.DataFrame:
- """Export the _Data object to a pandas DataFrame.
-
- Returns
- -------
- pd.DataFrame
- pandas dataframe with the data.
- """
- df = deepcopy(self.data)
- df.columns = self.names
- return df.astype(object)
-
- def combine_data_to_multiindex(self, other: _Data,
- jobs_df: pd.DataFrame) -> pd.DataFrame:
- """Combine the data to a multiindex dataframe.
-
- Parameters
- ----------
- other : _Data
- The other data to combine.
- jobs : pd.DataFrame
- The jobs dataframe.
-
- Returns
- -------
- pd.DataFrame
- The combined dataframe.
-
- Note
- ----
- This function is mainly used to show the combined ExperimentData
- object in a Jupyter Notebook
- """
- return pd.concat([jobs_df, self.to_dataframe(),
- other.to_dataframe()],
- axis=1, keys=['jobs', 'input', 'output'])
-
- def store(self, filename: Path) -> None:
- """Stores the data to a file.
-
- Parameters
- ----------
- filename : Path
- The filename to store the data to.
-
- Note
- ----
- The data is stored as a csv file.
- """
- # TODO: The column information is not saved in the .csv!
- self.to_dataframe().to_csv(filename.with_suffix('.csv'))
-
- def n_best_samples(self, nosamples: int,
- column_name: List[str] | str) -> pd.DataFrame:
- """Returns the n best samples. We consider to be lower values better.
-
- Parameters
- ----------
- nosamples : int
- The number of samples to return.
- column_name : List[str] | str
- The column name(s) to sort on. If this is a list; priority will \
- be given on the first entry.
-
- Returns
- -------
- pd.DataFrame
- The n best samples.
- """
- return self.data.nsmallest(
- n=nosamples, columns=self.columns.iloc(column_name))
-
- def select_columns(self, columns: Iterable[str] | str) -> _Data:
- """Filter the data on the selected columns.
-
- Parameters
- ----------
- columns : Iterable[str] | str
- The columns to select.
-
- Returns
- -------
- _Data
- The data only with the selected columns
- """
- # This is necessary otherwise self.data[columns] will be a Series
- if isinstance(columns, str):
- columns = [columns]
- _selected_columns = _Columns(
- {column: self.columns.columns[column] for column in columns})
- return _Data(
- self.data[self.columns.iloc(columns)], columns=_selected_columns)
-
- def drop(self, columns: Iterable[str] | str) -> _Data:
- """Drop the selected columns from the data.
-
- Parameters
- ----------
- columns : Iterable[str] | str
- The columns to drop.
-
- Returns
- -------
- _Data
- The data without the selected columns
- """
- if isinstance(columns, str):
- columns = [columns]
- _selected_columns = _Columns(
- {
- name: None for name in self.columns.columns
- if name not in columns})
- return _Data(
- data=self.data.drop(columns=self.columns.iloc(columns)),
- columns=_selected_columns)
-
-# Append and remove data
-# =============================================================================
-
- def add(self, data: pd.DataFrame):
- try:
- last_index = self.data.index[-1]
- except IndexError: # Empty dataframe
- self.data = data
- return
-
- new_indices = pd.RangeIndex(
- start=last_index + 1, stop=last_index + len(data) + 1, step=1)
-
- # set the indices of the data to new_indices
- data.index = new_indices
-
- self.data = pd.concat([self.data, data], ignore_index=False)
-
- def add_empty_rows(self, number_of_rows: int):
- if self.data.index.empty:
- last_index = -1
- else:
- last_index = self.data.index[-1]
-
- new_indices = pd.RangeIndex(
- start=last_index + 1, stop=last_index + number_of_rows + 1, step=1)
- empty_data = pd.DataFrame(
- np.nan, index=new_indices, columns=self.data.columns)
- self.data = pd.concat([self.data, empty_data], ignore_index=False)
-
- def add_column(self, name: str, exist_ok: bool = False):
- if name in self.columns.names:
- if not exist_ok:
- raise ValueError(
- f"Column {name} already exists in the data. "
- "Set exist_ok to True to allow skipping existing columns.")
- return
-
- if self.data.columns.empty:
- new_columns_index = 0
- else:
- new_columns_index = self.data.columns[-1] + 1
-
- self.columns.add(name)
- self.data[new_columns_index] = np.nan
-
- def remove(self, indices: List[int]):
- self.data = self.data.drop(indices)
-
- def round(self, decimals: int):
- self.data = self.data.round(decimals=decimals)
-
- def overwrite(self, indices: Iterable[int], other: _Data | Dict[str, Any]):
- if isinstance(other, Dict):
- other = _convert_dict_to_data(other)
-
- for other_column in other.columns.names:
- if other_column not in self.columns.names:
- self.add_column(other_column)
-
- self.data.update(other.data.set_index(pd.Index(indices)))
-
- def join(self, __o: _Data) -> _Data:
- """Join two Data objects together.
-
- Parameters
- ----------
- __o : Data
- The Data object to join.
-
- Returns
- -------
- The joined Data object.
- """
- return _Data(
- pd.concat([self.data, __o.data], axis=1, ignore_index=True),
- columns=self.columns + __o.columns)
-
-# Getters and setters
-# =============================================================================
-
- def get_data_dict(self, index: int) -> Dict[str, Any]:
- return self.to_dataframe().loc[index].to_dict()
-
- def set_data(self, index: int, value: Any, column: Optional[str] = None):
- # check if the index exists
- if index not in self.data.index:
- raise IndexError(f"Index {index} does not exist in the data.")
-
- if column is None:
- # Set the entire row to the values
- self.data.loc[index] = value
- return
-
- elif column not in self.columns.names:
- self.add_column(column)
-
- _column_index = self.columns.iloc(column)[0]
- try:
- self.data.at[index, _column_index] = value
- except ValueError:
- self.data = self.data.astype(object)
- self.data.at[index, _column_index] = value
-
- def reset_index(self, indices: Optional[Iterable[int]] = None) -> None:
- """Reset the index of the data.
-
- Parameters
- ----------
- indices : Optional[Iterable[int]], optional
- The indices to reset, by default None
-
- Note
- ----
- If indices is None, the entire index will be reset to a RangeIndex
- with the same length as the data.
- """
- if indices is None:
- self.data.reset_index(drop=True, inplace=True)
- else:
- self.data.index = indices
-
- def is_empty(self) -> bool:
- """Check if the data is empty."""
- return self.data.empty
-
- def get_index_with_nan(self) -> pd.Index:
- """Get the indices with NaN values.
-
- Returns
- -------
- pd.Index
- The indices with NaN values.
- """
- return self.indices[self.data.isna().any(axis=1)]
-
- def has_columnnames(self, names: Iterable[str]) -> bool:
- return set(names).issubset(self.names)
-
- def set_columnnames(self, names: Iterable[str]) -> None:
- for old_name, new_name in zip(self.names, names):
- self.columns.rename(old_name, new_name)
-
- def cast_types(self, domain: Domain):
- """Cast the types of the data to the types of the domain.
-
- Parameters
- ----------
- domain : Domain
- The domain with specific parameters to cast the types to.
-
- Raises
- ------
- ValueError
- If the types of the domain and the data do not match.
- """
- _dtypes = {index: parameter._type
- for index, (_, parameter) in enumerate(
- domain.space.items())}
- self.data = self.data.astype(_dtypes)
-
-
-def _convert_dict_to_data(dictionary: Dict[str, Any]) -> _Data:
- """Converts a dictionary with scalar values to a data object.
-
- Parameters
- ----------
- dict : Dict[str, Any]
- The dictionary to convert. Note that the dictionary
- should only have scalar values!
-
- Returns
- -------
- _Data
- The data object.
- """
- _columns = {name: None for name in dictionary.keys()}
- df = pd.DataFrame(dictionary, index=[0]).copy()
- return _Data(data=df, columns=_Columns(_columns))
-
-
-def _data_factory(data: DataTypes) -> _Data:
- if data is None:
- return _Data()
-
- elif isinstance(data, _Data):
- return data
-
- elif isinstance(data, pd.DataFrame):
- return _Data.from_dataframe(data)
-
- elif isinstance(data, (Path, str)):
- return _Data.from_file(data)
-
- elif isinstance(data, np.ndarray):
- return _Data.from_numpy(data)
-
- else:
- raise TypeError(
- f"Data must be of type _Data, pd.DataFrame, np.ndarray, "
- f"Path or str, not {type(data)}")
-
-
-DataTypes = Union[pd.DataFrame, np.ndarray, Path, str, _Data]
diff --git a/src/f3dasm/_src/experimentdata/_io.py b/src/f3dasm/_src/experimentdata/_io.py
deleted file mode 100644
index f602dbac..00000000
--- a/src/f3dasm/_src/experimentdata/_io.py
+++ /dev/null
@@ -1,367 +0,0 @@
-"""
-Module to load and save output data of experiments \
-and other common IO operations
-"""
-
-# Modules
-# =============================================================================
-
-from __future__ import annotations
-
-# Standard
-import pickle
-from pathlib import Path
-from typing import Any, Mapping, Optional, Type
-
-# Third-party
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import xarray as xr
-
-# Local
-from ..logger import logger
-
-# Authorship & Credits
-# =============================================================================
-__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
-__credits__ = ['Martin van der Schelling']
-__status__ = 'Stable'
-# =============================================================================
-
-# Global folder and file names
-# =============================================================================
-
-EXPERIMENTDATA_SUBFOLDER = "experiment_data"
-
-LOCK_FILENAME = "lock"
-DOMAIN_FILENAME = "domain"
-INPUT_DATA_FILENAME = "input"
-OUTPUT_DATA_FILENAME = "output"
-JOBS_FILENAME = "jobs"
-
-RESOLUTION_MATPLOTLIB_FIGURE = 300
-MAX_TRIES = 10
-
-# Storing methods
-# =============================================================================
-
-
-class StoreProtocol:
- """Base class for storing and loading output data from disk"""
- suffix: int
-
- def __init__(self, object: Any, path: Path):
- """
- Protocol class for storing and loading output data from disk
-
- Parameters
- ----------
- object : Any
- object to store
- path : Path
- location to store the object to
- """
- self.path = path
- self.object = object
-
- def store(self) -> None:
- """
- Protocol class for storing objects to disk
-
- Raises
- ------
- NotImplementedError
- Raises if the method is not implemented
- """
- raise NotImplementedError()
-
- def load(self) -> Any:
- """
- Protocol class for loading objects to disk
-
- Returns
- -------
- Any
- The loaded object
-
- Raises
- ------
- NotImplementedError
- Raises if the method is not implemented
- """
- raise NotImplementedError()
-
-
-class PickleStore(StoreProtocol):
- """Class to store and load objects using the pickle protocol"""
- suffix: str = '.pkl'
-
- def store(self) -> None:
- """
- Store the object to disk using the pickle protocol
- """
- with open(self.path.with_suffix(self.suffix), 'wb') as file:
- pickle.dump(self.object, file)
-
- def load(self) -> Any:
- """
- Load the object from disk using the pickle protocol
-
- Returns
- -------
- Any
- The loaded object
-
- """
- with open(self.path.with_suffix(self.suffix), 'rb') as file:
- return pickle.load(file)
-
-
-class NumpyStore(StoreProtocol):
- """Class to store and load objects using the numpy protocol"""
- suffix: str = '.npy'
-
- def store(self) -> None:
- """
- Store the object to disk using the numpy protocol
- """
- np.save(file=self.path.with_suffix(self.suffix), arr=self.object)
-
- def load(self) -> np.ndarray:
- """
- Load the object from disk using the numpy protocol
-
- Returns
- -------
- np.ndarray
- The loaded object
- """
- return np.load(file=self.path.with_suffix(self.suffix))
-
-
-class PandasStore(StoreProtocol):
- """Class to store and load objects using the pandas protocol"""
- suffix: str = '.csv'
-
- def store(self) -> None:
- """
- Store the object to disk using the pandas protocol
- """
- self.object.to_csv(self.path.with_suffix(self.suffix))
-
- def load(self) -> pd.DataFrame:
- """
- Load the object from disk using the pandas protocol
-
- Returns
- -------
- pd.DataFrame
- The loaded object
- """
- return pd.read_csv(self.path.with_suffix(self.suffix))
-
-
-class XarrayStore(StoreProtocol):
- """Class to store and load objects using the xarray protocol"""
- suffix: str = '.nc'
-
- def store(self) -> None:
- """
- Store the object to disk using the xarray protocol
- """
- self.object.to_netcdf(self.path.with_suffix(self.suffix))
-
- def load(self) -> xr.DataArray | xr.Dataset:
- """
- Load the object from disk using the xarray protocol
-
- Returns
- -------
- xr.DataArray | xr.Dataset
- The loaded object
- """
- return xr.open_dataset(self.path.with_suffix(self.suffix))
-
-
-class FigureStore(StoreProtocol):
- """Class to store and load objects using the matplotlib protocol"""
- suffix: str = '.png'
-
- def store(self) -> None:
- """
- Store the figure to disk as a png file
-
- Notes
- -----
- - The figure is saved with a resolution of 300 dpi.
- - The figure is saved with tight bounding boxes.
- """
- self.object.savefig(self.path.with_suffix(
- self.suffix), dpi=RESOLUTION_MATPLOTLIB_FIGURE,
- bbox_inches='tight')
-
- def load(self) -> np.ndarray:
- """
- Load the image as an numpy array from disk
- using the matplotlib `plt.imread` function.
-
- Returns
- -------
- np.ndarray
- The loaded image in the form of a numpy array
-
- Notes
- -----
- The returned array has shape
- - (M, N) for grayscale images.
- - (M, N, 3) for RGB images.
- - (M, N, 4) for RGBA images.
-
- Images are returned as float arrays (0-1).
- """
- return plt.imread(self.path.with_suffix(self.suffix))
-
-
-STORE_TYPE_MAPPING: Mapping[Type, StoreProtocol] = {
- np.ndarray: NumpyStore,
- pd.DataFrame: PandasStore,
- pd.Series: PandasStore,
- xr.DataArray: XarrayStore,
- xr.Dataset: XarrayStore,
- plt.Figure: FigureStore,
-}
-
-# Loading and saving functions
-# =============================================================================
-
-
-def load_object(path: Path, experimentdata_directory: Path,
- store_method: Type[StoreProtocol] = PickleStore) -> Any:
- """
- Load an object from disk from a given path and storing method
-
- Parameters
- ----------
- path : Path
- path of the object to load
- experimentdata_directory : Path
- path of the f3dasm project directory
- store_method : Type[_Store], optional
- storage method protocol, by default PickleStore
-
- Returns
- -------
- Any
- the object loaded from disk
-
- Raises
- ------
- ValueError
- Raises if no matching store type is found
-
- Note
- ----
- If no store method is provided, the function will try to find a matching
- store type based on the suffix of the item's path. If no matching store
- type is found, the function will raise a ValueError. By default, the
- function will use the PickleStore protocol to load the object from disk.
- """
-
- _path = experimentdata_directory / path
-
- if store_method is not None:
- return store_method(None, _path).load()
-
- if not _path.exists():
- return None
-
- # Extract the suffix from the item's path
- item_suffix = _path.suffix
-
- # Use a generator expression to find the first matching store type,
- # or None if no match is found
- matched_store_type: StoreProtocol = next(
- (store_type for store_type in STORE_TYPE_MAPPING.values() if
- store_type.suffix == item_suffix), PickleStore)
-
- if matched_store_type:
- return matched_store_type(None, _path).load()
- else:
- # Handle the case when no matching suffix is found
- raise ValueError(
- f"No matching store type for item type: '{item_suffix}'")
-
-
-def save_object(object: Any, path: Path, experimentdata_directory: Path,
- store_method: Optional[Type[StoreProtocol]] = None) -> str:
- """Function to save the object to path,
- with the appropriate storing method.
-
- Parameters
- ----------
- object : Any
- Object to store
- path : Path
- Path to store the object to
- store_method : Optional[Store], optional
- Storage method, by default None
-
- Returns
- -------
- str
- suffix of the storage method
-
- Raises
- ------
- TypeError
- Raises if the object type is not supported,
- and you haven't provided a custom store method.
- """
- _path = experimentdata_directory / path
-
- if store_method is not None:
- storage = store_method(object, _path)
- return
-
- # Check if object type is supported
- object_type = type(object)
-
- if object_type not in STORE_TYPE_MAPPING:
- storage: StoreProtocol = PickleStore(object, _path)
- logger.debug(f"Object type {object_type} is not natively supported. "
- f"The default pickle storage method will be used.")
-
- else:
- storage: StoreProtocol = STORE_TYPE_MAPPING[object_type](object, _path)
- # Store object
- storage.store()
- return storage.suffix
-
-
-def _project_dir_factory(project_dir: Path | str | None) -> Path:
- """Creates a Path object for the project directory from a particular input
-
- Parameters
- ----------
- project_dir : Path | str | None
- path of the user-defined directory where to create the f3dasm project \
- folder.
-
- Returns
- -------
- Path
- Path object
- """
- if isinstance(project_dir, Path):
- return project_dir.absolute()
-
- if project_dir is None:
- return Path().cwd()
-
- if isinstance(project_dir, str):
- return Path(project_dir).absolute()
-
- raise TypeError(
- f"project_dir must be of type Path, str or None, \
- not {type(project_dir).__name__}")
diff --git a/src/f3dasm/_src/experimentdata/_jobqueue.py b/src/f3dasm/_src/experimentdata/_jobqueue.py
deleted file mode 100644
index 438b6c4d..00000000
--- a/src/f3dasm/_src/experimentdata/_jobqueue.py
+++ /dev/null
@@ -1,346 +0,0 @@
-# Modules
-# =============================================================================
-
-from __future__ import annotations
-
-# Standard
-from enum import Enum
-from pathlib import Path
-from typing import Iterable, List, Optional, Type
-
-# Third-party
-import pandas as pd
-
-# Local
-from ._data import _Data
-
-# Authorship & Credits
-# =============================================================================
-__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
-__credits__ = ['Martin van der Schelling']
-__status__ = 'Stable'
-# =============================================================================
-#
-# =============================================================================
-
-
-class Status(str, Enum):
- """Enum class for the status of a job."""
- OPEN = 'open'
- IN_PROGRESS = 'in progress'
- FINISHED = 'finished'
- ERROR = 'error'
-
- def __str__(self) -> str:
- return self.value
-
-
-class NoOpenJobsError(Exception):
- """
- Exception raised when there are no open jobs.
-
- Attributes:
- message (str): The error message.
- """
-
- def __init__(self, message):
- super().__init__(message)
-
-
-class _JobQueue:
- def __init__(self, jobs: Optional[pd.Series] = None):
- """
- A class that represents a dictionary of jobs that
- can be marked as 'open', 'in progress', finished', or 'error'.
-
- Parameters
- ----------
- filename : str
- The name of the file that the jobs will be saved in.
- """
- if jobs is None:
- jobs = pd.Series(dtype='string')
-
- self.jobs: pd.Series = jobs
-
- def __add__(self, other: _JobQueue | str) -> _JobQueue:
- """Add two JobQueue objects together.
-
- Parameters
- ----------
- other : JobQueue
- JobQueue object to add.
-
- Returns
- -------
- JobQueue
- JobQueue object containing the added jobs.
- """
- if isinstance(other, str):
- # make _JobQueue from the jobnumber
- other = _JobQueue(
- pd.Series(other, index=[0], dtype='string'))
-
- try:
- last_index = self.jobs.index[-1]
- except IndexError: # Empty Series
- return _JobQueue(other.jobs)
-
- # Make a copy of other.jobs and modify its index
- other_jobs_copy = other.jobs.copy()
- other_jobs_copy.index = other_jobs_copy.index + last_index + 1
- return _JobQueue(pd.concat([self.jobs, other_jobs_copy]))
-
- def __getitem__(self, index: int | slice | Iterable[int]) -> _Data:
- """Get a subset of the data.
-
- Parameters
- ----------
- index : int, slice, list
- The index of the data to get.
-
- Returns
- -------
- A subset of the data.
- """
- if isinstance(index, int):
- index = [index]
- return _JobQueue(self.jobs[index].copy())
-
- def __eq__(self, __o: _JobQueue) -> bool:
- return self.jobs.equals(__o.jobs)
-
- def _repr_html_(self) -> str:
- return self.jobs.__repr__()
-
- @property
- def indices(self) -> pd.Index:
- """The indices of the jobs."""
- return self.jobs.index
- # Alternative Constructors
- # =========================================================================
-
- @classmethod
- def from_data(cls: Type[_JobQueue], data: _Data,
- value: str = Status.OPEN) -> _JobQueue:
- """Create a JobQueue object from a Data object.
-
- Parameters
- ----------
- data : Data
- Data object containing the data.
- value : str
- The value to assign to the jobs. Can be 'open',
- 'in progress', 'finished', or 'error'.
-
- Returns
- -------
- JobQueue
- JobQueue object containing the loaded data.
- """
- return cls(pd.Series([value] * len(data), dtype='string'))
-
- @classmethod
- def from_file(cls: Type[_JobQueue], filename: Path | str) -> _JobQueue:
- """Create a JobQueue object from a pickle file.
-
- Parameters
- ----------
- filename : Path | str
- Name of the file.
-
- Returns
- -------
- JobQueue
- JobQueue object containing the loaded data.
- """
- # Convert filename to Path
- filename = Path(filename).with_suffix('.pkl')
-
- # Check if the file exists
- if not filename.exists():
- raise FileNotFoundError(f"Jobfile {filename} does not exist.")
-
- return cls(pd.read_pickle(filename))
-
- def reset(self) -> None:
- """Resets the job queue."""
- self.jobs = pd.Series(dtype='string')
-
- # Select
- # =========================================================================
-
- def select_all(self, status: str) -> _JobQueue:
- """Selects all jobs with a certain status.
-
- Parameters
- ----------
- status : str
- Status of the jobs to select
-
- Returns
- -------
- JobQueue
- JobQueue object containing the selected jobs.
- """
- return _JobQueue(self.jobs[self.jobs == status])
-
- # Export
- # =========================================================================
-
- def store(self, filename: Path) -> None:
- """Stores the jobs in a pickle file.
-
- Parameters
- ----------
- filename : Path
- Path of the file.
- """
- self.jobs.to_pickle(filename.with_suffix('.pkl'))
-
- def to_dataframe(self, name: str = "") -> pd.DataFrame:
- """Converts the job queue to a DataFrame.
-
- Parameters
- ----------
- name : str, optional
- Name of the column, by default "".
-
- Note
- ----
- If the name is not specified, the column name will be an empty string
-
- Returns
- -------
- DataFrame
- DataFrame containing the jobs.
- """
- return self.jobs.to_frame("")
-
- # Append and remove jobs
- # =========================================================================
-
- def remove(self, indices: List[int]):
- """Removes a subset of the jobs.
-
- Parameters
- ----------
- indices : List[int]
- List of indices to remove.
- """
- self.jobs = self.jobs.drop(indices)
-
- def add(self, number_of_jobs: int = 1, status: str = Status.OPEN):
- """Adds a number of jobs to the job queue.
-
- Parameters
- ----------
- number_of_jobs : int, optional
- Number of jobs to add, by default 1
- status : str, optional
- Status of the jobs, by default 'open'.
- """
- try:
- last_index = self.jobs.index[-1]
- except IndexError: # Empty Series
- self.jobs = pd.Series([status] * number_of_jobs, dtype='string')
- return
-
- new_indices = pd.RangeIndex(
- start=last_index + 1, stop=last_index + number_of_jobs + 1, step=1)
- jobs_to_add = pd.Series(status, index=new_indices, dtype='string')
- self.jobs = pd.concat([self.jobs, jobs_to_add], ignore_index=False)
-
- def overwrite(
- self, indices: Iterable[int],
- other: _JobQueue | str) -> None:
-
- if isinstance(other, str):
- other = _JobQueue(
- pd.Series([other], index=[0], dtype='string'))
-
- self.jobs.update(other.jobs.set_axis(indices))
-
- # Mark
- # =========================================================================
-
- def mark(self, index: int | slice | Iterable[int], status: Status) -> None:
- """Marks a job with a certain status.
-
- Parameters
- ----------
- index : int
- Index of the job to mark.
- status : str
- Status to mark the job with.
- """
- self.jobs.loc[index] = status
-
- def mark_all_in_progress_open(self) -> None:
- """Marks all jobs as 'open'."""
- self.jobs = self.jobs.replace(Status.IN_PROGRESS, Status.OPEN)
-
- def mark_all_error_open(self) -> None:
- """Marks all jobs as 'open'."""
- self.jobs = self.jobs.replace(Status.ERROR, Status.OPEN)
- # Miscellanous
- # =========================================================================
-
- def is_all_finished(self) -> bool:
- """Checks if all jobs are finished.
-
- Returns
- -------
- bool
- True if all jobs are finished, False otherwise.
- """
- return all(self.jobs.isin([Status.FINISHED, Status.ERROR]))
-
- def get_open_job(self) -> int:
- """Returns the index of an open job.
-
- Returns
- -------
- int
- Index of an open job.
- """
- try: # try to find an open job
- return int(self.jobs[self.jobs == Status.OPEN].index[0])
- except IndexError:
- raise NoOpenJobsError("No open jobs found.")
-
- def reset_index(self) -> None:
- """Resets the index of the jobs."""
- self.jobs.reset_index(drop=True, inplace=True)
-
-
-def _jobs_factory(jobs: Path | str | _JobQueue | None, input_data: _Data,
- output_data: _Data, job_value: Status) -> _JobQueue:
- """Creates a _JobQueue object from particular inpute
-
- Parameters
- ----------
- jobs : Path | str | None
- input data for the jobs
- input_data : _Data
- _Data object of input data to extract indices from, if necessary
- output_data : _Data
- _Data object of output data to extract indices from, if necessary
- job_value : Status
- initial value of all the jobs
-
- Returns
- -------
- _JobQueue
- JobQueue object
- """
- if isinstance(jobs, _JobQueue):
- return jobs
-
- if isinstance(jobs, (Path, str)):
- return _JobQueue.from_file(Path(jobs))
-
- if input_data.is_empty():
- return _JobQueue.from_data(output_data, value=job_value)
-
- return _JobQueue.from_data(input_data, value=job_value)
diff --git a/src/f3dasm/_src/experimentdata/_newdata.py b/src/f3dasm/_src/experimentdata/_newdata.py
deleted file mode 100644
index b8a45d01..00000000
--- a/src/f3dasm/_src/experimentdata/_newdata.py
+++ /dev/null
@@ -1,828 +0,0 @@
-"""
-Module that contains the underlying data structure for ordering
-input and output data of experiments.
-
-Note
-----
-The data is stored as a list of lists, where each list represents
-this is a work in progress and not yet implemented, that's why the name is
-_newdata.py and the module is not imported in the __init__.py file.
-"""
-
-# Modules
-# =============================================================================
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import (Any, Dict, Iterable, Iterator, List, Optional, Tuple, Type,
- Union)
-
-import numpy as np
-import pandas as pd
-import xarray as xr
-
-from f3dasm._src.experimentdata._columns import _Columns
-from f3dasm.design import Domain
-
-# Authorship & Credits
-# =============================================================================
-__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
-__credits__ = ['Martin van der Schelling']
-__status__ = 'Stable'
-# =============================================================================
-#
-# =============================================================================
-
-
-DataType = List[List[Any]]
-
-
-class _Index:
- def __init__(self, indices: Optional[Iterable[int]] = None):
- if indices is None:
- indices = []
-
- self.indices: pd.Index = pd.Index(indices)
-
- def __add__(self, other: _Index) -> _Index:
-
- if self.is_empty():
- return _Index(other.indices.copy())
-
- return _Index(
- self.indices.append(other.indices + self.indices[-1] + 1))
-
- def __repr__(self) -> str:
- return self.indices.__repr__()
-
- def iloc(self, index: int | Iterable[int]) -> List[int]:
-
- if isinstance(index, int) or isinstance(index, np.int64):
- index = [index]
-
- _indices = []
- for n in index:
- _indices.append(self.indices.get_loc(n))
- return _indices
-
- def is_empty(self) -> bool:
- return self.indices.empty
-
-
-class _Data:
- def __init__(self, data: Optional[DataType] = None,
- columns: Optional[_Columns] = None,
- index: Optional[_Index] = None):
- """
- Class for capturing input or output data in a tabular format
-
- Parameters
- ----------
- data : Optional[DataType], optional
- Data in tabular format, by default None
- columns : Optional[_Columns], optional
- _Columns object representing the names of the parameters,
- by default None
- index : Optional[_Index], optional
- _Index object representing the indices of the experiments,
- by default
-
- Note
- ----
-
- * The data is stored as a list of lists, where each list represents
- a row in the table.
- * The columns are stored as a dict with the
- column names as keys and None as values.
- * The index is stored as a list of integers in a pd.Index object.
-
- If no column names are given, the are by default number starting from
- zero. If no index is given, the indices are by default numbers starting
- from zero.
- """
- if data is None:
- data = []
-
- if columns is None:
- try:
- columns = _Columns(
- {col: None for col, _ in enumerate(data[0])})
- except IndexError:
- columns = _Columns()
-
- if index is None:
- index = _Index(range(len(data)))
-
- self.columns = columns
- self.data = data
- self.index = index
-
- def __len__(self) -> int:
- """
- Calculate the number of rows in the data.
-
- Returns
- -------
- int
- the number of experiments
- """
- return len(self.data)
-
- def __iter__(self) -> Iterator[Tuple[Dict[str, Any]]]:
- """
- Iterator for the experiments in the data object
-
- Yields
- ------
- Iterator[Tuple[Dict[str, Any]]]
- Iterator object
- """
- self.current_index = 0
- return self
-
- def __next__(self):
- """
- Get the next experiment in the data object
-
- Returns
- -------
- Tuple[Dict[str, Any]]
- The next experiment
-
- Raises
- ------
- StopIteration
- If the last experiment has been reached
- """
- if self.current_index >= len(self):
- raise StopIteration
- else:
- current_value = self.data[self.current_index]
- self.current_index += 1
- return current_value
-
- def __getitem__(self, index: int | Iterable[int]) -> _Data:
- """
- Get the experiment(s) at the given index
-
- Parameters
- ----------
- index : int | Iterable[int]
- The index of the experiment(s) to get
-
- Returns
- -------
- _Data
- The experiment(s) at the given index
- """
- _index = self.index.iloc(index)
- if self.is_empty():
- return _Data(columns=self.columns, index=_Index(_index))
-
- else:
- return _Data(data=[self.data[i] for i in _index],
- columns=self.columns, index=_Index(_index))
-
- def __add__(self, other: _Data | Dict[str, Any]) -> _Data:
- """
- Add two data objects together
-
- Parameters
- ----------
- other : _Data
- The data object to add
-
- Returns
- -------
- _Data
- The combined data object
-
- Note
- ----
- * The columns of the two data objects must be the same.
- * The indices of the second object are shifted by the number of
- experiments in the first object.
- """
- # If other is a dictionary, convert it to a _Data object
- if not isinstance(other, _Data):
- other = _convert_dict_to_data(other)
-
- return _Data(data=self.data + other.data,
- columns=self.columns,
- index=self.index + other.index)
-
- def __eq__(self, __o: _Data) -> bool:
- """
- Check if two data objects are equal
-
- Parameters
- ----------
- __o : _Data
- The data object to compare with
-
- Returns
- -------
- bool
- True if the data objects are equal, False otherwise
-
- Note
- ----
- The data objects will first be converted to a pandas DataFrame and
- then compared.
- """
- return self.to_dataframe().equals(__o.to_dataframe())
-
- def _repr_html_(self) -> str:
- """
- HTML representation of the data object
-
- Returns
- -------
- str
- HTML representation of the data object
-
- Note
- ----
- This method is used by Jupyter Notebook to display the data object.
- """
- return self.to_dataframe()._repr_html_()
-
-# Properties
-# =============================================================================
-
- @property
- def names(self) -> List[str]:
- """
- Names of the columns of the data
-
- Returns
- -------
- List[str]
- Names of the columns of the data
-
- Note
- ----
- This is a shortcut for self.columns.names, accessing the private
- object.
- """
- return self.columns.names
-
- @property
- def indices(self) -> pd.Index:
- """
- Indices of the experiments in the data
-
- Returns
- -------
- pd.Index
- Indices of the experiments in the data
-
- Note
- ----
- This is a shortcut for self.index.indices, accessing the private
- object.
- """
- return self.index.indices
-
-# Alternative constructors
-# =============================================================================
-
- @classmethod
- def from_list(cls: Type[_Data], list: List[List[Any]]) -> _Data:
- """Creates a data object from a list of lists.
-
- Parameters
- ----------
- list : List[List[Any]]
- The list of lists to create the data object from.
-
- Returns
- -------
- _Data
- The data object.
- """
- return _Data(data=list)
-
- @classmethod
- def from_indices(cls: Type[_Data], indices: pd.Index) -> _Data:
- """Creates a data object from a pd.Index object.
-
- Parameters
- ----------
- indices : pd.Index
- The indices of the experiments.
-
- Returns
- -------
- _Data
- The data object.
-
- Note
- ----
- The returned object will have no columns and the indices will be
- the given indices. The data will be an empty list.
- """
- return _Data(index=_Index(indices))
-
- @classmethod
- def from_domain(cls: Type[_Data], domain: Domain) -> _Data:
- """Creates a data object from a domain.
-
- Parameters
- ----------
- domain : Domain
- The domain to create the data object from.
-
- Returns
- -------
- _Data
- The data object.
-
- Note
- ----
- * The returned object will have no data and empty indices.
- * The columns will be the names of the provided domain.
- """
- _columns = {name: None for name in domain.names}
- return _Data(columns=_Columns(_columns))
-
- @classmethod
- def from_file(cls: Type[_Data], filename: Path | str) -> _Data:
- # TODO: Fix this method for _newdata
- """Loads the data from a file.
-
- Parameters
- ----------
- filename : Path
- The filename to load the data from.
-
- Returns
- -------
- _Data
- The loaded data object.
- """
- file = Path(filename).with_suffix('.csv')
- df = pd.read_csv(file, header=0, index_col=0)
- return cls.from_dataframe(df)
-
- @classmethod
- def from_numpy(cls: Type[_Data], array: np.ndarray) -> _Data:
- """Loads the data from a numpy array.
-
- Parameters
- ----------
- array : np.ndarray
- The array to load the data from.
-
- Returns
- -------
- _Data
- The data object.
-
- Note
- ----
- The returned _Data object will have the default column names and
- indices.
- """
- return cls.from_dataframe(pd.DataFrame(array))
-
- @classmethod
- def from_dataframe(cls: Type[_Data], df: pd.DataFrame) -> _Data:
- """Loads the data from a pandas dataframe.
-
- Parameters
- ----------
- df : pd.DataFrame
- The dataframe to load the data from.
-
- Returns
- -------
- _Data
- The data object.
-
- Note
- ----
- The returned _Data object will have the column names of the dataframe
- and the indices of the dataframe.
- """
- _columns = {name: None for name in df.columns.to_list()}
- return _Data(data=df.to_numpy().tolist(),
- columns=_Columns(_columns),
- index=_Index(df.index))
-
- def reset(self, domain: Optional[Domain] = None):
- """Resets the data object.
-
- Parameters
- ----------
- domain : Optional[Domain], optional
- The domain to reset the data object to, by default None
-
- Note
- ----
- * If domain is None, the data object will be reset to an empty data
- object.
- * If a domain is provided, the data object will be reset to a data
- object with the given domain and no data.
- """
- if domain is None:
- self.data = []
- self.columns = _Columns()
-
- else:
- _reset_data = self.from_domain(domain)
- self.data = _reset_data.data
- self.columns = _reset_data.columns
-
- self.index = _Index()
-
-# Export
-# =============================================================================
-
- def to_numpy(self) -> np.ndarray:
- """
- Convert the data to a numpy array
-
- Returns
- -------
- np.ndarray
- The data as a numpy array
-
- Note
- ----
- This method converts the data to a pandas DataFrame and then to a
- numpy array.
- """
- return self.to_dataframe().to_numpy()
-
- def to_xarray(self, label: str) -> Any:
- # TODO: THIS WILL NOT WORK IF DATA IS INHOMOGENEOUS!
- return xr.DataArray(self.to_dataframe(), dims=['iterations', label],
- coords={'iterations': self.indices,
- label: self.names})
-
- def to_dataframe(self) -> pd.DataFrame:
- """
- Convert the data to a pandas DataFrame
-
- Returns
- -------
- pd.DataFrame
- The data as a pandas DataFrame
-
- Note
- ----
- The resulting dataframe has the indices as rows and the columns as
- column names.
- """
- return pd.DataFrame(self.data, columns=self.names, index=self.indices)
-
- def combine_data_to_multiindex(self, other: _Data,
- jobs_df: pd.DataFrame) -> pd.DataFrame:
- """
- Combine the data to a multiindex dataframe.
-
- Parameters
- ----------
- other : _Data
- The other data to combine.
- jobs : pd.DataFrame
- The jobs dataframe.
-
- Returns
- -------
- pd.DataFrame
- The combined dataframe.
-
- Note
- ----
- This function is mainly used to show the combined ExperimentData
- object in a Jupyter Notebook
- """
- return pd.concat([jobs_df, self.to_dataframe(),
- other.to_dataframe()],
- axis=1, keys=['jobs', 'input', 'output'])
-
- def store(self, filename: Path) -> None:
- """Stores the data to a file.
-
- Parameters
- ----------
- filename : Path
- The filename to store the data to.
-
- Note
- ----
- The data is stored as a csv file.
- """
- # TODO: Test this function!
- self.to_dataframe().to_csv(filename.with_suffix('.csv'))
-
- def n_best_samples(self, nosamples: int,
- column_name: List[str] | str) -> pd.DataFrame:
- return self.to_dataframe().nsmallest(n=nosamples,
- columns=column_name)
-
- def select_columns(self, columns: Iterable[str] | str) -> _Data:
- """Selects columns from the data.
-
- Parameters
- ----------
- columns : Iterable[str] | str
- The column(s) to select.
-
- Returns
- -------
- _Data
- The data with the selected columns.
-
- Note
- ----
- This method returns a new data object with the selected columns.
- """
- if isinstance(columns, str):
- columns = [columns]
-
- _selected_columns = _Columns(
- {column: None for column in columns})
-
- return _Data(
- data=self.to_dataframe()[columns].values.tolist(),
- columns=_selected_columns, index=self.index)
-
-# Append and remove data
-# =============================================================================
-
- def add(self, data: pd.DataFrame):
- """Adds data to the data object.
-
- Parameters
- ----------
- data : pd.DataFrame
- The data to add.
-
- Note
- ----
- This method adds the dataframe in-place to the currentdata object.
- The data is added to the end of the data object.
-
- The + operator will do the same thing but return a new data object.s
- """
- _other = _Data.from_dataframe(data)
-
- self.data += _other.data
- self.index += _other.index
-
- def add_empty_rows(self, number_of_rows: int):
- """Adds empty rows to the data object.
-
- Parameters
- ----------
- number_of_rows : int
- The number of rows to add.
-
- Note
- ----
- This method adds empty rows to the data object. The value of these
- empty rows is np.nan. The columns are not changed.
-
- The rows are added to the end of the data object.
- """
- self.data += [[np.nan for _ in self.names]
- for _ in range(number_of_rows)]
- self.index += _Index(range(number_of_rows))
-
- def add_column(self, name: str):
- """Adds a column to the data object.
-
- Parameters
- ----------
- name : str
- The name of the column to add.
-
- Note
- ----
- The values in the rows of this new column will be set to np.nan.
- """
- self.columns.add(name)
-
- if self.is_empty():
- self.data = [[np.nan] for _ in self.indices]
-
- else:
- for row in self.data:
- row.append(np.nan)
-
- def remove(self, indices: List[int] | int):
- """Removes rows from the data object.
-
- Parameters
- ----------
- indices : List[int] | int
- The indices of the rows to remove.
- """
- if isinstance(indices, int):
- indices = [indices]
-
- self.data = [row for i, row in enumerate(self.data)
- if self.index.iloc(i)[0] not in indices]
- self.index = _Index([i for i in self.indices if i not in indices])
-
- def round(self, decimals: int):
- """Rounds the data.
-
- Parameters
- ----------
- decimals : int
- The number of decimals to round to.
- """
- self.data = [[round(value, decimals) for value in row]
- for row in self.data]
-
- def overwrite(self, data: _Data, indices: Iterable[int]):
- # TODO: Implement this method!
- ...
-
-# Getters and setters
-# =============================================================================
-
- def get_data_dict(self, index: int) -> Dict[str, Any]:
- """
- Get the data as a dictionary.
-
- Parameters
- ----------
- index : int
- Index of the data to get.
-
- Returns
- -------
- Dict[str, Any]
- Dictionary with the data.
-
- Note
- ----
- If the data is empty, an empty dictionary is returned.
- """
- if self.is_empty():
- return {}
-
- _index = self.index.iloc(index)[0]
- return {name: value for name, value in zip(self.names,
- self.data[_index])}
-
- def set_data(self, index: int, value: Any, column: Optional[str] = None):
- """
- Set the data at the given index.
-
- Parameters
- ----------
- index : int
- Index of the data to set.
- value : Any
- Value to set.
- column : Optional[str], optional
- Column to set, by default None
-
- Raises
- ------
- IndexError
- If the index is not in the data.
-
- Note
- ----
- * If the column is not in the data, it will be added.
- * If the column is None, the value will be set to the whole row. Make
- sure that you provide a list with the same length as the number of
- columns in the data.
-
- """
- if index not in self.indices:
- raise IndexError(f'Index {index} not in data.')
-
- if column is None:
- _index = self.index.iloc(index)[0]
- self.data[_index] = value
- return
-
- elif column not in self.names:
- self.add_column(column)
-
- _column_index = self.columns.iloc(column)[0]
- _index = self.index.iloc(index)[0]
- self.data[_index][_column_index] = value
-
- def reset_index(self, indices: Optional[Iterable[int]] = None):
- """Resets the index of the data object.
-
- Parameters
- ----------
- indices : Optional[Iterable[int]], optional
- The indices to reset the index to, by default None
-
- Note
- ----
- This method resets the index of the data object.
-
- If no indices are provided, the index will be
- reset to range(len(data)). This means that the index will be
- [0, 1, 2, ..., len(data) - 1].
- """
- if indices is None:
- indices = range(len(self.data))
-
- self.index = _Index(indices)
-
- def is_empty(self) -> bool:
- """Checks if the data object is empty.
-
- Returns
- -------
- bool
- True if the data object is empty, False otherwise.
- """
- return len(self.data) == 0
-
- def has_columnnames(self, names: Iterable[str]) -> bool:
- """Checks if the data object has the given column names.
-
- Parameters
- ----------
- names : Iterable[str]
- The column names to check.
-
- Returns
- -------
- bool
- True if the data object has the given column names, False
- otherwise.
- """
- return set(names).issubset(self.names)
-
- def set_columnnames(self, names: Iterable[str]):
- """Sets the column names of the data object.
-
- Parameters
- ----------
- names : Iterable[str]
- The column names to set.
-
- Note
- ----
- This method overwrite the column names of the data object.
- The number of names should be equal to the number of columns in the
- data object.
- """
-
- for old_name, new_name in zip(self.names, names):
- self.columns.rename(old_name, new_name)
-
- def cast_types(self, domain: Domain):
- pass
-
-
-def _convert_dict_to_data(dictionary: Dict[str, Any]) -> _Data:
- """Converts a dictionary with scalar values to a data object.
-
- Parameters
- ----------
- dict : Dict[str, Any]
- The dictionary to convert. Note that the dictionary
- should only have scalar values!
-
- Returns
- -------
- _Data
- The data object.
- """
- df = pd.DataFrame(dictionary, index=[0]).copy()
- return _Data.from_dataframe(df)
-
-
-def _data_factory(data: DataTypes) -> _Data:
- if data is None:
- return _Data()
-
- elif isinstance(data, list):
- return _Data.from_list(data)
-
- elif isinstance(data, _Data):
- return data
-
- elif isinstance(data, pd.DataFrame):
- return _Data.from_dataframe(data)
-
- elif isinstance(data, (Path, str)):
- return _Data.from_file(data)
-
- elif isinstance(data, np.ndarray):
- return _Data.from_numpy(data)
-
- else:
- raise TypeError(
- f"Data must be of type _Data, pd.DataFrame, np.ndarray, "
- f"Path or str, not {type(data)}")
-
-
-DataTypes = Union[pd.DataFrame, np.ndarray, Path, str, _Data]
diff --git a/src/f3dasm/_src/experimentdata/experimentdata.py b/src/f3dasm/_src/experimentdata/experimentdata.py
deleted file mode 100644
index 71c60473..00000000
--- a/src/f3dasm/_src/experimentdata/experimentdata.py
+++ /dev/null
@@ -1,1848 +0,0 @@
-"""
-The ExperimentData object is the main object used to store implementations
- of a design-of-experiments, keep track of results, perform optimization and
- extract data for machine learning purposes.
-"""
-
-# Modules
-# =============================================================================
-
-from __future__ import annotations
-
-# Standard
-import inspect
-import traceback
-from copy import copy
-from functools import wraps
-from pathlib import Path
-from time import sleep
-from typing import (Any, Callable, Dict, Iterable, Iterator, List, Literal,
- Optional, Tuple, Type)
-
-# Third-party
-import numpy as np
-import pandas as pd
-import xarray as xr
-from filelock import FileLock
-from hydra.utils import get_original_cwd
-from omegaconf import DictConfig
-from pathos.helpers import mp
-
-# Local
-from ..datageneration.datagenerator import DataGenerator, convert_function
-from ..datageneration.functions.function_factory import _datagenerator_factory
-from ..design.domain import Domain, _domain_factory
-from ..logger import logger
-from ..optimization import Optimizer
-from ..optimization.optimizer_factory import _optimizer_factory
-from ._data import DataTypes, _Data, _data_factory
-from ._io import (DOMAIN_FILENAME, EXPERIMENTDATA_SUBFOLDER,
- INPUT_DATA_FILENAME, JOBS_FILENAME, LOCK_FILENAME, MAX_TRIES,
- OUTPUT_DATA_FILENAME, _project_dir_factory)
-from ._jobqueue import NoOpenJobsError, Status, _jobs_factory
-from .experimentsample import ExperimentSample
-from .samplers import Sampler, SamplerNames, _sampler_factory
-from .utils import number_of_overiterations, number_of_updates
-
-# Authorship & Credits
-# =============================================================================
-__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
-__credits__ = ['Martin van der Schelling']
-__status__ = 'Stable'
-# =============================================================================
-#
-# =============================================================================
-
-
-class ExperimentData:
- """
- A class that contains data for experiments.
- """
-
- def __init__(self,
- domain: Optional[Domain] = None,
- input_data: Optional[DataTypes] = None,
- output_data: Optional[DataTypes] = None,
- jobs: Optional[Path | str] = None,
- project_dir: Optional[Path] = None):
- """
- Initializes an instance of ExperimentData.
-
- Parameters
- ----------
- domain : Domain, optional
- The domain of the experiment, by default None
- input_data : DataTypes, optional
- The input data of the experiment, by default None
- output_data : DataTypes, optional
- The output data of the experiment, by default None
- jobs : Path | str, optional
- The path to the jobs file, by default None
- project_dir : Path | str, optional
- A user-defined directory where the f3dasm project folder will be \
- created, by default the current working directory.
-
- Note
- ----
-
- The following data formats are supported for input and output data:
-
- * numpy array
- * pandas Dataframe
- * path to a csv file
-
- If no domain object is provided, the domain is inferred from the \
- input_data.
-
- If the provided project_dir does not exist, it will be created.
-
- Raises
- ------
-
- ValueError
- If the input_data is a numpy array, the domain has to be provided.
- """
-
- if isinstance(input_data, np.ndarray) and domain is None:
- raise ValueError(
- 'If you provide a numpy array as input_data, \
- you have to provide the domain!')
-
- self.project_dir = _project_dir_factory(project_dir)
-
- self._input_data = _data_factory(input_data)
- self._output_data = _data_factory(output_data)
-
- # Create empty output_data from indices if output_data is empty
- if self._output_data.is_empty():
- self._output_data = _Data.from_indices(self._input_data.indices)
- job_value = Status.OPEN
-
- else:
- job_value = Status.FINISHED
-
- self.domain = _domain_factory(
- domain=domain, input_data=self._input_data.to_dataframe(),
- output_data=self._output_data.to_dataframe())
-
- # Create empty input_data from domain if input_data is empty
- if self._input_data.is_empty():
- self._input_data = _Data.from_domain(self.domain)
-
- self._jobs = _jobs_factory(
- jobs, self._input_data, self._output_data, job_value)
-
- # Check if the columns of input_data are in the domain
- if not self._input_data.has_columnnames(self.domain.names):
- self._input_data.set_columnnames(self.domain.names)
-
- if not self._output_data.has_columnnames(self.domain.output_names):
- self._output_data.set_columnnames(self.domain.output_names)
-
- # For backwards compatibility; if the output_data has
- # only one column, rename it to 'y'
- if self._output_data.names == [0]:
- self._output_data.set_columnnames(['y'])
-
- def __len__(self):
- """The len() method returns the number of datapoints"""
- if self._input_data.is_empty():
- return len(self._output_data)
-
- return len(self._input_data)
-
- def __iter__(self) -> Iterator[Tuple[Dict[str, Any]]]:
- self.current_index = 0
- return self
-
- def __next__(self) -> ExperimentSample:
- if self.current_index >= len(self):
- raise StopIteration
- else:
- index = self.index[self.current_index]
- self.current_index += 1
- return self.get_experiment_sample(index)
-
- def __add__(self,
- __o: ExperimentData | ExperimentSample) -> ExperimentData:
- """The + operator combines two ExperimentData objects"""
- # Check if the domains are the same
-
- if not isinstance(__o, (ExperimentData, ExperimentSample)):
- raise TypeError(
- f"Can only add ExperimentData or "
- f"ExperimentSample objects, not {type(__o)}")
-
- return ExperimentData(
- input_data=self._input_data + __o._input_data,
- output_data=self._output_data + __o._output_data,
- jobs=self._jobs + __o._jobs, domain=self.domain + __o.domain,
- project_dir=self.project_dir)
-
- def __eq__(self, __o: ExperimentData) -> bool:
- return all([self._input_data == __o._input_data,
- self._output_data == __o._output_data,
- self._jobs == __o._jobs,
- self.domain == __o.domain])
-
- def _repr_html_(self) -> str:
- return self._input_data.combine_data_to_multiindex(
- self._output_data, self._jobs.to_dataframe())._repr_html_()
-
- def __repr__(self) -> str:
- return self._input_data.combine_data_to_multiindex(
- self._output_data, self._jobs.to_dataframe()).__repr__()
-
- def _access_file(operation: Callable) -> Callable:
- """Wrapper for accessing a single resource with a file lock
-
- Parameters
- ----------
- operation : Callable
- The operation to be performed on the resource
-
- Returns
- -------
- Callable
- The wrapped operation
- """
- @wraps(operation)
- def wrapper_func(self: ExperimentData, *args, **kwargs) -> None:
- lock = FileLock(
- (self.
- project_dir / EXPERIMENTDATA_SUBFOLDER / LOCK_FILENAME)
- .with_suffix('.lock'))
-
- # If the lock has been acquired:
- with lock:
- tries = 0
- while tries < MAX_TRIES:
- try:
- self = ExperimentData.from_file(self.project_dir)
- value = operation(self, *args, **kwargs)
- self.store()
- break
-
- # Racing conditions can occur when the file is empty
- # and the file is being read at the same time
- except pd.errors.EmptyDataError:
- tries += 1
- logger.debug((
- f"EmptyDataError occurred, retrying"
- f" {tries+1}/{MAX_TRIES}"))
- sleep(1)
-
- raise pd.errors.EmptyDataError()
-
- return value
-
- return wrapper_func
- # Properties
- # =========================================================================
-
- @property
- def index(self) -> pd.Index:
- """Returns an iterable of the job number of the experiments
-
- Returns
- -------
- pd.Index
- The job number of all the experiments in pandas Index format
- """
- if self._input_data.is_empty():
- return self._output_data.indices
-
- return self._input_data.indices
-
- # Alternative Constructors
- # =========================================================================
-
- @classmethod
- def from_file(cls: Type[ExperimentData],
- project_dir: Path | str) -> ExperimentData:
- """Create an ExperimentData object from .csv and .json files.
-
- Parameters
- ----------
- project_dir : Path | str
- User defined path of the experimentdata directory.
-
- Returns
- -------
- ExperimentData
- ExperimentData object containing the loaded data.
- """
- if isinstance(project_dir, str):
- project_dir = Path(project_dir)
-
- try:
- return cls._from_file_attempt(project_dir)
- except FileNotFoundError:
- try:
- filename_with_path = Path(get_original_cwd()) / project_dir
- except ValueError: # get_original_cwd() hydra initialization error
- raise FileNotFoundError(
- f"Cannot find the folder {project_dir} !")
-
- return cls._from_file_attempt(filename_with_path)
-
- @classmethod
- def from_sampling(cls, sampler: Sampler | str, domain: Domain | DictConfig,
- n_samples: int = 1,
- seed: Optional[int] = None,
- **kwargs) -> ExperimentData:
- """Create an ExperimentData object from a sampler.
-
- Parameters
- ----------
- sampler : Sampler | str
- Sampler object containing the sampling strategy or one of the
- built-in sampler names.
- domain : Domain | DictConfig
- Domain object containing the domain of the experiment or hydra
- DictConfig object containing the configuration.
- n_samples : int, optional
- Number of samples, by default 1.
- seed : int, optional
- Seed for the random number generator, by default None.
-
- Returns
- -------
- ExperimentData
- ExperimentData object containing the sampled data.
-
- Note
- ----
-
- If a string is passed for the sampler argument, it should be one
- of the built-in samplers:
-
- * 'random' : Random sampling
- * 'latin' : Latin Hypercube Sampling
- * 'sobol' : Sobol Sequence Sampling
- * 'grid' : Grid Search Sampling
-
- Any additional keyword arguments are passed to the sampler.
- """
- experimentdata = cls(domain=domain)
- experimentdata.sample(
- sampler=sampler, n_samples=n_samples, seed=seed, **kwargs)
- return experimentdata
-
- @classmethod
- def from_yaml(cls, config: DictConfig) -> ExperimentData:
- """Create an ExperimentData object from a hydra yaml configuration.
-
- Parameters
- ----------
- config : DictConfig
- A DictConfig object containing the configuration of the \
- experiment data.
-
- Returns
- -------
- ExperimentData
- ExperimentData object containing the loaded data.
- """
- # Option 0: Both existing and sampling
- if 'from_file' in config and 'from_sampling' in config:
- return cls.from_file(config.from_file) + cls.from_sampling(
- **config.from_sampling)
-
- # Option 1: From exisiting ExperimentData files
- if 'from_file' in config:
- return cls.from_file(config.from_file)
-
- # Option 2: Sample from the domain
- if 'from_sampling' in config:
- return cls.from_sampling(**config.from_sampling)
-
- else:
- return cls(**config)
-
- @classmethod
- def _from_file_attempt(cls: Type[ExperimentData],
- project_dir: Path) -> ExperimentData:
- """Attempt to create an ExperimentData object
- from .csv and .pkl files.
-
- Parameters
- ----------
- path : Path
- Name of the user-defined directory where the files are stored.
-
- Returns
- -------
- ExperimentData
- ExperimentData object containing the loaded data.
-
- Raises
- ------
- FileNotFoundError
- If the files cannot be found.
- """
- subdirectory = project_dir / EXPERIMENTDATA_SUBFOLDER
-
- try:
- return cls(domain=subdirectory / DOMAIN_FILENAME,
- input_data=subdirectory / INPUT_DATA_FILENAME,
- output_data=subdirectory / OUTPUT_DATA_FILENAME,
- jobs=subdirectory / JOBS_FILENAME,
- project_dir=project_dir)
- except FileNotFoundError:
- raise FileNotFoundError(
- f"Cannot find the files from {subdirectory}.")
-
- # Selecting subsets
- # =========================================================================
-
- def select(self, indices: int | Iterable[int]) -> ExperimentData:
- """Select a subset of the ExperimentData object
-
- Parameters
- ----------
- indices : int | Iterable[int]
- The indices to select.
-
- Returns
- -------
- ExperimentData
- The selected ExperimentData object with only the selected indices.
- """
-
- return ExperimentData(input_data=self._input_data[indices],
- output_data=self._output_data[indices],
- jobs=self._jobs[indices],
- domain=self.domain, project_dir=self.project_dir)
-
- def drop_output(self, names: Iterable[str] | str) -> ExperimentData:
- """Drop a column from the output data
-
- Parameters
- ----------
- names : Iteraeble | str
- The names of the columns to drop.
-
- Returns
- -------
- ExperimentData
- The ExperimentData object with the column dropped.
- """
- return ExperimentData(input_data=self._input_data,
- output_data=self._output_data.drop(names),
- jobs=self._jobs, domain=self.domain.drop_output(
- names),
- project_dir=self.project_dir)
-
- def select_with_status(self, status: Literal['open', 'in progress',
- 'finished', 'error']
- ) -> ExperimentData:
- """Select a subset of the ExperimentData object with a given status
-
- Parameters
- ----------
- status : Literal['open', 'in progress', 'finished', 'error']
- The status to select.
-
- Returns
- -------
- ExperimentData
- The selected ExperimentData object with only the selected status.
-
- Raises
- ------
- ValueError
- Raised when invalid status is specified
- """
- if status not in [s.value for s in Status]:
- raise ValueError(f"Invalid status {status} given. "
- f"\nChoose from values: "
- f"{', '.join([s.value for s in Status])}")
-
- _indices = self._jobs.select_all(status).indices
- return self.select(_indices)
-
- def get_input_data(self,
- parameter_names: Optional[str | Iterable[str]] = None
- ) -> ExperimentData:
- """Retrieve a subset of the input data from the ExperimentData object
-
- Parameters
- ----------
- parameter_names : str | Iterable[str], optional
- The name(s) of the input parameters that you want to retrieve, \
- if None all input parameters are retrieved, by default None
-
- Returns
- -------
- ExperimentData
- The selected ExperimentData object with only the\
- selected input data.
-
- Note
- ----
- If parameter_names is None, all input data is retrieved. \
- The returned ExperimentData object has the domain of \
- the original ExperimentData object, \
- but only with the selected input parameters.\
- """
- if parameter_names is None:
- return ExperimentData(input_data=self._input_data,
- jobs=self._jobs,
- domain=self.domain.select(self.domain.names),
- project_dir=self.project_dir)
- else:
- return ExperimentData(input_data=self._input_data.select_columns(
- parameter_names),
- jobs=self._jobs,
- domain=self.domain.select(parameter_names),
- project_dir=self.project_dir)
-
- def get_output_data(self,
- parameter_names: Optional[str | Iterable[str]] = None
- ) -> ExperimentData:
- """Retrieve a subset of the output data from the ExperimentData object
-
- Parameters
- ----------
- parameter_names : str | Iterable[str], optional
- The name(s) of the output parameters that you want to retrieve, \
- if None all output parameters are retrieved, by default None
-
- Returns
- -------
- ExperimentData
- The selected ExperimentData object with only \
- the selected output data.
-
- Note
- ----
- If parameter_names is None, all output data is retrieved. \
- The returned ExperimentData object has no domain object and \
- no input data!
- """
- if parameter_names is None:
- # TODO: Make a domain where space is empty
- # but it tracks output_space!
- return ExperimentData(
- output_data=self._output_data, jobs=self._jobs,
- project_dir=self.project_dir)
- else:
- return ExperimentData(
- output_data=self._output_data.select_columns(parameter_names),
- jobs=self._jobs,
- project_dir=self.project_dir)
-
- # Export
- # =========================================================================
-
- def store(self, project_dir: Optional[Path | str] = None):
- """Write the ExperimentData to disk in the project directory.
-
- Parameters
- ----------
- project_dir : Optional[Path | str], optional
- The f3dasm project directory to store the \
- ExperimentData object to, by default None.
-
- Note
- ----
- If no project directory is provided, the ExperimentData object is \
- stored in the directory provided by the `.project_dir` attribute that \
- is set upon creation of the object.
-
- The ExperimentData object is stored in a subfolder 'experiment_data'.
-
- The ExperimentData object is stored in four files:
-
- * the input data (`input.csv`)
- * the output data (`output.csv`)
- * the jobs (`jobs.pkl`)
- * the domain (`domain.pkl`)
-
- To avoid the ExperimentData to be written simultaneously by multiple \
- processes, a '.lock' file is automatically created \
- in the project directory. Concurrent process can only sequentially \
- access the lock file. This lock file is removed after the \
- ExperimentData object is written to disk.
- """
- if project_dir is not None:
- self.set_project_dir(project_dir)
-
- subdirectory = self.project_dir / EXPERIMENTDATA_SUBFOLDER
-
- # Create the subdirectory if it does not exist
- subdirectory.mkdir(parents=True, exist_ok=True)
-
- self._input_data.store(subdirectory / Path(INPUT_DATA_FILENAME))
- self._output_data.store(subdirectory / Path(OUTPUT_DATA_FILENAME))
- self._jobs.store(subdirectory / Path(JOBS_FILENAME))
- self.domain.store(subdirectory / Path(DOMAIN_FILENAME))
-
- def to_numpy(self) -> Tuple[np.ndarray, np.ndarray]:
- """
- Convert the ExperimentData object to a tuple of numpy arrays.
-
- Returns
- -------
- tuple
- A tuple containing two numpy arrays, \
- the first one for input columns, \
- and the second for output columns.
- """
- return self._input_data.to_numpy(), self._output_data.to_numpy()
-
- def to_pandas(self) -> Tuple[pd.DataFrame, pd.DataFrame]:
- """
- Convert the ExperimentData object to a pandas DataFrame.
-
- Returns
- -------
- tuple
- A tuple containing two pandas DataFrames, \
- the first one for input columns, and the second for output
- """
- return (self._input_data.to_dataframe(),
- self._output_data.to_dataframe())
-
- def to_xarray(self) -> xr.Dataset:
- """
- Convert the ExperimentData object to an xarray Dataset.
-
- Returns
- -------
- xarray.Dataset
- An xarray Dataset containing the data.
- """
- return xr.Dataset(
- {'input': self._input_data.to_xarray('input_dim'),
- 'output': self._output_data.to_xarray('output_dim')})
-
- def get_n_best_output(self, n_samples: int) -> ExperimentData:
- """Get the n best samples from the output data. \
- We consider lower values to be better.
-
- Parameters
- ----------
- n_samples : int
- Number of samples to select.
-
- Returns
- -------
- ExperimentData
- New experimentData object with a selection of the n best samples.
-
- Note
- ----
-
- The n best samples are selected based on the output data. \
- The output data is sorted based on the first output parameter. \
- The n best samples are selected based on this sorting. \
- """
- df = self._output_data.n_best_samples(
- n_samples, self._output_data.names)
- return self.select(df.index)
-
- # Append or remove data
- # =========================================================================
-
- def add(self, domain: Optional[Domain] = None,
- input_data: Optional[DataTypes] = None,
- output_data: Optional[DataTypes] = None,
- jobs: Optional[Path | str] = None) -> None:
- """Add data to the ExperimentData object.
-
- Parameters
- ----------
- domain : Optional[Domain], optional
- Domain of the added object, by default None
- input_data : Optional[DataTypes], optional
- input parameters of the added object, by default None
- output_data : Optional[DataTypes], optional
- output parameters of the added object, by default None
- jobs : Optional[Path | str], optional
- jobs off the added object, by default None
- """
- self.add_experiments(ExperimentData(
- domain=domain, input_data=input_data,
- output_data=output_data,
- jobs=jobs))
-
- def add_experiments(self,
- experiment_sample: ExperimentSample | ExperimentData
- ) -> None:
- """
- Add an ExperimentSample or ExperimentData to the ExperimentData
- attribute.
-
- Parameters
- ----------
- experiment_sample : ExperimentSample or ExperimentData
- Experiment(s) to add.
-
- Raises
- ------
- ValueError
- If -after checked- the indices of the input and output data
- objects are not equal.
- """
-
- if isinstance(experiment_sample, ExperimentData):
- experiment_sample._reset_index()
- self.domain += experiment_sample.domain
-
- self._input_data += experiment_sample._input_data
- self._output_data += experiment_sample._output_data
- self._jobs += experiment_sample._jobs
-
- # Check if indices of the internal objects are equal
- if not (self._input_data.indices.equals(self._output_data.indices)
- and self._input_data.indices.equals(self._jobs.indices)):
- raise ValueError(f"Indices of the internal objects are not equal."
- f"input_data {self._input_data.indices}, "
- f"output_data {self._output_data.indices},"
- f"jobs: {self._jobs.indices}")
-
- # Apparently you need to cast the types again
- # TODO: Breaks if values are NaN or infinite
- # self._input_data.cast_types(self.domain)
-
- def overwrite(
- self, indices: Iterable[int],
- domain: Optional[Domain] = None,
- input_data: Optional[DataTypes] = None,
- output_data: Optional[DataTypes] = None,
- jobs: Optional[Path | str] = None,
- add_if_not_exist: bool = False
- ) -> None:
- """Overwrite the ExperimentData object.
-
- Parameters
- ----------
- indices : Iterable[int]
- The indices to overwrite.
- domain : Optional[Domain], optional
- Domain of the new object, by default None
- input_data : Optional[DataTypes], optional
- input parameters of the new object, by default None
- output_data : Optional[DataTypes], optional
- output parameters of the new object, by default None
- jobs : Optional[Path | str], optional
- jobs off the new object, by default None
- add_if_not_exist : bool, optional
- If True, the new objects are added if the requested indices
- do not exist in the current ExperimentData object, by default False
- """
-
- # Be careful, if a job has output data and gets overwritten with a
- # job that has no output data, the status is set to open. But the job
- # will still have the output data!
-
- # This is usually not a problem, because the output data will be
- # immediately overwritten in optimization.
-
- self._overwrite_experiments(
- indices=indices,
- experiment_sample=ExperimentData(
- domain=domain, input_data=input_data,
- output_data=output_data,
- jobs=jobs),
- add_if_not_exist=add_if_not_exist)
-
- def _overwrite_experiments(
- self, indices: Iterable[int],
- experiment_sample: ExperimentSample | ExperimentData,
- add_if_not_exist: bool) -> None:
- """
- Overwrite the ExperimentData object at the given indices.
-
- Parameters
- ----------
- indices : Iterable[int]
- The indices to overwrite.
- experimentdata : ExperimentData | ExperimentSample
- The new ExperimentData object to overwrite with.
- add_if_not_exist : bool
- If True, the new objects are added if the requested indices
- do not exist in the current ExperimentData object.
- """
- if not all(pd.Index(indices).isin(self.index)):
- if add_if_not_exist:
- self.add_experiments(experiment_sample)
- return
- else:
- raise ValueError(
- f"The given indices {indices} do not exist in the current "
- f"ExperimentData object. "
- f"If you want to add the new experiments, "
- f"set add_if_not_exist to True.")
-
- self._input_data.overwrite(
- indices=indices, other=experiment_sample._input_data)
- self._output_data.overwrite(
- indices=indices, other=experiment_sample._output_data)
-
- self._jobs.overwrite(
- indices=indices, other=experiment_sample._jobs)
-
- if isinstance(experiment_sample, ExperimentData):
- self.domain += experiment_sample.domain
-
- @_access_file
- def overwrite_disk(
- self, indices: Iterable[int],
- domain: Optional[Domain] = None,
- input_data: Optional[DataTypes] = None,
- output_data: Optional[DataTypes] = None,
- jobs: Optional[Path | str] = None,
- add_if_not_exist: bool = False
- ) -> None:
- self.overwrite(indices=indices, domain=domain, input_data=input_data,
- output_data=output_data, jobs=jobs,
- add_if_not_exist=add_if_not_exist)
-
- def add_input_parameter(
- self, name: str,
- type: Literal['float', 'int', 'category', 'constant'],
- **kwargs):
- """Add a new input column to the ExperimentData object.
-
- Parameters
- ----------
- name
- name of the new input column
- type
- type of the new input column: float, int, category or constant
- kwargs
- additional arguments for the new parameter
- """
- self._input_data.add_column(name)
- self.domain.add(name=name, type=type, **kwargs)
-
- def add_output_parameter(
- self, name: str, is_disk: bool, exist_ok: bool = False) -> None:
- """Add a new output column to the ExperimentData object.
-
- Parameters
- ----------
- name
- name of the new output column
- is_disk
- Whether the output column will be stored on disk or not
- exist_ok
- If True, it will not raise an error if the output column already
- exists, by default False
- """
- self._output_data.add_column(name, exist_ok=exist_ok)
- self.domain.add_output(name=name, to_disk=is_disk, exist_ok=exist_ok)
-
- def remove_rows_bottom(self, number_of_rows: int):
- """
- Remove a number of rows from the end of the ExperimentData object.
-
- Parameters
- ----------
- number_of_rows : int
- Number of rows to remove from the bottom.
- """
- if number_of_rows == 0:
- return # Don't do anything if 0 rows need to be removed
-
- # get the last indices from data.data
- indices = self.index[-number_of_rows:]
-
- # remove the indices rows_to_remove from data.data
- self._input_data.remove(indices)
- self._output_data.remove(indices)
- self._jobs.remove(indices)
-
- def _reset_index(self) -> None:
- """
- Reset the index of the ExperimentData object.
- """
- self._input_data.reset_index()
-
- if self._input_data.is_empty():
- self._output_data.reset_index()
- else:
- self._output_data.reset_index(self._input_data.indices)
- self._jobs.reset_index()
-
- def join(self, other: ExperimentData) -> ExperimentData:
- """Join two ExperimentData objects.
-
- Parameters
- ----------
- other : ExperimentData
- The other ExperimentData object to join with.
-
- Returns
- -------
- ExperimentData
- The joined ExperimentData object.
- """
- return ExperimentData(
- input_data=self._input_data.join(other._input_data),
- output_data=self._output_data.join(other._output_data),
- jobs=self._jobs,
- domain=self.domain + other.domain,
- project_dir=self.project_dir)
-# ExperimentSample
- # =============================================================================
-
- def get_experiment_sample(self, index: int) -> ExperimentSample:
- """
- Gets the experiment_sample at the given index.
-
- Parameters
- ----------
- index : int
- The index of the experiment_sample to retrieve.
-
- Returns
- -------
- ExperimentSample
- The ExperimentSample at the given index.
- """
- output_experiment_sample_dict = self._output_data.get_data_dict(index)
-
- dict_output = {k: (v, self.domain.output_space[k].to_disk)
- for k, v in output_experiment_sample_dict.items()}
-
- return ExperimentSample(dict_input=self._input_data.get_data_dict(
- index),
- dict_output=dict_output,
- jobnumber=index,
- experimentdata_directory=self.project_dir)
-
- def get_experiment_samples(
- self,
- indices: Optional[Iterable[int]] = None) -> List[ExperimentSample]:
- """
- Gets the experiment_samples at the given indices.
-
- Parameters
- ----------
- indices : Optional[Iterable[int]], optional
- The indices of the experiment_samples to retrieve, by default None
- If None, all experiment_samples are retrieved.
-
- Returns
- -------
- List[ExperimentSample]
- The ExperimentSamples at the given indices.
- """
- if indices is None:
- # Return a list of the iterator over ExperimentData
- return list(self)
-
- return [self.get_experiment_sample(index) for index in indices]
-
- def _set_experiment_sample(self,
- experiment_sample: ExperimentSample) -> None:
- """
- Sets the ExperimentSample at the given index.
-
- Parameters
- ----------
- experiment_sample : ExperimentSample
- The ExperimentSample to set.
- """
- for column, (value, is_disk) in experiment_sample._dict_output.items():
-
- if not self.domain.is_in_output(column):
- self.domain.add_output(column, to_disk=is_disk)
-
- self._output_data.set_data(
- index=experiment_sample.job_number, value=value,
- column=column)
-
- self._jobs.mark(experiment_sample._jobnumber, status=Status.FINISHED)
-
- @_access_file
- def _write_experiment_sample(self,
- experiment_sample: ExperimentSample) -> None:
- """
- Sets the ExperimentSample at the given index.
-
- Parameters
- ----------
- experiment_sample : ExperimentSample
- The ExperimentSample to set.
- """
- self._set_experiment_sample(experiment_sample)
-
- def _access_open_job_data(self) -> ExperimentSample:
- """Get the data of the first available open job.
-
- Returns
- -------
- ExperimentSample
- The ExperimentSample object of the first available open job.
- """
- job_index = self._jobs.get_open_job()
- self._jobs.mark(job_index, status=Status.IN_PROGRESS)
- experiment_sample = self.get_experiment_sample(job_index)
- return experiment_sample
-
- @_access_file
- def _get_open_job_data(self) -> ExperimentSample:
- """Get the data of the first available open job by
- accessing the ExperimenData on disk.
-
- Returns
- -------
- ExperimentSample
- The ExperimentSample object of the first available open job.
- """
- return self._access_open_job_data()
-
- # Jobs
- # =========================================================================
-
- def _set_error(self, index: int) -> None:
- """Mark the experiment_sample at the given index as error.
-
- Parameters
- ----------
- index
- index of the experiment_sample to mark as error
- """
- # self.jobs.mark_as_error(index)
- self._jobs.mark(index, status=Status.ERROR)
- self._output_data.set_data(
- index,
- value=['ERROR' for _ in self._output_data.names])
-
- @_access_file
- def _write_error(self, index: int):
- """Mark the experiment_sample at the given index as
- error and write to ExperimentData file.
-
- Parameters
- ----------
- index
- index of the experiment_sample to mark as error
- """
- self._set_error(index)
-
- @_access_file
- def is_all_finished(self) -> bool:
- """Check if all jobs are finished
-
- Returns
- -------
- bool
- True if all jobs are finished, False otherwise
- """
- return self._jobs.is_all_finished()
-
- def mark(self, indices: Iterable[int],
- status: Literal['open', 'in progress', 'finished', 'error']):
- """Mark the jobs at the given indices with the given status.
-
- Parameters
- ----------
- indices : Iterable[int]
- indices of the jobs to mark
- status : Literal['open', 'in progress', 'finished', 'error']
- status to mark the jobs with: choose between: 'open', \
- 'in progress', 'finished' or 'error'
-
- Raises
- ------
- ValueError
- If the given status is not any of 'open', 'in progress', \
- 'finished' or 'error'
- """
- # Check if the status is in Status
- if not any(status.lower() == s.value for s in Status):
- raise ValueError(f"Invalid status {status} given. "
- f"\nChoose from values: "
- f"{', '.join([s.value for s in Status])}")
-
- self._jobs.mark(indices, status)
-
- def mark_all(self,
- status: Literal['open', 'in progress', 'finished', 'error']):
- """Mark all the experiments with the given status
-
- Parameters
- ----------
- status : Literal['open', 'in progress', 'finished', 'error']
- status to mark the jobs with: \
- choose between:
-
- * 'open',
- * 'in progress',
- * 'finished'
- * 'error'
-
- Raises
- ------
- ValueError
- If the given status is not any of \
- 'open', 'in progress', 'finished' or 'error'
- """
- self.mark(self._jobs.indices, status)
-
- def mark_all_error_open(self) -> None:
- """
- Mark all the experiments that have the status 'error' open
- """
- self._jobs.mark_all_error_open()
-
- def mark_all_in_progress_open(self) -> None:
- """
- Mark all the experiments that have the status 'in progress' open
- """
- self._jobs.mark_all_in_progress_open()
-
- def mark_all_nan_open(self) -> None:
- """
- Mark all the experiments that have 'nan' in output open
- """
- indices = self._output_data.get_index_with_nan()
- self.mark(indices=indices, status='open')
- # Datageneration
- # =========================================================================
-
- def evaluate(self, data_generator: DataGenerator,
- mode: Literal['sequential', 'parallel',
- 'cluster', 'cluster_parallel'] = 'sequential',
- kwargs: Optional[dict] = None,
- output_names: Optional[List[str]] = None) -> None:
- """Run any function over the entirety of the experiments
-
- Parameters
- ----------
- data_generator : DataGenerator
- data generator to use
- mode : str, optional
- operational mode, by default 'sequential'. Choose between:
-
- * 'sequential' : Run the operation sequentially
- * 'parallel' : Run the operation on multiple cores
- * 'cluster' : Run the operation on the cluster
- * 'cluster_parallel' : Run the operation on the cluster in parallel
-
- kwargs, optional
- Any keyword arguments that need to
- be supplied to the function, by default None
- output_names : List[str], optional
- If you provide a function as data generator, you have to provide
- the names of all the output parameters that are in the return
- statement, in order of appearance.
-
- Raises
- ------
- ValueError
- Raised when invalid parallelization mode is specified
- """
- if kwargs is None:
- kwargs = {}
-
- if inspect.isfunction(data_generator):
- if output_names is None:
- raise TypeError(
- ("If you provide a function as data generator, you have to"
- "provide the names of the return arguments with the"
- "output_names attribute."))
- data_generator = convert_function(
- f=data_generator, output=output_names)
-
- elif isinstance(data_generator, str):
- data_generator = _datagenerator_factory(
- data_generator, self.domain, kwargs)
-
- if mode.lower() == "sequential":
- return self._run_sequential(data_generator, kwargs)
- elif mode.lower() == "parallel":
- return self._run_multiprocessing(data_generator, kwargs)
- elif mode.lower() == "cluster":
- return self._run_cluster(data_generator, kwargs)
- elif mode.lower() == "cluster_parallel":
- return self._run_cluster_parallel(data_generator, kwargs)
- else:
- raise ValueError("Invalid parallelization mode specified.")
-
- def _run_sequential(self, data_generator: DataGenerator, kwargs: dict):
- """Run the operation sequentially
-
- Parameters
- ----------
- operation : ExperimentSampleCallable
- function execution for every entry in the ExperimentData object
- kwargs : dict
- Any keyword arguments that need to be supplied to the function
-
- Raises
- ------
- NoOpenJobsError
- Raised when there are no open jobs left
- """
- while True:
- try:
- experiment_sample = self._access_open_job_data()
- logger.debug(
- f"Accessed experiment_sample \
- {experiment_sample._jobnumber}")
- except NoOpenJobsError:
- logger.debug("No Open Jobs left")
- break
-
- try:
-
- # If kwargs is empty dict
- if not kwargs:
- logger.debug(
- f"Running experiment_sample "
- f"{experiment_sample._jobnumber}")
- else:
- logger.debug(
- f"Running experiment_sample "
- f"{experiment_sample._jobnumber} with kwargs {kwargs}")
-
- _experiment_sample = data_generator._run(
- experiment_sample, **kwargs) # no *args!
- self._set_experiment_sample(_experiment_sample)
- except Exception as e:
- error_msg = f"Error in experiment_sample \
- {experiment_sample._jobnumber}: {e}"
- error_traceback = traceback.format_exc()
- logger.error(f"{error_msg}\n{error_traceback}")
- self._set_error(experiment_sample._jobnumber)
-
- def _run_multiprocessing(self, data_generator: DataGenerator,
- kwargs: dict):
- """Run the operation on multiple cores
-
- Parameters
- ----------
- operation : ExperimentSampleCallable
- function execution for every entry in the ExperimentData object
- kwargs : dict
- Any keyword arguments that need to be supplied to the function
-
- Raises
- ------
- NoOpenJobsError
- Raised when there are no open jobs left
- """
- # Get all the jobs
- options = []
- while True:
- try:
- experiment_sample = self._access_open_job_data()
- options.append(
- ({'experiment_sample': experiment_sample, **kwargs},))
- except NoOpenJobsError:
- break
-
- def f(options: Dict[str, Any]) -> Tuple[ExperimentSample, int]:
- try:
-
- logger.debug(
- f"Running experiment_sample "
- f"{options['experiment_sample'].job_number}")
-
- return (data_generator._run(**options), 0) # no *args!
-
- except Exception as e:
- error_msg = f"Error in experiment_sample \
- {options['experiment_sample'].job_number}: {e}"
- error_traceback = traceback.format_exc()
- logger.error(f"{error_msg}\n{error_traceback}")
- return (options['experiment_sample'], 1)
-
- with mp.Pool() as pool:
- # maybe implement pool.starmap_async ?
- _experiment_samples: List[
- Tuple[ExperimentSample, int]] = pool.starmap(f, options)
-
- for _experiment_sample, exit_code in _experiment_samples:
- if exit_code == 0:
- self._set_experiment_sample(_experiment_sample)
- else:
- self._set_error(_experiment_sample.job_number)
-
- def _run_cluster(self, data_generator: DataGenerator, kwargs: dict):
- """Run the operation on the cluster
-
- Parameters
- ----------
- operation : ExperimentSampleCallable
- function execution for every entry in the ExperimentData object
- kwargs : dict
- Any keyword arguments that need to be supplied to the function
-
- Raises
- ------
- NoOpenJobsError
- Raised when there are no open jobs left
- """
- # Retrieve the updated experimentdata object from disc
- try:
- self = self.from_file(self.project_dir)
- except FileNotFoundError: # If not found, store current
- self.store()
-
- while True:
- try:
- experiment_sample = self._get_open_job_data()
- except NoOpenJobsError:
- logger.debug("No Open jobs left!")
- break
-
- try:
- _experiment_sample = data_generator._run(
- experiment_sample, **kwargs)
- self._write_experiment_sample(_experiment_sample)
- except Exception:
- n = experiment_sample.job_number
- error_msg = f"Error in experiment_sample {n}: "
- error_traceback = traceback.format_exc()
- logger.error(f"{error_msg}\n{error_traceback}")
- self._write_error(experiment_sample._jobnumber)
- continue
-
- self = self.from_file(self.project_dir)
- # Remove the lockfile from disk
- (self.project_dir / EXPERIMENTDATA_SUBFOLDER / LOCK_FILENAME
- ).with_suffix('.lock').unlink(missing_ok=True)
-
- def _run_cluster_parallel(
- self, data_generator: DataGenerator, kwargs: dict):
- """Run the operation on the cluster and parallelize it over cores
-
- Parameters
- ----------
- operation : ExperimentSampleCallable
- function execution for every entry in the ExperimentData object
- kwargs : dict
- Any keyword arguments that need to be supplied to the function
-
- Raises
- ------
- NoOpenJobsError
- Raised when there are no open jobs left
- """
- # Retrieve the updated experimentdata object from disc
- try:
- self = self.from_file(self.project_dir)
- except FileNotFoundError: # If not found, store current
- self.store()
-
- no_jobs = False
-
- while True:
- es_list = []
- for core in range(mp.cpu_count()):
- try:
- es_list.append(self._get_open_job_data())
- except NoOpenJobsError:
- logger.debug("No Open jobs left!")
- no_jobs = True
- break
-
- d = self.select([e.job_number for e in es_list])
-
- d._run_multiprocessing(
- data_generator=data_generator, kwargs=kwargs)
-
- # TODO access resource first!
- self.overwrite_disk(
- indices=d.index, input_data=d._input_data,
- output_data=d._output_data, jobs=d._jobs,
- domain=d.domain, add_if_not_exist=False)
-
- if no_jobs:
- break
-
- self = self.from_file(self.project_dir)
- # Remove the lockfile from disk
- (self.project_dir / EXPERIMENTDATA_SUBFOLDER / LOCK_FILENAME
- ).with_suffix('.lock').unlink(missing_ok=True)
-
- # Optimization
- # =========================================================================
-
- def optimize(self, optimizer: Optimizer | str,
- data_generator: DataGenerator | str,
- iterations: int,
- kwargs: Optional[Dict[str, Any]] = None,
- hyperparameters: Optional[Dict[str, Any]] = None,
- x0_selection: Literal['best', 'random',
- 'last',
- 'new'] | ExperimentData = 'best',
- sampler: Optional[Sampler | str] = 'random',
- overwrite: bool = False,
- callback: Optional[Callable] = None) -> None:
- """Optimize the experimentdata object
-
- Parameters
- ----------
- optimizer : Optimizer | str
- Optimizer object
- data_generator : DataGenerator | str
- DataGenerator object
- iterations : int
- number of iterations
- kwargs : Dict[str, Any], optional
- any additional keyword arguments that will be passed to
- the DataGenerator
- hyperparameters : Dict[str, Any], optional
- any additional keyword arguments that will be passed to
- the optimizer
- x0_selection : str | ExperimentData
- How to select the initial design. By default 'best'
- The following x0_selections are available:
-
- * 'best': Select the best designs from the current experimentdata
- * 'random': Select random designs from the current experimentdata
- * 'last': Select the last designs from the current experimentdata
- * 'new': Create new random designs from the current experimentdata
-
- If the x0_selection is 'new', new designs are sampled with the
- sampler provided. The number of designs selected is equal to the
- population size of the optimizer.
-
- If an ExperimentData object is passed as x0_selection,
- the optimizer will use the input_data and output_data from this
- object as initial samples.
- sampler: Sampler, optional
- If x0_selection = 'new', the sampler to use. By default 'random'
- overwrite: bool, optional
- If True, the optimizer will overwrite the current data. By default
- False
- callback : Callable, optional
- A callback function that is called after every iteration. It has
- the following signature:
-
- ``callback(intermediate_result: ExperimentData)``
-
- where the first argument is a parameter containing an
- `ExperimentData` object with the current iterate(s).
-
- Raises
- ------
- ValueError
- Raised when invalid x0_selection is specified
- """
- # Create the data generator object if a string reference is passed
- if isinstance(data_generator, str):
- data_generator: DataGenerator = _datagenerator_factory(
- data_generator=data_generator,
- domain=self.domain, kwargs=kwargs)
-
- # Create a copy of the optimizer object
- _optimizer = copy(optimizer)
-
- # Create the optimizer object if a string reference is passed
- if isinstance(_optimizer, str):
- _optimizer: Optimizer = _optimizer_factory(
- _optimizer, self.domain, hyperparameters)
-
- # Create the sampler object if a string reference is passed
- if isinstance(sampler, str):
- sampler: Sampler = _sampler_factory(sampler, self.domain)
-
- if _optimizer.type == 'scipy':
- self._iterate_scipy(
- optimizer=_optimizer, data_generator=data_generator,
- iterations=iterations, kwargs=kwargs,
- x0_selection=x0_selection,
- sampler=sampler,
- overwrite=overwrite,
- callback=callback)
- else:
- self._iterate(
- optimizer=_optimizer, data_generator=data_generator,
- iterations=iterations, kwargs=kwargs,
- x0_selection=x0_selection,
- sampler=sampler,
- overwrite=overwrite,
- callback=callback)
-
- def _iterate(self, optimizer: Optimizer, data_generator: DataGenerator,
- iterations: int, kwargs: Dict[str, Any], x0_selection: str,
- sampler: Sampler, overwrite: bool,
- callback: Callable):
- """Internal represenation of the iteration process
-
- Parameters
- ----------
- optimizer : Optimizer
- Optimizer object
- data_generator : DataGenerator
- DataGenerator object
- iterations : int
- number of iterations
- kwargs : Dict[str, Any]
- any additional keyword arguments that will be passed to
- the DataGenerator
- x0_selection : str | ExperimentData
- How to select the initial design.
- The following x0_selections are available:
-
- * 'best': Select the best designs from the current experimentdata
- * 'random': Select random designs from the current experimentdata
- * 'last': Select the last designs from the current experimentdata
- * 'new': Create new random designs from the current experimentdata
-
- If the x0_selection is 'new', new designs are sampled with the
- sampler provided. The number of designs selected is equal to the
- population size of the optimizer.
-
- If an ExperimentData object is passed as x0_selection,
- the optimizer will use the input_data and output_data from this
- object as initial samples.
-
- sampler: Sampler
- If x0_selection = 'new', the sampler to use
- overwrite: bool
- If True, the optimizer will overwrite the current data.
- callback : Callable
- A callback function that is called after every iteration. It has
- the following signature:
-
- ``callback(intermediate_result: ExperimentData)``
-
- where the first argument is a parameter containing an
- `ExperimentData` object with the current iterate(s).
-
- Raises
- ------
- ValueError
- Raised when invalid x0_selection is specified
- """
- last_index = self.index[-1] if not self.index.empty else -1
-
- if isinstance(x0_selection, str):
- if x0_selection == 'new':
-
- if iterations < optimizer._population:
- raise ValueError(
- f'For creating new samples, the total number of '
- f'requested iterations ({iterations}) cannot be '
- f'smaller than the population size '
- f'({optimizer._population})')
-
- init_samples = ExperimentData.from_sampling(
- domain=self.domain,
- sampler=sampler,
- n_samples=optimizer._population,
- seed=optimizer._seed)
-
- init_samples.evaluate(
- data_generator=data_generator, kwargs=kwargs,
- mode='sequential')
-
- if callback is not None:
- callback(init_samples)
-
- if overwrite:
- _indices = init_samples.index + last_index + 1
- self._overwrite_experiments(
- experiment_sample=init_samples,
- indices=_indices,
- add_if_not_exist=True)
-
- else:
- self.add_experiments(init_samples)
-
- x0_selection = 'last'
- iterations -= optimizer._population
-
- x0 = x0_factory(experiment_data=self, mode=x0_selection,
- n_samples=optimizer._population)
- optimizer._set_data(x0)
-
- optimizer._check_number_of_datapoints()
-
- optimizer._construct_model(data_generator)
-
- for _ in range(number_of_updates(
- iterations,
- population=optimizer._population)):
- new_samples = optimizer.update_step(data_generator)
-
- # If new_samples is a tuple of input_data and output_data
- if isinstance(new_samples, tuple):
- new_samples = ExperimentData(
- domain=self.domain,
- input_data=new_samples[0],
- output_data=new_samples[1],
- )
- # If applicable, evaluate the new designs:
- new_samples.evaluate(
- data_generator, mode='sequential', kwargs=kwargs)
-
- if callback is not None:
- callback(new_samples)
-
- if overwrite:
- _indices = new_samples.index + last_index + 1
- self._overwrite_experiments(experiment_sample=new_samples,
- indices=_indices,
- add_if_not_exist=True)
-
- else:
- self.add_experiments(new_samples)
-
- optimizer._set_data(self)
-
- if not overwrite:
- # Remove overiterations
- self.remove_rows_bottom(number_of_overiterations(
- iterations,
- population=optimizer._population))
-
- # Reset the optimizer
- # optimizer.reset(ExperimentData(domain=self.domain))
-
- def _iterate_scipy(self, optimizer: Optimizer,
- data_generator: DataGenerator,
- iterations: int, kwargs: dict,
- x0_selection: str | ExperimentData,
- sampler: Sampler, overwrite: bool,
- callback: Callable):
- """Internal represenation of the iteration process for scipy-minimize
- optimizers.
-
- Parameters
- ----------
- optimizer : Optimizer
- Optimizer object
- data_generator : DataGenerator
- DataGenerator object
- iterations : int
- number of iterations
- kwargs : Dict[str, Any]
- any additional keyword arguments that will be passed to
- the DataGenerator
- x0_selection : str | ExperimentData
- How to select the initial design.
- The following x0_selections are available:
-
- * 'best': Select the best designs from the current experimentdata
- * 'random': Select random designs from the current experimentdata
- * 'last': Select the last designs from the current experimentdata
- * 'new': Create new random designs from the current experimentdata
-
- If the x0_selection is 'new', new designs are sampled with the
- sampler provided. The number of designs selected is equal to the
- population size of the optimizer.
-
- If an ExperimentData object is passed as x0_selection,
- the optimizer will use the input_data and output_data from this
- object as initial samples.
-
- sampler: Sampler
- If x0_selection = 'new', the sampler to use
- overwrite: bool
- If True, the optimizer will overwrite the current data.
- callback : Callable
- A callback function that is called after every iteration. It has
- the following signature:
-
- ``callback(intermediate_result: ExperimentData)``
-
- where the first argument is a parameter containing an
- `ExperimentData` object with the current iterate(s).
-
- Raises
- ------
- ValueError
- Raised when invalid x0_selection is specified
- """
- last_index = self.index[-1] if not self.index.empty else -1
- n_data_before_iterate = len(self)
-
- if isinstance(x0_selection, str):
- if x0_selection == 'new':
-
- if iterations < optimizer._population:
- raise ValueError(
- f'For creating new samples, the total number of '
- f'requested iterations ({iterations}) cannot be '
- f'smaller than the population size '
- f'({optimizer._population})')
-
- init_samples = ExperimentData.from_sampling(
- domain=self.domain,
- sampler=sampler,
- n_samples=optimizer._population,
- seed=optimizer._seed)
-
- init_samples.evaluate(
- data_generator=data_generator, kwargs=kwargs,
- mode='sequential')
-
- if callback is not None:
- callback(init_samples)
-
- if overwrite:
- _indices = init_samples.index + last_index + 1
- self._overwrite_experiments(
- experiment_sample=init_samples,
- indices=_indices,
- add_if_not_exist=True)
-
- else:
- self.add_experiments(init_samples)
-
- x0_selection = 'last'
-
- x0 = x0_factory(experiment_data=self, mode=x0_selection,
- n_samples=optimizer._population)
- optimizer._set_data(x0)
-
- optimizer._check_number_of_datapoints()
-
- optimizer.run_algorithm(iterations, data_generator)
-
- new_samples: ExperimentData = optimizer.data.select(
- optimizer.data.index[1:])
- new_samples.evaluate(data_generator, mode='sequential', kwargs=kwargs)
-
- if callback is not None:
- callback(new_samples)
-
- if overwrite:
- self.add_experiments(
- optimizer.data.select([optimizer.data.index[-1]]))
-
- elif not overwrite:
- # Do not add the first element, as this is already
- # in the sampled data
- self.add_experiments(new_samples)
-
- # TODO: At the end, the data should have
- # n_data_before_iterate + iterations amount of elements!
- # If x_new is empty, repeat best x0 to fill up total iteration
- if len(self) == n_data_before_iterate:
- repeated_sample = self.get_n_best_output(
- n_samples=1)
-
- for repetition in range(iterations):
- self.add_experiments(repeated_sample)
-
- # Repeat last iteration to fill up total iteration
- if len(self) < n_data_before_iterate + iterations:
- last_design = self.get_experiment_sample(len(self)-1)
-
- while len(self) < n_data_before_iterate + iterations:
- self.add_experiments(last_design)
-
- # Evaluate the function on the extra iterations
- self.evaluate(data_generator, mode='sequential', kwargs=kwargs)
-
- # Reset the optimizer
- # optimizer.reset(ExperimentData(domain=self.domain))
-
- # Sampling
- # =========================================================================
-
- def sample(self, sampler: Sampler | SamplerNames, n_samples: int = 1,
- seed: Optional[int] = None, **kwargs) -> None:
- """Sample data from the domain providing the sampler strategy
-
- Parameters
- ----------
- sampler: Sampler | str
- Sampler callable or string of built-in sampler
- If a string is passed, it should be one of the built-in samplers:
-
- * 'random' : Random sampling
- * 'latin' : Latin Hypercube Sampling
- * 'sobol' : Sobol Sequence Sampling
- * 'grid' : Grid Search Sampling
- n_samples : int, optional
- Number of samples to generate, by default 1
- seed : Optional[int], optional
- Seed to use for the sampler, by default None
-
- Note
- ----
- When using the 'grid' sampler, an optional argument
- 'stepsize_continuous_parameters' can be passed to specify the stepsize
- to cast continuous parameters to discrete parameters.
-
- - The stepsize should be a dictionary with the parameter names as keys\
- and the stepsize as values.
- - Alternatively, a single stepsize can be passed for all continuous\
- parameters.
-
- Raises
- ------
- ValueError
- Raised when invalid sampler type is specified
- """
-
- if isinstance(sampler, str):
- sampler = _sampler_factory(sampler, self.domain)
-
- sample_data: DataTypes = sampler(
- domain=self.domain, n_samples=n_samples, seed=seed, **kwargs)
- self.add(input_data=sample_data, domain=self.domain)
-
- # Project directory
- # =========================================================================
-
- def set_project_dir(self, project_dir: Path | str):
- """Set the directory of the f3dasm project folder.
-
- Parameters
- ----------
- project_dir : Path or str
- Path to the project directory
- """
- self.project_dir = _project_dir_factory(project_dir)
-
-
-def x0_factory(experiment_data: ExperimentData,
- mode: str | ExperimentData, n_samples: int):
- """Set the initial population to the best n samples of the given data
-
- Parameters
- ----------
- experiment_data : ExperimentData
- Data to be used for the initial population
- mode : str
- Mode of selecting the initial population, by default 'best'
- The following modes are available:
-
- - best: select the best n samples
- - random: select n random samples
- - last: select the last n samples
- n_samples : int
- Number of samples to select
-
- Raises
- ------
- ValueError
- Raises when the mode is not recognized
- """
- if isinstance(mode, ExperimentData):
- x0 = mode
-
- elif mode == 'best':
- x0 = experiment_data.get_n_best_output(n_samples)
-
- elif mode == 'random':
- x0 = experiment_data.select(
- np.random.choice(
- experiment_data.index,
- size=n_samples, replace=False))
-
- elif mode == 'last':
- x0 = experiment_data.select(
- experiment_data.index[-n_samples:])
-
- else:
- raise ValueError(
- f'Unknown selection mode {mode}, use best, random or last')
-
- x0._reset_index()
- return x0
diff --git a/src/f3dasm/_src/experimentdata/experimentsample.py b/src/f3dasm/_src/experimentdata/experimentsample.py
deleted file mode 100644
index dfea1f31..00000000
--- a/src/f3dasm/_src/experimentdata/experimentsample.py
+++ /dev/null
@@ -1,393 +0,0 @@
-"""
-A ExperimentSample object contains a single realization of
- the design-of-experiment in ExperimentData.
-"""
-
-# Modules
-# =============================================================================
-
-from __future__ import annotations
-
-# Standard
-from pathlib import Path
-from typing import Any, Dict, Literal, Optional, Tuple, Type
-
-# Third-party
-import autograd.numpy as np
-
-# Local
-from ..design.domain import Domain
-from ..logger import logger
-from ._io import StoreProtocol, load_object, save_object
-
-# Authorship & Credits
-# =============================================================================
-__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
-__credits__ = ['Martin van der Schelling']
-__status__ = 'Stable'
-# =============================================================================
-
-
-class ExperimentSample:
- def __init__(self, dict_input: Dict[str, Any],
- dict_output: Dict[str, Tuple[Any, bool]],
- jobnumber: int,
- experimentdata_directory: Optional[Path] = None):
- """Single realization of a design of experiments.
-
- Parameters
- ----------
- dict_input : Dict[str, Any]
- Input parameters of one experiment. \
- The key is the name of the parameter.
- dict_output : Dict[str, Tuple[Any, bool]]
- Output parameters of one experiment. \
- The key is the name of the parameter, \
- the first value of the tuple is the actual value and the second \
- if the value is stored to disk or not.
- jobnumber : int
- Index of the experiment
- """
- self._dict_input = dict_input
- self._dict_output = dict_output
- self._jobnumber = jobnumber
-
- if experimentdata_directory is None:
- experimentdata_directory = Path.cwd()
-
- self._experimentdata_directory = experimentdata_directory
-
- @classmethod
- def from_numpy(cls: Type[ExperimentSample], input_array: np.ndarray,
- output_value: Optional[float] = None,
- jobnumber: int = 0,
- domain: Optional[Domain] = None) -> ExperimentSample:
- """Create a ExperimentSample object from a numpy array.
-
- Parameters
- ----------
- input_array : np.ndarray
- input 1D numpy array
- output_value : Optional[float], optional
- objective value, by default None
- jobnumber : int
- jobnumber of the design
- domain : Optional[Domain], optional
- domain of the design, by default None
-
- Returns
- -------
- ExperimentSample
- ExperimentSample object
-
- Note
- ----
- If no domain is given, the default parameter names are used.
- These are x0, x1, x2, etc. for input and y for output.
- """
- if domain is None:
- dict_input, dict_output = cls._from_numpy_without_domain(
- input_array=input_array, output_value=output_value)
-
- else:
- dict_input, dict_output = cls._from_numpy_with_domain(
- input_array=input_array, domain=domain,
- output_value=output_value)
-
- return cls(dict_input=dict_input,
- dict_output=dict_output, jobnumber=jobnumber)
-
- @classmethod
- def _from_numpy_with_domain(
- cls: Type[ExperimentSample],
- input_array: np.ndarray,
- domain: Domain,
- output_value: Optional[float] = None
- ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
-
- dict_input = {name: val for name,
- val in zip(domain.names, input_array)}
-
- if output_value is None:
- dict_output = {name: (np.nan, False)
- for name in domain.output_space.keys()}
- else:
- dict_output = {
- name: (output_value, False) for
- name in domain.output_space.keys()}
-
- return dict_input, dict_output
-
- @classmethod
- def _from_numpy_without_domain(
- cls: Type[ExperimentSample],
- input_array: np.ndarray,
- output_value: Optional[float] = None
- ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
-
- default_input_names = [f"x{i}" for i in range(len(input_array))]
- default_output_name = "y"
-
- dict_input = {
- name: val for name, val
- in zip(default_input_names, input_array)}
-
- if output_value is None:
- dict_output = {name: (np.nan, False)
- for name in default_output_name}
- else:
- dict_output = {default_output_name: (output_value, False)}
-
- return dict_input, dict_output
-
- def get(self, item: str,
- load_method: Optional[Type[StoreProtocol]] = None) -> Any:
- """Retrieve a sample parameter by its name.
-
- Parameters
- ----------
- item : str
- name of the parameter
- load_method : Optional[Type[_Store]], optional
- class of defined type to load the data. By default None, \
- will try to load the data with the default methods
-
- Returns
- -------
- Any
- Value of the parameter of the sample
- """
- # Load the value literally (even if it is a reference)
- value, from_disk = self._load_from_experimentdata(item)
-
- if not from_disk:
- return value
-
- if isinstance(value, float):
- # value is NaN
- return value
-
- # Load the object from the reference
- return load_object(Path(value),
- self._experimentdata_directory, load_method)
-
- def _load_from_experimentdata(self, item: str) -> Tuple[Any, bool]:
- """Load the data from the experiment data.
-
- Parameters
- ----------
- item : str
- key of the data to load
-
- Returns
- -------
- Tuple[Any, bool]
- data and if it is stored to disk or not
- """
- value = self._dict_input.get(item, None)
-
- if value is None:
- return self._dict_output.get(item, None)
- else:
- return value, False
-
- def __setitem__(self, key: str, value: Any):
- self._dict_output[key] = (value, False)
-
- def __repr__(self) -> str:
- return (f"ExperimentSample({self.job_number} ({self.jobs}) :"
- f"{self.input_data} - {self.output_data})")
-
- @property
- def input_data(self) -> Dict[str, Any]:
- """Retrieve the input data of the design as a dictionary.
-
- Returns
- -------
- Dict[str, Any]
- The input data of the design as a dictionary.
- """
- return self._dict_input
-
- _input_data = input_data
-
- @property
- def output_data(self) -> Dict[str, Any]:
- """Retrieve the output data of the design as a dictionary.
-
- Returns
- -------
- Dict[str, Any]
- The output data of the design as a dictionary.
- """
- # This is the loaded data !
- return {key: self.get(key) for key in self._dict_output}
-
- # create an alias for output_data names output_data_loaded
- # this is for backward compatibility
- output_data_loaded = output_data
-
- _output_data = output_data
-
- @property
- def output_data_with_references(self) -> Dict[str, Any]:
- """Retrieve the output data of the design as a dictionary, \
- but refrain from loading the data from disk and give the references.
-
- Note
- ----
- If you want to use the data, you can load it in memory with the \
- :func:`output_data` property.
-
- Returns
- -------
- Dict[str, Any]
- The output data of the design as a dictionary with references.
- """
- return {key: value for key, (value, _) in self._dict_output.items()}
-
- @property
- def job_number(self) -> int:
- """Retrieve the job number of the design.
-
- Returns
- -------
- int
- The job number of the design.
- """
- return self._jobnumber
-
- @property
- def jobs(self) -> Literal['finished', 'open']:
- """Retrieve the job status.
-
- Returns
- -------
- str
- The job number of the design as a tuple.
- """
- # Check if the output contains values or not all nan
- has_all_nan = np.all(np.isnan(list(self._output_data.values())))
-
- if self._output_data and not has_all_nan:
- status = 'finished'
- else:
- status = 'open'
-
- return status
-
- # Alias
- _jobs = jobs
-
-# Export
-# =============================================================================
-
- def to_numpy(self) -> Tuple[np.ndarray, np.ndarray]:
- """Converts the design to a tuple of numpy arrays.
-
- Returns
- -------
- Tuple[np.ndarray, np.ndarray]
- A tuple of numpy arrays containing the input and output data.
- """
- return np.array(list(self.input_data.values())), np.array(
- list(self.output_data.values()))
-
- def to_dict(self) -> Dict[str, Any]:
- """Converts the design to a dictionary.
-
- Returns
- -------
- Dict[str, Any]
- A dictionary containing the input and output data.
- """
- return {**self.input_data, **self.output_data,
- 'job_number': self.job_number}
-
- def store(self, name: str, object: Any, to_disk: bool = False,
- store_method: Optional[Type[StoreProtocol]] = None) -> None:
- """Store an object to disk.
-
- Parameters
- ----------
-
- name : str
- The name of the file to store the object in.
- object : Any
- The object to store.
- to_disk : bool, optional
- Whether to store the object to disk, by default False
- store_method : Store, optional
- The method to use to store the object, by default None
-
- Note
- ----
- If to_disk is True and no store_method is provided, the default store \
- method will be used.
-
- The default store method is saving the object as a pickle file (.pkl).
- """
- if to_disk:
- self._store_to_disk(object=object, name=name,
- store_method=store_method)
- else:
- self._store_to_experimentdata(object=object, name=name)
-
- def _store_to_disk(
- self, object: Any, name: str,
- store_method: Optional[Type[StoreProtocol]] = None) -> None:
- file_path = Path(name) / str(self.job_number)
-
- # Check if the file_dir exists
- (self._experimentdata_directory / Path(name)
- ).mkdir(parents=True, exist_ok=True)
-
- # Save the object to disk
- suffix = save_object(
- object=object, path=file_path,
- experimentdata_directory=self._experimentdata_directory,
- store_method=store_method)
-
- # Store the path to the object in the output_data
- self._dict_output[name] = (str(
- file_path.with_suffix(suffix)), True)
-
- logger.info(f"Stored {name} to {file_path.with_suffix(suffix)}")
-
- def _store_to_experimentdata(self, object: Any, name: str) -> None:
- self._dict_output[name] = (object, False)
-
-
-def _experimentsample_factory(
- experiment_sample: np.ndarray | ExperimentSample | Dict,
- domain: Domain | None) \
- -> ExperimentSample:
- """Factory function for the ExperimentSample class.
-
- Parameters
- ----------
- experiment_sample : np.ndarray | ExperimentSample | Dict
- The experiment sample to convert to an ExperimentSample.
- domain: Domain | None
- The domain of the experiment sample.
-
- Returns
- -------
- ExperimentSample
- The converted experiment sample.
- """
- if isinstance(experiment_sample, np.ndarray):
- return ExperimentSample.from_numpy(input_array=experiment_sample,
- domain=domain)
-
- elif isinstance(experiment_sample, dict):
- return ExperimentSample(dict_input=experiment_sample,
- dict_output={}, jobnumber=0)
-
- elif isinstance(experiment_sample, ExperimentSample):
- return experiment_sample
-
- else:
- raise TypeError(
- f"The experiment_sample should be a numpy array"
- f", dictionary or ExperimentSample, not {type(experiment_sample)}")
diff --git a/src/f3dasm/_src/experimentdata/samplers.py b/src/f3dasm/_src/experimentdata/samplers.py
deleted file mode 100644
index 307a58ec..00000000
--- a/src/f3dasm/_src/experimentdata/samplers.py
+++ /dev/null
@@ -1,465 +0,0 @@
-"""Base class for sampling methods"""
-
-# Modules
-# =============================================================================
-
-from __future__ import annotations
-
-# Standard
-from itertools import product
-from typing import Dict, Literal, Optional, Protocol
-
-# Third-party
-import numpy as np
-import pandas as pd
-from SALib.sample import latin as salib_latin
-from SALib.sample import sobol_sequence
-
-# Locals
-from ..design.domain import Domain
-from ._data import DataTypes
-
-# Authorship & Credits
-# =============================================================================
-__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
-__credits__ = ['Martin van der Schelling']
-__status__ = 'Stable'
-# =============================================================================
-#
-# =============================================================================
-
-SamplerNames = Literal['random', 'latin', 'sobol', 'grid']
-
-
-class Sampler(Protocol):
- """
- Interface class for samplers
- """
- def __call__(domain: Domain, **kwargs) -> DataTypes:
- ...
-
-# Factory function
-# =============================================================================
-
-
-def _sampler_factory(sampler: str, domain: Domain) -> Sampler:
- """
- Factory function for samplers
-
- Parameters
- ----------
- sampler : str
- name of the sampler
- domain : Domain
- domain object
-
- Returns
- -------
- Sampler
- sampler object
- """
- if sampler.lower() == 'random':
- return randomuniform
-
- elif sampler.lower() == 'latin':
- return latin
-
- elif sampler.lower() == 'sobol':
- return sobol
-
- elif sampler.lower() == 'grid':
- return grid
-
- else:
- raise KeyError(f"Sampler {sampler} not found!"
- f"Available built-in samplers are: 'random',"
- f"'latin' and 'sobol'")
-
-
-# Utility functions
-# =============================================================================
-
-def _stretch_samples(domain: Domain, samples: np.ndarray) -> np.ndarray:
- """Stretch samples to their boundaries
-
- Parameters
- ----------
- domain : Domain
- domain object
- samples : np.ndarray
- samples to stretch
-
- Returns
- -------
- np.ndarray
- stretched samples
- """
- for dim, param in enumerate(domain.space.values()):
- samples[:, dim] = (
- samples[:, dim] * (
- param.upper_bound - param.lower_bound
- ) + param.lower_bound
- )
-
- # If param.log is True, take the 10** of the samples
- if param.log:
- samples[:, dim] = 10**samples[:, dim]
-
- return samples
-
-
-def sample_constant(domain: Domain, n_samples: int):
- """Sample the constant parameters
-
- Parameters
- ----------
- domain : Domain
- domain object
- n_samples : int
- number of samples
-
- Returns
- -------
- np.ndarray
- samples
- """
- samples = np.array([param.value for param in domain.space.values()])
- return np.tile(samples, (n_samples, 1))
-
-
-def sample_np_random_choice(
- domain: Domain, n_samples: int,
- seed: Optional[int] = None, **kwargs):
- """Sample with np random choice
-
- Parameters
- ----------
- domain : Domain
- domain object
- n_samples : int
- number of samples
- seed : Optional[int], optional
- random seed, by default None
-
- Returns
- -------
- np.ndarray
- samples
- """
- rng = np.random.default_rng(seed)
- samples = np.empty(shape=(n_samples, len(domain)), dtype=object)
- for dim, param in enumerate(domain.space.values()):
- samples[:, dim] = rng.choice(
- param.categories, size=n_samples)
-
- return samples
-
-
-def sample_np_random_choice_range(
- domain: Domain, n_samples: int,
- seed: Optional[int] = None, **kwargs):
- """Samples with np random choice with a range of values
-
- Parameters
- ----------
- domain : Domain
- domain object
- n_samples : int
- number of samples
- seed : Optional[int], optional
- random seed, by default None
-
- Returns
- -------
- np.ndarray
- samples
- """
- samples = np.empty(shape=(n_samples, len(domain)), dtype=np.int32)
- rng = np.random.default_rng(seed)
- for dim, param in enumerate(domain.space.values()):
- samples[:, dim] = rng.choice(
- range(param.lower_bound,
- param.upper_bound + 1, param.step),
- size=n_samples,
- )
-
- return samples
-
-
-def sample_np_random_uniform(
- domain: Domain, n_samples: int,
- seed: Optional[int] = None, **kwargs) -> np.ndarray:
- """Sample with numpy random uniform
-
- Parameters
- ----------
- domain : Domain
- domain object
- n_samples : int
- number of samples
- seed : Optional[int], optional
- random seed, by default None
-
- Returns
- -------
- np.ndarray
- samples
- """
- rng = np.random.default_rng(seed)
- samples = rng.uniform(low=0.0, high=1.0, size=(n_samples, len(domain)))
-
- # stretch samples
- samples = _stretch_samples(domain, samples)
- return samples
-
-
-def sample_latin_hypercube(
- domain: Domain, n_samples: int,
- seed: Optional[int] = None, **kwargs) -> np.ndarray:
- """Sample with Latin Hypercube sampling
-
- Parameters
- ----------
- domain : Domain
- domain object
- n_samples : int
- number of samples
- seed : Optional[int], optional
- random seed, by default None
-
- Returns
- -------
- np.ndarray
- samples
- """
- problem = {
- "num_vars": len(domain),
- "names": domain.names,
- "bounds": [[s.lower_bound, s.upper_bound]
- for s in domain.space.values()],
- }
-
- samples = salib_latin.sample(problem, N=n_samples, seed=seed)
- return samples
-
-
-def sample_sobol_sequence(
- domain: Domain, n_samples: int, **kwargs) -> np.ndarray:
- """Sample with Sobol sequence sampling
-
- Parameters
- ----------
- domain : Domain
- domain object
- n_samples : int
- number of samples
-
- Returns
- -------
- np.ndarray
- samples
- """
- samples = sobol_sequence.sample(n_samples, len(domain))
-
- # stretch samples
- samples = _stretch_samples(domain, samples)
- return samples
-
-
-# Built-in samplers
-# =============================================================================
-
-
-def randomuniform(
- domain: Domain, n_samples: int, seed: int, **kwargs) -> DataTypes:
- """
- Random uniform sampling
-
- Parameters
- ----------
- domain : Domain
- domain object
- n_samples : int
- number of samples
- seed : int
- random seed for reproducibility
-
- Returns
- -------
- DataTypes
- input samples in one of the supported data types for the ExperimentData
- input data.
- """
- _continuous = sample_np_random_uniform(
- domain=domain.continuous, n_samples=n_samples,
- seed=seed)
-
- _discrete = sample_np_random_choice_range(
- domain=domain.discrete, n_samples=n_samples,
- seed=seed)
-
- _categorical = sample_np_random_choice(
- domain=domain.categorical, n_samples=n_samples,
- seed=seed)
-
- _constant = sample_constant(domain.constant, n_samples)
-
- df = pd.concat(
- [pd.DataFrame(_continuous, columns=domain.continuous.names),
- pd.DataFrame(_discrete, columns=domain.discrete.names),
- pd.DataFrame(
- _categorical, columns=domain.categorical.names),
- pd.DataFrame(_constant, columns=domain.constant.names)], axis=1
- )[domain.names]
-
- return df
-
-
-def grid(
- domain: Domain, stepsize_continuous_parameters:
- Optional[Dict[str, float] | float] = None, **kwargs) -> DataTypes:
- """Receive samples of the search space
-
- Parameters
- ----------
- n_samples : int
- number of samples
- stepsize_continuous_parameters : Dict[str, float] | float, optional
- stepsize for the continuous parameters, by default None.
- If a float is given, all continuous parameters are sampled with
- the same stepsize. If a dictionary is given, the stepsize for each
- continuous parameter can be specified.
-
- Returns
- -------
- DataTypes
- input samples in one of the supported data types for the ExperimentData
- input data.
-
- Raises
- ------
- ValueError
- If the stepsize_continuous_parameters is given as a dictionary
- and not specified for all continuous parameters.
- """
- continuous = domain.continuous
-
- if not continuous.space:
- discrete_space = continuous.space
-
- elif isinstance(stepsize_continuous_parameters, (float, int)):
- discrete_space = {name: param.to_discrete(
- step=stepsize_continuous_parameters)
- for name, param in continuous.space.items()}
-
- elif isinstance(stepsize_continuous_parameters, dict):
- discrete_space = {key: continuous.space[key].to_discrete(
- step=value) for key,
- value in stepsize_continuous_parameters.items()}
-
- if len(discrete_space) != len(domain.continuous):
- raise ValueError(
- "If you specify the stepsize for continuous parameters, \
- the stepsize_continuous_parameters should \
- contain all continuous parameters")
-
- continuous_to_discrete = Domain(discrete_space)
-
- _iterdict = {}
-
- for k, v in domain.categorical.space.items():
- _iterdict[k] = v.categories
-
- for k, v, in domain.discrete.space.items():
- _iterdict[k] = range(v.lower_bound, v.upper_bound+1, v.step)
-
- for k, v, in continuous_to_discrete.space.items():
- _iterdict[k] = np.arange(
- start=v.lower_bound, stop=v.upper_bound, step=v.step)
-
- df = pd.DataFrame(list(product(*_iterdict.values())),
- columns=_iterdict, dtype=object)[domain.names]
-
- return df
-
-
-def sobol(domain: Domain, n_samples: int, seed: int, **kwargs) -> DataTypes:
- """
- Sobol sequence sampling
-
- Parameters
- ----------
- domain : Domain
- domain object
- n_samples : int
- number of samples
- seed : int
- random seed for reproducibility
-
- Returns
- -------
- DataTypes
- input samples in one of the supported data types for the ExperimentData
- input data.
- """
- _continuous = sample_sobol_sequence(
- domain=domain.continuous, n_samples=n_samples)
-
- _discrete = sample_np_random_choice_range(
- domain=domain.discrete, n_samples=n_samples, seed=seed)
-
- _categorical = sample_np_random_choice(
- domain=domain.categorical, n_samples=n_samples, seed=seed)
-
- _constant = sample_constant(domain=domain.constant, n_samples=n_samples)
-
- df = pd.concat(
- [pd.DataFrame(_continuous, columns=domain.continuous.names),
- pd.DataFrame(_discrete, columns=domain.discrete.names),
- pd.DataFrame(
- _categorical, columns=domain.categorical.names),
- pd.DataFrame(_constant, columns=domain.constant.names)], axis=1
- )[domain.names]
-
- return df
-
-
-def latin(domain: Domain, n_samples: int, seed: int, **kwargs) -> DataTypes:
- """
- Latin Hypercube sampling
-
- Parameters
- ----------
- domain : Domain
- domain object
- n_samples : int
- number of samples
- seed : int
- random seed for reproducibility
-
- Returns
- -------
- DataTypes
- input samples in one of the supported data types for the ExperimentData
- input data.
- """
- _continuous = sample_latin_hypercube(
- domain=domain.continuous, n_samples=n_samples, seed=seed)
-
- _discrete = sample_np_random_choice_range(
- domain=domain.discrete, n_samples=n_samples, seed=seed)
-
- _categorical = sample_np_random_choice(
- domain=domain.categorical, n_samples=n_samples, seed=seed)
-
- _constant = sample_constant(domain=domain.constant, n_samples=n_samples)
-
- df = pd.concat(
- [pd.DataFrame(_continuous, columns=domain.continuous.names),
- pd.DataFrame(_discrete, columns=domain.discrete.names),
- pd.DataFrame(
- _categorical, columns=domain.categorical.names),
- pd.DataFrame(_constant, columns=domain.constant.names)], axis=1
- )[domain.names]
-
- return df
diff --git a/src/f3dasm/_src/experimentdata/utils.py b/src/f3dasm/_src/experimentdata/utils.py
deleted file mode 100644
index 46a0267c..00000000
--- a/src/f3dasm/_src/experimentdata/utils.py
+++ /dev/null
@@ -1,55 +0,0 @@
-"""
-Utility functions for the experimentdata module
-"""
-
-# Modules
-# =============================================================================
-
-from __future__ import annotations
-
-# Authorship & Credits
-# =============================================================================
-__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
-__credits__ = ['Martin van der Schelling']
-__status__ = 'Stable'
-# =============================================================================
-#
-
-
-def number_of_updates(iterations: int, population: int):
- """Calculate number of update steps to acquire the
- correct number of iterations
-
- Parameters
- ----------
- iterations
- number of desired iteration steps
- population
- the population size of the optimizer
-
- Returns
- -------
- number of consecutive update steps
- """
- return iterations // population + (iterations % population > 0)
-
-
-def number_of_overiterations(iterations: int, population: int) -> int:
- """Calculate the number of iterations that are over the iteration limit
-
- Parameters
- ----------
- iterations
- number of desired iteration steos
- population
- the population size of the optimizer
-
- Returns
- -------
- number of iterations that are over the limit
- """
- overiterations: int = iterations % population
- if overiterations == 0:
- return overiterations
- else:
- return population - overiterations
diff --git a/src/f3dasm/_src/experimentsample.py b/src/f3dasm/_src/experimentsample.py
new file mode 100644
index 00000000..1466bb6b
--- /dev/null
+++ b/src/f3dasm/_src/experimentsample.py
@@ -0,0 +1,545 @@
+"""
+A ExperimentSample object contains a single realization of
+ the design-of-experiment in ExperimentData.
+"""
+
+# Modules
+# =============================================================================
+
+from __future__ import annotations
+
+# Standard
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Dict, Literal, Optional, Tuple, Type
+
+# Third-party
+import autograd.numpy as np
+
+# Local
+from ._io import load_object
+from .design.domain import Domain
+
+# Authorship & Credits
+# =============================================================================
+__author__ = 'Martin van der Schelling (M.P.vanderSchelling@tudelft.nl)'
+__credits__ = ['Martin van der Schelling']
+__status__ = 'Stable'
+# =============================================================================
+
+
+class JobStatus(Enum):
+ OPEN = 0
+ IN_PROGRESS = 1
+ FINISHED = 2
+ ERROR = 3
+
+
+class ExperimentSample:
+ def __init__(self, input_data: Optional[Dict[str, Any]] = None,
+ output_data: Optional[Dict[str, Any]] = None,
+ domain: Optional[Domain] = None,
+ job_status: Optional[str] = None,
+ project_dir: Optional[Path] = None):
+ """
+ Realization of a single experiment in the design-of-experiment.
+
+ Parameters
+ ----------
+ input_data : Optional[Dict[str, Any]]
+ Input parameters of one experiment.
+ The key is the name of the parameter.
+ output_data : Optional[Dict[str, Any]]
+ Output parameters of one experiment.
+ The key is the name of the parameter.
+ domain : Optional[Domain]
+ Domain of the experiment, by default None.
+ job_status : Optional[str]
+ Job status of the experiment, by default None.
+ project_dir : Optional[Path]
+ Directory of the project, by default None.
+
+ Examples
+ --------
+ >>> sample = ExperimentSample(
+ ... input_data={'param1': 1.0},
+ ... output_data={'result1': 2.0}
+ ... )
+ >>> print(sample)
+ ExperimentSample(input_data={'param1': 1.0},
+ output_data={'result1': 2.0}, job_status=JobStatus.OPEN)
+ """
+ if input_data is None:
+ input_data = dict()
+
+ if output_data is None:
+ output_data = dict()
+
+ if domain is None:
+ domain = Domain()
+
+ if job_status is None:
+ if output_data:
+ job_status = 'FINISHED'
+ else:
+ job_status = 'OPEN'
+
+ if project_dir is None:
+ project_dir = Path.cwd()
+
+ self._input_data = input_data
+ self._output_data = output_data
+ self.domain = domain
+ self.job_status = JobStatus[job_status]
+ self.project_dir = project_dir
+
+ def __repr__(self):
+ """
+ Return a string representation of the ExperimentSample instance.
+
+ Returns
+ -------
+ str
+ String representation of the ExperimentSample instance.
+ """
+ return (f"ExperimentSample("
+ f"input_data={self.input_data}, "
+ f"output_data={self.output_data}, "
+ f"job_status={self.job_status})")
+
+ def __add__(self, __o: ExperimentSample) -> ExperimentSample:
+ """
+ Add two ExperimentSample instances.
+
+ Parameters
+ ----------
+ __o : ExperimentSample
+ Another ExperimentSample instance.
+
+ Returns
+ -------
+ ExperimentSample
+ A new ExperimentSample instance with combined input
+ and output data.
+
+ Notes
+ -----
+ The job status of the new ExperimentSample instance will be
+ reconstructed from the absence or presence of output data.
+ If output data is present, the job status will be 'FINISHED'.
+ Otherwise, the job status will be 'OPEN'.
+
+ Examples
+ --------
+ >>> sample1 = ExperimentSample(input_data={'param1': 1.0})
+ >>> sample2 = ExperimentSample(output_data={'result1': 2.0})
+ >>> combined_sample = sample1 + sample2
+ >>> print(combined_sample)
+ ExperimentSample(input_data={'param1': 1.0},
+ output_data={'result1': 2.0}, job_status=JobStatus.FINISHED)
+ """
+ return ExperimentSample(
+ input_data={**self._input_data, **__o._input_data},
+ output_data={**self._output_data, **__o._output_data},
+ domain=self.domain + __o.domain,
+ project_dir=self.project_dir,
+ )
+
+ def __eq__(self, __o: ExperimentSample) -> bool:
+ """
+ Check if two ExperimentSample instances are equal.
+
+ Parameters
+ ----------
+ __o : ExperimentSample
+ Another ExperimentSample instance.
+
+ Returns
+ -------
+ bool
+ True if the instances are equal, False otherwise.
+ """
+ return (self._input_data == __o._input_data
+ and self._output_data == __o._output_data
+ and self.job_status == __o.job_status)
+
+ @property
+ def input_data(self) -> Dict[str, Any]:
+ """
+ Get the input data of the experiment.
+
+ Returns
+ -------
+ Dict[str, Any]
+ Input data of the experiment.
+ """
+ return {k: self._get_input(k) for k in self._input_data}
+
+ @property
+ def output_data(self) -> Dict[str, Any]:
+ """
+ Get the output data of the experiment.
+
+ Returns
+ -------
+ Dict[str, Any]
+ Output data of the experiment.
+ """
+ return {k: self._get_output(k) for k in self._output_data}
+
+ # Alternative constructors
+ # =========================================================================
+
+ @classmethod
+ def from_numpy(cls: Type[ExperimentSample], input_array: np.ndarray,
+ domain: Optional[Domain] = None) -> ExperimentSample:
+ """
+ Create an ExperimentSample instance from a numpy array.
+ The input data will be stored in the input space of the domain.
+
+ Parameters
+ ----------
+ cls : Type[ExperimentSample]
+ The class type.
+ input_array : np.ndarray
+ Numpy array containing input data.
+ domain : Optional[Domain]
+ Domain of the experiment, by default None.
+
+ Returns
+ -------
+ ExperimentSample
+ A new ExperimentSample instance.
+
+ Notes
+ -----
+ If no domain is provided, the default names will be 'x0', 'x1', etc.
+
+ Examples
+ --------
+ >>> import numpy as np
+ >>> sample = ExperimentSample.from_numpy(np.array([1.0, 2.0]))
+ >>> print(sample)
+ ExperimentSample(input_data={'x0': 1.0, 'x1': 2.0},
+ output_data={}, job_status=JobStatus.OPEN)
+ """
+ if domain is None:
+ n_dim = input_array.flatten().shape[0]
+ domain = Domain()
+ for i in range(n_dim):
+ domain.add_float(name=f'x{i}')
+
+ return cls(input_data={input_name: v for input_name, v in
+ zip(domain.input_space.keys(),
+ input_array.flatten())},
+ domain=domain,)
+ # Getters
+ # =========================================================================
+
+ def get(self, name: str) -> Any:
+ """
+ Get the value of a parameter by name.
+
+ Parameters
+ ----------
+ name : str
+ The name of the parameter.
+
+ Returns
+ -------
+ Any
+ The value of the parameter.
+
+ Raises
+ ------
+ KeyError
+ If the parameter is not found in input or output data.
+
+ Examples
+ --------
+ >>> sample = ExperimentSample(input_data={'param1': 1.0})
+ >>> sample.get('param1')
+ 1.0
+ """
+ value = self._get_input(name)
+
+ if value is not None:
+ return value
+
+ value = self._get_output(name)
+
+ if value is not None:
+ return value
+
+ raise KeyError(f"Parameter {name} not found in input or output data.")
+
+ def _get_input(self, name: str) -> Any:
+ """
+ Get the value of an input parameter by name.
+
+ Parameters
+ ----------
+ name : str
+ The name of the input parameter.
+
+ Returns
+ -------
+ Any
+ The value of the input parameter, or None if not found.
+ """
+ if name not in self.domain.input_names:
+ return None
+
+ parameter = self.domain.input_space[name]
+
+ if parameter.to_disk:
+ return load_object(project_dir=self.project_dir,
+ path=self._input_data[name],
+ load_function=parameter.load_function)
+ else:
+ return self._input_data[name]
+
+ def _get_output(self, name: str) -> Any:
+ """
+ Get the value of an output parameter by name.
+
+ Parameters
+ ----------
+ name : str
+ The name of the output parameter.
+
+ Returns
+ -------
+ Any
+ The value of the output parameter, or None if not found.
+ """
+ if name not in self.domain.output_names:
+ return None
+
+ parameter = self.domain.output_space[name]
+
+ if parameter.to_disk:
+ return load_object(project_dir=self.project_dir,
+ path=self._output_data[name],
+ load_function=parameter.load_function)
+ else:
+ return self._output_data[name]
+
+ # Setters
+ # =========================================================================
+
+ def mark(self,
+ status: Literal['open', 'in_progress', 'finished', 'error']):
+ """
+ Mark the job status of the experiment.
+
+ Parameters
+ ----------
+ status : Literal['open', 'in_progress', 'finished', 'error']
+ The new job status.
+
+ Raises
+ ------
+ ValueError
+ If the status is not valid.
+
+ Examples
+ --------
+ >>> sample = ExperimentSample()
+ >>> sample.mark('finished')
+ >>> sample.job_status
+