diff --git a/.github/workflows/test-pytest.yml b/.github/workflows/test-pytest.yml index 3ce245e0..4c7aeab7 100644 --- a/.github/workflows/test-pytest.yml +++ b/.github/workflows/test-pytest.yml @@ -26,4 +26,4 @@ jobs: python-version: ${{ matrix.python-version }} cache: "pip" - run: pip install ".[test]" - - run: pytest --doctest-modules + - run: pytest --doctest-modules --import-mode importlib diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index e3649715..600c860e 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,6 +1,6 @@ repos: - repo: https://github.com/ambv/black - rev: 22.12.0 + rev: 23.7.0 hooks: - id: black - repo: https://github.com/pycqa/isort @@ -11,7 +11,7 @@ repos: - "--filter-files" - "--project=autora" - repo: https://github.com/pycqa/flake8 - rev: 6.0.0 + rev: 6.1.0 hooks: - id: flake8 args: @@ -19,7 +19,7 @@ repos: - "--extend-ignore=E203" - "--per-file-ignores=__init__.py:F401" - repo: https://github.com/pre-commit/mirrors-mypy - rev: "v0.991" + rev: "v1.5.1" hooks: - id: mypy additional_dependencies: [types-requests,scipy,pytest] diff --git a/docs/cycle/Basic Introduction to Functions and States.ipynb b/docs/cycle/Basic Introduction to Functions and States.ipynb new file mode 100644 index 00000000..a41bf38a --- /dev/null +++ b/docs/cycle/Basic Introduction to Functions and States.ipynb @@ -0,0 +1,747 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Basic Introduction to Functions and States" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the functions and objects in `autora.state`, we can build flexible pipelines and cycles which operate on state\n", + "objects.\n", + "\n", + "## Theoretical Overview\n", + "\n", + "The fundamental idea is this:\n", + "- We define a \"state\" object $S$ which can be modified with a \"delta\" (a new result) $\\Delta S$.\n", + "- A new state at some point $i+1$ is $$S_{i+1} = S_i + \\Delta S_{i+1}$$\n", + "- The cycle state after $n$ steps is thus $$S_n = S_{0} + \\sum^{n}_{i=1} \\Delta S_{i}$$\n", + "\n", + "To represent $S$ and $\\Delta S$ in code, you can use `autora.state.State` and `autora.state.Delta`\n", + "respectively. To operate on these, we define functions.\n", + "\n", + "- Each operation in an AER cycle (theorist, experimentalist, experiment_runner, etc.) is implemented as a\n", + "function with $n$ arguments $s_j$ which are members of $S$ and $m$ others $a_k$ which are not.\n", + " $$ f(s_0, ..., s_n, a_0, ..., a_m) \\rightarrow \\Delta S_{i+1}$$\n", + "- There is a wrapper function $w$ (`autora.state.wrap_to_use_state`) which changes the signature of $f$ to\n", + "require $S$ and aggregates the resulting $\\Delta S_{i+1}$\n", + " $$w\\left[f(s_0, ..., s_n, a_0, ..., a_m) \\rightarrow \\Delta\n", + "S_{i+1}\\right] \\rightarrow \\left[ f^\\prime(S_i, a_0, ..., a_m) \\rightarrow S_{i} + \\Delta\n", + "S_{i+1} = S_{i+1}\\right]$$\n", + "\n", + "- Assuming that the other arguments $a_k$ are provided by partial evaluation of the $f^\\prime$, the full AER cycle can\n", + "then be represented as:\n", + " $$S_n = f_n^\\prime(...f_2^\\prime(f_1^\\prime(S_0)))$$\n", + "\n", + "There are additional helper functions to wrap common experimentalists, experiment runners and theorists so that we\n", + "can define a full AER cycle using python notation as shown in the following example." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example\n", + "\n", + "First initialize the State. In this case, we use the pre-defined `StandardState` which implements the standard AER\n", + "naming convention.\n", + "There are two variables `x` with a range [-10, 10] and `y` with an unspecified range." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from autora.state import StandardState\n", + "from autora.variable import VariableCollection, Variable\n", + "\n", + "s_0 = StandardState(\n", + " variables=VariableCollection(\n", + " independent_variables=[Variable(\"x\", value_range=(-10, 10))],\n", + " dependent_variables=[Variable(\"y\")]\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specify the experimentalist. Use a standard function `random_pool`.\n", + "This gets 5 independent random samples (by default, configurable using an argument)\n", + "from the value_range of the independent variables, and returns them in a DataFrame.\n", + "To make this work as a function on the State objects, we wrap it in the `on_state` function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StandardState(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-10, 10), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), conditions= x\n", + "0 5.479121\n", + "1 -1.222431\n", + "2 7.171958\n", + "3 3.947361\n", + "4 -8.116453, experiment_data=None, models=[])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from autora.experimentalist.random_ import random_pool\n", + "from autora.state import on_state\n", + "\n", + "experimentalist = on_state(function=random_pool, output=[\"conditions\"])\n", + "s_1 = experimentalist(s_0, random_state=42)\n", + "s_1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specify the experiment runner. This calculates a linear function, adds noise, assigns the value to the `y` column\n", + " in a new DataFrame." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StandardState(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-10, 10), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), conditions= x\n", + "0 5.479121\n", + "1 -1.222431\n", + "2 7.171958\n", + "3 3.947361\n", + "4 -8.116453, experiment_data= x y\n", + "0 5.479121 24.160713\n", + "1 -1.222431 -2.211546\n", + "2 7.171958 30.102304\n", + "3 3.947361 16.880769\n", + "4 -8.116453 -32.457650, models=[])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from autora.state import on_state\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "\n", + "@on_state(output=[\"experiment_data\"])\n", + "def experiment_runner(conditions: pd.DataFrame, c=[2, 4], random_state = None):\n", + " rng = np.random.default_rng(random_state)\n", + " x = conditions[\"x\"]\n", + " noise = rng.normal(0, 1, len(x))\n", + " y = c[0] + (c[1] * x) + noise\n", + " observations = conditions.assign(y = y)\n", + " return observations\n", + "\n", + "# Which does the following:\n", + "experiment_runner(s_1, random_state=43)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A completely analogous definition, using the separate `@inputs_from_state` and `@outputs_to_delta(...)` decorators\n", + "rather than the combined `@on_state(...)` decorator would be:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StandardState(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-10, 10), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), conditions= x\n", + "0 5.479121\n", + "1 -1.222431\n", + "2 7.171958\n", + "3 3.947361\n", + "4 -8.116453, experiment_data= x y\n", + "0 5.479121 24.221201\n", + "1 -1.222431 -3.929709\n", + "2 7.171958 31.438285\n", + "3 3.947361 18.730007\n", + "4 -8.116453 -32.416847, models=[])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from autora.state import inputs_from_state, outputs_to_delta\n", + "\n", + "\n", + "@inputs_from_state\n", + "@outputs_to_delta(\"experiment_data\")\n", + "def experiment_runner_alt_1(conditions: pd.DataFrame, c=[2, 4], random_state=None):\n", + " x = conditions[\"x\"]\n", + " rng = np.random.default_rng(random_state)\n", + " noise = rng.normal(0, 1, len(x))\n", + " y = c[0] + (c[1] * x) + noise\n", + " xy = conditions.assign(y = y)\n", + " return xy\n", + "\n", + "# Which does the following:\n", + "experiment_runner_alt_1(s_1, random_state=42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Or alternatively:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StandardState(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-10, 10), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), conditions= x\n", + "0 5.479121\n", + "1 -1.222431\n", + "2 7.171958\n", + "3 3.947361\n", + "4 -8.116453, experiment_data= x y\n", + "0 5.479121 24.372288\n", + "1 -1.222431 -1.583178\n", + "2 7.171958 30.032529\n", + "3 3.947361 16.745934\n", + "4 -8.116453 -31.388814, models=[])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def experiment_runner_alt_2_core(conditions: pd.DataFrame, c=[2, 4], random_state=None):\n", + " x = conditions[\"x\"]\n", + " rng = np.random.default_rng(random_state)\n", + " noise = rng.normal(0, 1, len(x))\n", + " y = c[0] + (c[1] * x) + noise\n", + " xy = conditions.assign(y = y)\n", + " return xy\n", + "\n", + "experiment_runner_alt_2 = on_state(experiment_runner_alt_2_core, output=[\"experiment_data\"])\n", + "experiment_runner_alt_2(s_1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specify a theorist, using a standard LinearRegression from scikit-learn." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LinearRegression\n", + "from autora.state import estimator_on_state\n", + "\n", + "theorist = estimator_on_state(LinearRegression(fit_intercept=True))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can run the theorist on the output from the experiment_runner,\n", + "which itself uses the output from the experimentalist." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StandardState(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-10, 10), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), conditions= x\n", + "0 6.159515\n", + "1 -7.713961\n", + "2 -0.655764\n", + "3 9.297426\n", + "4 2.601009, experiment_data= x y\n", + "0 6.159515 27.502964\n", + "1 -7.713961 -30.950686\n", + "2 -0.655764 -1.488309\n", + "3 9.297426 38.992089\n", + "4 2.601009 13.351848, models=[LinearRegression()])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "theorist(experiment_runner(experimentalist(s_0)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we like, we can run the experimentalist, experiment_runner and theorist ten times." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "s_ = s_0\n", + "for i in range(10):\n", + " s_ = experimentalist(s_, random_state=180+i)\n", + " s_ = experiment_runner(s_, random_state=2*180+i)\n", + " s_ = theorist(s_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The experiment_data has 50 entries (10 cycles and 5 samples per cycle):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
xy
01.5211278.997542
13.36212015.339784
21.0653915.938495
3-5.844244-21.453802
4-6.444732-24.975886
55.72458524.929289
61.7818059.555725
7-1.015081-2.632280
82.04408312.001204
97.70932430.806166
10-6.680454-24.846327
11-3.630735-11.346701
12-0.4983221.794183
13-4.043702-15.594289
145.77286525.094876
159.02893137.677228
168.05263734.472556
173.77411516.791553
18-8.405662-31.734315
195.43350622.975112
20-9.644367-36.919598
211.6731317.548614
227.60031632.294054
234.35466620.998850
246.04727326.670616
25-5.608438-20.570161
260.7338905.029705
27-2.781912-9.190651
28-2.308464-6.179939
29-3.547105-12.875100
300.9450896.013183
312.69489714.141356
327.44589331.312279
334.42310519.647015
342.20096111.587911
35-4.915881-17.061782
36-2.997968-10.397403
370.0994544.949820
38-3.924786-13.532503
397.05095031.085545
40-8.077780-31.084307
414.39148117.991533
426.74916230.242121
432.24680410.411612
444.47798919.571584
45-0.2627341.181040
46-7.187250-26.718313
47-0.7909850.058681
486.54533427.510641
49-7.185274-26.510872
\n", + "
" + ], + "text/plain": [ + " x y\n", + "0 1.521127 8.997542\n", + "1 3.362120 15.339784\n", + "2 1.065391 5.938495\n", + "3 -5.844244 -21.453802\n", + "4 -6.444732 -24.975886\n", + "5 5.724585 24.929289\n", + "6 1.781805 9.555725\n", + "7 -1.015081 -2.632280\n", + "8 2.044083 12.001204\n", + "9 7.709324 30.806166\n", + "10 -6.680454 -24.846327\n", + "11 -3.630735 -11.346701\n", + "12 -0.498322 1.794183\n", + "13 -4.043702 -15.594289\n", + "14 5.772865 25.094876\n", + "15 9.028931 37.677228\n", + "16 8.052637 34.472556\n", + "17 3.774115 16.791553\n", + "18 -8.405662 -31.734315\n", + "19 5.433506 22.975112\n", + "20 -9.644367 -36.919598\n", + "21 1.673131 7.548614\n", + "22 7.600316 32.294054\n", + "23 4.354666 20.998850\n", + "24 6.047273 26.670616\n", + "25 -5.608438 -20.570161\n", + "26 0.733890 5.029705\n", + "27 -2.781912 -9.190651\n", + "28 -2.308464 -6.179939\n", + "29 -3.547105 -12.875100\n", + "30 0.945089 6.013183\n", + "31 2.694897 14.141356\n", + "32 7.445893 31.312279\n", + "33 4.423105 19.647015\n", + "34 2.200961 11.587911\n", + "35 -4.915881 -17.061782\n", + "36 -2.997968 -10.397403\n", + "37 0.099454 4.949820\n", + "38 -3.924786 -13.532503\n", + "39 7.050950 31.085545\n", + "40 -8.077780 -31.084307\n", + "41 4.391481 17.991533\n", + "42 6.749162 30.242121\n", + "43 2.246804 10.411612\n", + "44 4.477989 19.571584\n", + "45 -0.262734 1.181040\n", + "46 -7.187250 -26.718313\n", + "47 -0.790985 0.058681\n", + "48 6.545334 27.510641\n", + "49 -7.185274 -26.510872" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s_.experiment_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The fitted coefficients are close to the original intercept = 2, gradient = 4" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2.08476524] [[4.00471062]]\n" + ] + } + ], + "source": [ + "print(s_.model.intercept_, s_.model.coef_)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/docs/cycle/Combining Experimentalists with State.ipynb b/docs/cycle/Combining Experimentalists with State.ipynb new file mode 100644 index 00000000..a7d6680a --- /dev/null +++ b/docs/cycle/Combining Experimentalists with State.ipynb @@ -0,0 +1,2643 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Building Mixture Experimentalists\n", + "\n", + "## Introduction\n", + "\n", + "One thing the State/Delta mechanism should support is making more complex experimentalists which combine others.\n", + "One example which have been suggested by the AER group are a \"mixture experimentalist\" which weights the outputs of\n", + "other experimentalists.\n", + "\n", + "How experimentalists are typically defined has a major impact on whether this kind of mixture experimentalist is easy\n", + " or hard to implement. Since the research group is currently (August 2023) deciding how experimentalists should\n", + " generally be defined, now seems a good time to look at the different basic options for standards & conventions.\n", + "\n", + "To help the discussion, here we've put together some examples based on some toy experimentalists.\n", + "\n", + "### Outline of the Open Question\n", + "The question has to do with whether \"additional data\" beyond the conditions are included in the same or a different\n", + "data array.\n", + " (\"Additional data\" are data which are generated by the experimentalist and potentially needed by another\n", + " experimentalist down the line, but are not the conditions themselves).\n", + "\n", + "The two competing conventions are if an experimentalist returns some extra data:\n", + "- They are included in the `conditions` array as additional columns, _or_\n", + "- They are passed as a _different_ array alongside the `conditions`.\n", + "\n", + "### Notebook Outline\n", + "\n", + "The examples are organized as follows:\n", + "\n", + "- A combination experimentalist which aggregates additional measures from the component experimentalists.\n", + " - Where the measure is passed back in the conditions array, or\n", + " - Where the measure is passed back in a separate array\n", + "- A combination experimentalist where the components need the full State as they have complex arguments\n", + "\n", + "\n", + "### Toy Experimentalists\n", + "\n", + "We're combining experimentalists which samples conditions based on whether they are downvoted (or not)\n", + "according to some criteria:\n", + "- The \"Avoid Negative\" experimentalist, which downvotes conditions which have negative values (with one downvote per\n", + "negative value in the conditions $x_i$: if both $x_1$ and $x_2$ are negative, the condition gets 2 downvotes, and so\n", + "on) and returns all the conditions in the \"preferred\" order (fewest downvotes first),\n", + "- The \"Avoid Even\" experimentalist, which downvotes conditions which are closer to even numbers more (with one downvote\n", + "per even value in the conditions and half a downvote if a condition is $1/2$ away from an even number) and returns all the conditions in the \"preferred\" order,\n", + "- The \"Avoid Repeat\" experimentalist, which downvotes conditions which have already been seen based on the number of\n", + "times a condition has been seen and returns all the conditions in the \"preferred\" order,\n", + "- The \"Combine Downvotes\" experimentalist, which sums the downvotes of the others and returns the top $n$ \"preferred\"\n", + "conditions\n", + "(with the fewest downvotes); in the case of a tie, it returns conditions the order of the original conditions list.\n", + "\n", + "\n", + "We also need to see what happens when we:\n", + "- Try to extend a dataframe with an extra data frame which has new columns." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Combination Experimentalist which Aggregates Measures" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Returns an extended conditions array" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List, Optional\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from autora.variable import VariableCollection, Variable" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2
0-3.0-1.0
1-2.00.0
2-1.01.0
30.02.0
41.03.0
52.04.0
63.05.0
\n", + "
" + ], + "text/plain": [ + " x1 x2\n", + "0 -3.0 -1.0\n", + "1 -2.0 0.0\n", + "2 -1.0 1.0\n", + "3 0.0 2.0\n", + "4 1.0 3.0\n", + "5 2.0 4.0\n", + "6 3.0 5.0" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "conditions_ = pd.DataFrame({\"x1\": np.linspace(-3, 3, 7), \"x2\": np.linspace(-1, 5, 7)})\n", + "conditions_" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2downvotes
30.02.00
41.03.00
52.04.00
63.05.00
1-2.00.01
2-1.01.01
0-3.0-1.02
\n", + "
" + ], + "text/plain": [ + " x1 x2 downvotes\n", + "3 0.0 2.0 0\n", + "4 1.0 3.0 0\n", + "5 2.0 4.0 0\n", + "6 3.0 5.0 0\n", + "1 -2.0 0.0 1\n", + "2 -1.0 1.0 1\n", + "0 -3.0 -1.0 2" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def avoid_negative(conditions: pd.DataFrame):\n", + " downvotes = (conditions_ < 0).sum(axis=1)\n", + " with_votes = pd.DataFrame.assign(conditions, downvotes=downvotes)\n", + " with_votes_sorted = with_votes.sort_values(by=\"downvotes\", ascending=True)\n", + " return with_votes_sorted\n", + "\n", + "avoid_negative(conditions_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Avoid-even function')" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def avoid_even_function(x):\n", + " y = 1 - np.minimum(np.mod(x, 2), np.mod(-x, 2))\n", + " return y\n", + "\n", + "x = np.linspace(-1, 4, 101)\n", + "plt.plot(x, avoid_even_function(x))\n", + "plt.title(\"Avoid-even function\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2downvotes
0-3.0-1.00.0
2-1.01.00.0
41.03.00.0
63.05.00.0
1-2.00.02.0
30.02.02.0
52.04.02.0
\n", + "
" + ], + "text/plain": [ + " x1 x2 downvotes\n", + "0 -3.0 -1.0 0.0\n", + "2 -1.0 1.0 0.0\n", + "4 1.0 3.0 0.0\n", + "6 3.0 5.0 0.0\n", + "1 -2.0 0.0 2.0\n", + "3 0.0 2.0 2.0\n", + "5 2.0 4.0 2.0" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def avoid_even(conditions: pd.DataFrame):\n", + " downvotes = avoid_even_function(conditions_).sum(axis=1)\n", + " with_votes = pd.DataFrame.assign(conditions, downvotes=downvotes)\n", + " with_votes_sorted = with_votes.sort_values(by=\"downvotes\", ascending=True)\n", + " return with_votes_sorted\n", + "\n", + "avoid_even(conditions_)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x20.downvotes1.downvotesdownvotes
0-3.0-1.0101
1-2.00.0112
2-1.01.0123
30.02.0134
41.03.0145
52.04.0156
63.05.0167
\n", + "
" + ], + "text/plain": [ + " x1 x2 0.downvotes 1.downvotes downvotes\n", + "0 -3.0 -1.0 1 0 1\n", + "1 -2.0 0.0 1 1 2\n", + "2 -1.0 1.0 1 2 3\n", + "3 0.0 2.0 1 3 4\n", + "4 1.0 3.0 1 4 5\n", + "5 2.0 4.0 1 5 6\n", + "6 3.0 5.0 1 6 7" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def combine_downvotes(conditions, *arrays: pd.DataFrame):\n", + " result = conditions.copy()\n", + " for i, a in enumerate(arrays):\n", + " a_name = a.attrs.get(\"name\", i)\n", + " result[f\"{a_name}.downvotes\"] = a.downvotes\n", + " result[\"downvotes\"] = result.loc[:,result.columns.str.contains('.*\\.downvotes')].sum(axis=1)\n", + " return result\n", + "\n", + "combine_downvotes(\n", + " conditions_,\n", + " conditions_.assign(downvotes=1),\n", + " conditions_.assign(downvotes=[0, 1, 2, 3, 4, 5, 6]).sample(frac=1)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2downvotes
0-3.0-1.00.0
1-2.00.00.0
2-1.01.00.0
30.02.00.0
41.03.00.0
52.04.00.0
63.05.00.0
\n", + "
" + ], + "text/plain": [ + " x1 x2 downvotes\n", + "0 -3.0 -1.0 0.0\n", + "1 -2.0 0.0 0.0\n", + "2 -1.0 1.0 0.0\n", + "3 0.0 2.0 0.0\n", + "4 1.0 3.0 0.0\n", + "5 2.0 4.0 0.0\n", + "6 3.0 5.0 0.0" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def downvote_order(conditions: pd.DataFrame, experimentalists: List):\n", + " downvoted_conditions = []\n", + " for e in experimentalists:\n", + " new_downvoted_conditions = e(conditions)\n", + " new_downvoted_conditions.attrs[\"name\"] = e.__name__\n", + " downvoted_conditions.append(new_downvoted_conditions)\n", + " result = combine_downvotes(conditions, *downvoted_conditions)\n", + " result = result.sort_values(by=\"downvotes\", ascending=True)\n", + " return result\n", + "\n", + "downvote_order(conditions_, experimentalists=[])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2avoid_negative.downvotesdownvotes
30.02.000
41.03.000
52.04.000
63.05.000
1-2.00.011
2-1.01.011
0-3.0-1.022
\n", + "
" + ], + "text/plain": [ + " x1 x2 avoid_negative.downvotes downvotes\n", + "3 0.0 2.0 0 0\n", + "4 1.0 3.0 0 0\n", + "5 2.0 4.0 0 0\n", + "6 3.0 5.0 0 0\n", + "1 -2.0 0.0 1 1\n", + "2 -1.0 1.0 1 1\n", + "0 -3.0 -1.0 2 2" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "downvote_order(conditions_, experimentalists=[avoid_negative])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2avoid_negative.downvotesavoid_even.downvotesdownvotes
41.03.000.00.0
63.05.000.00.0
2-1.01.010.01.0
0-3.0-1.020.02.0
30.02.002.02.0
52.04.002.02.0
1-2.00.012.03.0
\n", + "
" + ], + "text/plain": [ + " x1 x2 avoid_negative.downvotes avoid_even.downvotes downvotes\n", + "4 1.0 3.0 0 0.0 0.0\n", + "6 3.0 5.0 0 0.0 0.0\n", + "2 -1.0 1.0 1 0.0 1.0\n", + "0 -3.0 -1.0 2 0.0 2.0\n", + "3 0.0 2.0 0 2.0 2.0\n", + "5 2.0 4.0 0 2.0 2.0\n", + "1 -2.0 0.0 1 2.0 3.0" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "downvote_order(conditions_, experimentalists=[avoid_negative, avoid_even])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Adding this dataframe to a State object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2avoid_negative.downvotesavoid_even.downvotesdownvotes
41.03.000.00.0
63.05.000.00.0
2-1.01.010.01.0
0-3.0-1.020.02.0
30.02.002.02.0
52.04.002.02.0
1-2.00.012.03.0
\n", + "
" + ], + "text/plain": [ + " x1 x2 avoid_negative.downvotes avoid_even.downvotes downvotes\n", + "4 1.0 3.0 0 0.0 0.0\n", + "6 3.0 5.0 0 0.0 0.0\n", + "2 -1.0 1.0 1 0.0 1.0\n", + "0 -3.0 -1.0 2 0.0 2.0\n", + "3 0.0 2.0 0 2.0 2.0\n", + "5 2.0 4.0 0 2.0 2.0\n", + "1 -2.0 0.0 1 2.0 3.0" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from autora.state import Delta, on_state, State, StandardState, inputs_from_state\n", + "\n", + "s = StandardState() + Delta(conditions=downvote_order(conditions_, experimentalists=[avoid_negative, avoid_even]))\n", + "s.conditions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Return a separate array of additional measures\n", + "\n", + "To ensure we don't mix up the order of return values and to facilitate updating the returned values in future without\n", + " breaking dependents functions when returning multiple objects, we return a structured object –\n", + "in this case a simple dictionary of results. (We could just as well use a `UserDict` or a `Delta` object for this\n", + "purpose – they have the same interface.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2
30.02.0
41.03.0
52.04.0
63.05.0
1-2.00.0
2-1.01.0
0-3.0-1.0
\n", + "
" + ], + "text/plain": [ + " x1 x2\n", + "3 0.0 2.0\n", + "4 1.0 3.0\n", + "5 2.0 4.0\n", + "6 3.0 5.0\n", + "1 -2.0 0.0\n", + "2 -1.0 1.0\n", + "0 -3.0 -1.0" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def avoid_negative_separate(conditions: pd.DataFrame):\n", + " downvotes = (conditions_ < 0).sum(axis=1).sort_values(ascending=True)\n", + " conditions_sorted = pd.DataFrame(conditions, index=downvotes.index)\n", + " return {\"conditions\": conditions_sorted, \"downvotes\": downvotes}\n", + "\n", + "avoid_negative_separate(conditions_)[\"conditions\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "( x1 x2\n", + " 0 -3.0 -1.0\n", + " 2 -1.0 1.0\n", + " 4 1.0 3.0\n", + " 6 3.0 5.0\n", + " 1 -2.0 0.0\n", + " 3 0.0 2.0\n", + " 5 2.0 4.0,\n", + " 0 0.0\n", + " 2 0.0\n", + " 4 0.0\n", + " 6 0.0\n", + " 1 2.0\n", + " 3 2.0\n", + " 5 2.0\n", + " dtype: float64)" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def avoid_even_separate(conditions: pd.DataFrame):\n", + " downvotes = avoid_even_function(conditions_).sum(axis=1).sort_values(ascending=True)\n", + " conditions_sorted = pd.DataFrame(conditions, index=downvotes.index)\n", + " return {\"conditions\": conditions_sorted, \"downvotes\": downvotes}\n", + "\n", + "avoid_even_separate(conditions_)[\"conditions\"], avoid_even_separate(conditions_)[\"downvotes\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'conditions': x1 x2\n", + " 0 -3.0 -1.0\n", + " 1 -2.0 0.0\n", + " 2 -1.0 1.0\n", + " 3 0.0 2.0\n", + " 4 1.0 3.0\n", + " 5 2.0 4.0\n", + " 6 3.0 5.0,\n", + " 'downvotes': initial total\n", + " 0 0 0\n", + " 1 0 0\n", + " 2 0 0\n", + " 3 0 0\n", + " 4 0 0\n", + " 5 0 0\n", + " 6 0 0}" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def downvote_order_separate(conditions: pd.DataFrame, experimentalists: List):\n", + " downvote_arrays = {\"initial\": pd.Series(0, index=conditions.index)}\n", + " for e in experimentalists:\n", + " downvote_arrays[e.__name__] = e(conditions)[\"downvotes\"]\n", + " combined_downvotes = pd.DataFrame(downvote_arrays)\n", + " combined_downvotes[\"total\"] = combined_downvotes.sum(axis=1)\n", + " combined_downvotes_sorted = combined_downvotes.sort_values(by=\"total\", ascending=True)\n", + " conditions_sorted = pd.DataFrame(conditions, index=combined_downvotes_sorted.index)\n", + " return {\n", + " \"conditions\": conditions_sorted,\n", + " \"downvotes\": combined_downvotes_sorted,\n", + " }\n", + "\n", + "downvote_order_separate(conditions_, experimentalists=[])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2initialavoid_even_separateavoid_negative_separatetotal
0-3.0-1.000.022.0
1-2.00.002.013.0
2-1.01.000.011.0
30.02.002.002.0
41.03.000.000.0
52.04.002.002.0
63.05.000.000.0
\n", + "
" + ], + "text/plain": [ + " x1 x2 initial avoid_even_separate avoid_negative_separate total\n", + "0 -3.0 -1.0 0 0.0 2 2.0\n", + "1 -2.0 0.0 0 2.0 1 3.0\n", + "2 -1.0 1.0 0 0.0 1 1.0\n", + "3 0.0 2.0 0 2.0 0 2.0\n", + "4 1.0 3.0 0 0.0 0 0.0\n", + "5 2.0 4.0 0 2.0 0 2.0\n", + "6 3.0 5.0 0 0.0 0 0.0" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results = downvote_order_separate(conditions_, experimentalists=[avoid_even_separate, avoid_negative_separate])\n", + "\n", + "pd.DataFrame.join(results[\"conditions\"], results[\"downvotes\"]).sort_index()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Combination Experimentalist Needing The Full State\n", + "In this case, we have at least one component-experimentalist which needs the full state.\n", + "\n", + "### Experimentalists Return Combined Results and Measures" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2downvotes
0-3.0-1.02.0
1-2.00.00.0
2-1.01.00.0
30.02.00.0
41.03.00.0
52.04.00.0
63.05.01.0
\n", + "
" + ], + "text/plain": [ + " x1 x2 downvotes\n", + "0 -3.0 -1.0 2.0\n", + "1 -2.0 0.0 0.0\n", + "2 -1.0 1.0 0.0\n", + "3 0.0 2.0 0.0\n", + "4 1.0 3.0 0.0\n", + "5 2.0 4.0 0.0\n", + "6 3.0 5.0 1.0" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def avoid_repeat(conditions, experiment_data: pd.DataFrame, variables: VariableCollection):\n", + " iv_column_names = [v.name for v in variables.independent_variables]\n", + " count_already_seen = pd.Series(experiment_data.groupby(iv_column_names).size(), name=\"downvotes\")\n", + " conditions = pd.DataFrame.join(conditions, count_already_seen, on=iv_column_names).fillna(0)\n", + " return {\"conditions\": conditions, \"already_seen\": count_already_seen}\n", + "\n", + "experiment_data_ = pd.DataFrame(dict(x1=[-3, 3, -3], x2=[-1, 5, -1]))\n", + "variables_ = VariableCollection(independent_variables=[Variable(\"x1\"), Variable(\"x2\")])\n", + "\n", + "avoid_repeat(\n", + " conditions=conditions_,\n", + " experiment_data=experiment_data_,\n", + " variables=variables_\n", + ")[\"conditions\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We wrap the `avoid_repeat` function with the usual `on_state` wrapper to make it compatible with the state mechanism.\n", + " As it already returns a dictionary, we don't need to specify the output names.\n", + " Then we can the wrapped function on the State object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jholla10/Developer/autora-core/src/autora/state/delta.py:273: UserWarning: These fields: ['already_seen'] could not be used to update StandardState, which has these fields & aliases: ['variables', 'conditions', 'experiment_data', 'models', 'model']\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "StandardState(variables=VariableCollection(independent_variables=[Variable(name='x1', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False), Variable(name='x2', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[], covariates=[]), conditions= x1 x2 downvotes\n", + "0 -3.0 -1.0 2.0\n", + "1 -2.0 0.0 0.0\n", + "2 -1.0 1.0 0.0\n", + "3 0.0 2.0 0.0\n", + "4 1.0 3.0 0.0\n", + "5 2.0 4.0 0.0\n", + "6 3.0 5.0 1.0, experiment_data= x1 x2\n", + "0 -3 -1\n", + "1 3 5\n", + "2 -3 -1, models=[])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "avoid_repeat_state = on_state(avoid_repeat)\n", + "s = StandardState(\n", + " experiment_data=pd.DataFrame(dict(x1=[-3, 3, -3], x2=[-1, 5, -1])),\n", + " variables=VariableCollection(independent_variables=[Variable(\"x1\"), Variable(\"x2\")])\n", + ")\n", + "avoid_repeat_state(s, conditions=conditions_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The way we handle this is to write a function which operates on the State directly, passing it to\n", + "experimentalists wrapped with `on_state`, then combine their outputs.\n", + "This is done as follows if our conditions are returned with the downvotes in the same dataframe:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jholla10/Developer/autora-core/src/autora/state/delta.py:273: UserWarning: These fields: ['already_seen'] could not be used to update StandardState, which has these fields & aliases: ['variables', 'conditions', 'experiment_data', 'models', 'model']\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2avoid_repeat.downvotesavoid_negative.downvotesavoid_even.downvotesdownvotes
41.03.00.000.00.0
2-1.01.00.010.01.0
63.05.01.000.01.0
30.02.00.002.02.0
52.04.00.002.02.0
1-2.00.00.012.03.0
0-3.0-1.02.020.04.0
\n", + "
" + ], + "text/plain": [ + " x1 x2 avoid_repeat.downvotes avoid_negative.downvotes \\\n", + "4 1.0 3.0 0.0 0 \n", + "2 -1.0 1.0 0.0 1 \n", + "6 3.0 5.0 1.0 0 \n", + "3 0.0 2.0 0.0 0 \n", + "5 2.0 4.0 0.0 0 \n", + "1 -2.0 0.0 0.0 1 \n", + "0 -3.0 -1.0 2.0 2 \n", + "\n", + " avoid_even.downvotes downvotes \n", + "4 0.0 0.0 \n", + "2 0.0 1.0 \n", + "6 0.0 1.0 \n", + "3 2.0 2.0 \n", + "5 2.0 2.0 \n", + "1 2.0 3.0 \n", + "0 0.0 4.0 " + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "@on_state()\n", + "def combine_downvotes_state(\n", + " state: State,\n", + " conditions: pd.DataFrame,\n", + " experimentalists: List,\n", + " num_samples: int\n", + "):\n", + " # iv_column_names = [v.name for v in s.variables.independent_variables]\n", + " downvoted_conditions = []\n", + " for e in experimentalists:\n", + " new_state = e(state, conditions=conditions)\n", + " this_downvoted_conditions = new_state.conditions\n", + " this_downvoted_conditions.attrs[\"name\"] = e.__name__\n", + " downvoted_conditions.append(this_downvoted_conditions)\n", + " combined_downvotes = combine_downvotes(conditions, *downvoted_conditions)\n", + " combined_downvotes_sorted_filtered = combined_downvotes\\\n", + " .sort_values(by=\"downvotes\", ascending=True)\\\n", + " .iloc[:num_samples]\n", + "\n", + " d = Delta(conditions=combined_downvotes_sorted_filtered)\n", + " return d\n", + "\n", + "combine_downvotes_state(\n", + " s,\n", + " conditions=conditions_,\n", + " experimentalists=[\n", + " on_state(avoid_repeat),\n", + " on_state(avoid_negative, output=[\"conditions\"]),\n", + " on_state(avoid_even, output=[\"conditions\"])\n", + " ],\n", + " num_samples=7\n", + ").conditions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Experimentalists Return Separate Conditions and Additional Measures\n", + "\n", + "If we return separate conditions and measures, then we need to split up the\n", + "combined downvoted conditions from the downvotes:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'conditions': x1 x2\n", + " 0 -3.0 -1.0\n", + " 1 -2.0 0.0\n", + " 2 -1.0 1.0\n", + " 3 0.0 2.0\n", + " 4 1.0 3.0\n", + " 5 2.0 4.0\n", + " 6 3.0 5.0,\n", + " 'downvotes': 0 2.0\n", + " 1 0.0\n", + " 2 0.0\n", + " 3 0.0\n", + " 4 0.0\n", + " 5 0.0\n", + " 6 1.0\n", + " Name: downvotes, dtype: float64}" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def avoid_repeat_separate(\n", + " conditions: pd.DataFrame,\n", + " experiment_data: pd.DataFrame,\n", + " variables: VariableCollection\n", + "):\n", + " conditions_with_downvotes = avoid_repeat(\n", + " conditions=conditions,\n", + " experiment_data=experiment_data,\n", + " variables=variables\n", + " )[\"conditions\"]\n", + "\n", + " # Now we split up the results\n", + " iv_column_names = [v.name for v in variables.independent_variables]\n", + " conditions = conditions_with_downvotes[iv_column_names]\n", + " downvotes = conditions_with_downvotes[\"downvotes\"]\n", + "\n", + " return {\"conditions\": conditions, \"downvotes\": downvotes}\n", + "\n", + "avoid_repeat_separate(\n", + " conditions=conditions_,\n", + " experiment_data=experiment_data_,\n", + " variables=variables_\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the aggregation function, we have to gather the \"downvotes\" from the individual experimentalists\n", + "(having passed them the full state as well as some seed conditions), then combine them,\n", + "before we can split off the conditions and downvotes for the result object" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jholla10/Developer/autora-core/src/autora/state/delta.py:273: UserWarning: These fields: ['downvotes'] could not be used to update StandardState, which has these fields & aliases: ['variables', 'conditions', 'experiment_data', 'models', 'model']\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2
41.03.0
2-1.01.0
63.05.0
30.02.0
52.04.0
1-2.00.0
0-3.0-1.0
\n", + "
" + ], + "text/plain": [ + " x1 x2\n", + "4 1.0 3.0\n", + "2 -1.0 1.0\n", + "6 3.0 5.0\n", + "3 0.0 2.0\n", + "5 2.0 4.0\n", + "1 -2.0 0.0\n", + "0 -3.0 -1.0" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "@on_state()\n", + "def combine_downvotes_separate_state(\n", + " state: State,\n", + " conditions: pd.DataFrame,\n", + " experimentalists: List,\n", + " variables: VariableCollection,\n", + " num_samples: int\n", + "):\n", + " # iv_column_names = [v.name for v in s.variables.independent_variables]\n", + " all_downvotes = []\n", + " for e in experimentalists:\n", + " delta = e(state, conditions=conditions)\n", + " this_downvotes_series = delta[\"downvotes\"]\n", + " this_downvotes_series.attrs[\"name\"] = e.__name__\n", + " all_downvotes.append(this_downvotes_series.to_frame(\"downvotes\"))\n", + " combined_downvotes = combine_downvotes(conditions, *all_downvotes)\n", + "\n", + " combined_downvotes_sorted_filtered = combined_downvotes\\\n", + " .sort_values(by=\"downvotes\", ascending=True)\\\n", + " .iloc[:num_samples]\n", + "\n", + " iv_column_names = [v.name for v in variables.independent_variables]\n", + " result_conditions = combined_downvotes_sorted_filtered[iv_column_names]\n", + " result_downvotes = combined_downvotes_sorted_filtered[\"downvotes\"]\n", + "\n", + " d = Delta(conditions=result_conditions, downvotes=result_downvotes)\n", + " return d\n", + "\n", + "combine_downvotes_separate_state(\n", + " s,\n", + " conditions=conditions_,\n", + " experimentalists=[\n", + " # Here we have to use `inputs_from_state` but return our dictionary.\n", + " # There isn't a `downvotes` field we can update,\n", + " # so if we try to use the state mechanism, we lose the downvotes data\n", + " inputs_from_state(avoid_repeat_separate),\n", + " inputs_from_state(avoid_negative_separate),\n", + " inputs_from_state(avoid_even_separate)\n", + " ],\n", + " num_samples=7\n", + ").conditions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Chained Experimentalists\n", + "We can also define experimentalists which add their vote to the existing vote, if it exists:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def combine_downvotes(a, b, *arrays):\n", + " if isinstance(b, pd.Series):\n", + " new_downvotes = b\n", + " elif isinstance(b, pd.DataFrame):\n", + " new_downvotes = b.downvotes\n", + " if \"downvotes\" in a.columns:\n", + " result = a.assign(downvotes=a.downvotes + new_downvotes)\n", + " else:\n", + " result = a.assign(downvotes=new_downvotes)\n", + " if len(arrays) == 0:\n", + " return result\n", + " else:\n", + " return combine_downvotes(result, arrays[0], *arrays[1:])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we pass in some conditions with no downvotes (`conditions_`)\n", + "and then combine with a DataFrame with constant downvotes `conditions_.assign(downvotes=1)`\n", + "we get constant total downvotes:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2downvotes
0-3.0-1.01
1-2.00.01
2-1.01.01
30.02.01
41.03.01
52.04.01
63.05.01
\n", + "
" + ], + "text/plain": [ + " x1 x2 downvotes\n", + "0 -3.0 -1.0 1\n", + "1 -2.0 0.0 1\n", + "2 -1.0 1.0 1\n", + "3 0.0 2.0 1\n", + "4 1.0 3.0 1\n", + "5 2.0 4.0 1\n", + "6 3.0 5.0 1" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "combine_downvotes(\n", + " conditions_,\n", + " conditions_.assign(downvotes=1)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can add another set of downvotes, which are summed with the existing ones:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2downvotes
0-3.0-1.01
1-2.00.02
2-1.01.03
30.02.04
41.03.05
52.04.06
63.05.07
\n", + "
" + ], + "text/plain": [ + " x1 x2 downvotes\n", + "0 -3.0 -1.0 1\n", + "1 -2.0 0.0 2\n", + "2 -1.0 1.0 3\n", + "3 0.0 2.0 4\n", + "4 1.0 3.0 5\n", + "5 2.0 4.0 6\n", + "6 3.0 5.0 7" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "combine_downvotes(\n", + " conditions_,\n", + " conditions_.assign(downvotes=1),\n", + " conditions_.assign(downvotes=[0, 1, 2, 3, 4, 5, 6]).sample(frac=1)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using these, we can build functions which are aware of and add to existing downvotes if they exist." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StandardState(variables=VariableCollection(independent_variables=[Variable(name='x1', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False), Variable(name='x2', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[], covariates=[]), conditions= x1 x2 downvotes avoid_even.downvotes\n", + "0 -3.0 -1.0 0.0 0.0\n", + "1 -2.0 0.0 2.0 2.0\n", + "2 -1.0 1.0 0.0 0.0\n", + "3 0.0 2.0 2.0 2.0\n", + "4 1.0 3.0 0.0 0.0\n", + "5 2.0 4.0 2.0 2.0\n", + "6 3.0 5.0 0.0 0.0, experiment_data= x1 x2\n", + "0 -3 -1\n", + "1 3 5\n", + "2 -3 -1, models=[])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "@on_state()\n", + "def avoid_even_chainable(conditions: pd.DataFrame, variables: VariableCollection):\n", + " iv_names = [v.name for v in variables.independent_variables]\n", + " downvotes = avoid_even_function(conditions_[iv_names]).sum(axis=1)\n", + " result = combine_downvotes(conditions, downvotes)\n", + " result[\"avoid_even.downvotes\"] = downvotes\n", + " return {\"conditions\": result}\n", + "avoid_even_chainable(s, conditions=conditions_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StandardState(variables=VariableCollection(independent_variables=[Variable(name='x1', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False), Variable(name='x2', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[], covariates=[]), conditions= x1 x2 downvotes avoid_negative.downvotes\n", + "0 -3.0 -1.0 2 2\n", + "1 -2.0 0.0 1 1\n", + "2 -1.0 1.0 1 1\n", + "3 0.0 2.0 0 0\n", + "4 1.0 3.0 0 0\n", + "5 2.0 4.0 0 0\n", + "6 3.0 5.0 0 0, experiment_data= x1 x2\n", + "0 -3 -1\n", + "1 3 5\n", + "2 -3 -1, models=[])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "@on_state()\n", + "def avoid_negative_chainable(conditions: pd.DataFrame, variables: VariableCollection):\n", + " iv_names = [v.name for v in variables.independent_variables]\n", + " downvotes = (conditions_[iv_names] < 0).sum(axis=1)\n", + " result = combine_downvotes(conditions, downvotes)\n", + " result[\"avoid_negative.downvotes\"] = downvotes\n", + " return {\"conditions\": result}\n", + "avoid_negative_chainable(s, conditions=conditions_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StandardState(variables=VariableCollection(independent_variables=[Variable(name='x1', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False), Variable(name='x2', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[], covariates=[]), conditions= x1 x2 downvotes avoid_repeat.downvotes\n", + "0 -3.0 -1.0 2.0 2.0\n", + "1 -2.0 0.0 0.0 0.0\n", + "2 -1.0 1.0 0.0 0.0\n", + "3 0.0 2.0 0.0 0.0\n", + "4 1.0 3.0 0.0 0.0\n", + "5 2.0 4.0 0.0 0.0\n", + "6 3.0 5.0 1.0 1.0, experiment_data= x1 x2\n", + "0 -3 -1\n", + "1 3 5\n", + "2 -3 -1, models=[])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "@on_state()\n", + "def avoid_repeat_chainable(\n", + " conditions: pd.DataFrame,\n", + " experiment_data: pd.DataFrame,\n", + " variables: VariableCollection\n", + "):\n", + " iv_column_names = [v.name for v in variables.independent_variables]\n", + " count_already_seen = pd.Series(experiment_data.groupby(iv_column_names).size(), name=\"downvotes\")\n", + " downvotes = pd.DataFrame.join(conditions, count_already_seen, on=iv_column_names).fillna(0)[\"downvotes\"]\n", + " result = combine_downvotes(conditions, downvotes)\n", + " result[\"avoid_repeat.downvotes\"] = downvotes\n", + " return {\"conditions\": result}\n", + "\n", + "\n", + "avoid_repeat_chainable(\n", + " s, conditions=conditions_\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2downvotesavoid_repeat.downvotes
1-2.00.00.00.0
2-1.01.00.00.0
30.02.00.00.0
41.03.00.00.0
52.04.00.00.0
63.05.01.01.0
\n", + "
" + ], + "text/plain": [ + " x1 x2 downvotes avoid_repeat.downvotes\n", + "1 -2.0 0.0 0.0 0.0\n", + "2 -1.0 1.0 0.0 0.0\n", + "3 0.0 2.0 0.0 0.0\n", + "4 1.0 3.0 0.0 0.0\n", + "5 2.0 4.0 0.0 0.0\n", + "6 3.0 5.0 1.0 1.0" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "@on_state()\n", + "def sample_downvotes(conditions: pd.DataFrame, num_samples:Optional[int]=None):\n", + " conditions = conditions.sort_values(by=\"downvotes\").iloc[:num_samples]\n", + " return Delta(conditions=conditions)\n", + "\n", + "sample_downvotes(\n", + " avoid_repeat_chainable(s, conditions=conditions_),\n", + " num_samples=6\n", + ").conditions\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2downvotesavoid_repeat.downvotesavoid_even.downvotesavoid_negative.downvotes
41.03.00.00.00.00
2-1.01.01.00.00.01
63.05.01.01.00.00
30.02.02.00.02.00
52.04.02.00.02.00
1-2.00.03.00.02.01
0-3.0-1.04.02.00.02
\n", + "
" + ], + "text/plain": [ + " x1 x2 downvotes avoid_repeat.downvotes avoid_even.downvotes \\\n", + "4 1.0 3.0 0.0 0.0 0.0 \n", + "2 -1.0 1.0 1.0 0.0 0.0 \n", + "6 3.0 5.0 1.0 1.0 0.0 \n", + "3 0.0 2.0 2.0 0.0 2.0 \n", + "5 2.0 4.0 2.0 0.0 2.0 \n", + "1 -2.0 0.0 3.0 0.0 2.0 \n", + "0 -3.0 -1.0 4.0 2.0 0.0 \n", + "\n", + " avoid_negative.downvotes \n", + "4 0 \n", + "2 1 \n", + "6 0 \n", + "3 0 \n", + "5 0 \n", + "1 1 \n", + "0 2 " + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s_0 = s + Delta(conditions=conditions_) # add the seed conditions\n", + "s_1 = avoid_repeat_chainable(s_0)\n", + "s_2 = avoid_even_chainable(s_1)\n", + "s_3 = avoid_negative_chainable(s_2)\n", + "s_4 = sample_downvotes(s_3, num_samples=7)\n", + "s_4.conditions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What Happens When We Extend a Dataframe With New Columns in the State Mechanism\n", + "If we have an experiment_data field which has particular columns:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "s_0 = StandardState(\n", + " experiment_data=pd.DataFrame({\"x1\":[-10], \"x2\":[-10], \"y\":[-10]})\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "... and we add data with extra columns:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "new_experiment_data = pd.DataFrame({\"x1\":[5], \"x2\":[5], \"y\":[5], \"new_column\": [15]})\n", + "s_1 = s_0 + Delta(experiment_data=new_experiment_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " then the additional columns just\n", + "get added on the end, and any missing values are replaced by NaNs:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2ynew_column
0-10-10-10NaN
155515.0
\n", + "
" + ], + "text/plain": [ + " x1 x2 y new_column\n", + "0 -10 -10 -10 NaN\n", + "1 5 5 5 15.0" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s_1.experiment_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb index e2a9babb..f04ee104 100644 --- a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb +++ b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb @@ -46,7 +46,7 @@ "import numpy as np\n", "import pandas as pd\n", "from autora.variable import VariableCollection, Variable\n", - "from autora.state.bundled import StandardState\n", + "from autora.state import StandardState\n", "\n", "s = StandardState(\n", " variables=VariableCollection(independent_variables=[Variable(\"x\", value_range=(-15,15))],\n", @@ -121,12 +121,12 @@ "metadata": {}, "outputs": [], "source": [ - "from autora.state.delta import wrap_to_use_state, Delta\n", + "from autora.state import on_state, Delta\n", "\n", "def ground_truth(x: pd.Series, c=(432, -144, -3, 1)):\n", " return c[0] + c[1] * x + c[2] * x**2 + c[3] * x**3\n", "\n", - "@wrap_to_use_state\n", + "@on_state\n", "def experiment_runner(conditions, std=100., random_state=None):\n", " \"\"\"Coefs from https://www.maa.org/sites/default/files/0025570x28304.di021116.02p0130a.pdf\"\"\"\n", " rng = np.random.default_rng(random_state)\n", @@ -178,27 +178,27 @@ " \n", " 0\n", " -15.0\n", - " -1457.949701\n", + " -1457.218119\n", " \n", " \n", " 1\n", " -14.7\n", - " -1275.900522\n", + " -1275.332030\n", " \n", " \n", " 2\n", " -14.4\n", - " -1101.584447\n", + " -1102.558433\n", " \n", " \n", " 3\n", " -14.1\n", - " -938.510951\n", + " -937.742130\n", " \n", " \n", " 4\n", " -13.8\n", - " -780.229165\n", + " -780.935825\n", " \n", " \n", " ...\n", @@ -208,27 +208,27 @@ " \n", " 96\n", " 13.8\n", - " 500.274061\n", + " 501.733867\n", " \n", " \n", " 97\n", " 14.1\n", - " 608.306420\n", + " 607.023667\n", " \n", " \n", " 98\n", " 14.4\n", - " 720.885521\n", + " 721.623458\n", " \n", " \n", " 99\n", " 14.7\n", - " 843.944513\n", + " 843.627156\n", " \n", " \n", " 100\n", " 15.0\n", - " 971.655807\n", + " 973.391517\n", " \n", " \n", "\n", @@ -237,17 +237,17 @@ ], "text/plain": [ " x y\n", - "0 -15.0 -1457.949701\n", - "1 -14.7 -1275.900522\n", - "2 -14.4 -1101.584447\n", - "3 -14.1 -938.510951\n", - "4 -13.8 -780.229165\n", + "0 -15.0 -1457.218119\n", + "1 -14.7 -1275.332030\n", + "2 -14.4 -1102.558433\n", + "3 -14.1 -937.742130\n", + "4 -13.8 -780.935825\n", ".. ... ...\n", - "96 13.8 500.274061\n", - "97 14.1 608.306420\n", - "98 14.4 720.885521\n", - "99 14.7 843.944513\n", - "100 15.0 971.655807\n", + "96 13.8 501.733867\n", + "97 14.1 607.023667\n", + "98 14.4 721.623458\n", + "99 14.7 843.627156\n", + "100 15.0 973.391517\n", "\n", "[101 rows x 2 columns]" ] @@ -268,7 +268,7 @@ "### Defining The Theorist\n", "\n", "Now we define a theorist, which does a linear regression on the polynomial of degree 5. We define a regressor and a\n", - "method to return its feature names and coefficients, and then the theorist to handle it. Here, we use a different wrapper `theorist_from_estimator` that wraps the regressor and returns a function with the same functionality, but operating on `State` fields. In this case, we want to use the `State` field `experiment_data` and extend the `State` field `models`." + "method to return its feature names and coefficients, and then the theorist to handle it. Here, we use a different wrapper `estimator_on_state` that wraps the regressor and returns a function with the same functionality, but operating on `State` fields. In this case, we want to use the `State` field `experiment_data` and extend the `State` field `models`." ] }, { @@ -278,13 +278,13 @@ "outputs": [], "source": [ "from sklearn.linear_model import LinearRegression\n", - "from autora.state.wrapper import theorist_from_estimator\n", + "from autora.state import estimator_on_state\n", "from sklearn.pipeline import make_pipeline as make_theorist_pipeline\n", "from sklearn.preprocessing import PolynomialFeatures\n", "\n", "# Completely standard scikit-learn pipeline regressor\n", "regressor = make_theorist_pipeline(PolynomialFeatures(degree=5), LinearRegression())\n", - "theorist = theorist_from_estimator(regressor)\n", + "theorist = estimator_on_state(regressor)\n", "\n", "def get_equation(r):\n", " t = r.named_steps['polynomialfeatures'].get_feature_names_out()\n", @@ -744,7 +744,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -776,7 +776,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -874,17 +874,17 @@ "\n", "v1.model=None, \n", "v1.experiment_data= x y\n", - "0 -15.0 -1386.402949\n", - "1 -14.7 -1073.690228\n", - "2 -14.4 -1072.951606\n", - "3 -14.1 -1096.806703\n", - "4 -13.8 -838.977013\n", + "0 -15.0 -1646.530156\n", + "1 -14.7 -1336.437358\n", + "2 -14.4 -1055.375424\n", + "3 -14.1 -1100.425725\n", + "4 -13.8 -929.288485\n", ".. ... ...\n", - "96 13.8 384.625949\n", - "97 14.1 559.333146\n", - "98 14.4 795.556490\n", - "99 14.7 920.071641\n", - "100 15.0 907.742229\n", + "96 13.8 461.151029\n", + "97 14.1 512.259065\n", + "98 14.4 795.078025\n", + "99 14.7 930.233261\n", + "100 15.0 986.124289\n", "\n", "[101 rows x 2 columns]\n" ] @@ -952,6 +952,118 @@ "v3 = next(cycle_generator)\n", "print(f\"{v3.model=}, \\n{v3.experiment_data.shape=}\")\n" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adding The Experimentalist\n", + "\n", + "Modifying the code to use a custom experimentalist is simple. We define an experimentalist which adds some observations\n", + "each cycle:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StandardState(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-15, 15), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), conditions= x\n", + "0 -3.681470\n", + "1 13.752780\n", + "2 -4.058959\n", + "3 10.911147\n", + "4 -1.159941, experiment_data=Empty DataFrame\n", + "Columns: [x, y]\n", + "Index: [], models=[])" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from autora.experimentalist.random_ import random_pool\n", + "experimentalist = on_state(random_pool, output=[\"conditions\"])\n", + "experimentalist(s)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAHHCAYAAABwaWYjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACDZElEQVR4nOzdeVxU1f/H8dfMsO+ygyKIKIobiolrrommlaVpZaVmaWaLmZa2qOm3rGwvy2xRW9yz+lXmkllm4r7vICgqmxv7PnN/f4xMEqigwJ0ZPs/HYx7AvXfuvGcYnQ/nnHuORlEUBSGEEEIIUWlatQMIIYQQQlgaKaCEEEIIIapICighhBBCiCqSAkoIIYQQooqkgBJCCCGEqCIpoIQQQgghqkgKKCGEEEKIKpICSgghhBCiiqSAEkIIIYSoIimghLhs4cKFaDQaTp48qXaUCo0cOZKQkJBaeazly5fj6elJTk5OrTyetTh58iQajYaFCxeqHaXW9ejRgx49eqjy2PPmzaNhw4YUFhaq8viibpICSoga8Prrr9OxY0d8fHxwcHCgSZMmTJgwgXPnzqkd7br0ej3Tp0/nqaeewsXF5YbOUVhYyAsvvEBgYCCOjo5ER0ezfv36ak4qbtTq1auZMWOG2jEAyMvLY8aMGfz55583fI6RI0dSVFTEZ599Vn3BrnDixAkcHBzQaDTs3Lmz3P6MjAzGjBmDj48Pzs7O9OzZk927d9dIFmE+pIAS4rKHHnqI/Px8goODb/pcu3btIjIykpdeeom5c+dy1113sWDBAjp37kxubm41pK05P//8M8eOHWPMmDE3fI6RI0fy7rvvMnz4cD744AN0Oh233347mzdvrsak5ic4OJj8/HweeughtaNc0+rVq3n11VfVjgEYC6hXX331pgooBwcHRowYwbvvvktNLO/67LPPYmNjU+E+g8HAgAEDWLx4MU8++SRvvfUW6enp9OjRg7i4uGrPIsyIIoSoFStXrlQAZcmSJTd0/xEjRijBwcHVG6oCd955p9K1a9cbvv+2bdsUQJkzZ45pW35+vtK4cWOlU6dO1RHR7BQXFyuFhYVqx6i08ePHK9X933/37t2V7t27V/l+586dUwBl+vTpN/X4O3fuVABlw4YNN3We/1qzZo1iZ2envPzyywqg7Nixo8z+ZcuWKYCyYsUK07b09HTFw8NDuf/++6s1izAv0gIlxGU1PQaqdPxSRkZGtZ3TYDDw/vvv06JFCxwcHPDz82Ps2LFcunSp3GMPHDiQzZs306FDBxwcHAgNDeXrr78uc1xBQQFr1qyhT58+ZbZfa2yPRqMp0x20cuVKdDpdmRYsBwcHRo8eTWxsLKdPn77u89q2bRv9+vXD3d0dJycnunfvzj///GPaf+TIERwdHXn44YfL3G/z5s3odDpeeOGFcs993bp1REZG4uDgQEREBKtWrSr3uBkZGUyYMIGgoCDs7e0JCwvjzTffxGAwlHst3n77bd5//30aN26Mvb09hw8frvB1GjlyJC4uLiQlJTFw4EBcXFyoX78+c+fOBeDAgQP06tULZ2dngoODWbx48U3nmj9/vinXLbfcwo4dO8rkKX1sjUZjulVF6fkdHR3p0KEDf//9d7ljioqKmDZtGlFRUbi7u+Ps7Ey3bt3YuHFjmcw+Pj4AvPrqq6Yspe+n/fv3M3LkSEJDQ3FwcMDf359HHnmECxculHu8qKgoPD09+emnn6r0XK6luLiYZ555hmeeeYbGjRtXeMzKlSvx8/PjnnvuMW3z8fFh6NCh/PTTTzIuy4pV3CYphAAgJyeHgoKC6x5na2uLu7t7mW2KonDhwgVKSkqIi4tjypQp6HS6ah1oO3bsWBYuXMioUaN4+umnSUxM5OOPP2bPnj38888/2Nramo6Nj49nyJAhjB49mhEjRvDVV18xcuRIoqKiaNGiBWDseiwqKqJdu3Y3nGnPnj00bdoUNze3Mts7dOgAwN69ewkKCrrq/f/44w/69+9PVFQU06dPR6vVsmDBAnr16sXff/9Nhw4daN68ObNmzWLy5MkMGTKEO++8k9zcXEaOHEmzZs2YOXNmmXPGxcUxbNgwHn/8cUaMGMGCBQu49957WbNmDbfddhtg7Erq3r07Z8+eZezYsTRs2JAtW7YwdepUUlJSeP/998ucc8GCBRQUFDBmzBjs7e3x9PQsU9BcSa/X079/f2699VbeeustvvvuO5588kmcnZ156aWXGD58OPfccw/z5s3j4YcfplOnTjRq1OiGci1evJjs7GzGjh2LRqPhrbfe4p577iEhIQFbW1vGjh1LcnIy69ev55tvvrnu7/O/vvzyS8aOHUvnzp2ZMGECCQkJ3HnnnXh6epb5vWZlZfHFF19w//3389hjj5Gdnc2XX35JTEwM27dvJzIyEh8fHz799FPGjRvH3XffbSpCWrduDcD69etJSEhg1KhR+Pv7c+jQIebPn8+hQ4fYunVrucKvXbt2ZQptgMzMTIqLi6/7vBwcHMqN+Xv//fe5dOkSL7/8coUFNxjf7+3atUOrLdse0aFDB+bPn8/x48dp1arVdR9fWCC1m8CEMBcLFixQACUxMdG0bcSIEQpw3VtFXRcpKSlljmnQoIGybNmyG8733y68v//+WwGU7777rsxxa9asKbc9ODhYAZRNmzaZtqWnpyv29vbKc889Z9r2xRdfKIBy4MCBMudMTExUAGXBggXlcvGf7pcWLVoovXr1KnfcoUOHFECZN2/eVZ+jwWBQmjRposTExCgGg8G0PS8vT2nUqJFy2223mbbp9Xqla9euip+fn3L+/Hll/Pjxio2NTbkultLn/v3335u2ZWZmKgEBAUrbtm1N22bNmqU4Ozsrx48fL3P/KVOmKDqdTklKSirzWri5uSnp6enXfZ1K30Ovv/66adulS5cUR0dHRaPRKEuXLjVtP3r0aLnXs6q5vLy8lIsXL5qO++mnnxRA+fnnn03bbrQLr6ioSPH19VUiIyPLdFnOnz+/3L+DkpKSct2aly5dUvz8/JRHHnnEtO1aXXh5eXnlti1ZsqTce7nUmDFjFEdHxzLbunfvXql/wyNGjChzv5SUFMXV1VX57LPPFEX59/+H/76/nJ2dyzyfUr/++qsCKGvWrCm3T1gHaYES4hqef/55HnzwweseV69evXLbPD09Wb9+PQUFBezZs4dVq1ZV67QAK1aswN3dndtuu43z58+btkdFReHi4sLGjRt54IEHTNsjIiLo1q2b6WcfHx/Cw8NJSEgwbSvtGqno+VRWfn4+9vb25bY7ODiY9l/N3r17iYuL4+WXXy7XTdO7d2+++eYbDAYDWq0WrVbLwoULadOmDf3792fnzp28/PLLtG/fvtx5AwMDufvuu00/u7m58fDDD/Pmm2+SmpqKv78/K1asoFu3btSrV6/M69mnTx/eeOMNNm3axPDhw03bBw8ebOp+qoxHH33U9L2Hhwfh4eHEx8czdOhQ0/bw8HA8PDzK/E6qmmvYsGFlfn+lv/Mrz3mjdu7cSXp6OjNnzsTOzs60feTIkUyePLnMsTqdDp1OBxi7mjMyMjAYDLRv377SV6g5Ojqavi8oKCAnJ4eOHTsCsHv37jLvZzC+b/Pz88nLy8PJyQmAd955p1yXdkUCAwPL/PzCCy8QGhpa5vdWkZt5vwvLJgWUENcQERFBRETEDd3Xzs7ONJZo4MCB9O7dmy5duuDr68vAgQNvOltcXByZmZn4+vpWuD89Pb3Mzw0bNix3TL169Sr8cFFu4komR0fHCsd9lHaFXvmh+F+lVy2NGDHiqsdkZmaaCoTGjRszY8YMJk+eTMuWLXnllVcqvE9YWFi57p6mTZsCxnE4/v7+xMXFsX///qsWRf99PUu72CrDwcGh3Hnd3d1p0KBBuVzu7u5lfidVzfXf33Ppa1WZIuJ6Tp06BUCTJk3KbLe1tSU0NLTc8YsWLeKdd97h6NGjZbrRKvvaXbx4kVdffZWlS5eWe56ZmZnlji993175mkZFRVXqsa60detWvvnmGzZs2FCua+6/bub9LiybFFBCXENmZmal/oK0s7PD09Pzmsd07tyZgIAAvvvuu2opoAwGA76+vnz33XcV7v/vB25pa8B/XVkseXl5AcYP2wYNGpi2X22QsV6vL7ctICCAs2fPltuekpIClP9L/0qlY4jmzJlDZGRkhcf8d5zKunXrAEhOTubChQv4+/tf9fzXYjAYuO2223j++ecr3F9acJWqygfj1V77yvxOqpqrMuesDd9++y0jR45k0KBBTJ48GV9fX3Q6HbNnz+bEiROVOsfQoUPZsmULkydPJjIyEhcXFwwGA/369atwvNmlS5dwcnIq87u5ePEiRUVF130sR0dH0zjG559/nm7dutGoUSPTRSWlrX8pKSkkJSWZCtWAgADTe/tKlXm/C8smBZQQ1/DMM8+waNGi6x7XvXv3Ss1jU1BQUOFfzjeicePG/P7773Tp0qXa/spt1qwZAImJiWUGvpa2Yvz3CsLSFokrRUZGsnHjRrKyssoMJN+2bZtp/9WUXunk5uZW7krAisybN4/169fz2muvMXv2bMaOHVvhVVjx8fEoilKmEDx+/Djw79WRjRs3Jicnp1KPW5tqIldVr7orVTpHWlxcHL169TJtLy4uJjExkTZt2pi2rVy5ktDQUFatWlXm8aZPn16pLJcuXWLDhg28+uqrTJs2zbT9WnMrJSYm0rx58zLb7rnnHv7666/rPrcRI0aYrp5MSkri1KlTFbaU3Xnnnbi7u5v+LURGRvL333+bupZLbdu2DScnp3IFrrAeUkAJcQ03MgYqNzcXjUZjGoNR6vvvv+fSpUsVjtG5EUOHDuWTTz5h1qxZvP7662X2lZSUkJOTg4eHR5XOGRUVhZ2dHTt37uTOO+80bXdzc8Pb25tNmzYxYcIE0/ZPPvmk3DmGDBliupR+0qRJgHFm8gULFhAdHV3mSq2kpCTy8vJMhVtUVBSNGzfm7bff5oEHHijX2nTu3DlTy1piYiKTJ09m8ODBvPjii3h5efH444/z9ddfl5veIDk5mR9++MF0lVdWVhZff/01kZGRpharoUOHMmPGDNauXUtMTEyZ+2dkZODi4nLVyRRrUk3kcnZ2Nt2/Ku+R9u3b4+Pjw7x58xg1apRpHNTChQvLFdelLWFXFq7btm0jNja2TDdj6b+Ta93/Sv+96vBKu3fvLjMeDG5sDNT8+fPJy8srs/+PP/7go48+4u233za9X8H4fl+5ciWrVq1iyJAhgLG1asWKFdxxxx0Vjo8S1kEKKCGu4UbGQMXFxdGnTx+GDRtGs2bN0Gq17Ny5k2+//ZaQkBCeeeaZMseXtoBUdf6p7t27M3bsWGbPns3evXvp27cvtra2xMXFsWLFCj744APTf+iV5eDgQN++ffn999/LTQXw6KOP8sYbb/Doo4/Svn17Nm3aZGrFuVJ0dDT33nsvU6dOJT09nbCwMBYtWsTJkyf58ssvyxz78MMP89dff5k+JLVaLV988QX9+/enRYsWjBo1ivr163P27Fk2btyIm5sbP//8M4qi8Mgjj+Do6Minn34KGKd0+P7773nmmWfo06dPmQ/Epk2bMnr0aHbs2IGfnx9fffUVaWlpLFiwwHTM5MmT+b//+z8GDhxomt4hNzeXAwcOsHLlSk6ePIm3t3eVXs/qUBO5SscFPf3008TExKDT6bjvvvuuez9bW1v+97//MXbsWHr16sWwYcNITExkwYIF5cZADRw4kFWrVnH33XczYMAAEhMTmTdvHhEREWUupnB0dCQiIoJly5bRtGlTPD09admyJS1btjRN+1BcXEz9+vVZt24diYmJFWbbtWsXFy9e5K677qrwuVZF3759y20rLfC6d+9e5o+gIUOG0LFjR0aNGsXhw4fx9vbmk08+Qa/Xm81s76KGqHX5nxDmpqJpDG7EuXPnlDFjxijNmjVTnJ2dFTs7O6VJkybKhAkTlHPnzpU73tvbW+nYseN1z3u1mcjnz5+vREVFKY6Ojoqrq6vSqlUr5fnnn1eSk5NNxwQHBysDBgwod9+KZo9etWqVotFoTJfHl8rLy1NGjx6tuLu7K66ursrQoUOV9PT0Ci9Bz8/PVyZNmqT4+/sr9vb2yi233FLh5dyll5j/1549e5R77rlH8fLyUuzt7ZXg4GBl6NChplmmP/jgg3JTEyiKoiQlJSlubm7K7bffXu65r127VmndurVib2+vNGvWrMzM0aWys7OVqVOnKmFhYYqdnZ3i7e2tdO7cWXn77beVoqIiRVH+nS7gypnWS11tGgNnZ+cKn3uLFi3Kba/od3Wzuf77OyopKVGeeuopxcfHR9FoNFWe0uCTTz5RGjVqpNjb2yvt27dXNm3aVO69ZDAYlNdff10JDg5W7O3tlbZt2yq//PJLhe/jLVu2KFFRUYqdnV2ZrGfOnFHuvvtuxcPDQ3F3d1fuvfdeJTk5ucL33AsvvKA0bNiwzPQX1elq0xgoiqJcvHhRGT16tOLl5aU4OTkp3bt3r/A4YV00ilLLIwuFECaHDx+mRYsW/PLLLwwYMEDtOIBxYHhERARDhw5l1qxZase5aSEhIbRs2ZJffvlF7SiihhQWFhISEsKUKVPKtfAKUVNkKRchVLRx40Y6depkNsUTGMeezJw5k7lz51brvFVC1JQFCxZga2vL448/rnYUUYdIC5QQwqpJC1TlXO9yf51OV6WJQ4WwdjKIXAghxHUv9w8ODq6xhbaFsETSAiWEEIJdu3Zd83J/R0dHunTpUouJhDBvUkAJIYQQQlSRDCIXQgghhKgiGQNVAwwGA8nJybi6ut7wkglCCCGEqF2KopCdnU1gYOB1F5KWAqoGJCcnl1muQgghhBCW4/Tp02UWVK+IFFA1wNXVFTD+Aq5cTFUIIYQQ5isrK4ugoCDT5/i1SAFVA0q77dzc3KSAEkIIISxMZYbfyCByIYQQQogqkgJKCCGEEKKKpIASQgghhKgiKaCEEEIIIapICighhBBCiCqSAkoIIYQQooqkgBJCCCGEqCIpoIQQQgghqkgKKCGEEEKIKpICSgghhBCiiqSAEkIIIYSoIimghBBCCCGqyKIKqE2bNnHHHXcQGBiIRqPhxx9/LLNfURSmTZtGQEAAjo6O9OnTh7i4uDLHXLx4keHDh+Pm5oaHhwejR48mJyenzDH79++nW7duODg4EBQUxFtvvVXTT00IIYQQFsSiCqjc3FzatGnD3LlzK9z/1ltv8eGHHzJv3jy2bduGs7MzMTExFBQUmI4ZPnw4hw4dYv369fzyyy9s2rSJMWPGmPZnZWXRt29fgoOD2bVrF3PmzGHGjBnMnz+/xp+fEGpLTk5m8+bNJCcnqx1FCCHMmkZRFEXtEDdCo9Hwww8/MGjQIMDY+hQYGMhzzz3HpEmTAMjMzMTPz4+FCxdy3333ceTIESIiItixYwft27cHYM2aNdx+++2cOXOGwMBAPv30U1566SVSU1Oxs7MDYMqUKfz4448cPXq0UtmysrJwd3cnMzMTNze36n/yQtSQzZs3Ex8fT1hYGF27dlU7jhBC1KqqfH5bVAvUtSQmJpKamkqfPn1M29zd3YmOjiY2NhaA2NhYPDw8TMUTQJ8+fdBqtWzbts10zK233moqngBiYmI4duwYly5dqvCxCwsLycrKKnMTwhKFhoYSFhZGaGio2lGEEMKsWU0BlZqaCoCfn1+Z7X5+fqZ9qamp+Pr6ltlvY2ODp6dnmWMqOseVj/Ffs2fPxt3d3XQLCgq6+SckhAoCAwPp2rUrgYGBakcRQgizZqN2AGswdepUJk6caPo5KytLiihRqxRFIaewhPTsQtKzCjmXU0iJ3oBOq8FGq8VGp8HZzoZADwcCPRxxsNWpHVkIISya1RRQ/v7+AKSlpREQEGDanpaWRmRkpOmY9PT0MvcrKSnh4sWLpvv7+/uTlpZW5pjSn0uP+S97e3vs7e2r5XkIcT2KonA2I599SZc4cvIsJ86kkJKWhq44Bz06snEkW3EiB0fysAc05c7h62pPkKcTrRu40z7Yk6jgevi7O9T+kxFCiKo6Hw+XTkJwJ7BzVi2G1RRQjRo1wt/fnw0bNpgKpqysLLZt28a4ceMA6NSpExkZGezatYuoqCgA/vjjDwwGA9HR0aZjXnrpJYqLi7G1tQVg/fr1hIeHU69evdp/YkIAysVEzhyO5fSRHehTDxFUfJL+mnQGaC5fA6IFKqjhi7El2aY+p3UNOUEDduf7s6MohORsb9KzC9l16hIL/jkJQH0PR25t6k3/lgF0auyFrc5qeviFENZk32L4+x1ocz/cPU+1GBZ1FV5OTg7x8fEAtG3blnfffZeePXvi6elJw4YNefPNN3njjTdYtGgRjRo14pVXXmH//v0cPnwYBwfjX9f9+/cnLS2NefPmUVxczKhRo2jfvj2LFy8GjFfuhYeH07dvX1544QUOHjzII488wnvvvVdmuoNrkavwxE3Tl8DpbeQe/IXCQ7/imX/q6odqbVHs3NA6uqFV9FCQBYXZoOivep9Ct0ac9ezIVk1rVl0KZXeaHsMV/xN4ONnSN8KPO9oE0qWxN1pt+VYsIYRQxRd94MwOuOsTaDu8Wk9dlc9viyqg/vzzT3r27Flu+4gRI1i4cCGKojB9+nTmz59PRkYGXbt25ZNPPqFp06amYy9evMiTTz7Jzz//jFarZfDgwXz44Ye4uLiYjtm/fz/jx49nx44deHt789RTT/HCCy9UOqcUUOKGnTsG2+ej378SXWGGaXOxouMowWS5heMe0obGLaNxDGgOTp5gU0HTk6JAcR7kpMP543DuqPHcaYcg9UDZ4kprQ0njPhzzG8jSzAhWH77Ihdwi0+5Qb2ce7hTM4KgGuDrY1uCTF0KI6yjIgjdDjP+HTTgIHtU73thqCyhLIQWUqBKDAeLWwfbP4MQfps2XFBc2GiJJqNeV5t3upkfrMJztq6HXvSATEv+GhI2Q8CdciP93n4MHhpaDOeh7F8uTPflpTzLZhSUAONvpGBLVgDHdG1Pfw/HmcwghRFUdWwNLhoFnKDy9p9pPLwWUyqSAEpWiKHDk/+D3V+HiCQAMiobfDe34Wt8X5/CejOnRhKhgz5rNkX4U9i2B/csh+4oZyBt1p6DDU6y4FMairUnEpxuXPLLTaXkguiFP9GyMr6sMPBdC1KI1L8LWuRA1Eu74oNpPLwWUyqSAEtd1dhesfQmSjJO8ZuHMkpIefKO/jVYtWjMpJpzGPi7XOUk1M+ghcRPs+RYO/fBvN59/K5TOz/CP/a3M/SuR2IQLADjYahnROYRx3Rvj4WR3jRMLIUQ1+bQrpB2AIV9By8HVfnopoFQmBZS4qqxkWD8dDiwHoBB75pUM4LOSgQT5+TD9jgg6h3mrHBLISILYT2D3IuNYKgC/lnDbTLbQhjnrjrEnKQOAek62TOnfjHujgmSwuRCi5uRegDmXV0mYFAcuvtc+/gZIAaUyKaBEhQ6shF8nGscgAT8ptzK78F5yHfyY1Dec4dENsTG3qQPyLsKOLyD2Y1NuGvdCuW0mf1zy5c01RzmeZuzaa9fQg1mDWtIi0F3FwEIIq3XoR1gxAnwj4InYGnkIKaBUJgVU3ZKcnExCQgKhoaEVL4GSnwGrJ5tanU7aN+PJrAc5qITSIcST9+6LNP9B2XkXYdPbsH0+GIoBDbR7iOJer7Jwdwbv/36c3CI9Wg2M7NyIyTHhONrJbOdCiGr0y0TY+SVEPw7936yRh6iTiwkLoZaEhATi4+NJSEgovzPxb/i0CxxYjqLR8ZXNUPpkvsgRTWMmx4SzZExH8y+ewDhdQr/X4cnt0OJuQIHdX2P7aTSPee5lw8TuDGgdgEGBr/5JZMBHf7P3dIbaqYUQ1iRxk/Fro1vVzXGZtEDVAGmBqlsqbIFSFIidC+teBhTyXRoyOnsMWwpDaejpxIf3tyUyyEPN2Dfn1Bb4+RnjHFMATfvBgHf4M9WOF77fT1pWITqthvE9w3iqV5jMai6EuDlZyfBuc9Bo4flEcPSomYeRLjx1SQFVx+mL4dfnjAOwgbjAu7g78S5yFAeiG3ky78Eo6jlbwVVrJYXw97vGJRUMxWDnAv3eICN8KK/832F+3mecEqFVfXc+ur8tId7qrVklhLBw+5bCD2MhsC2M+bPGHka68IRQS95F+PYe2L0IRaPlt/rPcFvCUHIUB+6NasA3o6Oto3gC4wzoPafC45shKBqKcuD/nsTj18f4aFAIH97fFndHWw6czeSOjzaz9lCq2omFEJbKzLrvQAooIarPhRPGNZoSN6HYufBZ4GuMOxGNRqNhSv9mvDWkNXY2Zf/JJScns3nzZpKTk69yUgvg2wxG/QZ9ZoDWBg7/BJ924U73BNZOuJX2wfXILixh7De7eH31EUr0BrUTCyEsiaJIASWE1Uo/Cl/1g4snUNwb8Lr/B7xxIhgbrYaP72/H490bo9GUnyPpmgPQLYlWB12fhdHrwLMxZJ2FhQPx3/U2Sx69hUe7NgJg/qYEHvh8G+lZBSoHFkJYjEuJkHna+Adaw05qpzGRAkqIm5V+BBYNhNx0DH4tmezxHp8fd8RWp+HTB6MY0DrgqncNDQ0lLCyM0NDQWgxcg+pHwdhN0PZBQIFNc7BdOoyXe/nzyfB2uNjbsP3kRe78+B8Ons1UO60QwhKUtj41uAXszGcspRRQQtyMtMOwcCDknsPg35pn7Wey8lgxdjotnz0UxW0Rfte8e2BgIF27dq14/ihLZe8Cd82FwV+CjSOc2ADze3C79zn+78kuNPZxJjWrgHvnxbJOxkUJIa7H1H3XXd0c/yEFlBA3KvWgseUp7zxKQBsmOczkp+MF2Nlo+XxEe3o1u3bxdCWrGAv1X62GwKO/Q70QyDgFX/YlNGU1q57oQtcwb/KL9Yz9dhfzN51ALgYWQlTITMc/gRRQQtyYc8dg0R2QdwElIJLZ3m+w6mgedjotX45oT/emPlU6ndWMhfov/5bw2EYI6wMl+bDqMdw3z2LByCiGRzdEUeD11UeZuuqADC4XQpSXfhhyzxlbsxu0VztNGVJACVFVOenw3RDIvwiBbfky9H3m77iERgPvDmtDtyZVK57ACsdCXcnJEx5YDt0mGX/+5wNsVz3C/wY0ZvodEWg1sHTHaR7/djcFxXp1swohzEv8BuPXkK7GqVPMiBRQQlRFUS4sHgoZSVCvET+3/JD/bTB2u70yIIKBrW9sLJNVjoW6klYHvV+Bu+eD1hYO/4Tm6zsZ1caFeQ9GYWej5fcjaTz85XYy84vVTiuEMBcn/jB+bdxL3RwVkAJKiMrSl8DKRyB5Dzh6sr3L5zz7yxkAxtwayiOXL9UX19BmGDz8Izh4wJkd8EVv+vpm8c0jHXC9fIXesM9iZZoDIQQU5xuXjQIpoISwWIoCa16A42vAxoEzty/gkZ8vUmJQuLNNIFP6NVM7oeUI6fqfweW3EW2bwMf3NMbdXsPR1GwGz9tC0oU8tZMKIdR0agvoC8E1EHzC1U5TjhRQQlRG7FzY8QWgIf+OTxm5XkNOYQkdQjyZc29rtNryk2SKa/BuAo9uMM7rUpABX9+F18nfGFH/PL5OWk5fzGfY/FhOns9VO6kQQi1Xdt9VMBGx2qSAEuJ6Ev+G9a8AoPSdxcQDwcSn5+DnZs/Hw9tib6NTOaCFcvaGh38y/udYnEuLfa/Sw+kEz7YyEFzPnpTMAobNj+XEuRy1kwoh1HBio/FrmPl134EUUEJcW3aqcdyTYoA29zOvsD+/HUzFVqfhk+FR+Lo6qJ3Qstk5w/1LIWIQGkMxbeM/pOGZn3i+vR1N/VxIyyrk3k//Ydlvf1nXHFlCiGvLToX0Q4AGGvVQOUzFpIAS4mpKB43npoNvC/5p9iJz1h0DYMadLYgKrqdyQCthYw9DvoKokWgw0OXCMroWb2bJYx1p5u/KxbwSXt2cxV9749ROKoSoLaWtT4GR4OylapSrkQJKiKv5Yyac+gfsXEnrP58nVxzFoMDQ9g14oENDtdNZF60OBr5vXJAYcN/6Jl775rHksY409XEkT6/lrR0F0p0nhJU6ciKJX37f9G9LsxlPX1BKCighKnL0V/jnAwD0d37M0+uyuZRXTKv67sy8qyUaMxzQaPE0Gug9HbpPMf68fhr1dn/MinHdiAhw41J+CcM/38bpi3J1nhDWZtHmOJ78PZvpPx0Cg0EKKCEs0qVT8MM44/cdn2D++VZsS7yIk52Oj+5vi4OtDBqvMRoN9JwKPV8y/rzhVdx3vM83ozsQ5utCalYB93++lZTM/OueyirXFxTCSsVl2wDQItgH0g5A3nmwc4EGHVROdnVSQAlxJYMBfnwCCjOhQQcORDzHu+svj3u6owUh3s4qB6wjuj8PvacZv9/4P7x2vs/iR6MJ8XLizKV8hn++jfRs42SbVyuUrHZ9QSGsTE5hCftTjFOW3NWhyb+tTyHdwMZOxWTXJgWUEFfaNg9ObQZbZwrumMczKw5SrFfo39Kfe9s3UDtd3dLtOejzqvH7P1/Hd/+nfPdYR+p7OJJwPpeHvthOZl7xVQslq15fUAgrEnviAsV6hYaeToR4OVlE9x2AjdoBhDAb547Dhssf2DH/Y9aWPBLO5eLnZs/rd7eScU9q6DrB+PX36fD7DOrbOrH4sQe5d14sx9KyGb1oB2/dHgJQrlAKDAy03rUFhbAifx5LB6B7Ux80xXmQtNW4w8wLKGmBEgKMUxb8MBZKCqBxbzY43c5325IAeHdoJPWczbcZ2ep1nQDdXzB+/9vzBJ/6nkWPdMDVwYadpy7x2sYUOnbqLMWSEBZIURT+On4OgB7hPpeXbykC94bg1VjldNcmBZQQAJvfg+Td4OBOdr/3efHHgwA81q0RXcK8VQ4n6DEVOj9l/P7/nqb5ubV8OeIW7G20bDiazpRVB1AURd2MQogqSzify5lL+djptHRq7AXxG4w7Gvc0y+VbriQFlBAp++CvN4zf3/42b2zOJC2rkEbezjzX1/wWsKyTNBq4bRbc8iigwA9j6VCwhY8faIdOq2HlrjO8seao2imFEFX05zFj61OHRp442dlA3DrjjrA+KqaqHCmgRN2mL4Efx4OhBJrfwXaX3qauu9n3tJIpC8yJRgP950DkcFD0sPIRbnM8zux7WgHw2V8JLPwnUeWQQoiqKO2+697UBy6cgIsnQGtrbIEyc1JAibpt+2fGOUccPCiIeZspqw4AcH+HhnQMNc/lA+o0rRbu+BCaDQR9ISy5n6H1LzI5xthS+Oovh1l3KFXlkEKIysgv0rM14QJwefzT8bXGHcGdwd5VxWSVIwWUqLsyz8LG143f3/YqH2/LJOF8Lr6u9kzp30zdbOLqdDYw+EsI7gpF2fDtYJ5oreH+DkEoCjy9dA/7TmeonVIIcR1bEy9QVGIg0N2BMF+Xf7vvmvRVN1glSQEl6q61U6EoBxp04EjAIOb9dQKAmXe1xN3RVuVw4ppsHeD+xeDfCnLPofnmbmb18qZ7Ux8Kig2MXrRDlnwRwsz9dXn8U7i7ntSkeOPaowBNY1RMVXlSQIm6Ke53OPwTaHQYbn+HqT8cosRgnDCzX0t/tdOJynBwhwdXQb1GkHEKmyX3MndwGBEBbpzPKWLkgu1k5BWpnVIIcRWl45989ee5tOtH4/QF9ULAK0zVXJUlBZSoe4rzYfVzxu+jH+f75HrsPZ2Bi70Nr97ZQt1sompcfOGhH8DFD9IO4vLTKL56qA0B7g6cOJfLE9/tplhvUDulEOI/Tl3IJfF8Ljot9G4ZRHCRccksmsSY/fQFpaSAEnXP5vfg0klwDSCr0yTeXGP8h/tM7yb4ujmom01UnWcjeGA52DpDwp/4//U8X41oj7Odji0nLjD9/w7JHFFCmJnS1qf2wZ707dEV57OXu+8sZPwTSAEl6poLJ4wFFEC/2Xy0OZXzOYWE+jgzonOIqtHETQiMhKFfg0YH+5bQ/OjHfHBfWzQaWLwtiUVbTqqdUAhxhdLxT93DfSDtIGQng40jhHRVOVnlSQEl6pbfpxv72Rv3It67Dwv+OQnAtIER2NnIPweL1qQP3PG+8ftNb9Enfw1TL19NOfOXw6b1toQQ6ioo1vPPifMA9Gjq++/0BaHdjReIWAj5xBB1x6lYOPIzaLQofV/j1V8OU2JQ6NPclx7hvmqnE9Wh3cNw6/PG7395lscCEhjavgEGBZ5avIf49Gx18wkh2HLiPAXFxukLmge4Qtx64w4L6r4DKaBEXaEosO5l4/dtH+L3C178HXceO52WlwdEqJtNVK+eL0Kb+0HRo1kxitc66+jQyJPswhJGL9opV+YJobINR4ytwb2a+6LJvwRntht3SAElhBk69AOc3Qm2zhR2e4FZvxwGYHS3RoR4O6scTlQrjcY4W/nliTZtl93PZ3cH0aCeI6cu5PHUkj2UyJV5QqhCURT+OGosoHo384MTf4BiAN8I8AhSOV3VSAElrF9JIfw+w/h9l2f45mAhSRfz8HW1Z3xPy5hvRFSRjR0M+wY8G0NmEvV+GsEXD7TA0VbH33HneWvtMbUTClEnHU7JIiWzAEdbHZ0ae/07/snCWp9ACihRF2z/HDJOgYs/We3GMndjPAATb2uKi72NyuFEjXHyhOErwMEDzu6k2dYpvD3EuPDw/E0J/LjnrLr5hKiDSrvvujbxxkEHxP9u3CEFlBDqS05OZvPmzSQnJ0PeRdg0x7ij18vMj03jUl4xjX2cGRLVQN2gouZ5NYZh3xpXdz+0igEXFvJEj8YAvPD9fg6cyVQ5oBB1y4YjaQD0ae4Lp7dD/kXjqgJB0SonqzopoITVSUhIID4+noSEBPj7HSjIAN8WpIfew5ebEwGYHNMMG528/euERt3KTG8wKfAgPcN9KCwxMPabnZzPKVQ1nhB1RXp2Afsu/9HSM9wXjv5i3NEkxrhIuIWRTxBhdUJDQwkLCyPMz9nYfQdw20w+2JhAfrGetg09iGnhp25IUbvaPgidnwZA+3/j+agHhHo7k5xZwFOLZVC5ELVh4+XB420auOPrag9HfzXuaDZAxVQ3TgooYXUCAwPp2rUr/nGLQV8IDTuR4B7N0h2nAXihXzM0FrLWkrhxZbpyAfrMMI6zKCnAZdUIvrinAU52OmITLjBnnQwqF6Km/X55/FPv5n5w7ihcSgSdHYT1VjnZjZECSlinzLOwa6Hx+x5TeWd9HHqDQs9wHzqGeqkaTdSOMl25AFodDP4CvMMhO5nQDWN5527jTOWf/ZXAbwdSVEwrhHUrKNazOc44+3ivZr7/tj6F9gB7V/WC3QQpoIR12vyuccmW4C7st23NrwdS0Gjg+X7N1E4maklpV25oaOi/Gx3c4f4lpivz+ifO5rGuIQBMWrFPZioXoobEJlwgv1hPgLsDLQLdLL77DqSAEtYo4zTs/tr4fc8Xeff3OADujqxP8wA3FYOJ2lTalRsYGFh2h1djGLrIuPDw/qVM8fidjqGe5BbpGfvNLnIKS9QJLIQVK736rlczXzTZKZC8G9BA0/7qBrsJUkAJ6/P3O8bWp5Bu7NW15M9j59BpNTzdu4nayYS5CO0B/WYDoNswg886Z+Hv5sCJc7m88P1+FEVRN58QVkRRFP4wjX/yhWOrjTsa3AKulntBjxRQwrpkJMGeb43f93yRDzcYW5/uigyUJVtEWR3GQOSDoBhw/2UMX9zpjY1Ww6/7U1i05aTa6YSwGodTskjOLMDBVkvnxt5XdN/drm6wmyQFlLAum94GQzE06s4BXQv+OJqOVgNP9ZLWJ/EfGg0MeAfqR0FBBi03jWN6vxAAXlt9hN1Jl9TNJ4SVWHvI2H3XvakPDvocSPzbuKPZQBVT3TwpoIT1uHQK9n4HwD6vgbz56wEA7oqsTyNpfRIVsXUwzlTu7Avph3gw7S0GtPSnWK8w/rvdXMwtUjuhEBZv7cFUAGJa+EPceuMfuV5NwNuy/7C1qgJqxowZaDSaMrdmzf696qqgoIDx48fj5eWFi4sLgwcPJi0trcw5kpKSGDBgAE5OTvj6+jJ58mRKSmRQqUXY8hEYSrjkGcnqM05sTsxEq4Ene8mCweIa3AKNCw9rbdEc+oF3628k1NuZlMwCnlm6B71BxkMJcaMSz+dyLC0bG62G3s38/h3/ZMFX35WyqgIKoEWLFqSkpJhumzdvNu179tln+fnnn1mxYgV//fUXycnJ3HPPPab9er2eAQMGUFRUxJYtW1i0aBELFy5k2rRpajwVURW5501jn/SdnmFnvg8Ad7QJpLGPi5rJhCVo2BFufwsA+7/+x8Lu2TjYavk77jwf/xGvcjghLNfaQ8bWp06NvXC3U4wtUCAFlDmysbHB39/fdPP29gYgMzOTL7/8knfffZdevXoRFRXFggUL2LJlC1u3bgVg3bp1HD58mG+//ZbIyEj69+/PrFmzmDt3LkVF0pRv1rZ/DiX5ENiW9MDe7EorQaOBp6T1SVRW+0eg3cOAQsM/nuK9vp4AvL/hOFviz6ubTQgLVVpA9W3hDyf/hsIsY5d5/fYqJ7t5VldAxcXFERgYSGhoKMOHDycpKQmAXbt2UVxcTJ8+fUzHNmvWjIYNGxIbGwtAbGwsrVq1ws/v38sqY2JiyMrK4tChQ1d9zMLCQrKyssrcRC0qyoXt843fd3mGjzYaWwwGtg4kzNcyZ7gVKuk/BwLbQv4l+h+ezAPtfFAUeHrpXtKzC9ROJ4RFSc0sYE9SBhoNxET4/bt4cHh/0Fp++WH5z+AK0dHRLFy4kDVr1vDpp5+SmJhIt27dyM7OJjU1FTs7Ozw8PMrcx8/Pj9RUY4Wcmppapngq3V+672pmz56Nu7u76RYUFFS9T0xc255vIf8i1GtEgncv1lz+i0dan0SV2TrA0G/AyQtS9jHT5iua+jpzPqeQZ5ftlfFQQlTB+sPG/4vbBnng62ILR3427mh+p4qpqo9VFVD9+/fn3nvvpXXr1sTExLB69WoyMjJYvnx5jT7u1KlTyczMNN1Onz5do48nrqAvgS0fG7/v/BSf/5OEokDvZr409ZPWJ3EDPIJgyALQaLHZv4RvIw/jaKvjn/gLMh5KiCoo/WO2X0t/OPUP5J4zLqMU2l3dYNXEqgqo//Lw8KBp06bEx8fj7+9PUVERGRkZZY5JS0vD398fAH9//3JX5ZX+XHpMRezt7XFzcytzE7Xk8I+QmQRO3pxrPJjvd58BYGz3xurmEpYttDv0ng6A7+ZpfNJdD8AHG46z5YSMhxLiejLyitiacBG4PH3BoR+NO5oNBJ2tesGqkVUXUDk5OZw4cYKAgACioqKwtbVlw4YNpv3Hjh0jKSmJTp06AdCpUycOHDhAenq66Zj169fj5uZGRERErecX16Eo8M/7xu+jH2fRjjSKSgy0bejBLSH1VI0mrECXZyDiLjAU03P/ZEa2ccGgwDNL93Iuu1DtdEKYtd+PpKM3KDTzdyW4nsO/3XctBqmaqzpZVQE1adIk/vrrL06ePMmWLVu4++670el03H///bi7uzN69GgmTpzIxo0b2bVrF6NGjaJTp0507NgRgL59+xIREcFDDz3Evn37WLt2LS+//DLjx4/H3t5e5WcnyjnxB6QeAFtnctuM5JutpwAYe2soGo1G5XDC4mk0cNdc44R/WWd5pfAdmvk6ci67kInL92KQ8VBCXNWaKyfPTIqF3HRwcIdG1tF9B1ZWQJ05c4b777+f8PBwhg4dipeXF1u3bsXHxzgn0HvvvcfAgQMZPHgwt956K/7+/qxatcp0f51Oxy+//IJOp6NTp048+OCDPPzww8ycOVOtpySuZcuHxq9RI1h2MIfM/GIaeTtzW8TVu1uFqBJ7V+NM5bbO6E7+xXdhG03zQ322KUHtdEKYpdzCEv6OOwdcHv90ZfedjZ16waqZRpFlx6tdVlYW7u7uZGZmyniompJ+FD6JBo2W4if30OPzBM5m5PPa3S0ZHh2sdjphbQ6shO9HA7Ap6mMe/scTnVbD8rGdiAqW7mIhrrT6QApPfLebhp5O/PVcNzTvRUBOGjywApr2VTveNVXl89uqWqBEHVI671P47aw+bcvZjHy8XewY3K6BurmEdWo1BDqMBaDboZcY0UxBb1B4eskeMvOKVQ4nhHn59UAKYGx90pzeZiyeHNwhtIe6waqZFFDC8hRkwr6lACgdxjDvL2NXyohOITjY6tRMJqxZ3/9Bg1vQFGQyLe8NwurpOJuRzwvf70ca8oUwyisq4Y8jxguxBrQKMF4pDVbXfQdSQAlLtOc7KM4F3whiDREcScnC0VbHQ52k607UIBs7uHcROHmjSz/AsoY/YqvTsOZQKt9evoDhapKTk9m8eTPJycm1FFYIdWw4kk5+sZ6Gnk60ru8Kh//PuCNikKq5aoIUUMKyGAyw43Pj9x0eY+EW4wfX4Kj6eDhZ1183wgy514fBXwAavI4t4Ys2xwGY9esRjqZefQmnhIQE4uPjSUiQgefCuv2639h9N6B1wOXuu1Sr7L4DKaCEpYn/HS4mgL07Z4Lu5PcjxolOR3QKUTeXqDsa94QeUwG49fgbPNgoh6ISA08t3kN+kb7Cu4SGhhIWFkZoaGhtJhWiVuUUlrDxmLH7bmDrgH+vvgsfYHXddyAFlLA02z8zfm37IN/sOodBgW5NvGkiy7aI2nTrZGjcC01JPjMK3iTYxUBceg6zfj1c4eGBgYF07dqVwMDAWg4qRO35/XAahSUGQr2difB3gSOXu++saPLMK0kBJSzH+XhjCxQa8tuOYsn2JEBan4QKtFq453Nwq4/NpROsDFyMRqOweFsSv12+AkmIuuaX/cYxfgNbB6BJioXsFLC3zu47kAJKWJLSsU9N+vLDSXuyCkpo6OlEz2a+6uYSdZOzN9y7ELQ2+CStZn74HgBe+H4/Zy7lqZtNiFqWmV/MX8eNk2cObBMI+5cZd0TcCTbWuZKHFFDCMhRmw97FgHHqgkVbTgLwcKdgdFpZtkWoJKgD3GZcqaBP0gcM8U8nq6CECUv3UqI3qBxOiNqz/nAaxXqFJr4uNPWyg8M/GXe0HqpusBokBZSwDAdWQGEWeIURq2nNsbRsHG113Ns+SO1koq7r+AQ0G4jGUMwb+rcJtC9g56lLfPRHvNrJhKg1/3bfBULcOuN8fW71IbiryslqjhRQwjLsWmT8GjWKhVuMY58GR9XH3dFWxVBC8O+iw/VCsMk+w/cB3wAKH/0Rx/bEi2qnE6LGXcotYnPceQAGtgn4t/uu5WDjeEErZb3PTFiPlH2Qshe0tpwNvkumLhDmx9HDOMmmzo6A1I182HAzBgUmLJWlXoT1W3solRKDQvMANxq7lMDxtcYdVtx9B1JACUuw+2vj1+YD+fZALgYFuobJ1AXCzARGQr/ZANxxbj4DPU6RnFnA1B9kqRdh3X65PHnmwNYBxqkL9EXg0xz8WqqcrGZJASXMW1Ee7F8BQHGbh1mx8zQAD3ZsqGYqISrWfjS0HIxG0fOu9gN8tdmsPpDKsh2n1U4mRI1IyyrgnxPG7rs72wTC/uXGHa3vNXZvWzEpoIR5O/wTFGaCRzDrC8I5n1OEj6s9vZv7qZ1MiPI0GrjjA/Bqgl1eKiv9F6HBwIyfDxGfnqN2OiGq3U97z6IocEtIPYJ0l+DkZuOOVveqG6wWSAElzNvuy4PH2z3Ekh1nABjavgG2OnnrCjNl72qcH8rGgYYXt/CG7wYKig08s3QPhSUVL/UihKVatfssAIPa1oeDKwEFGnYGD+vvJZBPIWG+zh2HpFjQ6DgTfA9/x51Ho4H7brH+f5jCwvm3hNvnADA0exG9HeM4lJzF22uPqRxMiOpzJCWLo6nZ2Om0DGwVaBpuQWvrb30CKaCEOSttfWoaw3dHjFcydWviQ5Cnk4qhhKiktg9B6/vQKAY+sZ+LF5l8/ncimy7P1iyEpfthj7H1qVczX9yz4yDtAGhtIWKQusFqiRRQwjyVFMG+JQAUt3nQNHj8gQ7S+iQshEYDA98F73DsC9JZ5vMVWgw8t2IfF3IK1U4nxE3RGxR+2mssoO5uVx8OXB483uQ2cPJUMVntkQJKmKdjv0LeBXANYH1Ra87nFOHrak/v5rLunbAgds4wdBHYOhGWvYNp7qs5l13I8ytlagNh2WJPXCAtqxAPJ1t6NvGEfUuNO1oPUzdYLZICSpin0rmf2j7I4p3GJQKGtg+SwePC8vg2hwHvADCiaCndbI+w4Wg6X8eeUjmYEDdu1R7jRT0DWwdgd/JPyE4BR08I769usFokn0bC/GQlw4mNAJwJvofN8cbB48NukXXvhIWKfAAiH0SjGPjM8VO8yeS11Uc4lpqtdjIhqiyvqIQ1B1MBuLttfdjzjXFH62FgY69istolBZQwPwdWUHop7LfHjW/RW2XwuLB0t88Bn+Y4FZ3na4/PKCkp4ekleygolqkNhGVZdyiNvCI9wV5OtPPSw7HfjDvaPqhusFomBZQwL4pi6kvXtxrK97uNzcT3y+BxYcaSk5PZvHkzycnJVz/IzunyeChnIgr28oLTzxxLy+aN347WXlAhqsGqy1ffDYqsj+bACjAUQ2Bb4/QddYgUUMK8pB6A9MOgs+cf+66cyy7Ey9lOBo8Ls5aQkEB8fDwJCQnXPtAnHAa+B8AYw3I6aw+ycMtJ/jiaVgsphbh5aVkFbI4zTsVxd2Tgv913daz1CaSAEuam9EqO8P4sPZAFwF2R9WXwuDBroaGhhIWFERoaev2D2wyDtg+hQWG+06f4cIlJK/aTnlVQ80GFuEkrd53BoED74HqEFB0z/sFr4wAth6gdrdbJp5IwH/qSy+OfICd8CL8fTgdgSFQDNVMJcV2BgYF07dqVwMDAyt3h9jng2wKXkkt84TKPzNx8nluxD4NBpjYQ5stgUFh+eU6+YbcEwZ5vjTua3wGOHuoFU4kUUMJ8JGyE3HRw8uKHnGYU6Q1EBLgREeimdjIhqpeto3E8lJ0LbUoO8JzdKv6OO89X/ySqnUyIq9qWeJFTF/JwsbdhQHN3OLDSuKMOdt+BFFDCnJR237UcwvLdxjEh97aX1idhpbybwB0fADBO+yPdtPt5c81RDp7NVDmYEBVbtiMJgDsjA3E6sQYKs8C9IYTcqnIydUgBJcxDQRYc/QWAkw0GcuBsJrY6DXdF1lc5mBA1qNUQaP8IGhQ+cfgUT/0Fnl66h7yiErWTCVFGZl4xv12e+2lY+6ArBo8PB23dLCXq5rMW5ufI/0FJAXg35bskL8C4QKWns53KwYSoYTGzwb81roZM5jnO5dS5LGb9cljtVEKU8dO+sxSWGGjm70prp4uQuAnQGCeJraOkgBLm4Yq5n37YmwLAkCiZeVzUAbYOcO9CsHOlrXKESTbLWbL9NL8dSFE7mRAmS7cbB4/fd0sQml1fGTc27gUedXeOPimghPoykuDk3wBscerD+ZxCvF3s6BHuo3IwIWqJV2O462MAxtn8TC/tbqasOkByRr7KwYSAg2czOZyShZ2NlkEtPf+9+q7DY+oGU5kUUEJ9B783fg3uyndHDQDc4gvn0lJVDCVELWsxCKIfB+AD+3m45CczYdle9DK1gVDZ0suDx/u18McjcTXkXwL3IGjSV+Vk6pICSqjv4CoA8sIHseHyjMzBhtTrz+oshLW5bRbUj8JVyeFT+4/Yk5jO3I3xaqcSdVh+kZ6f9hiXKBp2SxDs+MK4o/0o0OpUTKY+KaCEui6cgNT9oNGx9GI4xXqFRh62dG3ZqHKzOgthTWzsjOOhHDxorYnnRZvveP/34+w8eVHtZKKOWn0ghezCEoI8HenkcBrO7gStLbR9WO1oqpMCSqjrcusTod1ZfjgPgOgAXdVmdRbCmng0hLs/A2CUzVr6abbyzNK9ZOYXqxxM1EVfbz0FwH23NES760vjxhaDwEXGqEoBJdR1yFhAXQodyNGLejTAfR0bq5tJCLWF94MuEwCYY/c5dpkJvPjDARRFxkOJ2rPvdAb7Tmdgp9NyfyvXf2cev+VRdYOZCSmghHrSjxoXotTasiqvHQAdGnkSGR6ibi4hzEGvV6BhZ5zJ51Pb99mw/6RpHTIhasPXscbWpwGtA/CM+x5K8sGvJQRFq5zMPEgBJdRzufWJxr1YcSgbgEFtZeZxIQDQ2cC9C8DZl2ba0/zPdgHT/+8g8enZaicTdcDF3CJ+3m8cPP5wxysGj98yGjQaFZOZDymghDoUxTT+KSWoP0dTs7HVaejf0l/lYEKYEVd/GPIlikbLEN0m7jT8wZOL91BQrFc7mbByy3eepqjEQKv67kSW7IeLJ8DOFVoNVTua2ZACSqgj7SBciAOdPUuzWgHQI9wXDydZukWIMhrdiqbXywDMsl2ILu0Ar68+UuGhycnJbN68meTk5NpMKKyM3qDwzeXuu4c6BaPZPt+4I/J+sHdRMZl5kQJKqONy65MS1oeVB7MAGCQLBwtRsS7PQtN+2FPMJ7bv82PsYdYeKj/RbEJCAvHx8TKHmrgpG4+mczYjHw8nW+5qkAfHfjPu6DBG3WBmRgooUfsUxTT+KcEvhrMZ+bjY29C7ua/KwYQwU1otDPoUPBoSrE3nHdt5vLBib7mlXkJDQwkLC5M51MRNKZ26YFj7IOx3zgMUaNofvJuoG8zMSAElal/yHrh0Emwc+fZiMwBiWvjjYFu3Z7UV4pqcPGHo1yg6O27T7eKB4lU8s3QPJXqD6ZDAwECZQ03clMTzuWw6fg6NBh5u4wJ7Fxt3dH5S3WBmSAooUfsutz7pm8Tww+FMAO6KlP/whbiuwLZobp8DwHM2y7FN+pv3f49TOZSwJqVjn3qG+1I/fgmUFEBAJAR3UTeYGZICStQuRYFDPwFw2LM3GXnFeLvY07mxl8rBhLAQ7UZA5IPoNAof2X7Eqj+3sTnuvNqphBXIzC9m2eWFg0d28IfSweOdn5KpCyogBZSoXSn7IDPJ2H13oSkAA1r5Y6OTt6IQlaLRwIC3wb81Xpps5tp+wOSlO0jPLlA7mbBwS7cnkVukJ9zPlW75f0DuOXBrABF3qR3NLMmnlqhdR38BQN+4N6uPGLvvBraR7jshqsTWEYZ9g+LgQVttPE8UfsGzy/aiN8hSL+LGFJUYWPDPSQAe7RqCZusnxh0dHwedrXrBzJgUUKJ2HTEWUEc9upNdWIKfmz1RDeupHEoIC1QvBM09n6Og4SGb3/FP+IFP/4xXO5WwUL/sTyY1qwBfV3sGuR6Gc0eNE2e2e1jtaGZLCihRe87Hw7kjoLVh8aXmAPRvGYBWK33rQtyQpn3RdH8BgNdtv2Tt72vZmnBB5VDC0iiKwvxNxrnDRnYJwXbb5danqBHg4K5iMvMmBZSoPUd/BsAQ3JX/O5YHGBepFEJUTZkZx7u/YJxkU1PMp7bv8crivziXXah2RGFBNsef52hqNk52Oh5qeAkS/wKNDqIfVzuaWZMCStSey913x+r1lO47IW5CmRnHtVq4+zMM9UJpoDnP9MK3eW7pLhkPJSqttPVp2C1BuG57z7ix1RDwCFIxlfmTAkrUjqxkOLsT0JjWvru9lXTfCXEjys047uiB9r7vMNg40lV3iM6nPuGjP2R+KHF9R1Ky+DvuPFoNjA3Ph2O/AhroNkntaGZPCihRO47+CoChfntWxZUAMKCVdN8JcSMqnHHcLwLtIOPYlcdtfiZu4zf8Ey/zQ4lr+/xvY+vT7a0C8N/7kXFji7vBp6mKqSyDFFCidhwxjn+K9+pFdmEJ/m4OtJPuOyGqV8t7jJMeAnNsPuOjJT+QliXzQ4mKnbmUx//tTQbgqVYlcNg4yTG3SutTZUgBJWpe3kU4uRmA5bltAOjfyl+674SoCb1noG/UAydNIXOK32TqtxspvmK9PCFKffrnCUoMCl3CvAg/Ph9QoNlA8GuhdjSLIAXUVcydO5eQkBAcHByIjo5m+/btakeyXMfXgKLH4BvB0ngbAAbK1XdC1AydDbp7F1DsFkyQ9hyjU2Yx57eDaqcSZiY5I5/lO08D8PwttnDwe+OOWyermMqySAFVgWXLljFx4kSmT5/O7t27adOmDTExMaSnp6sdzTJdvvou0bsnOYUlBLg70DZIuu+EqDFOntgOX0qJzokuukP4b32NNQdT1E4lzMhnf52gWK/QMdSTNolfgmKApv0gMFLtaBZDCqgKvPvuuzz22GOMGjWKiIgI5s2bh5OTE1999ZXa0SxPUS6c2ADAqvx2gEyeKUSt8IvAZvBnADxis4ZNKz4k4VyOyqGEOUjLKmDJDmPr0+QO9rBvqXHHrc+rmMrySAH1H0VFRezatYs+ffqYtmm1Wvr06UNsbGyF9yksLCQrK6vMTVwWvwFKClA8gvk60QUwjn8SQtSCiDsxdDN2yUxnPh8tWkx+kV7lUEJt8/46QVGJgVtC6tHu1Feg6KFxL2gQpXY0iyIF1H+cP38evV6Pn59fme1+fn6kpqZWeJ/Zs2fj7u5uugUFyeRjJsfXAHDWryfZBXq8Xezl6jshapG254sUNu6HvaaEF7P/x5vL1qMoMslmXZWeXcDibUkAvNBeg2bvd8YdPaaqmMoySQFVDaZOnUpmZqbpdvr0abUjmQeDAY6vBWBtcVsAbovwQyfdd0LUHq0W+6FfkOcRjo8mk3vjnuebTUfKHFJmaRhh1T7flEBhiYF2DT2Iiv/YOPYpfAAEdVA7msWRAuo/vL290el0pKWlldmelpaGv3/FXU/29va4ubmVuQkgeTfknUexd+PLJGOLXkwLv+vcSQhRXUyF0YVsnEauJN+2Hi20p/Dd8AxbT5wzHVdmaRhhtc7nFPLtVmPr08ttctAc/QU0Wug9TeVklkkKqP+ws7MjKiqKDRs2mLYZDAY2bNhAp06dVExmgS53310K6EZyjgFXexs6N/ZWOZQQdUeZwsijIQ4PLqFEY0s/7XYOfDuFlMx8oIKlYYRVmrsxnvxiPW3qu9H2+PvGjZEPgG8zVXNZKimgKjBx4kQ+//xzFi1axJEjRxg3bhy5ubmMGjVK7WiW5ZixgPpH2x6Ans18sbORt5wQteW/hZEmuBOGAe8D8JiyksVfvEthib7ipWGEVTl9MY9vt54C4PVWqWhObQEbBxn7dBNs1A5gjoYNG8a5c+eYNm0aqampREZGsmbNmnIDy8U1ZJ6BtAMoaPgitTEAMS3k6jshalNgYGC5osiu/YNkJR/CbfcnPJn1Hl8tDubxh4aj0dz42MTk5GQSEhIIDQ2VIsxMvbPuGMV6hVvD6tHi8GvGjR3GgHsDdYNZMGkOuIonn3ySU6dOUVhYyLZt24iOjlY7kmW5PHi8wC+KfRdtsLPR0iPcR+VQQggAt4H/43yD27DXFDP0xBR++GPzTZ1PxlCZt4NnM/nx8pp3r4cdhfRD4OAOXZ9VOZllkwJK1IzLBdQeR2Ph2S3MG2d7afAUwixodXg/vIh01+Z4abJps2kM2w/F3/DpZAyVeXtr7TEA7mnlTYM97xk3dn0WnDxVTGX5pIAS1a8oDxL/AuDbi80B6b4TwuzYOePz2A9csvGlsSYZ7YqHSErPuKFTyRgq87Ul/jybjp/DVqdhmtcfkJkEroHQYaza0SyeFFCi+iX+BSUFlLg2YHV6PbQa6N3cV+1UQoj/0LgF4DRqFXkaR9pzmGOfjyKnoFjtWKKaKIrCG2uOAjCurQMeuz407rhtJtg5qZjMOkgBJarf5ekLjrt3ATTcEuKJl4u9upmEEBWyr9+KgkELKEHLbcV/8Oe8CRgMMlO5Nfj1QAr7z2TibKdjfPFCKM6Dhp2h1RC1o1kFKaBE9VIU0/inH3JbAdJ9J4S582zTn7NdjFdmDcz4lnXfzFY5kbhZ+UV6Zq82tj692voC9sd+Mk6aeftbcBNXXIp/SQElqlfqfshOQbF14ptU4+WxfWX2cSHMXvBtT3AkfBwAtyW8xeZfvlY5kbgZn/51grMZ+QS52XBP6gfGjbc8Cv6t1A1mRaSAEtXrcutTildHChQ7mge40aCe9LULYQma3zebA753oNMoRO14jgNb16sdSdyApAt5zPvrBACfNduD9vwxcPKCni+qnMy6SAElqtfl8U9/GNoB0EcGjwthOTQaWjz2FQedo3HUFNFgzShOH9+rdipRRbN+PUxRiYHbG2lofmyucWPv6eBYT91gVkYKKFF9cs/D2d0AfJkWBkDv5tJ9J4Ql0draEfbESo7bNKUe2dguGUJG6km1Y4lK2ngsnfWH07DRanjDZTmawiwIbAttH1I7mtWRAkpUnxMbAYVcj2YkFrrh42pP6/ruaqcSQlSRg7Mbno/9QJImEH/lHNmfD6QgM13tWOI6Ckv0zPz5MACvtTiDW9wPlweOvwNa+bivbvKKiupzYgMAe+yjAOgV7otWK1d7CGGJvP0aUDJ8Fal4EaQ/TeonA9HnZ6kdS1zDl5sTSTyfSyOXEu5Nece4seMT0CBK3WBWSgooUT0MBog3FlArMpoCMnmmEJYuNKw5qXct5aLiSkjhMZLm3oVSnK92LFGBUxdy+WiDcTmeBYE/oc1JBc/G0OtllZNZLymgRPVIOwi56RhsnPgtMwQ7Gy1dm3irnUoIcZMi23bgYM8FZCuONMrZzanP7gO9zFZuTgwGhSnfHyC/WM9jgScJSfoe0MBdH4Oto9rxrJYUUKJ6xP8OQJJ7FEXY0rmxF052sniwENbg1h638Ve7DylUbAk5/ydnvnoY9CVqxxKXLd6eRGzCBbxsi3ih+BPjxg5jILizusGsnBRQonqc+AOA9UXGSdrk6jshrMuAO+/l+7DXKVJ0NDi7mtRvRoNBr3asOu9sRj6zVx8B4Nvg1dhknwGPhtB7msrJrJ8UUOLmFWZDUiwA355vAkDvZjL+SQhrotFouG/4Y3xdfwYlihb/kz9ybsnjxvGPQhWKojB11QFyi/SM9k+g+Znlxh13fgT2LuqGqwOkgBI3L3ETGErIcQrilOJHRIAbgR7S7y6EtdFqNYwY/STzfV5Er2jwiVvOxRVPGdfAFNUmOTmZzZs3k5ycfM3jVu46w6bj56hvk8mLhe8ZN97yKIT2qPmQQgooUQ0uX32301ZmHxfC2tnqtIwaM5G5HpMxKBo8j3xL1qoJ0hJVjRISEoiPjychIeGqx6Rk5jPrl8NoMbDM+yt0+RfAryX0fa0Wk9ZtUkCJm6MopgHkKy6FAzL+SQhr52inY+S453nf+RkMiga3AwvJ+X68jImqJqGhoYSFhREaGlrh/hK9gWeW7CWroISZnmtpkLEDbJ1gyAKwdajltHWXFFDi5lxMgIxTGLS2bCxqho+rPa1k9nEhrJ6bgy0PP/Eibzo8g17R4HJoMXnLx1R4dV5lu6SEUWBgIF27diUwMLDC/a//tIftJy/S1fY4w/O/M268/W3waVqLKUWVC6gRI0awadOmmsgiLNHl1qdTzq3Jw4Ge4T4y+7gQdYS3iz2jnpjKLIfnKFZ0OB1dSf7SkeXmiapMl5SonNgTF1iwPRUPsvnE/iM0igFaD4PIB9SOVudUuYDKzMykT58+NGnShNdff52zZ8/WRC5hKS6Pf1pX2BKAHuEy/kmIusTf3YEx4yYxzX4yRYoOx7ifKVg8HIoLTMdcr0tKVM6FnEImLNuDFj2LXD/FreSCcbbxAe+ARv5wrW1VLqB+/PFHzp49y7hx41i2bBkhISH079+flStXUlwss9PWKSWFcPJvAH7MboZOq6FLmMw+LkRdE+jhyPhxzzDVbioFii0OJ9ZStOhuyM8w7r9Ol5S4PkVRmLRiH2lZhbzpupw2xXvBxhHuXQj2rmrHq5NuaAyUj48PEydOZN++fWzbto2wsDAeeughAgMDefbZZ4mLi6vunMIcJcVCcR55dt4cURoSFVwPd0dbtVMJIVTQoJ4TE8aN5zm7V8hSHLE7s4WiL/tDVora0azCvL8S2HjsHA/abmRI8c/GjXfPg4DW6garw25qEHlKSgrr169n/fr16HQ6br/9dg4cOEBERATvvfdedWUU5urERgD22LYFNPQI91E3jxBCVUGeTkwZ9xjPOL5GuuKB3fnDFH9+G5yPVzuaRVt/OI231h6lo/YwM20WGDf2fBlaDFI1V11X5QKquLiY77//noEDBxIcHMyKFSuYMGECycnJLFq0iN9//53ly5czc+bMmsgrzEnCnwD8lG2cfbxHUxn/JERdF+TpxOxxw5no8iaJBj9ss09T8sVtcGaX2tEs0tHULCYs3UNDUvnK8UO0Sgm0HAK3TlI7Wp1X5dVeAwICMBgM3H///Wzfvp3IyMhyx/Ts2RMPD49qiCfMVt5FSNkHwJ9FLfBzs6d5gPTDCyGMA8s/GHc3T37uzNRLr9C6IBHDgv5o7/kMWtytdjyLcT6nkNELd2JblMFil/dwKsmC+u3hro9l0LgZqHIL1HvvvUdycjJz586tsHgC8PDwIDEx8WazCXN2cjOgcM4hhHTq0b2pDxr5By2EuMzLxZ55j/fjDd85/KGPRKsvhBUj4a+3ZOmXSigs0fP4N7vIyrjAMqe3qF9yGtzqw32LwVaWyjIHVS6gHnroIRwcZKbTOu9y993f+hZA+ekLZOI8IYS7oy2fP9aTbxq9wRcl/Y0bN74G3z8KxfnqhjNjBoPClO8PcPhUCl87zCHccAKcvOGhH8BVVnowFzITubgxiX8B8FtuODqthq5Nyk5fIBPnCSEAnO1t+HxENPFtX2RK8aMUKzo4uBJl4UDIlHkE/0tRFKb/3yFW70nkS7u3acsxcHCHh38En3C144krSAElqi7zDFyIx4CWrYYIooLr4eZQdvoCmThPCFHKRqdl9j2tqN/rcR4unkKG4ozm7E6Uz241Xc0rjMXTG78dZdnWeObZvkcn7WGwc4UHfwD/VmWOlVZ+9UkBJaouwdj6lGjXlGycKpy+QCbOE0JcSaPR8FTvJgwZ/AD3FL/GIUMwmrzzKN/cbRwXZTCoHbHGVLbY+XBDPF9vOsw82/foqdtnXCB4+ApoEFXuWGnlV1+Vr8ITorT7bl1Bc0CmLxBCVN7gqAbUr3cnj33rw1NFX3C/zUbjuKjT2+Ge+eDkqXbEalda7ABX/aPy800JLPp9J0vs3iJSm2CcZfy+xRDcqcLjS1v3pZVfPVJAiapRFNMA8k0lETJ9gRCiyjqGerHi6d6M+dqdXWlN+Z/NVzjEr0f5pBOau+ZCkz5qR6xW1yp2FEXhoz/iWfn733xv9waNtGng6AkPLIOgDlc9Z2BgoLTwq0y68ETVnDsGOWkUa+zYbWgi0xcIIW5IfQ9HVj7emaKW9zOoaBYnDAFoclLhu8Hwy0QoylU7YrW52pAGvUHh5R8Psv73NXxvN51G2jQUj4Ywet01iydhHqSAElVzuftuvzaCQuzoLt13Qogb5Gin44P7Ihlyewx3lcxmQUmMccfOL2FeVzi9Q92ANaigWM+4b3eRs2MxS+1m4aPJAv9WaEavB+8mascTlSAFlKiay9136wuaodFAlzAvdfMIISyaRqPh0W6hfDeuJwvdxzG8aCrJiidcTED5qi+sfh4KMtWOWa0u5RbxyOd/0ev4LD6w+wRnTSE07gUjV4Orv9rxRCVJASUqT19yeQZy2GxoSesGHng42akcSghhDdoEefDr093wa9OPfoVvsErfFY1igO2fwUftYf8Kq5jBfNepSzzx/hKmpT7NfTZ/oqCB7lNg+EpwcFM7nqgCGUQuKi95DxRmkat15bASwvj/TJ4phBA3w8XehneHRfJDU2+m/eTByqJbmWW7kMa5ybDqUdi9CPq/BX4RaketMkVR+GLTCU6t/4QvdN/irC2kxNEHm3u/hNDuascTN0BaoETlJf4JQKyhBQa0dA2TAkoIUf3ubtuADRO74x7Rh/6Fs3mreCiF2MHJv+HTzrBqLFy0nPVWM/KKmPX5EtpvGMb/bL7EWVNIScit2DzxjxRPFkxaoETlXZ5A88/i5jjb6WjbsJ7KgYQQ1srXzYFPH4xizcH6TPvJhf/L6cJUm+8YoNsO+5fCwZXQ7mG4dTK4mefl/Iqi8OuOI+T+NpOXDGvQaRWKdM7Y9nkJm+jHQatTO6K4CVJAicopLjBOdAf8Y2hJp6Ze2NlIA6YQomqSk5NJSEggNDS0UvMY9WvpT6fGXry77hjPbPPl05ITTLJdQQ/2wc6vYM930GoIRD8OAa1r4RlUTsLps2xdPoe+Wd/jrckCDWQ0vguPu94EtwC144lqIAWUqJyzO0FfyCWtJ4mKPyOblF++RQghrqcys3L/l7ujLa/e1ZIRnUN4c40vIw+F0kFzhOftltNefwz2fme8BXeB6LEQPgB0Nffxdq0i8GLaaY7++BatklfwgCYfNHDJMRiXez7Ao0nPGsskap8UUKJySq++K2kGaOgmA8iFEDfgZpYgCfVx4bOH2rPj5EVeX+3BkKRmtNPEMdJmLQN029Gd+gdO/QNOXtD8Tmh5j7GouomusoqKpXJFYEkR5w+s5ezf3xJ+YQOdNcWggbO2wTj0eA6vjg+AzvZaDyMskBRQonIuF1Cx+ubU93CkkbezyoGEEJaoOpYguSXEk1XjOhObcIH5m3x5+lhTXiu+yIM2v/OQ7UY88i7ArgXGm7MPNBsIIV2hYSdwr1+lx6qoxSw0NBRdSR5hNmdJ/24szgmr8dZn4Q2ggeM2TcnvOIE2ve4HrQx1sFYaRbGCiTXMTFZWFu7u7mRmZuLmZgXzehQXwJvBUFJAr8K36dA+mjcGm89YAyFE3XYsNZsv/k7gp73JGPRFdNQeYYB2KwNtd+KqZJc92L0hNOxonArBIxjqBYNHiHER4/8uS6UopJw6TvKx3QR7OeKtyUA5s5OCxG04ZMSh4d+Pz3OKO39rbkET1odBD4xFI4WTRarK57cUUDXA6gqok//Awtu5qPGgXf5c5j4QxYDWMghSCGFeMvOK+e1gCj/uPcu2xIvolBK6aA/RXbuPDjZxNCcRHYYK76vo7NCjQ2tjh9bGDrQ2KPkZaEryr/p4pw0+bNO25lzIHYS16oRj/vlKD44X5qkqn9/ShSeu79Q/APxT0gyNRiPLtwghalRVr9Qr5e5ky30dGnJfh4YkZ+Sz+kAKW04E8m5iFDkFJThRQFttHFGaOEK0qQRp0gnWnseXi2j0RcYPRH0+FBrPV9oelaU4ck7x4KzizX4llKPapng07UT3di25o6k39jYyHUFdJAWUuL6TfwOw1RBB6/rusnyLEKJG3ciVev8V6OHIo91CebRbKCV6A4eSs9iacIEjKaH8daEbX1/IJSOvGAB7ivAmExuNHhv+vWXhRJbOE1/PekQGeRDZ0IOeQR487ueKjU666Oo6KaDEtZUUmuZ/2mpoTn+ZvkAIUcNu5kq9itjotLQJ8qBNkEeZ7Rl5RSRnFFBYoqeoxEBhiYFivQE3R1u8XezxdrHDxd4GzX/HRgmBFFDies7uhpICLuDOCSWQrjJ9gRCihlXHlXqV4eFkV6ZFvbTrsH5oKIHenjX++MKySRukuDbT9AXNcLS1oZ0s3yKEsALJycls3ryZ5ORk07bSrsOEhAQVkwlLIS1Q4tpOGQuorYYIbmnsKcu3CCGswtXmd7ryqxDXIgWUuLqSIkjaBhjHP93bWK6+E0JYh4qKpdrqOhTWQQoocXXJu6EknwuKG/FKfbqEyfgnIYR1kGJJ3CzpjxFXd7K0+64Z7o52NA+wgklBhRBCiGpgVQVUSEgIGo2mzO2NN94oc8z+/fvp1q0bDg4OBAUF8dZbb5U7z4oVK2jWrBkODg60atWK1atX19ZTMC+XC6hthuZ0CvVCp5VLeYUQQgiwsgIKYObMmaSkpJhuTz31lGlfVlYWffv2JTg4mF27djFnzhxmzJjB/PnzTcds2bKF+++/n9GjR7Nnzx4GDRrEoEGDOHjwoBpPRz36YjhdOv4pQmYfF0IIIa5gdWOgXF1d8ff3r3Dfd999R1FREV999RV2dna0aNGCvXv38u677zJmzBgAPvjgA/r168fkyZMBmDVrFuvXr+fjjz9m3rx5tfY8VJe8B4rzuKi4EqfUp1NjGf8khBBClLK6Fqg33ngDLy8v2rZty5w5cygpKTHti42N5dZbb8XO7t+J02JiYjh27BiXLl0yHdOnT58y54yJiSE2NrZ2noC5uLz+3TZDM3zdHGns46xyICGEEMJ8WFUL1NNPP027du3w9PRky5YtTJ06lZSUFN59910AUlNTadSoUZn7+Pn5mfbVq1eP1NRU07Yrj0lNTb3q4xYWFlJYWGj6OSsrq7qeknpOGQvGHYZmdGnsLUsZCCGEEFcw+xaoKVOmlBsY/t/b0aNHAZg4cSI9evSgdevWPP7447zzzjt89NFHZYqbmjB79mzc3d1Nt6CgoBp9vBpnMMDprQDsMITTWaYvEEIIIcow+xao5557jpEjR17zmKvNGhsdHU1JSQknT54kPDwcf39/0tLSyhxT+nPpuKmrHXO1cVUAU6dOZeLEiaafs7KyLLuIOncUCjLJVew5rATTWSbQFEIIIcow+wLKx8cHHx+fG7rv3r170Wq1+Pr6AtCpUydeeukliouLsbW1BWD9+vWEh4dTr1490zEbNmxgwoQJpvOsX7+eTp06XfVx7O3tsbe3v6GMZinJ2H23xxBGQ283Aj0cVQ4khBBCmBez78KrrNjYWN5//3327dtHQkIC3333Hc8++ywPPvigqTh64IEHsLOzY/To0Rw6dIhly5bxwQcflGk9euaZZ1izZg3vvPMOR48eZcaMGezcuZMnn3xSradW+5JKu++aSeuTEEIIUQGzb4GqLHt7e5YuXcqMGTMoLCykUaNGPPvss2WKI3d3d9atW8f48eOJiorC29ubadOmmaYwAOjcuTOLFy/m5Zdf5sUXX6RJkyb8+OOPtGzZUo2npY7LLVA7lHCGy/QFQghBcnIyCQkJhIaGyhIwAgCNoiiK2iGsTVZWFu7u7mRmZuLmZmHLn2SchvdbUqJoaV34BZtfuQNPZ7vr308IIazY5s2biY+PJywsjK5du6odR9SQqnx+W00LlKgml2cfP6SEEBzgK8WTEELw78VKV7toSdQ9UkCJsi533+00hNMx1FPlMEIIYR4CAwOl606UYTWDyEU1uTyAfLshnI6hMoBcCCGEqIgUUOJf+RkoaYcA2K2EE91IWqCEEEKIikgBJf51ejsaFBIM/nj7B+HhJOOfhBBCiIpIASX+JeOfhBBCiEqRAkr8q3QCTSWc6EYy/kkIIYS4GimghFFJIcrZXYCxBUrGPwkhhBBXJwWUMEreg0ZfyDnFDXvfJtST+Z+EEEKIq5ICShhdOf5Jlm8RQgghrkkKKGF0efzTTpn/SQghhLguKaAEGAwYTAVUUzrI+CchhBDimqSAEnAhHm1BBvmKHSW+rWT9OyGEEOI6pIAScGY7APuVUG5p7KdyGCGEEML8SQEl4LSxgNpjaCITaAohhBCVIAWUoCTJWEDtNoTRQSbQFEIIIa5LCqi6riAT3fmjAGR6tZXxT0IIIUQlSAFV153dhQaFJIMP4WGN1U4jhBBCWAQpoOq60zsA2K00kekLhBBCiEqSAqqOKz61DYDdhiZ0CJECSgghhKgMKaDqMoMBzhhboFJdW+Hr5qByICGEEMIySAFVl12Iw7Y4i3zFjnqh7dROI4QQQlgMKaDqsEsH1gHGCTSjQn1VTiOEEEJYDimg6rD8uE2AcQJNGf8khBBCVJ4UUHWYa3Y8AHG24QR7OamcRgghhLAcUkDVVQWZuOQkAmAb0gmNRqNyICGEEMJySAFVV53ZaZpAs3mTMLXTCCGEEBZFCqg6Sl+6/p3ShFtk/JMQQghRJVJA1VF5CbEAHNY1I9zfVeU0QgghhGWRAqouMhiwS90FQJF/FDqtjH8SQgghqkIKqLro/HHsS3LIV+zwbxqldhohhBDC4kgBVQcpp43r3+1XQmkf6qdyGiGEEMLySAFVB2WdMBZQB2hCqwbuKqcRQgghLI8UUHWQ/rRx/FOmZxvsbXQqpxFCCCEsjxRQdU1RHu7ZcQC4NI5WOYwQQghhmaSAqmtS96NDT5riQfOmzdROI4QQQlgkKaDqmOwTWwHYZ2hM2+B6KqcRQgghLJMUUHVM9uUB5MnOLXB1sFU5jRBCCGGZpICqYxzT9wKg1G+nbhAhhBDCgkkBVZfknqdeUTIAvuEdVQ4jhBBCWC4poOqQwlM7AThhCKB1WLDKaYQQQgjLJQVUHZJ+9B8Ajtk0pUE9R5XTCCGEEJZLCqg6xHDGOIFmjlcbNBpZQFgIIYS4UVJA1RWKgmfGAQAcQjqoHEYIIYSwbFJA1RGGiydxNWRRqNgQ0kIKKCGEEOJmSAFVR6QdMY5/OkoIzYN8VE4jhBBCWDYpoOqIzHjjDOQpLhHY6uTXLoQQQtwM+SStI+zT9gJgCJAJNIUQQoibJQVUXaAvJiD/GACe4Z1UDiOEEEJYPimg6oBLp/bhQBFZihPNI9qqHUcIIYSweFJA1QHJh4wDyONtm+DubK9yGiGEEMLySQFVBxQn7QAg07O1ykmEEEII6yAFVB3gcdE4gaZ9sMz/JIQQQlQHKaCsXEFuFkElpwBo2LKLymmEEEII6yAFlJU7eWgrOo3COepRv2Go2nGEEEIIqyAFlJW7FL8dgLNOzWQBYSGEEKKaSAFl5bQpewEo8pUB5EIIIUR1sZgC6rXXXqNz5844OTnh4eFR4TFJSUkMGDAAJycnfH19mTx5MiUlJWWO+fPPP2nXrh329vaEhYWxcOHCcueZO3cuISEhODg4EB0dzfbt22vgGdUOn5yjALiF3qJyEiGEEMJ6WEwBVVRUxL333su4ceMq3K/X6xkwYABFRUVs2bKFRYsWsXDhQqZNm2Y6JjExkQEDBtCzZ0/27t3LhAkTePTRR1m7dq3pmGXLljFx4kSmT5/O7t27adOmDTExMaSnp9f4c6xuqefOE2w4A0DDlp1VTiOEEEJYD42iKIraIapi4cKFTJgwgYyMjDLbf/vtNwYOHEhycjJ+fn4AzJs3jxdeeIFz585hZ2fHCy+8wK+//srBgwdN97vvvvvIyMhgzZo1AERHR3PLLbfw8ccfA2AwGAgKCuKpp55iypQplcqYlZWFu7s7mZmZuLm5VcOzvjGxG3+h01/DOa/xwnt6gmo5hBBCCEtQlc9vi2mBup7Y2FhatWplKp4AYmJiyMrK4tChQ6Zj+vTpU+Z+MTExxMbGAsZWrl27dpU5RqvV0qdPH9MxliQrwTiB5jnX5ionEUIIIayLjdoBqktqamqZ4gkw/ZyamnrNY7KyssjPz+fSpUvo9foKjzl69OhVH7uwsJDCwkLTz1lZWTf1XKqLffo+AJSASHWDCCGEEFZG1RaoKVOmoNFornm7VuFiLmbPno27u7vpFhQUpHYkCkv0NCg4DoBnk2iV0wghhBDWRdUWqOeee46RI0de85jQ0MpN/ujv71/uarm0tDTTvtKvpduuPMbNzQ1HR0d0Oh06na7CY0rPUZGpU6cyceJE089ZWVmqF1FHTyXTimQA/MKlgBJCCCGqk6oFlI+PDz4+PtVyrk6dOvHaa6+Rnp6Or68vAOvXr8fNzY2IiAjTMatXry5zv/Xr19OpUycA7OzsiIqKYsOGDQwaNAgwDiLfsGEDTz755FUf297eHnt7+2p5HtXlzOHttNEoXNT54Onqd/07CCGEEKLSLGYQeVJSEnv37iUpKQm9Xs/evXvZu3cvOTk5APTt25eIiAgeeugh9u3bx9q1a3n55ZcZP368qbh5/PHHSUhI4Pnnn+fo0aN88sknLF++nGeffdb0OBMnTuTzzz9n0aJFHDlyhHHjxpGbm8uoUaNUed43Kj9pFwAZHhEqJxFCCCGsj8UMIp82bRqLFi0y/dy2bVsANm7cSI8ePdDpdPzyyy+MGzeOTp064ezszIgRI5g5c6bpPo0aNeLXX3/l2Wef5YMPPqBBgwZ88cUXxMTEmI4ZNmwY586dY9q0aaSmphIZGcmaNWvKDSw3d64XDgBg06CdykmEEEII62Nx80BZArXngUrPKiDr7baEaZPJH7oMx4h+tZ5BCCGEsDR1ch4o8a99J84QqkkBwLFhlMpphBBCCOsjBZQVSju2Ha1GIcPWF1yqZ5C+EEIIIf4lBZQVKjxlnIH8klszlZMIIYQQ1kkKKCtTrDfgk2OcfDTHqaHKaYQQQgjrJAWUlTmSkkULTSIA/i26qZxGCCGEsE5SQFmZgwlnaKw1DiD3adXnOkcLIYQQ4kZIAWVlQktOAJBt7w/O3iqnEUIIIayTFFBWpqPDaQBcG7VXOYkQQghhvaSAsjYp+4xfAyJVjSGEEEJYMymgrE3qfuPXgNbq5hBCCCGsmBRQ1qQoD84fN37vLwWUEEIIUVOkgLIm6YdBMYCzD7j6q51GCCGEsFpSQFmT0vFP/q1Bo1E3ixBCCGHFpICyJjL+SQghhKgVUkBZk5TLBZSMfxJCCCFqlBRQ1kJfYhwDBRDQRt0sQgghhJWTAspanD8OJQVg5wr1GqmdRgghhLBqUkBZi9LxT/4tQSu/ViGEEKImySettZDxT0IIIUStsVE7gKgmcgWeEEKY6PV6iouL1Y4hzIytrS06na5aziUFlDVQlCu68KSAEkLUXYqikJqaSkZGhtpRhJny8PDA398fzU3OlygFlDXIOAUFmaC1BZ9maqcRQgjVlBZPvr6+ODk53fSHpLAeiqKQl5dHeno6AAEBATd1PimgrEHqAeNX3+ZgY6duFiGEUIlerzcVT15eXmrHEWbI0dERgPT0dHx9fW+qO08GkVuDFBn/JIQQpWOenJycVE4izFnp++Nmx8hJAWUNTOOfZAJNIYSQbjtxLdX1/pACyhpIC5QQQli0Hj16MGHCBLVjAPDjjz8SFhaGTqdjwoQJLFy4EA8PD7VjmR0poCxd7nnITgY04NdS7TRCCCHM0J9//olGo6nU1Yljx45lyJAhnD59mlmzZjFs2DCOHz9u2j9jxgwiIyNrLqyFkEHkli5ln/GrV2Owd1E3ixBCCIuWk5NDeno6MTExBAYGmraXDr4W/5IWKEsn8z8JIYRVKCkp4cknn8Td3R1vb29eeeUVFEUx7S8sLGTSpEnUr18fZ2dnoqOj+fPPP037T506xR133EG9evVwdnamRYsWrF69mpMnT9KzZ08A6tWrh0ajYeTIkeUe/88//8TV1RWAXr16odFo+PPPP8t04S1cuJBXX32Vffv2odFo0Gg0LFy4sKZeErMmLVCWTsY/CSHEVSmKQn6xXpXHdrTVVWnA8qJFixg9ejTbt29n586djBkzhoYNG/LYY48B8OSTT3L48GGWLl1KYGAgP/zwA/369ePAgQM0adKE8ePHU1RUxKZNm3B2dubw4cO4uLgQFBTE999/z+DBgzl27Bhubm4Vtih17tyZY8eOER4ezvfff0/nzp3x9PTk5MmTpmOGDRvGwYMHWbNmDb///jsA7u7uN/dCWSgpoCydtEAJIcRV5RfriZi2VpXHPjwzBie7yn/MBgUF8d5776HRaAgPD+fAgQO89957PPbYYyQlJbFgwQKSkpJMXWuTJk1izZo1LFiwgNdff52kpCQGDx5Mq1atAAgNDTWd29PTEwBfX9+rDgi3s7PD19fXdLy/v3+5YxwdHXFxccHGxqbC/XWJFFCWrCgXLpwwfi8FlBBCWLSOHTuWabHq1KkT77zzDnq9ngMHDqDX62natGmZ+xQWFpomDX366acZN24c69ato0+fPgwePJjWreWzoaZIAWXJ0g4DCrj4gYuP2mmEEMLsONrqODwzRrXHri45OTnodDp27dpVbvZsFxfjBUSPPvooMTEx/Prrr6xbt47Zs2fzzjvv8NRTT1VbDvEvKaAsWdpB41eZvkAIISqk0Wiq1I2mpm3btpX5eevWrTRp0gSdTkfbtm3R6/Wkp6fTrVu3q54jKCiIxx9/nMcff5ypU6fy+eef89RTT2FnZ1zmS6+/+fFgdnZ21XIeSydX4Vmy0gLKXwooIYSwdElJSUycOJFjx46xZMkSPvroI5555hkAmjZtyvDhw3n44YdZtWoViYmJbN++ndmzZ/Prr78CMGHCBNauXUtiYiK7d+9m48aNNG/eHIDg4GA0Gg2//PIL586dIycn54ZzhoSEkJiYyN69ezl//jyFhYU3/+QtkBRQlixVWqCEEMJaPPzww+Tn59OhQwfGjx/PM888w5gxY0z7FyxYwMMPP8xzzz1HeHg4gwYNYseOHTRs2BAwti6NHz+e5s2b069fP5o2bconn3wCQP369Xn11VeZMmUKfn5+PPnkkzecc/DgwfTr14+ePXvi4+PDkiVLbu6JWyiNcuUkE6JaZGVl4e7uTmZmJm5ubjXzIIoCs4OgKBvGxYJfRM08jhBCWIiCggISExNp1KgRDg4OascRZupa75OqfH5LC5SlyjhlLJ50duDdRO00QgghRJ0iBZSlKu2+8wkHna26WYQQQog6RgooS5V2yPjVr5W6OYQQQog6SAooS5V2wPhVrsATQgghap0UUJbKdAVeC3VzCCGEEHWQFFCWqDAHLiUav5cuPCGEEKLWSQFlidIPG7+6BoCzl7pZhBBCiDpICihLlHp5/JN03wkhhBCqkALKEpmuwJMB5EIIIYQapICyRKY18GT8kxBCCHUsXLgQDw8PtWMwcuRIBg0aVOuPKwWUpTEYrmiBki48IYQQ5unkyZNoNBr27t1rlue7WVJAWZqMU1CUAzp78JIlXIQQoq4qKipSO0K1sNTnIQWUpSntvvNtBjobdbMIIYSoFtnZ2QwfPhxnZ2cCAgJ477336NGjBxMmTDAdExISwqxZs3j44Ydxc3NjzJgxAHz//fe0aNECe3t7QkJCeOedd8qcW6PR8OOPP5bZ5uHhwcKFC4F/W3ZWrVpFz549cXJyok2bNsTGxpa5z8KFC2nYsCFOTk7cfffdXLhw4ZrPqVGjRgC0bdsWjUZDjx49gH+73F577TUCAwMJDw+vVM6rna/U22+/TUBAAF5eXowfP57i4uJr5rtZ8glsaUwTaMoAciGEuC5FgeI8dR7b1gk0mkodOnHiRP755x/+7//+Dz8/P6ZNm8bu3buJjIwsc9zbb7/NtGnTmD59OgC7du1i6NChzJgxg2HDhrFlyxaeeOIJvLy8GDlyZJXivvTSS7z99ts0adKEl156ifvvv5/4+HhsbGzYtm0bo0ePZvbs2QwaNIg1a9aYMlzN9u3b6dChA7///jstWrTAzs7OtG/Dhg24ubmxfv36Sue71vk2btxIQEAAGzduJD4+nmHDhhEZGcljjz1WpdegKqSAsjRpUkAJIUSlFefB64HqPPaLyWDnfN3DsrOzWbRoEYsXL6Z3794ALFiwgMDA8rl79erFc889Z/p5+PDh9O7dm1deeQWApk2bcvjwYebMmVPlAmrSpEkMGDAAgFdffZUWLVoQHx9Ps2bN+OCDD+jXrx/PP/+86XG2bNnCmjVrrno+Hx8fALy8vPD39y+zz9nZmS+++KJMEXQ91zpfvXr1+Pjjj9HpdDRr1owBAwawYcOGGi2gpAvP0piuwJMCSgghrEFCQgLFxcV06NDBtM3d3d3UtXWl9u3bl/n5yJEjdOnSpcy2Ll26EBcXh16vr1KO1q1bm74PCAgAID093fQ40dHRZY7v1KlTlc5/pVatWlWpeLqeFi1aoNPpTD8HBASYstcUaYGyJAVZcOmk8XtpgRJCiOuzdTK2BKn12NXM2fn6LVr/pdFoUBSlzLaKxgfZ2tqWuQ+AwWCo8uNVRkXPo7I5K3Jl9tJz1VT2UlJAWZL0I8avroHg5KluFiGEsAQaTaW60dQUGhqKra0tO3bsoGHDhgBkZmZy/Phxbr311mvet3nz5vzzzz9ltv3zzz80bdrU1CLj4+NDSkqKaX9cXBx5eVUbF9a8eXO2bdtWZtvWrVuveZ/SFqbKtoRdL2dVz1fTpICyJGmXl3CR7jshhLAarq6ujBgxgsmTJ+Pp6Ymvry/Tp09Hq9WaWoKu5rnnnuOWW25h1qxZDBs2jNjYWD7++GM++eQT0zG9evXi448/plOnTuj1el544YVyLTbX8/TTT9OlSxfefvtt7rrrLtauXXvN8U8Avr6+ODo6smbNGho0aICDgwPu7u5XPf56Oat6vpomY6AsSUEm2DhK950QQliZd999l06dOjFw4ED69OlDly5daN68OQ4ODte8X7t27Vi+fDlLly6lZcuWTJs2jZkzZ5YZQP7OO+8QFBREt27deOCBB5g0aRJOTlXrXuzYsSOff/45H3zwAW3atGHdunW8/PLL17yPjY0NH374IZ999hmBgYHcdddd1zz+ejmrer4ap1iI//3vf0qnTp0UR0dHxd3dvcJjgHK3JUuWlDlm48aNStu2bRU7OzulcePGyoIFC8qd5+OPP1aCg4MVe3t7pUOHDsq2bduqlDUzM1MBlMzMzCrdr1L0JYpSmFP95xVCCAuXn5+vHD58WMnPz1c7yk3LyclR3N3dlS+++ELtKFbnWu+Tqnx+W0wLVFFREffeey/jxo275nELFiwgJSXFdLtyfZzExEQGDBhAz5492bt3LxMmTODRRx9l7dq1pmOWLVvGxIkTmT59Ort376ZNmzbExMTU+Gj+StPqzL4/XwghRNXs2bOHJUuWcOLECXbv3s3w4cMB1G9lEVdlMWOgXn31VQDTjKRX4+HhUW5+iFLz5s2jUaNGpllamzdvzubNm3nvvfeIiYkBjM2ojz32GKNGjTLd59dff+Wrr75iypQp1fRshBBCiLLefvttjh07hp2dHVFRUfz99994e3urHUtchcW0QFXW+PHj8fb2pkOHDnz11VdlLomMjY2lT58+ZY6PiYkxTVdfVFTErl27yhyj1Wrp06dPuSnthRBCiOrStm1bdu3aRU5ODhcvXmT9+vW0atVK7VjiGiymBaoyZs6cSa9evXBycmLdunU88cQT5OTk8PTTTwOQmpqKn59fmfv4+fmRlZVFfn4+ly5dQq/XV3jM0aNHr/q4hYWFFBYWmn7OysqqxmclhBBCCHOjagvUlClT0Gg017xdq3D5r1deeYUuXbrQtm1bXnjhBZ5//nnmzJlTg8/AaPbs2bi7u5tuQUFBNf6YQgghhFCPqi1Qzz333HXX6gkNDb3h80dHRzNr1iwKCwuxt7fH39+ftLS0MsekpaXh5uaGo6MjOp0OnU5X4TFXG1cFMHXqVCZOnGj6OSsrS4ooIYRQifKf2ayFuFJ1vT9ULaB8fHxMiwPWhL1791KvXj3s7e0B47o9q1evLnPM+vXrTev5lA7c27Bhg+nqPYPBwIYNG3jyySev+jj29vamxxBCCKGO0kkX8/LycHR0VDmNMFels5tXdTLR/7KYMVBJSUlcvHiRpKQk9Ho9e/fuBSAsLAwXFxd+/vln0tLS6NixIw4ODqxfv57XX3+dSZMmmc7x+OOP8/HHH/P888/zyCOP8Mcff7B8+XJ+/fVX0zETJ05kxIgRtG/fng4dOvD++++Tm5truipPCCGEedLpdHh4eJimnXFycrruTN6i7lAUhby8PNLT0/Hw8Ciz+PCNsJgCatq0aSxatMj0c9u2bQHYuHEjPXr0wNbWlrlz5/Lss8+iKAphYWGmKQlKNWrUiF9//ZVnn32WDz74gAYNGvDFF1+YpjAAGDZsGOfOnWPatGmkpqYSGRnJmjVryg0sF0IIYX5Kh1uYzdx9wuxca7qjqtAo0llc7bKysnB3dyczMxM3Nze14wghRJ2j1+spLi5WO4YwM7a2ttdsearK57fFtEAJIYQQlVV6UZAQNcXqJtIUQgghhKhpUkAJIYQQQlSRFFBCCCGEEFUkY6BqQOm4fFnSRQghhLAcpZ/blbm+TgqoGpCdnQ0gs5ELIYQQFig7Oxt3d/drHiPTGNQAg8FAcnIyrq6u1T6JW+kyMadPn5YpEq5DXqvKk9eq8uS1qjx5rSpPXqvKq8nXSlEUsrOzCQwMRKu99ignaYGqAVqtlgYNGtToY7i5uck/skqS16ry5LWqPHmtKk9eq8qT16ryauq1ul7LUykZRC6EEEIIUUVSQAkhhBBCVJEUUBbG3t6e6dOnY29vr3YUsyevVeXJa1V58lpVnrxWlSevVeWZy2slg8iFEEIIIapIWqCEEEIIIapICighhBBCiCqSAkoIIYQQooqkgBJCCCGEqCIpoCzEa6+9RufOnXFycsLDw6PCYzQaTbnb0qVLazeomajM65WUlMSAAQNwcnLC19eXyZMnU1JSUrtBzVBISEi599Ebb7yhdiyzMXfuXEJCQnBwcCA6Oprt27erHcnszJgxo9x7qFmzZmrHMgubNm3ijjvuIDAwEI1Gw48//lhmv6IoTJs2jYCAABwdHenTpw9xcXHqhFXZ9V6rkSNHlnuf9evXr9bySQFlIYqKirj33nsZN27cNY9bsGABKSkpptugQYNqJ6CZud7rpdfrGTBgAEVFRWzZsoVFixaxcOFCpk2bVstJzdPMmTPLvI+eeuoptSOZhWXLljFx4kSmT5/O7t27adOmDTExMaSnp6sdzey0aNGizHto8+bNakcyC7m5ubRp04a5c+dWuP+tt97iww8/ZN68eWzbtg1nZ2diYmIoKCio5aTqu95rBdCvX78y77MlS5bUXkBFWJQFCxYo7u7uFe4DlB9++KFW85i7q71eq1evVrRarZKammra9umnnypubm5KYWFhLSY0P8HBwcp7772ndgyz1KFDB2X8+PGmn/V6vRIYGKjMnj1bxVTmZ/r06UqbNm3UjmH2/vt/tsFgUPz9/ZU5c+aYtmVkZCj29vbKkiVLVEhoPir6fBsxYoRy1113qZJHURRFWqCszPjx4/H29qZDhw589dVXKDLNV4ViY2Np1aoVfn5+pm0xMTFkZWVx6NAhFZOZhzfeeAMvLy/atm3LnDlzpGsTY6vmrl276NOnj2mbVqulT58+xMbGqpjMPMXFxREYGEhoaCjDhw8nKSlJ7UhmLzExkdTU1DLvMXd3d6Kjo+U9dhV//vknvr6+hIeHM27cOC5cuFBrjy2LCVuRmTNn0qtXL5ycnFi3bh1PPPEEOTk5PP3002pHMzupqalliifA9HNqaqoakczG008/Tbt27fD09GTLli1MnTqVlJQU3n33XbWjqer8+fPo9foK3zdHjx5VKZV5io6OZuHChYSHh5OSksKrr75Kt27dOHjwIK6urmrHM1ul//dU9B6r6/8vVaRfv37cc889NGrUiBMnTvDiiy/Sv39/YmNj0el0Nf74UkCpaMqUKbz55pvXPObIkSOVHnz5yiuvmL5v27Ytubm5zJkzx2oKqOp+veqSqrx2EydONG1r3bo1dnZ2jB07ltmzZ6u+dIKwDP379zd937p1a6KjowkODmb58uWMHj1axWTCmtx3332m71u1akXr1q1p3Lgxf/75J717967xx5cCSkXPPfccI0eOvOYxoaGhN3z+6OhoZs2aRWFhoVV88FXn6+Xv71/u6qm0tDTTPmtzM69ddHQ0JSUlnDx5kvDw8BpIZxm8vb3R6XSm90mptLQ0q3zPVCcPDw+aNm1KfHy82lHMWun7KC0tjYCAANP2tLQ0IiMjVUplOUJDQ/H29iY+Pl4KKGvn4+ODj49PjZ1/79691KtXzyqKJ6je16tTp0689tprpKen4+vrC8D69etxc3MjIiKiWh7DnNzMa7d37160Wq3pdaqr7OzsiIqKYsOGDaarWw0GAxs2bODJJ59UN5yZy8nJ4cSJEzz00ENqRzFrjRo1wt/fnw0bNpgKpqysLLZt23bdK7AFnDlzhgsXLpQpPmuSFFAWIikpiYsXL5KUlIRer2fv3r0AhIWF4eLiws8//0xaWhodO3bEwcGB9evX8/rrrzNp0iR1g6vkeq9X3759iYiI4KGHHuKtt94iNTWVl19+mfHjx1tNwXkjYmNj2bZtGz179sTV1ZXY2FieffZZHnzwQerVq6d2PNVNnDiRESNG0L59ezp06MD7779Pbm4uo0aNUjuaWZk0aRJ33HEHwcHBJCcnM336dHQ6Hffff7/a0VSXk5NTpiUuMTGRvXv34unpScOGDZkwYQL/+9//aNKkCY0aNeKVV14hMDCwTk5Jc63XytPTk1dffZXBgwfj7+/PiRMneP755wkLCyMmJqZ2Aqp2/Z+okhEjRihAudvGjRsVRVGU3377TYmMjFRcXFwUZ2dnpU2bNsq8efMUvV6vbnCVXO/1UhRFOXnypNK/f3/F0dFR8fb2Vp577jmluLhYvdBmYNeuXUp0dLTi7u6uODg4KM2bN1def/11paCgQO1oZuOjjz5SGjZsqNjZ2SkdOnRQtm7dqnYkszNs2DAlICBAsbOzU+rXr68MGzZMiY+PVzuWWdi4cWOF/zeNGDFCURTjVAavvPKK4ufnp9jb2yu9e/dWjh07pm5olVzrtcrLy1P69u2r+Pj4KLa2tkpwcLDy2GOPlZmapqZpFEWucxdCCCGEqAqZB0oIIYQQooqkgBJCCCGEqCIpoIQQQgghqkgKKCGEEEKIKpICSgghhBCiiqSAEkIIIYSoIimghBBCCCGqSAooIYQQQogqkgJKCCGEEKKKpIASQgjx/+3dIcoyYRiG0QeDFtEm7mCKgkGsLkH3YXYLRpnmAqxGMSkIgkUMYhYEweICBIP87a+fb3rLOXHSHS+eGRggkYAC+MPr9Yp2ux2z2ez/s+PxGNVqNXa7XcZlQC7+hQfwg81mE+PxOI7HYxRFEb1eL0ajUczn89zTgAwEFMCPJpNJbLfb6Pf7cb1e43Q6Ra1Wyz0LyEBAAfzo/X5Hp9OJx+MR5/M5ut1u7klAJr6BAvjR7XaL5/MZ3+837vd77jlARi5QAD/4fD4xGAyi1+tFURRRlmVcr9dotVq5pwEZCCiAH0yn01itVnG5XKJer8dwOIxmsxnr9Tr3NCADr/AA/rDf76Msy1gul9FoNKJSqcRyuYzD4RCLxSL3PCADFygAgEQuUAAAiQQUAEAiAQUAkEhAAQAkElAAAIkEFABAIgEFAJBIQAEAJBJQAACJBBQAQCIBBQCQSEABACT6B5FSCP5WhrYUAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "u0 = s\n", + "for i in range(5):\n", + " u0 = experimentalist(u0, num_samples=10, random_state=42+i)\n", + " u0 = experiment_runner(u0, random_state=43+i)\n", + " u0 = theorist(u0)\n", + " show_best_fit(u0)\n", + " plt.title(f\"{i=}, {len(u0.experiment_data)=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/docs/experimentalists/pooler/grid/index.md b/docs/experimentalists/grid/index.md similarity index 81% rename from docs/experimentalists/pooler/grid/index.md rename to docs/experimentalists/grid/index.md index 97b314aa..474f78f1 100644 --- a/docs/experimentalists/pooler/grid/index.md +++ b/docs/experimentalists/grid/index.md @@ -22,12 +22,14 @@ This means that there are various combinations that these variables can form, th ### Example Code + ```python -from autora.experimentalist.pooler.grid import grid_pool -from autora.variable import Variable +from autora.experimentalist.grid import grid_pool +from autora.variable import Variable, VariableCollection iv_1 = Variable(allowed_values=[1, 2, 3]) iv_2 = Variable(allowed_values=[4, 5, 6]) +variables = VariableCollection(independent_variables=[iv_1, iv_2]) -pool = grid_pool([iv_1, iv_2]) +pool = grid_pool(variables) ``` diff --git a/docs/experimentalists/pooler/grid/quickstart.md b/docs/experimentalists/grid/quickstart.md similarity index 83% rename from docs/experimentalists/pooler/grid/quickstart.md rename to docs/experimentalists/grid/quickstart.md index 740bb904..35777517 100644 --- a/docs/experimentalists/pooler/grid/quickstart.md +++ b/docs/experimentalists/grid/quickstart.md @@ -10,5 +10,5 @@ You will need: you can import the grid pooler via: ```python -from autora.experimentalist.pooler.grid import grid_pool +from autora.experimentalist.grid import grid_pool ``` diff --git a/docs/experimentalists/pooler/random/quickstart.md b/docs/experimentalists/pooler/random/quickstart.md deleted file mode 100644 index 4219f89b..00000000 --- a/docs/experimentalists/pooler/random/quickstart.md +++ /dev/null @@ -1,14 +0,0 @@ -# Quickstart Guide - -You will need: - -- `python` 3.8 or greater: [https://www.python.org/downloads/](https://www.python.org/downloads/) - - -*Random Pooler* is part of the `autora-core` package and does not need to be installed separately - -you can import the random pooler via: - -```python -from autora.experimentalist.pooler.random_pooler import random_pool -``` diff --git a/docs/experimentalists/pooler/random/index.md b/docs/experimentalists/random/index.md similarity index 87% rename from docs/experimentalists/pooler/random/index.md rename to docs/experimentalists/random/index.md index 59fe7450..774283ba 100644 --- a/docs/experimentalists/pooler/random/index.md +++ b/docs/experimentalists/random/index.md @@ -22,8 +22,10 @@ This means that there are 9 possible combinations for these variables (3x3), fro | 3 | (3,4) | (3,5) | X | ### Example Code + ```python -from autora.experimentalist.pooler.random_pooler import random_pool -pool = random_pool([1, 2, 3],[4, 5, 6], n=3) +from autora.experimentalist.random import random_pool + +pool = random_pool([1, 2, 3], [4, 5, 6], num_samples=3) ``` diff --git a/docs/experimentalists/random/quickstart.md b/docs/experimentalists/random/quickstart.md new file mode 100644 index 00000000..491c1528 --- /dev/null +++ b/docs/experimentalists/random/quickstart.md @@ -0,0 +1,29 @@ +# Quickstart Guide + +You will need: + +- `python` 3.8 or greater: [https://www.python.org/downloads/](https://www.python.org/downloads/) + + +*Random Pooler* and *Sampler* are part of the `autora-core` package and do not need to be installed separately + +You can import and invoke the pool like this: + +```python +from autora.variable import VariableCollection, Variable +from autora.experimentalist.random import pool + +pool( + VariableCollection(independent_variables=[Variable(name="x", allowed_values=range(10))]), + random_state=1 +) +``` + +You can import the sampler like this: + +```python +from autora.experimentalist.random import sample + +sample([1, 1, 2, 2, 3, 3], num_samples=2) +``` + diff --git a/docs/experimentalists/sampler/random/index.md b/docs/experimentalists/sampler/random/index.md deleted file mode 100644 index e20be0d5..00000000 --- a/docs/experimentalists/sampler/random/index.md +++ /dev/null @@ -1,10 +0,0 @@ -# Random Sampler - -Uniform random sampling without replacement from a pool of conditions. - -### Example Code -```python -from autora.experimentalist.sampler.random_sampler import random_sample - -pool = random_sample([1, 1, 2, 2, 3, 3], n=2) -``` diff --git a/docs/experimentalists/sampler/random/quickstart.md b/docs/experimentalists/sampler/random/quickstart.md deleted file mode 100644 index a9337826..00000000 --- a/docs/experimentalists/sampler/random/quickstart.md +++ /dev/null @@ -1,14 +0,0 @@ -# Quickstart Guide - -You will need: - -- `python` 3.8 or greater: [https://www.python.org/downloads/](https://www.python.org/downloads/) - - -*Random Sampler* is part of the `autora-core` package and does not need to be installed separately - -you can import the random sampler via: - -```python -from autora.experimentalist.sampler.random_sampler import random_sample -``` diff --git a/src/autora/experimentalist/grid.py b/src/autora/experimentalist/grid.py new file mode 100644 index 00000000..f605efb5 --- /dev/null +++ b/src/autora/experimentalist/grid.py @@ -0,0 +1,108 @@ +"""Tools to make grids of experimental conditions.""" +from itertools import product + +import pandas as pd + +from autora.variable import VariableCollection + + +def pool(variables: VariableCollection) -> pd.DataFrame: + """Creates exhaustive pool of conditions given a definition of variables with allowed_values. + + Args: + variables: a VariableCollection with `independent_variables` – a sequence of Variable + objects, each of which has an attribute `allowed_values` containing a sequence of + values. + + Returns: a Result / Delta object with the conditions as a pd.DataFrame in the `conditions` field + + Examples: + >>> from autora.state import State + >>> from autora.variable import VariableCollection, Variable + >>> from dataclasses import dataclass, field + >>> import pandas as pd + >>> import numpy as np + + With one independent variable "x", and some allowed values, we get exactly those values + back when running the experimentalist: + >>> pool(VariableCollection( + ... independent_variables=[Variable(name="x", allowed_values=[1, 2, 3])] + ... )) + x + 0 1 + 1 2 + 2 3 + + The allowed_values must be specified: + >>> pool(VariableCollection(independent_variables=[Variable(name="x")])) + Traceback (most recent call last): + ... + AssertionError: grid_pool only supports independent variables with discrete... + + With two independent variables, we get the cartesian product: + >>> pool( + ... VariableCollection(independent_variables=[ + ... Variable(name="x1", allowed_values=[1, 2]), + ... Variable(name="x2", allowed_values=[3, 4]), + ... ])) + x1 x2 + 0 1 3 + 1 1 4 + 2 2 3 + 3 2 4 + + If any of the variables have unspecified allowed_values, we get an error: + >>> pool( + ... VariableCollection(independent_variables=[ + ... Variable(name="x1", allowed_values=[1, 2]), + ... Variable(name="x2"), + ... ])) + Traceback (most recent call last): + ... + AssertionError: grid_pool only supports independent variables with discrete... + + + We can specify arrays of allowed values: + >>> pool( + ... VariableCollection(independent_variables=[ + ... Variable(name="x", allowed_values=np.linspace(-10, 10, 101)), + ... Variable(name="y", allowed_values=[3, 4]), + ... Variable(name="z", allowed_values=np.linspace(20, 30, 11)), + ... ])) + x y z + 0 -10.0 3 20.0 + 1 -10.0 3 21.0 + 2 -10.0 3 22.0 + 3 -10.0 3 23.0 + 4 -10.0 3 24.0 + ... ... .. ... + 2217 10.0 4 26.0 + 2218 10.0 4 27.0 + 2219 10.0 4 28.0 + 2220 10.0 4 29.0 + 2221 10.0 4 30.0 + + [2222 rows x 3 columns] + + """ + ivs = variables.independent_variables + # Get allowed values for each IV + l_iv_values = [] + l_iv_names = [] + for iv in ivs: + assert iv.allowed_values is not None, ( + f"grid_pool only supports independent variables with discrete allowed values, " + f"but allowed_values is None on {iv=} " + ) + l_iv_values.append(iv.allowed_values) + l_iv_names.append(iv.name) + + # Return Cartesian product of all IV values + pool = product(*l_iv_values) + conditions = pd.DataFrame(pool, columns=l_iv_names) + + return conditions + + +grid_pool = pool +"""Alias for pool""" diff --git a/src/autora/experimentalist/pooler/grid.py b/src/autora/experimentalist/pooler/grid.py deleted file mode 100644 index dadc2a4a..00000000 --- a/src/autora/experimentalist/pooler/grid.py +++ /dev/null @@ -1,19 +0,0 @@ -from itertools import product -from typing import List - -from autora.variable import IV - - -def grid_pool(ivs: List[IV]): - """Creates exhaustive pool from discrete values using a Cartesian product of sets""" - # Get allowed values for each IV - l_iv_values = [] - for iv in ivs: - assert iv.allowed_values is not None, ( - f"gridsearch_pool only supports independent variables with discrete allowed values, " - f"but allowed_values is None on {iv=} " - ) - l_iv_values.append(iv.allowed_values) - - # Return Cartesian product of all IV values - return product(*l_iv_values) diff --git a/src/autora/experimentalist/pooler/random_pooler.py b/src/autora/experimentalist/pooler/random_pooler.py deleted file mode 100644 index 78ad104e..00000000 --- a/src/autora/experimentalist/pooler/random_pooler.py +++ /dev/null @@ -1,52 +0,0 @@ -import random -from typing import Iterable, List, Tuple - -import numpy as np - -from autora.utils.deprecation import deprecated_alias -from autora.variable import IV - - -def random_pool( - ivs: List[IV], num_samples: int = 1, duplicates: bool = True -) -> Iterable: - """ - Creates combinations from lists of discrete values using random selection. - Args: - ivs: List of independent variables - n: Number of samples to sample - duplicates: Boolean if duplicate value are allowed. - - """ - l_samples: List[Tuple] = [] - # Create list of pools of values sample from - l_iv_values = [] - for iv in ivs: - assert iv.allowed_values is not None, ( - f"gridsearch_pool only supports independent variables with discrete allowed values, " - f"but allowed_values is None on {iv=} " - ) - l_iv_values.append(iv.allowed_values) - - # Check to ensure infinite search won't occur if duplicates not allowed - if not duplicates: - l_pool_len = [len(set(s)) for s in l_iv_values] - n_combinations = np.product(l_pool_len) - try: - assert num_samples <= n_combinations - except AssertionError: - raise AssertionError( - f"Number to sample n({num_samples}) is larger than the number " - f"of unique combinations({n_combinations})." - ) - - # Random sample from the pools until n is met - while len(l_samples) < num_samples: - l_samples.append(tuple(map(random.choice, l_iv_values))) - if not duplicates: - l_samples = [*set(l_samples)] - - return iter(l_samples) - - -random_pooler = deprecated_alias(random_pool, "random_pooler") diff --git a/src/autora/experimentalist/random.py b/src/autora/experimentalist/random.py new file mode 100644 index 00000000..b4101adf --- /dev/null +++ b/src/autora/experimentalist/random.py @@ -0,0 +1,183 @@ +from typing import Optional, Union + +import numpy as np +import pandas as pd + +from autora.variable import ValueType, VariableCollection + + +def pool( + variables: VariableCollection, + num_samples: int = 5, + random_state: Optional[int] = None, + replace: bool = True, +) -> pd.DataFrame: + """ + Create a sequence of conditions randomly sampled from independent variables. + + Args: + variables: the description of all the variables in the AER experiment. + num_samples: the number of conditions to produce + random_state: the seed value for the random number generator + replace: if True, allow repeated values + + Returns: the generated conditions as a dataframe + + Examples: + >>> from autora.state import State + >>> from autora.variable import VariableCollection, Variable + >>> from dataclasses import dataclass, field + >>> import pandas as pd + >>> import numpy as np + + With one independent variable "x", and some allowed_values we get some of those values + back when running the experimentalist: + >>> pool( + ... VariableCollection( + ... independent_variables=[Variable(name="x", allowed_values=range(10)) + ... ]), random_state=1) + x + 0 4 + 1 5 + 2 7 + 3 9 + 4 0 + + + ... with one independent variable "x", and a value_range, + we get a sample of the range back when running the experimentalist: + >>> pool( + ... VariableCollection(independent_variables=[ + ... Variable(name="x", value_range=(-5, 5)) + ... ]), random_state=1) + x + 0 0.118216 + 1 4.504637 + 2 -3.558404 + 3 4.486494 + 4 -1.881685 + + + + The allowed_values or value_range must be specified: + >>> pool(VariableCollection(independent_variables=[Variable(name="x")])) + Traceback (most recent call last): + ... + ValueError: allowed_values or [value_range and type==REAL] needs to be set... + + With two independent variables, we get independent samples on both axes: + >>> pool(VariableCollection(independent_variables=[ + ... Variable(name="x1", allowed_values=range(1, 5)), + ... Variable(name="x2", allowed_values=range(1, 500)), + ... ]), num_samples=10, replace=True, random_state=1) + x1 x2 + 0 2 434 + 1 3 212 + 2 4 137 + 3 4 414 + 4 1 129 + 5 1 205 + 6 4 322 + 7 4 275 + 8 1 43 + 9 2 14 + + If any of the variables have unspecified allowed_values, we get an error: + >>> pool( + ... VariableCollection(independent_variables=[ + ... Variable(name="x1", allowed_values=[1, 2]), + ... Variable(name="x2"), + ... ])) + Traceback (most recent call last): + ... + ValueError: allowed_values or [value_range and type==REAL] needs to be set... + + + We can specify arrays of allowed values: + + >>> pool( + ... VariableCollection(independent_variables=[ + ... Variable(name="x", allowed_values=np.linspace(-10, 10, 101)), + ... Variable(name="y", allowed_values=[3, 4]), + ... Variable(name="z", allowed_values=np.linspace(20, 30, 11)), + ... ]), random_state=1) + x y z + 0 -0.6 3 29.0 + 1 0.2 4 24.0 + 2 5.2 4 23.0 + 3 9.0 3 29.0 + 4 -9.4 3 22.0 + + + """ + rng = np.random.default_rng(random_state) + + raw_conditions = {} + for iv in variables.independent_variables: + if iv.allowed_values is not None: + raw_conditions[iv.name] = rng.choice( + iv.allowed_values, size=num_samples, replace=replace + ) + elif (iv.value_range is not None) and (iv.type == ValueType.REAL): + raw_conditions[iv.name] = rng.uniform(*iv.value_range, size=num_samples) + + else: + raise ValueError( + "allowed_values or [value_range and type==REAL] needs to be set for " + "%s" % (iv) + ) + + return pd.DataFrame(raw_conditions) + + +random_pool = pool +"""Alias for `pool`""" + + +def sample( + conditions: Union[pd.DataFrame, np.ndarray, np.recarray], + num_samples: int = 1, + random_state: Optional[int] = None, + replace: bool = False, +) -> pd.DataFrame: + """ + Take a random sample from some input conditions. + + Args: + conditions: the conditions to sample from + num_samples: the number of conditions to produce + random_state: the seed value for the random number generator + replace: if True, allow repeated values + + Returns: a Result object with a field `conditions` containing a DataFrame of the sampled + conditions + + Examples: + From a pd.DataFrame: + >>> import pandas as pd + >>> sample( + ... pd.DataFrame({"x": range(100, 200)}), num_samples=5, random_state=180) + x + 67 167 + 71 171 + 64 164 + 63 163 + 96 196 + + From a list (returns a DataFrame): + >>> sample(range(1000), num_samples=5, random_state=180) + 0 + 270 270 + 908 908 + 109 109 + 331 331 + 978 978 + """ + conditions_ = pd.DataFrame(conditions) + return pd.DataFrame.sample( + conditions_, random_state=random_state, n=num_samples, replace=replace + ) + + +random_sample = sample +"""Alias for `sample`""" diff --git a/src/autora/experimentalist/sampler/random_sampler.py b/src/autora/experimentalist/sampler/random_sampler.py deleted file mode 100644 index 7e28d2c3..00000000 --- a/src/autora/experimentalist/sampler/random_sampler.py +++ /dev/null @@ -1,26 +0,0 @@ -import random -from typing import Iterable, Sequence, Union - -from autora.utils.deprecation import deprecated_alias - - -def random_sample(conditions: Union[Iterable, Sequence], num_samples: int = 1): - """ - Uniform random sampling without replacement from a pool of conditions. - Args: - conditions: Pool of conditions - n: number of samples to collect - - Returns: Sampled pool - - """ - - if isinstance(conditions, Iterable): - conditions = list(conditions) - random.shuffle(conditions) - samples = conditions[0:num_samples] - - return samples - - -random_sampler = deprecated_alias(random_sample, "random_sampler") diff --git a/src/autora/state.py b/src/autora/state.py new file mode 100644 index 00000000..ab25baac --- /dev/null +++ b/src/autora/state.py @@ -0,0 +1,1365 @@ +"""Classes to represent cycle state $S$ as $S_n = S_{0} + \\sum_{i=1}^n \\Delta S_{i}$.""" + +from __future__ import annotations + +import inspect +import logging +import warnings +from collections import UserDict +from dataclasses import dataclass, field, fields, is_dataclass, replace +from enum import Enum +from functools import singledispatch, wraps +from typing import ( + Callable, + Generic, + List, + Mapping, + Optional, + Protocol, + Sequence, + TypeVar, + Union, +) + +import numpy as np +import pandas as pd +from sklearn.base import BaseEstimator + +from autora.variable import VariableCollection + +_logger = logging.getLogger(__name__) +T = TypeVar("T") +C = TypeVar("C", covariant=True) + + +class DeltaAddable(Protocol[C]): + """A class which a Delta or other Mapping can be added to, returning the same class""" + + def __add__(self: C, other: Union[Delta, Mapping]) -> C: + ... + + +S = TypeVar("S", bound=DeltaAddable) + + +@dataclass(frozen=True) +class State: + """ + Base object for dataclasses which use the Delta mechanism. + + Examples: + >>> from dataclasses import dataclass, field + >>> from typing import List, Optional + + We define a dataclass where each field (which is going to be delta-ed) has additional + metadata "delta" which describes its delta behaviour. + >>> @dataclass(frozen=True) + ... class ListState(State): + ... l: List = field(default_factory=list, metadata={"delta": "extend"}) + ... m: List = field(default_factory=list, metadata={"delta": "replace"}) + + Now we instantiate the dataclass... + >>> l = ListState(l=list("abc"), m=list("xyz")) + >>> l + ListState(l=['a', 'b', 'c'], m=['x', 'y', 'z']) + + ... and can add deltas to it. `l` will be extended: + >>> l + Delta(l=list("def")) + ListState(l=['a', 'b', 'c', 'd', 'e', 'f'], m=['x', 'y', 'z']) + + ... wheras `m` will be replaced: + >>> l + Delta(m=list("uvw")) + ListState(l=['a', 'b', 'c'], m=['u', 'v', 'w']) + + ... they can be chained: + >>> l + Delta(l=list("def")) + Delta(m=list("uvw")) + ListState(l=['a', 'b', 'c', 'd', 'e', 'f'], m=['u', 'v', 'w']) + + ... and we update multiple fields with one Delta: + >>> l + Delta(l=list("ghi"), m=list("rst")) + ListState(l=['a', 'b', 'c', 'g', 'h', 'i'], m=['r', 's', 't']) + + A non-existent field will be ignored: + >>> l + Delta(o="not a field") + ListState(l=['a', 'b', 'c'], m=['x', 'y', 'z']) + + ... but will trigger a warning: + >>> with warnings.catch_warnings(record=True) as w: + ... _ = l + Delta(o="not a field") + ... print(w[0].message) # doctest: +NORMALIZE_WHITESPACE + These fields: ['o'] could not be used to update ListState, + which has these fields & aliases: ['l', 'm'] + + We can also use the `.update` method to do the same thing: + >>> l.update(l=list("ghi"), m=list("rst")) + ListState(l=['a', 'b', 'c', 'g', 'h', 'i'], m=['r', 's', 't']) + + We can also define fields which `append` the last result: + >>> @dataclass(frozen=True) + ... class AppendState(State): + ... n: List = field(default_factory=list, metadata={"delta": "append"}) + + >>> m = AppendState(n=list("ɑβɣ")) + >>> m + AppendState(n=['ɑ', 'β', 'ɣ']) + + `n` will be appended: + >>> m + Delta(n="∂") + AppendState(n=['ɑ', 'β', 'ɣ', '∂']) + + The metadata key "converter" is used to coerce types (inspired by + [PEP 712](https://peps.python.org/pep-0712/)): + >>> @dataclass(frozen=True) + ... class CoerceStateList(State): + ... o: Optional[List] = field(default=None, metadata={"delta": "replace"}) + ... p: List = field(default_factory=list, metadata={"delta": "replace", + ... "converter": list}) + + >>> r = CoerceStateList() + + If there is no `metadata["converter"]` set for a field, no coercion occurs + >>> r + Delta(o="not a list") + CoerceStateList(o='not a list', p=[]) + + If there is a `metadata["converter"]` set for a field, the data are coerced: + >>> r + Delta(p="not a list") + CoerceStateList(o=None, p=['n', 'o', 't', ' ', 'a', ' ', 'l', 'i', 's', 't']) + + If the input data are of the correct type, they are returned unaltered: + >>> r + Delta(p=["a", "list"]) + CoerceStateList(o=None, p=['a', 'list']) + + With a converter, inputs are converted to the type output by the converter: + >>> @dataclass(frozen=True) + ... class CoerceStateDataFrame(State): + ... q: pd.DataFrame = field(default_factory=pd.DataFrame, + ... metadata={"delta": "replace", + ... "converter": pd.DataFrame}) + + If the type is already correct, the object is passed to the converter, + but should be returned unchanged: + >>> s = CoerceStateDataFrame() + >>> (s + Delta(q=pd.DataFrame([("a",1,"alpha"), ("b",2,"beta")], columns=list("xyz")))).q + x y z + 0 a 1 alpha + 1 b 2 beta + + If the type is not correct, the object is converted if possible. For a dataframe, + we can convert records: + >>> (s + Delta(q=[("a",1,"alpha"), ("b",2,"beta")])).q + 0 1 2 + 0 a 1 alpha + 1 b 2 beta + + ... or an array: + >>> (s + Delta(q=np.linspace([1, 2], [10, 15], 3))).q + 0 1 + 0 1.0 2.0 + 1 5.5 8.5 + 2 10.0 15.0 + + ... or a dictionary: + >>> (s + Delta(q={"a": [1,2,3], "b": [4,5,6]})).q + a b + 0 1 4 + 1 2 5 + 2 3 6 + + ... or a list: + >>> (s + Delta(q=[11, 12, 13])).q + 0 + 0 11 + 1 12 + 2 13 + + ... but not, for instance, a string: + >>> (s + Delta(q="not compatible with pd.DataFrame")).q + Traceback (most recent call last): + ... + ValueError: DataFrame constructor not properly called! + + Without a converter: + >>> @dataclass(frozen=True) + ... class CoerceStateDataFrameNoConverter(State): + ... r: pd.DataFrame = field(default_factory=pd.DataFrame, metadata={"delta": "replace"}) + + ... there is no coercion – the object is passed unchanged + >>> t = CoerceStateDataFrameNoConverter() + >>> (t + Delta(r=np.linspace([1, 2], [10, 15], 3))).r + array([[ 1. , 2. ], + [ 5.5, 8.5], + [10. , 15. ]]) + + + A converter can cast from a DataFrame to a np.ndarray (with a single datatype), + for instance: + >>> @dataclass(frozen=True) + ... class CoerceStateArray(State): + ... r: Optional[np.ndarray] = field(default=None, + ... metadata={"delta": "replace", + ... "converter": np.asarray}) + + Here we pass a dataframe, but expect a numpy array: + >>> (CoerceStateArray() + Delta(r=pd.DataFrame([("a",1), ("b",2)], columns=list("xy")))).r + array([['a', 1], + ['b', 2]], dtype=object) + + We can define aliases which can transform between different potential field + names. + + >>> @dataclass(frozen=True) + ... class FieldAliasState(State): + ... things: List[str] = field( + ... default_factory=list, + ... metadata={"delta": "extend", + ... "aliases": {"thing": lambda m: [m]}} + ... ) + + In the "normal" case, the Delta object is expected to include a list of data in the + correct format which is used to extend the object: + >>> FieldAliasState(things=["0"]) + Delta(things=["1", "2"]) + FieldAliasState(things=['0', '1', '2']) + + However, say the standard return from a step in AER is a single `thing`, rather than a + sequence of them: + >>> FieldAliasState(things=["0"]) + Delta(thing="1") + FieldAliasState(things=['0', '1']) + + + If a cycle function relies on the existence of the `s.thing` as a property of your state + `s`, rather than accessing `s.things[-1]`, then you could additionally define a `property`: + + >>> class FieldAliasStateWithProperty(FieldAliasState): # inherit from FieldAliasState + ... @property + ... def thing(self): + ... return self.things[-1] + + Now you can access both `s.things` and `s.thing` as required by your code. The State only + shows `things` in the string representation... + >>> u = FieldAliasStateWithProperty(things=["0"]) + Delta(thing="1") + >>> u + FieldAliasStateWithProperty(things=['0', '1']) + + ... and exposes `things` as an attribute: + >>> u.things + ['0', '1'] + + ... but also exposes `thing`, always returning the last value. + >>> u.thing + '1' + + """ + + def __add__(self, other: Union[Delta, Mapping]): + updates = dict() + other_fields_unused = list(other.keys()) + for self_field in fields(self): + other_value, key = _get_value(self_field, other) + if other_value is None: + continue + other_fields_unused.remove(key) + + self_field_key = self_field.name + self_value = getattr(self, self_field_key) + delta_behavior = self_field.metadata["delta"] + + if (constructor := self_field.metadata.get("converter", None)) is not None: + coerced_other_value = constructor(other_value) + else: + coerced_other_value = other_value + + if delta_behavior == "extend": + extended_value = _extend(self_value, coerced_other_value) + updates[self_field_key] = extended_value + elif delta_behavior == "append": + appended_value = _append(self_value, coerced_other_value) + updates[self_field_key] = appended_value + elif delta_behavior == "replace": + updates[self_field_key] = coerced_other_value + else: + raise NotImplementedError( + "delta_behaviour=`%s` not implemented" % delta_behavior + ) + + if len(other_fields_unused) > 0: + warnings.warn( + "These fields: %s could not be used to update %s, " + "which has these fields & aliases: %s" + % ( + other_fields_unused, + type(self).__name__, + _get_field_names_and_aliases(self), + ), + ) + + new = replace(self, **updates) + return new + + def update(self, **kwargs): + """ + Return a new version of the State with values updated. + + This is identical to adding a `Delta`. + + If you need to replace values, ignoring the State value aggregation rules, + use `dataclasses.replace` instead. + """ + return self + Delta(**kwargs) + + +def _get_value(f, other: Union[Delta, Mapping]): + """ + Given a `State`'s `dataclasses.field` f, get a value from `other` and report its name. + + Returns: a tuple (the value, the key associated with that value) + + Examples: + >>> from dataclasses import field, dataclass, fields + >>> @dataclass + ... class Example: + ... a: int = field() # base case + ... b: List[int] = field(metadata={"aliases": {"ba": lambda b: [b]}}) # Single alias + ... c: List[int] = field(metadata={"aliases": { + ... "ca": lambda x: x, # pass the value unchanged + ... "cb": lambda x: [x] # wrap the value in a list + ... }}) # Multiple alias + + For a field with no aliases, we retrieve values with the base name: + >>> f_a = fields(Example)[0] + >>> _get_value(f_a, Delta(a=1)) + (1, 'a') + + ... and only the base name: + >>> print(_get_value(f_a, Delta(b=2))) # no match for b + (None, None) + + Any other names are unimportant: + >>> _get_value(f_a, Delta(b=2, a=1)) + (1, 'a') + + For fields with an alias, we retrieve values with the base name: + >>> f_b = fields(Example)[1] + >>> _get_value(f_b, Delta(b=[2])) + ([2], 'b') + + ... or for the alias name, transformed by the alias lambda function: + >>> _get_value(f_b, Delta(ba=21)) + ([21], 'ba') + + We preferentially get the base name, and then any aliases: + >>> _get_value(f_b, Delta(b=2, ba=21)) + (2, 'b') + + ... , regardless of their order in the `Delta` object: + >>> _get_value(f_b, Delta(ba=21, b=2)) + (2, 'b') + + Other names are ignored: + >>> _get_value(f_b, Delta(a=1)) + (None, None) + + and the order of other names is unimportant: + >>> _get_value(f_b, Delta(a=1, b=2)) + (2, 'b') + + For fields with multiple aliases, we retrieve values with the base name: + >>> f_c = fields(Example)[2] + >>> _get_value(f_c, Delta(c=[3])) + ([3], 'c') + + ... for any alias: + >>> _get_value(f_c, Delta(ca=31)) + (31, 'ca') + + ... transformed by the alias lambda function : + >>> _get_value(f_c, Delta(cb=32)) + ([32], 'cb') + + ... and ignoring any other names: + >>> print(_get_value(f_c, Delta(a=1))) + (None, None) + + ... preferentially in the order base name, 1st alias, 2nd alias, ... nth alias: + >>> _get_value(f_c, Delta(c=3, ca=31, cb=32)) + (3, 'c') + + >>> _get_value(f_c, Delta(ca=31, cb=32)) + (31, 'ca') + + >>> _get_value(f_c, Delta(cb=32)) + ([32], 'cb') + + >>> print(_get_value(f_c, Delta())) + (None, None) + + This works with dict objects: + >>> _get_value(f_a, dict(a=13)) + (13, 'a') + + ... with multiple keys: + >>> _get_value(f_b, dict(a=13, b=24, c=35)) + (24, 'b') + + ... and with aliases: + >>> _get_value(f_b, dict(ba=222)) + ([222], 'ba') + + This works with UserDicts: + >>> class MyDelta(UserDict): + ... pass + + >>> _get_value(f_a, MyDelta(a=14)) + (14, 'a') + + ... with multiple keys: + >>> _get_value(f_b, MyDelta(a=1, b=4, c=9)) + (4, 'b') + + ... and with aliases: + >>> _get_value(f_b, MyDelta(ba=234)) + ([234], 'ba') + + """ + + key = f.name + aliases = f.metadata.get("aliases", {}) + + value, used_key = None, None + + if key in other.keys(): + value = other[key] + used_key = key + elif aliases: # ... is not an empty dict + for alias_key, wrapping_function in aliases.items(): + if alias_key in other: + value = wrapping_function(other[alias_key]) + used_key = alias_key + break # we only evaluate the first match + + return value, used_key + + +def _get_field_names_and_aliases(s: State): + """ + Get a list of field names and their aliases from a State object + + Args: + s: a State object + + Returns: a list of field names and their aliases on `s` + + Examples: + >>> from dataclasses import field + >>> @dataclass(frozen=True) + ... class SomeState(State): + ... l: List = field(default_factory=list) + ... m: List = field(default_factory=list) + >>> _get_field_names_and_aliases(SomeState()) + ['l', 'm'] + + >>> @dataclass(frozen=True) + ... class SomeStateWithAliases(State): + ... l: List = field(default_factory=list, metadata={"aliases": {"l1": None, "l2": None}}) + ... m: List = field(default_factory=list, metadata={"aliases": {"m1": None}}) + >>> _get_field_names_and_aliases(SomeStateWithAliases()) + ['l', 'l1', 'l2', 'm', 'm1'] + + """ + result = [] + + for f in fields(s): + name = f.name + result.append(name) + + aliases = f.metadata.get("aliases", {}) + result.extend(aliases) + + return result + + +class Delta(UserDict, Generic[S]): + """ + Represents a delta where the base object determines the extension behavior. + + Examples: + >>> from dataclasses import dataclass + + First we define the dataclass to act as the basis: + >>> from typing import Optional, List + >>> @dataclass(frozen=True) + ... class ListState: + ... l: Optional[List] = None + ... m: Optional[List] = None + ... + """ + + pass + + +Result = Delta +"""`Result` is an alias for `Delta`.""" + + +@singledispatch +def _extend(a, b): + """ + Function to extend supported datatypes. + + """ + raise NotImplementedError("`_extend` not implemented for %s, %s" % (a, b)) + + +@_extend.register(type(None)) +def _extend_none(_, b): + """ + Implementation of `_extend` to support None-types. + + Examples: + >>> _extend(None, []) + [] + + >>> _extend(None, [3]) + [3] + """ + return b + + +@_extend.register(list) +def _extend_list(a, b): + """ + Implementation of `_extend` to support Lists. + + Examples: + >>> _extend([], []) + [] + + >>> _extend([1,2], [3]) + [1, 2, 3] + """ + return a + b + + +@_extend.register(pd.DataFrame) +def _extend_pd_dataframe(a, b): + """ + Implementation of `_extend` to support DataFrames. + + Examples: + >>> _extend(pd.DataFrame({"a": []}), pd.DataFrame({"a": []})) + Empty DataFrame + Columns: [a] + Index: [] + + >>> _extend(pd.DataFrame({"a": [1,2,3]}), pd.DataFrame({"a": [4,5,6]})) + a + 0 1 + 1 2 + 2 3 + 3 4 + 4 5 + 5 6 + """ + return pd.concat((a, b), ignore_index=True) + + +@_extend.register(np.ndarray) +def _extend_np_ndarray(a, b): + """ + Implementation of `_extend` to support Numpy ndarrays. + + Examples: + >>> _extend(np.array([(1,2,3), (4,5,6)]), np.array([(7,8,9)])) + array([[1, 2, 3], + [4, 5, 6], + [7, 8, 9]]) + """ + return np.row_stack([a, b]) + + +@_extend.register(dict) +def _extend_dict(a, b): + """ + Implementation of `_extend` to support Dictionaries. + + Examples: + >>> _extend({"a": "cats"}, {"b": "dogs"}) + {'a': 'cats', 'b': 'dogs'} + """ + return dict(a, **b) + + +def _append(a: List[T], b: T) -> List[T]: + """ + Function to create a new list with an item appended to it. + + Examples: + Given a starting list `a_`: + >>> a_ = [1, 2, 3] + + ... we can append a value: + >>> _append(a_, 4) + [1, 2, 3, 4] + + `a_` is unchanged + >>> a_ == [1, 2, 3] + True + + Why not just use `list.append`? `list.append` mutates `a` in place, which we can't allow + in the AER cycle – parts of the cycle rely on purely functional code which doesn't + (accidentally or intentionally) manipulate existing data. + >>> list.append(a_, 4) # not what we want + >>> a_ + [1, 2, 3, 4] + """ + return a + [b] + + +def inputs_from_state(f): + """Decorator to make target `f` into a function on a `State` and `**kwargs`. + + This wrapper makes it easier to pass arguments to a function from a State. + + It was inspired by the pytest "fixtures" mechanism. + + Args: + f: a function with arguments that could be fields on a `State` + and that returns a `Delta`. + + Returns: a version of `f` which takes and returns `State` objects. + + Examples: + >>> from dataclasses import dataclass, field + >>> import pandas as pd + >>> from typing import List, Optional + + The `State` it operates on needs to have the metadata described in the state module: + >>> @dataclass(frozen=True) + ... class U(State): + ... conditions: List[int] = field(metadata={"delta": "replace"}) + + We indicate the inputs required by the parameter names. + The output must be (compatible with) a `Delta` object. + >>> @inputs_from_state + ... def experimentalist(conditions): + ... new_conditions = [c + 10 for c in conditions] + ... return new_conditions + + >>> experimentalist(U(conditions=[1,2,3,4])) + [11, 12, 13, 14] + + >>> experimentalist(U(conditions=[101,102,103,104])) + [111, 112, 113, 114] + + A dictionary can be returned and used: + >>> @inputs_from_state + ... def returns_a_dictionary(conditions): + ... new_conditions = [c + 10 for c in conditions] + ... return {"conditions": new_conditions} + >>> returns_a_dictionary(U(conditions=[2])) + {'conditions': [12]} + + >>> from autora.variable import VariableCollection, Variable + >>> from sklearn.base import BaseEstimator + >>> from sklearn.linear_model import LinearRegression + + >>> @inputs_from_state + ... def theorist(experiment_data: pd.DataFrame, variables: VariableCollection, **kwargs): + ... ivs = [vi.name for vi in variables.independent_variables] + ... dvs = [vi.name for vi in variables.dependent_variables] + ... X, y = experiment_data[ivs], experiment_data[dvs] + ... model = LinearRegression(fit_intercept=True).set_params(**kwargs).fit(X, y) + ... return model + + >>> @dataclass(frozen=True) + ... class V(State): + ... variables: VariableCollection # field(metadata={"delta":... }) omitted ∴ immutable + ... experiment_data: pd.DataFrame = field(metadata={"delta": "extend"}) + ... model: Optional[BaseEstimator] = field(metadata={"delta": "replace"}, default=None) + + >>> v = V( + ... variables=VariableCollection(independent_variables=[Variable("x")], + ... dependent_variables=[Variable("y")]), + ... experiment_data=pd.DataFrame({"x": [0,1,2,3,4], "y": [2,3,4,5,6]}) + ... ) + >>> model = theorist(v) + >>> model.coef_, model.intercept_ + (array([[1.]]), array([2.])) + + Arguments from the state can be overridden by passing them in as keyword arguments (kwargs): + >>> theorist(v, experiment_data=pd.DataFrame({"x": [0,1,2,3], "y": [12,13,14,15]}))\\ + ... .intercept_ + array([12.]) + + ... and other arguments supported by the inner function can also be passed + (if and only if the inner function allows for and handles `**kwargs` arguments alongside + the values from the state). + >>> theorist(v, fit_intercept=False).intercept_ + 0.0 + + Any parameters not provided by the state must be provided by default values or by the + caller. If the default is specified: + >>> @inputs_from_state + ... def experimentalist(conditions, offset=25): + ... new_conditions = [c + offset for c in conditions] + ... return new_conditions + + ... then it need not be passed. + >>> experimentalist(U(conditions=[1,2,3,4])) + [26, 27, 28, 29] + + If a default isn't specified: + >>> @inputs_from_state + ... def experimentalist(conditions, offset): + ... new_conditions = [c + offset for c in conditions] + ... return new_conditions + + ... then calling the experimentalist without it will throw an error: + >>> experimentalist(U(conditions=[1,2,3,4])) + Traceback (most recent call last): + ... + TypeError: experimentalist() missing 1 required positional argument: 'offset' + + ... which can be fixed by passing the argument as a keyword to the wrapped function. + >>> experimentalist(U(conditions=[1,2,3,4]), offset=2) + [3, 4, 5, 6] + + The state itself is passed through if the inner function requests the `state`: + >>> @inputs_from_state + ... def function_which_needs_whole_state(state, conditions): + ... print("Doing something on: ", state) + ... new_conditions = [c + 2 for c in conditions] + ... return new_conditions + >>> function_which_needs_whole_state(U(conditions=[1,2,3,4])) + Doing something on: U(conditions=[1, 2, 3, 4]) + [3, 4, 5, 6] + + """ + # Get the set of parameter names from function f's signature + parameters_ = set(inspect.signature(f).parameters.keys()) + + @wraps(f) + def _f(state_: S, /, **kwargs) -> S: + # Get the parameters needed which are available from the state_. + # All others must be provided as kwargs or default values on f. + assert is_dataclass(state_) + from_state = parameters_.intersection({i.name for i in fields(state_)}) + arguments_from_state = {k: getattr(state_, k) for k in from_state} + if "state" in parameters_: + arguments_from_state["state"] = state_ + arguments = dict(arguments_from_state, **kwargs) + result = f(**arguments) + return result + + return _f + + +def outputs_to_delta(*output: str): + """ + Decorator factory to wrap outputs from a function as Deltas. + + Examples: + >>> @outputs_to_delta("conditions") + ... def add_five(x): + ... return [xi + 5 for xi in x] + + >>> add_five([1, 2, 3]) + {'conditions': [6, 7, 8]} + + >>> @outputs_to_delta("c") + ... def add_six(conditions): + ... return [c + 5 for c in conditions] + + >>> add_six([1, 2, 3]) + {'c': [6, 7, 8]} + + >>> @outputs_to_delta("+1", "-1") + ... def plus_minus_1(x): + ... a = [xi + 1 for xi in x] + ... b = [xi - 1 for xi in x] + ... return a, b + + >>> plus_minus_1([1, 2, 3]) + {'+1': [2, 3, 4], '-1': [0, 1, 2]} + + + If the wrong number of values are specified for the return, then there might be errors. + If multiple outputs are expected, but only a single output is returned, we get a warning: + >>> @outputs_to_delta("1", "2") + ... def returns_single_result_when_more_expected(): + ... return "a" + >>> returns_single_result_when_more_expected() # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS + Traceback (most recent call last): + ... + AssertionError: function `` + has to return multiple values to match `('1', '2')`. Got `a` instead. + + If multiple outputs are expected, but the wrong number are returned, we get a warning: + >>> @outputs_to_delta("1", "2", "3") + ... def returns_wrong_number_of_results(): + ... return "a", "b" + >>> returns_wrong_number_of_results() # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS + Traceback (most recent call last): + ... + AssertionError: function `` + has to return exactly `3` values to match `('1', '2', '3')`. Got `('a', 'b')` instead. + + However, if a single output is expected, and multiple are returned, these are treated as + a single object and no error occurs: + >>> @outputs_to_delta("foo") + ... def returns_a_tuple(): + ... return "a", "b", "c" + >>> returns_a_tuple() + {'foo': ('a', 'b', 'c')} + + If we fail to specify output names, an error is returned immediately. + >>> @outputs_to_delta() + ... def decorator_missing_arguments(): + ... return "a", "b", "c" + Traceback (most recent call last): + ... + ValueError: `output` names must be specified. + + """ + + def decorator(f): + if len(output) == 0: + raise ValueError("`output` names must be specified.") + + elif len(output) == 1: + + @wraps(f) + def inner(*args, **kwargs): + result = f(*args, **kwargs) + delta = Delta(**{output[0]: result}) + return delta + + else: + + @wraps(f) + def inner(*args, **kwargs): + result = f(*args, **kwargs) + assert isinstance(result, tuple), ( + "function `%s` has to return multiple values " + "to match `%s`. Got `%s` instead." % (f, output, result) + ) + assert len(output) == len(result), ( + "function `%s` has to return " + "exactly `%s` values " + "to match `%s`. " + "Got `%s` instead." + "" % (f, len(output), output, result) + ) + delta = Delta(**dict(zip(output, result))) + return delta + + return inner + + return decorator + + +def delta_to_state(f): + """Decorator to make `f` which takes a `State` and returns a `Delta` return an updated `State`. + + This wrapper handles adding a returned Delta to an input State object. + + Args: + f: the function which returns a `Delta` object + + Returns: the function modified to return a State object + + Examples: + >>> from dataclasses import dataclass, field + >>> import pandas as pd + >>> from typing import List, Optional + + The `State` it operates on needs to have the metadata described in the state module: + >>> @dataclass(frozen=True) + ... class U(State): + ... conditions: List[int] = field(metadata={"delta": "replace"}) + + We indicate the inputs required by the parameter names. + The output must be (compatible with) a `Delta` object. + >>> @delta_to_state + ... @inputs_from_state + ... def experimentalist(conditions): + ... new_conditions = [c + 10 for c in conditions] + ... return Delta(conditions=new_conditions) + + >>> experimentalist(U(conditions=[1,2,3,4])) + U(conditions=[11, 12, 13, 14]) + + >>> experimentalist(U(conditions=[101,102,103,104])) + U(conditions=[111, 112, 113, 114]) + + If the output of the function is not a `Delta` object (or something compatible with its + interface), then an error is thrown. + >>> @delta_to_state + ... @inputs_from_state + ... def returns_bare_conditions(conditions): + ... new_conditions = [c + 10 for c in conditions] + ... return new_conditions + + >>> returns_bare_conditions(U(conditions=[1])) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + Traceback (most recent call last): + ... + AssertionError: Output of must be a `Delta`, + `UserDict`, or `dict`. + + A dictionary can be returned and used: + >>> @delta_to_state + ... @inputs_from_state + ... def returns_a_dictionary(conditions): + ... new_conditions = [c + 10 for c in conditions] + ... return {"conditions": new_conditions} + >>> returns_a_dictionary(U(conditions=[2])) + U(conditions=[12]) + + ... as can an object which subclasses UserDict (like `Delta`) + >>> class MyDelta(UserDict): + ... pass + >>> @delta_to_state + ... @inputs_from_state + ... def returns_a_userdict(conditions): + ... new_conditions = [c + 10 for c in conditions] + ... return MyDelta(conditions=new_conditions) + >>> returns_a_userdict(U(conditions=[3])) + U(conditions=[13]) + + We recommend using the `Delta` object rather than a `UserDict` or `dict` as its + functionality may be expanded in future. + + >>> from autora.variable import VariableCollection, Variable + >>> from sklearn.base import BaseEstimator + >>> from sklearn.linear_model import LinearRegression + + >>> @delta_to_state + ... @inputs_from_state + ... def theorist(experiment_data: pd.DataFrame, variables: VariableCollection, **kwargs): + ... ivs = [vi.name for vi in variables.independent_variables] + ... dvs = [vi.name for vi in variables.dependent_variables] + ... X, y = experiment_data[ivs], experiment_data[dvs] + ... new_model = LinearRegression(fit_intercept=True).set_params(**kwargs).fit(X, y) + ... return Delta(model=new_model) + + >>> @dataclass(frozen=True) + ... class V(State): + ... variables: VariableCollection # field(metadata={"delta":... }) omitted ∴ immutable + ... experiment_data: pd.DataFrame = field(metadata={"delta": "extend"}) + ... model: Optional[BaseEstimator] = field(metadata={"delta": "replace"}, default=None) + + >>> v = V( + ... variables=VariableCollection(independent_variables=[Variable("x")], + ... dependent_variables=[Variable("y")]), + ... experiment_data=pd.DataFrame({"x": [0,1,2,3,4], "y": [2,3,4,5,6]}) + ... ) + >>> v_prime = theorist(v) + >>> v_prime.model.coef_, v_prime.model.intercept_ + (array([[1.]]), array([2.])) + + Arguments from the state can be overridden by passing them in as keyword arguments (kwargs): + >>> theorist(v, experiment_data=pd.DataFrame({"x": [0,1,2,3], "y": [12,13,14,15]}))\\ + ... .model.intercept_ + array([12.]) + + ... and other arguments supported by the inner function can also be passed + (if and only if the inner function allows for and handles `**kwargs` arguments alongside + the values from the state). + >>> theorist(v, fit_intercept=False).model.intercept_ + 0.0 + + Any parameters not provided by the state must be provided by default values or by the + caller. If the default is specified: + >>> @delta_to_state + ... @inputs_from_state + ... def experimentalist(conditions, offset=25): + ... new_conditions = [c + offset for c in conditions] + ... return Delta(conditions=new_conditions) + + ... then it need not be passed. + >>> experimentalist(U(conditions=[1,2,3,4])) + U(conditions=[26, 27, 28, 29]) + + If a default isn't specified: + >>> @delta_to_state + ... @inputs_from_state + ... def experimentalist(conditions, offset): + ... new_conditions = [c + offset for c in conditions] + ... return Delta(conditions=new_conditions) + + ... then calling the experimentalist without it will throw an error: + >>> experimentalist(U(conditions=[1,2,3,4])) + Traceback (most recent call last): + ... + TypeError: experimentalist() missing 1 required positional argument: 'offset' + + ... which can be fixed by passing the argument as a keyword to the wrapped function. + >>> experimentalist(U(conditions=[1,2,3,4]), offset=2) + U(conditions=[3, 4, 5, 6]) + + The state itself is passed through if the inner function requests the `state`: + >>> @delta_to_state + ... @inputs_from_state + ... def function_which_needs_whole_state(state, conditions): + ... print("Doing something on: ", state) + ... new_conditions = [c + 2 for c in conditions] + ... return Delta(conditions=new_conditions) + >>> function_which_needs_whole_state(U(conditions=[1,2,3,4])) + Doing something on: U(conditions=[1, 2, 3, 4]) + U(conditions=[3, 4, 5, 6]) + + """ + + @wraps(f) + def _f(state_: S, **kwargs) -> S: + delta = f(state_, **kwargs) + assert isinstance(delta, Mapping), ( + "Output of %s must be a `Delta`, `UserDict`, " "or `dict`." % f + ) + new_state = state_ + delta + return new_state + + return _f + + +def on_state( + function: Optional[Callable] = None, output: Optional[Sequence[str]] = None +): + """Decorator (factory) to make target `function` into a function on a `State` and `**kwargs`. + + This combines the functionality of `outputs_to_delta` and `inputs_from_state` + + Args: + function: the function to be wrapped + output: list specifying State field names for the return values of `function` + + Returns: + + Examples: + >>> from dataclasses import dataclass, field + >>> import pandas as pd + >>> from typing import List, Optional + + The `State` it operates on needs to have the metadata described in the state module: + >>> @dataclass(frozen=True) + ... class W(State): + ... conditions: List[int] = field(metadata={"delta": "replace"}) + + We indicate the inputs required by the parameter names. + >>> def add_ten(conditions): + ... return [c + 10 for c in conditions] + >>> experimentalist = on_state(function=add_ten, output=["conditions"]) + + >>> experimentalist(W(conditions=[1,2,3,4])) + W(conditions=[11, 12, 13, 14]) + + You can wrap functions which return a Delta object natively, by omitting the `output` + argument: + >>> @on_state() + ... def add_five(conditions): + ... return Delta(conditions=[c + 5 for c in conditions]) + + >>> add_five(W(conditions=[1, 2, 3, 4])) + W(conditions=[6, 7, 8, 9]) + + If you fail to declare outputs for a function which doesn't return a Delta: + >>> @on_state() + ... def missing_output_param(conditions): + ... return [c + 5 for c in conditions] + + ... an exception is raised: + >>> missing_output_param(W(conditions=[1])) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + Traceback (most recent call last): + ... + AssertionError: Output of must be a `Delta`, + `UserDict`, or `dict`. + + You can use the @on_state(output=[...]) as a decorator: + >>> @on_state(output=["conditions"]) + ... def add_six(conditions): + ... return [c + 6 for c in conditions] + + >>> add_six(W(conditions=[1, 2, 3, 4])) + W(conditions=[7, 8, 9, 10]) + + """ + + def decorator(f): + f_ = f + if output is not None: + f_ = outputs_to_delta(*output)(f_) + f_ = inputs_from_state(f_) + f_ = delta_to_state(f_) + return f_ + + if function is None: + return decorator + else: + return decorator(function) + + +StateFunction = Callable[[State], State] + + +class StandardStateVariables(Enum): + CONDITIONS = "conditions" + EXPERIMENT_DATA = "experiment_data" + MODELS = "models" + VARIABLES = "variables" + + +@dataclass(frozen=True) +class StandardState(State): + """ + Examples: + The state can be initialized emtpy + >>> from autora.variable import VariableCollection, Variable + >>> s = StandardState() + >>> s + StandardState(variables=None, conditions=None, experiment_data=None, models=[]) + + The `variables` can be updated using a `Delta`: + >>> dv1 = Delta(variables=VariableCollection(independent_variables=[Variable("1")])) + >>> s + dv1 + StandardState(variables=VariableCollection(independent_variables=[Variable(name='1',...) + + ... and are replaced by each `Delta`: + >>> dv2 = Delta(variables=VariableCollection(independent_variables=[Variable("2")])) + >>> s + dv1 + dv2 + StandardState(variables=VariableCollection(independent_variables=[Variable(name='2',...) + + The `conditions` can be updated using a `Delta`: + >>> dc1 = Delta(conditions=pd.DataFrame({"x": [1, 2, 3]})) + >>> (s + dc1).conditions + x + 0 1 + 1 2 + 2 3 + + ... and are replaced by each `Delta`: + >>> dc2 = Delta(conditions=pd.DataFrame({"x": [4, 5]})) + >>> (s + dc1 + dc2).conditions + x + 0 4 + 1 5 + + Datatypes other than `pd.DataFrame` will be coerced into a `DataFrame` if possible. + >>> import numpy as np + >>> dc3 = Delta(conditions=np.core.records.fromrecords([(8, "h"), (9, "i")], names="n,c")) + >>> (s + dc3).conditions + n c + 0 8 h + 1 9 i + + If they are passed without column names, no column names are inferred. + This is to ensure that accidental mislabeling of columns cannot occur. + Column names should usually be provided. + >>> dc4 = Delta(conditions=[(6,), (7,)]) + >>> (s + dc4).conditions + 0 + 0 6 + 1 7 + + Datatypes which are incompatible with a pd.DataFrame will throw an error: + >>> s + Delta(conditions="not compatible with pd.DataFrame") + Traceback (most recent call last): + ... + ValueError: ... + + Experiment data can be updated using a Delta: + >>> ded1 = Delta(experiment_data=pd.DataFrame({"x": [1,2,3], "y": ["a", "b", "c"]})) + >>> (s + ded1).experiment_data + x y + 0 1 a + 1 2 b + 2 3 c + + ... and are extended with each Delta: + >>> ded2 = Delta(experiment_data=pd.DataFrame({"x": [4, 5, 6], "y": ["d", "e", "f"]})) + >>> (s + ded1 + ded2).experiment_data + x y + 0 1 a + 1 2 b + 2 3 c + 3 4 d + 4 5 e + 5 6 f + + If they are passed without column names, no column names are inferred. + This is to ensure that accidental mislabeling of columns cannot occur. + >>> ded3 = Delta(experiment_data=pd.DataFrame([(7, "g"), (8, "h")])) + >>> (s + ded3).experiment_data + 0 1 + 0 7 g + 1 8 h + + If there are already data present, the column names must match. + >>> (s + ded2 + ded3).experiment_data + x y 0 1 + 0 4.0 d NaN NaN + 1 5.0 e NaN NaN + 2 6.0 f NaN NaN + 3 NaN NaN 7.0 g + 4 NaN NaN 8.0 h + + `experiment_data` other than `pd.DataFrame` will be coerced into a `DataFrame` if possible. + >>> import numpy as np + >>> ded4 = Delta( + ... experiment_data=np.core.records.fromrecords([(1, "a"), (2, "b")], names=["x", "y"])) + >>> (s + ded4).experiment_data + x y + 0 1 a + 1 2 b + + `experiment_data` which are incompatible with a pd.DataFrame will throw an error: + >>> s + Delta(experiment_data="not compatible with pd.DataFrame") + Traceback (most recent call last): + ... + ValueError: ... + + `models` can be updated using a Delta: + >>> from sklearn.dummy import DummyClassifier + >>> dm1 = Delta(models=[DummyClassifier(constant=1)]) + >>> dm2 = Delta(models=[DummyClassifier(constant=2), DummyClassifier(constant=3)]) + >>> (s + dm1).models + [DummyClassifier(constant=1)] + + >>> (s + dm1 + dm2).models + [DummyClassifier(constant=1), DummyClassifier(constant=2), DummyClassifier(constant=3)] + + The last model is available under the `model` property: + >>> (s + dm1 + dm2).model + DummyClassifier(constant=3) + + If there is no model, `None` is returned: + >>> print(s.model) + None + + `models` can also be updated using a Delta with a single `model`: + >>> dm3 = Delta(model=DummyClassifier(constant=4)) + >>> (s + dm1 + dm3).model + DummyClassifier(constant=4) + + As before, the `models` list is extended: + >>> (s + dm1 + dm3).models + [DummyClassifier(constant=1), DummyClassifier(constant=4)] + + No coercion or validation occurs with `models` or `model`: + >>> (s + dm1 + Delta(model="not a model")).models + [DummyClassifier(constant=1), 'not a model'] + + """ + + variables: Optional[VariableCollection] = field( + default=None, metadata={"delta": "replace"} + ) + conditions: Optional[pd.DataFrame] = field( + default=None, metadata={"delta": "replace", "converter": pd.DataFrame} + ) + experiment_data: Optional[pd.DataFrame] = field( + default=None, metadata={"delta": "extend", "converter": pd.DataFrame} + ) + models: List[BaseEstimator] = field( + default_factory=list, + metadata={"delta": "extend", "aliases": {"model": lambda model: [model]}}, + ) + + @property + def model(self): + """Alias for the last model in the `models`.""" + try: + return self.models[-1] + except IndexError: + return None + + +X = TypeVar("X") +Y = TypeVar("Y") +XY = TypeVar("XY") + + +def estimator_on_state(estimator: BaseEstimator) -> StateFunction: + """ + Convert a scikit-learn compatible estimator into a function on a `State` object. + + Supports passing additional `**kwargs` which are used to update the estimator's params + before fitting. + + Examples: + Initialize a function which operates on the state, `state_fn` and runs a LinearRegression. + >>> from sklearn.linear_model import LinearRegression + >>> state_fn = estimator_on_state(LinearRegression()) + + Define the state on which to operate (here an instance of the `StandardState`): + >>> from autora.state import StandardState + >>> from autora.variable import Variable, VariableCollection + >>> import pandas as pd + >>> s = StandardState( + ... variables=VariableCollection( + ... independent_variables=[Variable("x")], + ... dependent_variables=[Variable("y")]), + ... experiment_data=pd.DataFrame({"x": [1,2,3], "y":[3,6,9]}) + ... ) + + Run the function, which fits the model and adds the result to the `StandardState` + >>> state_fn(s).model.coef_ + array([[3.]]) + + """ + + @on_state() + def theorist( + experiment_data: pd.DataFrame, variables: VariableCollection, **kwargs + ): + ivs = [v.name for v in variables.independent_variables] + dvs = [v.name for v in variables.dependent_variables] + X, y = experiment_data[ivs], experiment_data[dvs] + new_model = estimator.set_params(**kwargs).fit(X, y) + return Delta(model=new_model) + + return theorist + + +def experiment_runner_on_state(f: Callable[[X], XY]) -> StateFunction: + """Wrapper for experiment_runner of the form $f(x) \rarrow (x,y)$, where `f` + returns both $x$ and $y$ values in a complete dataframe. + + Examples: + The conditions are some x-values in a StandardState object: + >>> from autora.state import StandardState + >>> s = StandardState(conditions=pd.DataFrame({"x": [1, 2, 3]})) + + The function can be defined on a DataFrame, allowing the explicit inclusion of + metadata like column names. + >>> def x_to_xy_fn(c: pd.DataFrame) -> pd.Series: + ... result = c.assign(y=lambda df: 2 * df.x + 1) + ... return result + + We apply the wrapped function to `s` and look at the returned experiment_data: + >>> experiment_runner_on_state(x_to_xy_fn)(s).experiment_data + x y + 0 1 3 + 1 2 5 + 2 3 7 + + We can also define functions of several variables: + >>> def xs_to_xy_fn(c: pd.DataFrame) -> pd.Series: + ... result = c.assign(y=c.x0 + c.x1) + ... return result + + With the relevant variables as conditions: + >>> t = StandardState(conditions=pd.DataFrame({"x0": [1, 2, 3], "x1": [10, 20, 30]})) + >>> experiment_runner_on_state(xs_to_xy_fn)(t).experiment_data + x0 x1 y + 0 1 10 11 + 1 2 20 22 + 2 3 30 33 + + """ + + @on_state() + def experiment_runner(conditions: pd.DataFrame, **kwargs): + x = conditions + experiment_data = f(x, **kwargs) + return Delta(experiment_data=experiment_data) + + return experiment_runner diff --git a/src/autora/state/bundled.py b/src/autora/state/bundled.py deleted file mode 100644 index 7a878907..00000000 --- a/src/autora/state/bundled.py +++ /dev/null @@ -1,175 +0,0 @@ -from dataclasses import dataclass, field -from typing import List, Optional - -import pandas as pd -from sklearn.base import BaseEstimator - -from autora.state.delta import State -from autora.variable import VariableCollection - - -@dataclass(frozen=True) -class StandardState(State): - """ - Examples: - The state can be initialized emtpy - >>> from autora.state.delta import Delta - >>> from autora.variable import VariableCollection, Variable - >>> s = StandardState() - >>> s - StandardState(variables=None, conditions=None, experiment_data=None, models=[]) - - The `variables` can be updated using a `Delta`: - >>> dv1 = Delta(variables=VariableCollection(independent_variables=[Variable("1")])) - >>> s + dv1 - StandardState(variables=VariableCollection(independent_variables=[Variable(name='1',...) - - ... and are replaced by each `Delta`: - >>> dv2 = Delta(variables=VariableCollection(independent_variables=[Variable("2")])) - >>> s + dv1 + dv2 - StandardState(variables=VariableCollection(independent_variables=[Variable(name='2',...) - - The `conditions` can be updated using a `Delta`: - >>> dc1 = Delta(conditions=pd.DataFrame({"x": [1, 2, 3]})) - >>> (s + dc1).conditions - x - 0 1 - 1 2 - 2 3 - - ... and are replaced by each `Delta`: - >>> dc2 = Delta(conditions=pd.DataFrame({"x": [4, 5]})) - >>> (s + dc1 + dc2).conditions - x - 0 4 - 1 5 - - Datatypes other than `pd.DataFrame` will be coerced into a `DataFrame` if possible. - >>> import numpy as np - >>> dc3 = Delta(conditions=np.core.records.fromrecords([(8, "h"), (9, "i")], names="n,c")) - >>> (s + dc3).conditions - n c - 0 8 h - 1 9 i - - If they are passed without column names, no column names are inferred. - This is to ensure that accidental mislabeling of columns cannot occur. - Column names should usually be provided. - >>> dc4 = Delta(conditions=[(6,), (7,)]) - >>> (s + dc4).conditions - 0 - 0 6 - 1 7 - - Datatypes which are incompatible with a pd.DataFrame will throw an error: - >>> s + Delta(conditions="not compatible with pd.DataFrame") - Traceback (most recent call last): - ... - ValueError: ... - - Experiment data can be updated using a Delta: - >>> ded1 = Delta(experiment_data=pd.DataFrame({"x": [1,2,3], "y": ["a", "b", "c"]})) - >>> (s + ded1).experiment_data - x y - 0 1 a - 1 2 b - 2 3 c - - ... and are extended with each Delta: - >>> ded2 = Delta(experiment_data=pd.DataFrame({"x": [4, 5, 6], "y": ["d", "e", "f"]})) - >>> (s + ded1 + ded2).experiment_data - x y - 0 1 a - 1 2 b - 2 3 c - 3 4 d - 4 5 e - 5 6 f - - If they are passed without column names, no column names are inferred. - This is to ensure that accidental mislabeling of columns cannot occur. - >>> ded3 = Delta(experiment_data=pd.DataFrame([(7, "g"), (8, "h")])) - >>> (s + ded3).experiment_data - 0 1 - 0 7 g - 1 8 h - - If there are already data present, the column names must match. - >>> (s + ded2 + ded3).experiment_data - x y 0 1 - 0 4.0 d NaN NaN - 1 5.0 e NaN NaN - 2 6.0 f NaN NaN - 3 NaN NaN 7.0 g - 4 NaN NaN 8.0 h - - `experiment_data` other than `pd.DataFrame` will be coerced into a `DataFrame` if possible. - >>> import numpy as np - >>> ded4 = Delta( - ... experiment_data=np.core.records.fromrecords([(1, "a"), (2, "b")], names=["x", "y"])) - >>> (s + ded4).experiment_data - x y - 0 1 a - 1 2 b - - `experiment_data` which are incompatible with a pd.DataFrame will throw an error: - >>> s + Delta(experiment_data="not compatible with pd.DataFrame") - Traceback (most recent call last): - ... - ValueError: ... - - `models` can be updated using a Delta: - >>> from sklearn.dummy import DummyClassifier - >>> dm1 = Delta(models=[DummyClassifier(constant=1)]) - >>> dm2 = Delta(models=[DummyClassifier(constant=2), DummyClassifier(constant=3)]) - >>> (s + dm1).models - [DummyClassifier(constant=1)] - - >>> (s + dm1 + dm2).models - [DummyClassifier(constant=1), DummyClassifier(constant=2), DummyClassifier(constant=3)] - - The last model is available under the `model` property: - >>> (s + dm1 + dm2).model - DummyClassifier(constant=3) - - If there is no model, `None` is returned: - >>> print(s.model) - None - - `models` can also be updated using a Delta with a single `model`: - >>> dm3 = Delta(model=DummyClassifier(constant=4)) - >>> (s + dm1 + dm3).model - DummyClassifier(constant=4) - - As before, the `models` list is extended: - >>> (s + dm1 + dm3).models - [DummyClassifier(constant=1), DummyClassifier(constant=4)] - - No coercion or validation occurs with `models` or `model`: - >>> (s + dm1 + Delta(model="not a model")).models - [DummyClassifier(constant=1), 'not a model'] - - - """ - - variables: Optional[VariableCollection] = field( - default=None, metadata={"delta": "replace"} - ) - conditions: Optional[pd.DataFrame] = field( - default=None, metadata={"delta": "replace", "converter": pd.DataFrame} - ) - experiment_data: Optional[pd.DataFrame] = field( - default=None, metadata={"delta": "extend", "converter": pd.DataFrame} - ) - models: List[BaseEstimator] = field( - default_factory=list, - metadata={"delta": "extend", "aliases": {"model": lambda model: [model]}}, - ) - - @property - def model(self): - """Alias for the last model in the `models`.""" - try: - return self.models[-1] - except IndexError: - return None diff --git a/src/autora/state/delta.py b/src/autora/state/delta.py deleted file mode 100644 index 3763c7d6..00000000 --- a/src/autora/state/delta.py +++ /dev/null @@ -1,619 +0,0 @@ -"""Classes to represent cycle state $S$ as $S_n = S_{0} + \\sum_{i=1}^n \\Delta S_{i}$.""" -from __future__ import annotations - -import dataclasses -import inspect -import logging -from collections import UserDict -from dataclasses import dataclass, fields, replace -from functools import singledispatch, wraps -from typing import Generic, List, TypeVar - -import numpy as np -import pandas as pd - -_logger = logging.getLogger(__name__) -S = TypeVar("S") -T = TypeVar("T") - - -@dataclass(frozen=True) -class State: - """ - Base object for dataclasses which use the Delta mechanism. - - Examples: - >>> from dataclasses import dataclass, field - >>> from typing import List, Optional - - We define a dataclass where each field (which is going to be delta-ed) has additional - metadata "delta" which describes its delta behaviour. - >>> @dataclass(frozen=True) - ... class ListState(State): - ... l: List = field(default_factory=list, metadata={"delta": "extend"}) - ... m: List = field(default_factory=list, metadata={"delta": "replace"}) - - Now we instantiate the dataclass... - >>> l = ListState(l=list("abc"), m=list("xyz")) - >>> l - ListState(l=['a', 'b', 'c'], m=['x', 'y', 'z']) - - ... and can add deltas to it. `l` will be extended: - >>> l + Delta(l=list("def")) - ListState(l=['a', 'b', 'c', 'd', 'e', 'f'], m=['x', 'y', 'z']) - - ... wheras `m` will be replaced: - >>> l + Delta(m=list("uvw")) - ListState(l=['a', 'b', 'c'], m=['u', 'v', 'w']) - - ... they can be chained: - >>> l + Delta(l=list("def")) + Delta(m=list("uvw")) - ListState(l=['a', 'b', 'c', 'd', 'e', 'f'], m=['u', 'v', 'w']) - - ... and we update multiple fields with one Delta: - >>> l + Delta(l=list("ghi"), m=list("rst")) - ListState(l=['a', 'b', 'c', 'g', 'h', 'i'], m=['r', 's', 't']) - - A non-existent field will be ignored: - >>> l + Delta(o="not a field") - ListState(l=['a', 'b', 'c'], m=['x', 'y', 'z']) - - We can also use the `.update` method to do the same thing: - >>> l.update(l=list("ghi"), m=list("rst")) - ListState(l=['a', 'b', 'c', 'g', 'h', 'i'], m=['r', 's', 't']) - - We can also define fields which `append` the last result: - >>> @dataclass(frozen=True) - ... class AppendState(State): - ... n: List = field(default_factory=list, metadata={"delta": "append"}) - - >>> m = AppendState(n=list("ɑβɣ")) - >>> m - AppendState(n=['ɑ', 'β', 'ɣ']) - - `n` will be appended: - >>> m + Delta(n="∂") - AppendState(n=['ɑ', 'β', 'ɣ', '∂']) - - The metadata key "converter" is used to coerce types (inspired by - [PEP 712](https://peps.python.org/pep-0712/)): - >>> @dataclass(frozen=True) - ... class CoerceStateList(State): - ... o: Optional[List] = field(default=None, metadata={"delta": "replace"}) - ... p: List = field(default_factory=list, metadata={"delta": "replace", - ... "converter": list}) - - >>> r = CoerceStateList() - - If there is no `metadata["converter"]` set for a field, no coercion occurs - >>> r + Delta(o="not a list") - CoerceStateList(o='not a list', p=[]) - - If there is a `metadata["converter"]` set for a field, the data are coerced: - >>> r + Delta(p="not a list") - CoerceStateList(o=None, p=['n', 'o', 't', ' ', 'a', ' ', 'l', 'i', 's', 't']) - - If the input data are of the correct type, they are returned unaltered: - >>> r + Delta(p=["a", "list"]) - CoerceStateList(o=None, p=['a', 'list']) - - With a converter, inputs are converted to the type output by the converter: - >>> import pandas as pd - >>> @dataclass(frozen=True) - ... class CoerceStateDataFrame(State): - ... q: pd.DataFrame = field(default_factory=pd.DataFrame, - ... metadata={"delta": "replace", - ... "converter": pd.DataFrame}) - - If the type is already correct, the object is passed to the converter, - but should be returned unchanged: - >>> s = CoerceStateDataFrame() - >>> (s + Delta(q=pd.DataFrame([("a",1,"alpha"), ("b",2,"beta")], columns=list("xyz")))).q - x y z - 0 a 1 alpha - 1 b 2 beta - - If the type is not correct, the object is converted if possible. For a dataframe, - we can convert records: - >>> (s + Delta(q=[("a",1,"alpha"), ("b",2,"beta")])).q - 0 1 2 - 0 a 1 alpha - 1 b 2 beta - - ... or an array: - >>> (s + Delta(q=np.linspace([1, 2], [10, 15], 3))).q - 0 1 - 0 1.0 2.0 - 1 5.5 8.5 - 2 10.0 15.0 - - ... or a dictionary: - >>> (s + Delta(q={"a": [1,2,3], "b": [4,5,6]})).q - a b - 0 1 4 - 1 2 5 - 2 3 6 - - ... or a list: - >>> (s + Delta(q=[11, 12, 13])).q - 0 - 0 11 - 1 12 - 2 13 - - ... but not, for instance, a string: - >>> (s + Delta(q="not compatible with pd.DataFrame")).q - Traceback (most recent call last): - ... - ValueError: DataFrame constructor not properly called! - - Without a converter: - >>> @dataclass(frozen=True) - ... class CoerceStateDataFrameNoConverter(State): - ... r: pd.DataFrame = field(default_factory=pd.DataFrame, metadata={"delta": "replace"}) - - ... there is no coercion – the object is passed unchanged - >>> t = CoerceStateDataFrameNoConverter() - >>> (t + Delta(r=np.linspace([1, 2], [10, 15], 3))).r - array([[ 1. , 2. ], - [ 5.5, 8.5], - [10. , 15. ]]) - - - A converter can cast from a DataFrame to a np.ndarray (with a single datatype), - for instance: - >>> import numpy as np - >>> @dataclass(frozen=True) - ... class CoerceStateArray(State): - ... r: Optional[np.ndarray] = field(default=None, - ... metadata={"delta": "replace", - ... "converter": np.asarray}) - - Here we pass a dataframe, but expect a numpy array: - >>> (CoerceStateArray() + Delta(r=pd.DataFrame([("a",1), ("b",2)], columns=list("xy")))).r - array([['a', 1], - ['b', 2]], dtype=object) - - We can define aliases which can transform between different potential field - names. - - >>> @dataclass(frozen=True) - ... class FieldAliasState(State): - ... things: List[str] = field( - ... default_factory=list, - ... metadata={"delta": "extend", - ... "aliases": {"thing": lambda m: [m]}} - ... ) - - In the "normal" case, the Delta object is expected to include a list of data in the - correct format which is used to extend the object: - >>> FieldAliasState(things=["0"]) + Delta(things=["1", "2"]) - FieldAliasState(things=['0', '1', '2']) - - However, say the standard return from a step in AER is a single `thing`, rather than a - sequence of them: - >>> FieldAliasState(things=["0"]) + Delta(thing="1") - FieldAliasState(things=['0', '1']) - - - If a cycle function relies on the existence of the `s.thing` as a property of your state - `s`, rather than accessing `s.things[-1]`, then you could additionally define a `property`: - - >>> class FieldAliasStateWithProperty(FieldAliasState): # inherit from FieldAliasState - ... @property - ... def thing(self): - ... return self.things[-1] - - Now you can access both `s.things` and `s.thing` as required by your code. The State only - shows `things` in the string representation... - >>> s = FieldAliasStateWithProperty(things=["0"]) + Delta(thing="1") - >>> s - FieldAliasStateWithProperty(things=['0', '1']) - - ... and exposes `things` as an attribute: - >>> s.things - ['0', '1'] - - ... but also exposes `thing`, always returning the last value. - >>> s.thing - '1' - - - - - """ - - def __add__(self, other: Delta): - updates = dict() - for self_field in fields(self): - - other_value = _get_value(self_field, other) - if other_value is None: - continue - - self_field_key = self_field.name - self_value = getattr(self, self_field_key) - delta_behavior = self_field.metadata["delta"] - - if (constructor := self_field.metadata.get("converter", None)) is not None: - coerced_other_value = constructor(other_value) - else: - coerced_other_value = other_value - - if delta_behavior == "extend": - extended_value = extend(self_value, coerced_other_value) - updates[self_field_key] = extended_value - elif delta_behavior == "append": - appended_value = append(self_value, coerced_other_value) - updates[self_field_key] = appended_value - elif delta_behavior == "replace": - updates[self_field_key] = coerced_other_value - else: - raise NotImplementedError( - "delta_behaviour=`%s` not implemented" % (delta_behavior) - ) - - new = replace(self, **updates) - return new - - def update(self, **kwargs): - return self + Delta(**kwargs) - - -def _get_value(f, other: Delta): - """ - Given a `State`'s `dataclasses.field` f, get a value from `other` - - Examples: - >>> from dataclasses import field, dataclass, fields - >>> @dataclass - ... class Example: - ... a: int = field() # base case - ... b: List[int] = field(metadata={"aliases": {"ba": lambda b: [b]}}) # Single alias - ... c: List[int] = field(metadata={"aliases": { - ... "ca": lambda x: x, # pass the value unchanged - ... "cb": lambda x: [x] # wrap the value in a list - ... }}) # Multiple alias - - For a field with no aliases, we retrieve values with the base name: - >>> f_a = fields(Example)[0] - >>> _get_value(f_a, Delta(a=1)) - 1 - - ... and only the base name: - >>> print(_get_value(f_a, Delta(b=2))) # no match for b - None - - Any other names are unimportant: - >>> _get_value(f_a, Delta(b=2, a=1)) - 1 - - For fields with an alias, we retrieve values with the base name: - >>> f_b = fields(Example)[1] - >>> _get_value(f_b, Delta(b=[2])) - [2] - - ... or for the alias name, transformed by the alias lambda function: - >>> _get_value(f_b, Delta(ba=21)) - [21] - - We preferentially get the base name, and then any aliases: - >>> _get_value(f_b, Delta(b=2, ba=21)) - 2 - - ... , regardless of their order in the `Delta` object: - >>> _get_value(f_b, Delta(ba=21, b=2)) - 2 - - Other names are ignored: - >>> print(_get_value(f_b, Delta(a=1))) - None - - and the order of other names is unimportant: - >>> _get_value(f_b, Delta(a=1, b=2)) - 2 - - For fields with multiple aliases, we retrieve values with the base name: - >>> f_c = fields(Example)[2] - >>> _get_value(f_c, Delta(c=[3])) - [3] - - ... for any alias: - >>> _get_value(f_c, Delta(ca=31)) - 31 - - ... transformed by the alias lambda function : - >>> _get_value(f_c, Delta(cb=32)) - [32] - - ... and ignoring any other names: - >>> print(_get_value(f_c, Delta(a=1))) - None - - ... preferentially in the order base name, 1st alias, 2nd alias, ... nth alias: - >>> _get_value(f_c, Delta(c=3, ca=31, cb=32)) - 3 - - >>> _get_value(f_c, Delta(ca=31, cb=32)) - 31 - - >>> _get_value(f_c, Delta(cb=32)) - [32] - - >>> print(_get_value(f_c, Delta())) - None - - """ - - key = f.name - - try: - value = other.data[key] - return value - except KeyError: - pass - - try: - aliases = f.metadata["aliases"] - except KeyError: - return - - for alias_key, wrapping_function in aliases.items(): - try: - value = wrapping_function(other.data[alias_key]) - return value - except KeyError: - pass - - return - - -class Delta(UserDict, Generic[S]): - """ - Represents a delta where the base object determines the extension behavior. - - Examples: - >>> from dataclasses import dataclass - - First we define the dataclass to act as the basis: - >>> from typing import Optional, List - >>> @dataclass(frozen=True) - ... class ListState: - ... l: Optional[List] = None - ... m: Optional[List] = None - ... - """ - - pass - - -Result = Delta -"""`Result` is an alias for `Delta`.""" - - -@singledispatch -def extend(a, b): - """ - Function to extend supported datatypes. - - """ - raise NotImplementedError("`extend` not implemented for %s, %s" % (a, b)) - - -@extend.register(type(None)) -def extend_none(a, b): - """ - Examples: - >>> extend(None, []) - [] - - >>> extend(None, [3]) - [3] - """ - return b - - -@extend.register(list) -def extend_list(a, b): - """ - Examples: - >>> extend([], []) - [] - - >>> extend([1,2], [3]) - [1, 2, 3] - """ - return a + b - - -@extend.register(pd.DataFrame) -def extend_pd_dataframe(a, b): - """ - Examples: - >>> extend(pd.DataFrame({"a": []}), pd.DataFrame({"a": []})) - Empty DataFrame - Columns: [a] - Index: [] - - >>> extend(pd.DataFrame({"a": [1,2,3]}), pd.DataFrame({"a": [4,5,6]})) - a - 0 1 - 1 2 - 2 3 - 3 4 - 4 5 - 5 6 - """ - return pd.concat((a, b), ignore_index=True) - - -@extend.register(np.ndarray) -def extend_np_ndarray(a, b): - """ - Examples: - >>> extend(np.array([(1,2,3), (4,5,6)]), np.array([(7,8,9)])) - array([[1, 2, 3], - [4, 5, 6], - [7, 8, 9]]) - """ - return np.row_stack([a, b]) - - -@extend.register(dict) -def extend_dict(a, b): - """ - Examples: - >>> extend({"a": "cats"}, {"b": "dogs"}) - {'a': 'cats', 'b': 'dogs'} - """ - return dict(a, **b) - - -def append(a: List[T], b: T) -> List[T]: - """ - Function to create a new list with an item appended to it. - - Examples: - Given a starting list `a`: - >>> a = [1, 2, 3] - - ... we can append a value: - >>> append(a, 4) - [1, 2, 3, 4] - - `a` is unchanged - >>> a == [1, 2, 3] - True - - Why not just use `list.append`? `list.append` mutates `a` in place, which we can't allow - in the AER cycle – parts of the cycle rely on purely functional code which doesn't - (accidentally or intentionally) manipulate existing data. - >>> list.append(a, 4) # not what we want - >>> a - [1, 2, 3, 4] - """ - return a + [b] - - -def wrap_to_use_state(f): - """Decorator to make target `f` into a function on a `State` and `**kwargs`. - - This wrapper makes it easier to pass arguments to a function from a State. - - It was inspired by the pytest "fixtures" mechanism. - - Args: - f: a function with arguments that could be fields on a `State` - and that returns a `Delta`. - - Returns: a version of `f` which takes and returns `State` objects. - - Examples: - >>> from autora.state.delta import State, Delta - >>> from dataclasses import dataclass, field - >>> import pandas as pd - >>> from typing import List, Optional - - The `State` it operates on needs to have the metadata described in the state module: - >>> @dataclass(frozen=True) - ... class S(State): - ... conditions: List[int] = field(metadata={"delta": "replace"}) - - We indicate the inputs required by the parameter names. - The output must be a `Delta` object. - >>> from autora.state.delta import Delta - >>> @wrap_to_use_state - ... def experimentalist(conditions): - ... new_conditions = [c + 10 for c in conditions] - ... return Delta(conditions=new_conditions) - - >>> experimentalist(S(conditions=[1,2,3,4])) - S(conditions=[11, 12, 13, 14]) - - >>> experimentalist(S(conditions=[101,102,103,104])) - S(conditions=[111, 112, 113, 114]) - - >>> from autora.variable import VariableCollection, Variable - >>> from sklearn.base import BaseEstimator - >>> from sklearn.linear_model import LinearRegression - - >>> @wrap_to_use_state - ... def theorist(experiment_data: pd.DataFrame, variables: VariableCollection, **kwargs): - ... ivs = [v.name for v in variables.independent_variables] - ... dvs = [v.name for v in variables.dependent_variables] - ... X, y = experiment_data[ivs], experiment_data[dvs] - ... new_model = LinearRegression(fit_intercept=True).set_params(**kwargs).fit(X, y) - ... return Delta(model=new_model) - - >>> @dataclass(frozen=True) - ... class T(State): - ... variables: VariableCollection # field(metadata={"delta":... }) omitted ∴ immutable - ... experiment_data: pd.DataFrame = field(metadata={"delta": "extend"}) - ... model: Optional[BaseEstimator] = field(metadata={"delta": "replace"}, default=None) - - >>> t = T( - ... variables=VariableCollection(independent_variables=[Variable("x")], - ... dependent_variables=[Variable("y")]), - ... experiment_data=pd.DataFrame({"x": [0,1,2,3,4], "y": [2,3,4,5,6]}) - ... ) - >>> t_prime = theorist(t) - >>> t_prime.model.coef_, t_prime.model.intercept_ - (array([[1.]]), array([2.])) - - Arguments from the state can be overridden by passing them in as keyword arguments (kwargs): - >>> theorist(t, experiment_data=pd.DataFrame({"x": [0,1,2,3], "y": [12,13,14,15]}))\\ - ... .model.intercept_ - array([12.]) - - ... and other arguments supported by the inner function can also be passed - (if and only if the inner function allows for and handles `**kwargs` arguments alongside - the values from the state). - >>> theorist(t, fit_intercept=False).model.intercept_ - 0.0 - - Any parameters not provided by the state must be provided by default values or by the - caller. If the default is specified: - >>> @wrap_to_use_state - ... def experimentalist(conditions, offset=25): - ... new_conditions = [c + offset for c in conditions] - ... return Delta(conditions=new_conditions) - - ... then it need not be passed. - >>> experimentalist(S(conditions=[1,2,3,4])) - S(conditions=[26, 27, 28, 29]) - - If a default isn't specified: - >>> @wrap_to_use_state - ... def experimentalist(conditions, offset): - ... new_conditions = [c + offset for c in conditions] - ... return Delta(conditions=new_conditions) - - ... then calling the experimentalist without it will throw an error: - >>> experimentalist(S(conditions=[1,2,3,4])) - Traceback (most recent call last): - ... - TypeError: experimentalist() missing 1 required positional argument: 'offset' - - ... which can be fixed by passing the argument as a keyword to the wrapped function. - >>> experimentalist(S(conditions=[1,2,3,4]), offset=2) - S(conditions=[3, 4, 5, 6]) - - """ - # Get the set of parameter names from function f's signature - parameters_ = set(inspect.signature(f).parameters.keys()) - - @wraps(f) - def _f(state_: S, /, **kwargs) -> S: - # Get the parameters needed which are available from the state_. - # All others must be provided as kwargs or default values on f. - assert dataclasses.is_dataclass(state_) - from_state = parameters_.intersection( - {i.name for i in dataclasses.fields(state_)} - ) - arguments_from_state = {k: getattr(state_, k) for k in from_state} - arguments = dict(arguments_from_state, **kwargs) - delta = f(**arguments) - new_state = state_ + delta - return new_state - - return _f diff --git a/src/autora/state/history.py b/src/autora/state/history.py deleted file mode 100644 index fbb33944..00000000 --- a/src/autora/state/history.py +++ /dev/null @@ -1,722 +0,0 @@ -""" Classes for storing and passing a cycle's state as an immutable history. """ -from __future__ import annotations - -from dataclasses import dataclass -from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Union - -from numpy.typing import ArrayLike -from sklearn.base import BaseEstimator - -from autora.state.delta import Delta -from autora.state.protocol import ( - ResultKind, - SupportsControllerStateHistory, - SupportsDataKind, -) -from autora.state.snapshot import Snapshot -from autora.variable import VariableCollection - - -class History(SupportsControllerStateHistory): - """ - An immutable object for tracking the state and history of an AER cycle. - """ - - def __init__( - self, - variables: Optional[VariableCollection] = None, - params: Optional[Dict] = None, - conditions: Optional[List[ArrayLike]] = None, - observations: Optional[List[ArrayLike]] = None, - models: Optional[List[BaseEstimator]] = None, - history: Optional[Sequence[Result]] = None, - ): - """ - - Args: - variables: a single datum to be marked as "variables" - params: a single datum to be marked as "params" - conditions: an iterable of data, each to be marked as "conditions" - observations: an iterable of data, each to be marked as "observations" - models: an iterable of data, each to be marked as "models" - history: an iterable of Result objects to be used as the initial history. - - Examples: - Empty input leads to an empty state: - >>> History() - History([]) - - ... or with values for any or all of the parameters: - >>> from autora.variable import VariableCollection - >>> History(variables=VariableCollection()) # doctest: +ELLIPSIS - History([Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)]) - - >>> History(params={"some": "params"}) - History([Result(data={'some': 'params'}, kind=ResultKind.PARAMS)]) - - >>> History(conditions=["a condition"]) - History([Result(data='a condition', kind=ResultKind.CONDITION)]) - - >>> History(observations=["an observation"]) - History([Result(data='an observation', kind=ResultKind.OBSERVATION)]) - - >>> from sklearn.linear_model import LinearRegression - >>> History(models=[LinearRegression()]) - History([Result(data=LinearRegression(), kind=ResultKind.MODEL)]) - - Parameters passed to the constructor are included in the history in the following order: - `history`, `variables`, `params`, `conditions`, `observations`, `models` - >>> History(models=['m1', 'm2'], conditions=['c1', 'c2'], - ... observations=['o1', 'o2'], params={'a': 'param'}, - ... variables=VariableCollection(), - ... history=[Result("from history", ResultKind.VARIABLES)] - ... ) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - History([Result(data='from history', kind=ResultKind.VARIABLES), - Result(data=VariableCollection(...), kind=ResultKind.VARIABLES), - Result(data={'a': 'param'}, kind=ResultKind.PARAMS), - Result(data='c1', kind=ResultKind.CONDITION), - Result(data='c2', kind=ResultKind.CONDITION), - Result(data='o1', kind=ResultKind.OBSERVATION), - Result(data='o2', kind=ResultKind.OBSERVATION), - Result(data='m1', kind=ResultKind.MODEL), - Result(data='m2', kind=ResultKind.MODEL)]) - """ - self.data: List - - if history is not None: - self.data = list(history) - else: - self.data = [] - - self.data += _init_result_list( - variables=variables, - params=params, - conditions=conditions, - observations=observations, - models=models, - ) - - def update( - self, - variables=None, - params=None, - conditions=None, - observations=None, - models=None, - history=None, - ): - """ - Create a new object with updated values. - - Examples: - The initial object is empty: - >>> h0 = History() - >>> h0 - History([]) - - We can update the variables using the `.update` method: - >>> from autora.variable import VariableCollection - >>> h1 = h0.update(variables=VariableCollection()) - >>> h1 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - History([Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)]) - - ... the original object is unchanged: - >>> h0 - History([]) - - We can update the variables again: - >>> h2 = h1.update(variables=VariableCollection(["some IV"])) - >>> h2._by_kind # doctest: +ELLIPSIS - Snapshot(variables=VariableCollection(independent_variables=['some IV'],...), ...) - - ... and we see that there is only ever one variables object returned. - - Params is treated the same way as variables: - >>> hp = h0.update(params={'first': 'params'}) - >>> hp - History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS)]) - - ... where only the most recent "params" object is returned from the `.params` property. - >>> hp = hp.update(params={'second': 'params'}) - >>> hp.params - {'second': 'params'} - - ... however, the full history of the params objects remains available, if needed: - >>> hp # doctest: +NORMALIZE_WHITESPACE - History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS), - Result(data={'second': 'params'}, kind=ResultKind.PARAMS)]) - - When we update the conditions, observations or models, a new entry is added to the - history: - >>> h3 = h0.update(models=["1st model"]) - >>> h3 # doctest: +NORMALIZE_WHITESPACE - History([Result(data='1st model', kind=ResultKind.MODEL)]) - - ... so we can see the history of all the models, for instance. - >>> h3 = h3.update(models=["2nd model"]) # doctest: +NORMALIZE_WHITESPACE - >>> h3 # doctest: +NORMALIZE_WHITESPACE - History([Result(data='1st model', kind=ResultKind.MODEL), - Result(data='2nd model', kind=ResultKind.MODEL)]) - - ... and the full history of models is available using the `.models` parameter: - >>> h3.models - ['1st model', '2nd model'] - - The same for the observations: - >>> h4 = h0.update(observations=["1st observation"]) - >>> h4 - History([Result(data='1st observation', kind=ResultKind.OBSERVATION)]) - - >>> h4.update(observations=["2nd observation"] - ... ) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - History([Result(data='1st observation', kind=ResultKind.OBSERVATION), - Result(data='2nd observation', kind=ResultKind.OBSERVATION)]) - - - The same for the conditions: - >>> h5 = h0.update(conditions=["1st condition"]) - >>> h5 - History([Result(data='1st condition', kind=ResultKind.CONDITION)]) - - >>> h5.update(conditions=["2nd condition"]) # doctest: +NORMALIZE_WHITESPACE - History([Result(data='1st condition', kind=ResultKind.CONDITION), - Result(data='2nd condition', kind=ResultKind.CONDITION)]) - - You can also update with multiple conditions, observations and models: - >>> h0.update(conditions=['c1', 'c2']) # doctest: +NORMALIZE_WHITESPACE - History([Result(data='c1', kind=ResultKind.CONDITION), - Result(data='c2', kind=ResultKind.CONDITION)]) - - >>> h0.update(models=['m1', 'm2'], variables={'m': 1} - ... ) # doctest: +NORMALIZE_WHITESPACE - History([Result(data={'m': 1}, kind=ResultKind.VARIABLES), - Result(data='m1', kind=ResultKind.MODEL), - Result(data='m2', kind=ResultKind.MODEL)]) - - >>> h0.update(models=['m1'], observations=['o1'], variables={'m': 1} - ... ) # doctest: +NORMALIZE_WHITESPACE - History([Result(data={'m': 1}, kind=ResultKind.VARIABLES), - Result(data='o1', kind=ResultKind.OBSERVATION), - Result(data='m1', kind=ResultKind.MODEL)]) - - We can also update with a complete history: - >>> History().update(history=[Result(data={'m': 2}, kind=ResultKind.VARIABLES), - ... Result(data='o1', kind=ResultKind.OBSERVATION), - ... Result(data='m1', kind=ResultKind.MODEL)], - ... conditions=['c1'] - ... ) # doctest: +NORMALIZE_WHITESPACE - History([Result(data={'m': 2}, kind=ResultKind.VARIABLES), - Result(data='o1', kind=ResultKind.OBSERVATION), - Result(data='m1', kind=ResultKind.MODEL), - Result(data='c1', kind=ResultKind.CONDITION)]) - - """ - - if history is not None: - history_extension = history - else: - history_extension = [] - - history_extension += _init_result_list( - variables=variables, - params=params, - conditions=conditions, - observations=observations, - models=models, - ) - new_full_history = self.data + history_extension - - return History(history=new_full_history) - - def __add__(self, other: Delta): - """The initial object is empty: - >>> h0 = History() - >>> h0 - History([]) - - We can update the variables using the `.update` method: - >>> from autora.variable import VariableCollection - >>> h1 = h0 + Delta(variables=VariableCollection()) - >>> h1 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - History([Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)]) - - ... the original object is unchanged: - >>> h0 - History([]) - - We can update the variables again: - >>> h2 = h1 + Delta(variables=VariableCollection(["some IV"])) - >>> h2._by_kind # doctest: +ELLIPSIS - Snapshot(variables=VariableCollection(independent_variables=['some IV'],...), ...) - - ... and we see that there is only ever one variables object returned. - - Params is treated the same way as variables: - >>> hp = h0 + Delta(params={'first': 'params'}) - >>> hp - History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS)]) - - ... where only the most recent "params" object is returned from the `.params` property. - >>> hp = hp + Delta(params={'second': 'params'}) - >>> hp.params - {'second': 'params'} - - ... however, the full history of the params objects remains available, if needed: - >>> hp # doctest: +NORMALIZE_WHITESPACE - History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS), - Result(data={'second': 'params'}, kind=ResultKind.PARAMS)]) - - When we update the conditions, observations or models, a new entry is added to the - history: - >>> h3 = h0 + Delta(models=["1st model"]) - >>> h3 # doctest: +NORMALIZE_WHITESPACE - History([Result(data='1st model', kind=ResultKind.MODEL)]) - - ... so we can see the history of all the models, for instance. - >>> h3 = h3 + Delta(models=["2nd model"]) # doctest: +NORMALIZE_WHITESPACE - >>> h3 # doctest: +NORMALIZE_WHITESPACE - History([Result(data='1st model', kind=ResultKind.MODEL), - Result(data='2nd model', kind=ResultKind.MODEL)]) - - ... and the full history of models is available using the `.models` parameter: - >>> h3.models - ['1st model', '2nd model'] - - The same for the observations: - >>> h4 = h0 + Delta(observations=["1st observation"]) - >>> h4 - History([Result(data='1st observation', kind=ResultKind.OBSERVATION)]) - - >>> h4 + Delta(observations=["2nd observation"] - ... ) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - History([Result(data='1st observation', kind=ResultKind.OBSERVATION), - Result(data='2nd observation', kind=ResultKind.OBSERVATION)]) - - - The same for the conditions: - >>> h5 = h0 + Delta(conditions=["1st condition"]) - >>> h5 - History([Result(data='1st condition', kind=ResultKind.CONDITION)]) - - >>> h5 + Delta(conditions=["2nd condition"]) # doctest: +NORMALIZE_WHITESPACE - History([Result(data='1st condition', kind=ResultKind.CONDITION), - Result(data='2nd condition', kind=ResultKind.CONDITION)]) - - You can also update with multiple conditions, observations and models: - >>> h0 + Delta(conditions=['c1', 'c2']) # doctest: +NORMALIZE_WHITESPACE - History([Result(data='c1', kind=ResultKind.CONDITION), - Result(data='c2', kind=ResultKind.CONDITION)]) - - >>> h0 + Delta(models=['m1', 'm2'], variables={'m': 1} - ... ) # doctest: +NORMALIZE_WHITESPACE - History([Result(data={'m': 1}, kind=ResultKind.VARIABLES), - Result(data='m1', kind=ResultKind.MODEL), - Result(data='m2', kind=ResultKind.MODEL)]) - - >>> h0 + Delta(models=['m1'], observations=['o1'], variables={'m': 1} - ... ) # doctest: +NORMALIZE_WHITESPACE - History([Result(data={'m': 1}, kind=ResultKind.VARIABLES), - Result(data='o1', kind=ResultKind.OBSERVATION), - Result(data='m1', kind=ResultKind.MODEL)]) - - We can also update with a complete history: - >>> History() + Delta(history=[Result(data={'m': 2}, kind=ResultKind.VARIABLES), - ... Result(data='o1', kind=ResultKind.OBSERVATION), - ... Result(data='m1', kind=ResultKind.MODEL)], - ... conditions=['c1'] - ... ) # doctest: +NORMALIZE_WHITESPACE - History([Result(data={'m': 2}, kind=ResultKind.VARIABLES), - Result(data='o1', kind=ResultKind.OBSERVATION), - Result(data='m1', kind=ResultKind.MODEL), - Result(data='c1', kind=ResultKind.CONDITION)]) - """ - return self.update(**other) - - def __repr__(self): - return f"{type(self).__name__}({self.history})" - - @property - def _by_kind(self): - return _history_to_kind(self.data) - - @property - def variables(self) -> VariableCollection: - """ - - Examples: - The initial object is empty: - >>> h = History() - - ... and returns an emtpy variables object - >>> h.variables - VariableCollection(independent_variables=[], dependent_variables=[], covariates=[]) - - We can update the variables using the `.update` method: - >>> from autora.variable import VariableCollection - >>> h = h.update(variables=VariableCollection(independent_variables=['some IV'])) - >>> h.variables # doctest: +ELLIPSIS - VariableCollection(independent_variables=['some IV'], ...) - - We can update the variables again: - >>> h = h.update(variables=VariableCollection(["some other IV"])) - >>> h.variables # doctest: +ELLIPSIS - VariableCollection(independent_variables=['some other IV'], ...) - - ... and we see that there is only ever one variables object returned.""" - return self._by_kind.variables - - @property - def params(self) -> Dict: - """ - - Returns: - - Examples: - Params is treated the same way as variables: - >>> h = History() - >>> h = h.update(params={'first': 'params'}) - >>> h.params - {'first': 'params'} - - ... where only the most recent "params" object is returned from the `.params` property. - >>> h = h.update(params={'second': 'params'}) - >>> h.params - {'second': 'params'} - - ... however, the full history of the params objects remains available, if needed: - >>> h # doctest: +NORMALIZE_WHITESPACE - History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS), - Result(data={'second': 'params'}, kind=ResultKind.PARAMS)]) - """ - return self._by_kind.params - - @property - def conditions(self) -> List[ArrayLike]: - """ - Returns: - - Examples: - View the sequence of models with one conditions: - >>> h = History(conditions=[(1,2,3,)]) - >>> h.conditions - [(1, 2, 3)] - - ... or more conditions: - >>> h = h.update(conditions=[(4,5,6),(7,8,9)]) # doctest: +NORMALIZE_WHITESPACE - >>> h.conditions - [(1, 2, 3), (4, 5, 6), (7, 8, 9)] - - """ - return self._by_kind.conditions - - @property - def observations(self) -> List[ArrayLike]: - """ - - Returns: - - Examples: - The sequence of all observations is returned - >>> h = History(observations=["1st observation"]) - >>> h.observations - ['1st observation'] - - >>> h = h.update(observations=["2nd observation"]) - >>> h.observations # doctest: +ELLIPSIS - ['1st observation', '2nd observation'] - - """ - return self._by_kind.observations - - @property - def models(self) -> List[BaseEstimator]: - """ - - Returns: - - Examples: - View the sequence of models with one model: - >>> s = History(models=["1st model"]) - >>> s.models # doctest: +NORMALIZE_WHITESPACE - ['1st model'] - - ... or more models: - >>> s = s.update(models=["2nd model"]) # doctest: +NORMALIZE_WHITESPACE - >>> s.models - ['1st model', '2nd model'] - - """ - return self._by_kind.models - - @property - def history(self) -> List[Result]: - """ - - Examples: - We initialze some history: - >>> h = History(models=['m1', 'm2'], conditions=['c1', 'c2'], - ... observations=['o1', 'o2'], params={'a': 'param'}, - ... variables=VariableCollection(), - ... history=[Result("from history", ResultKind.VARIABLES)]) - - Parameters passed to the constructor are included in the history in the following order: - `history`, `variables`, `params`, `conditions`, `observations`, `models` - - >>> h.history # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - [Result(data='from history', kind=ResultKind.VARIABLES), - Result(data=VariableCollection(...), kind=ResultKind.VARIABLES), - Result(data={'a': 'param'}, kind=ResultKind.PARAMS), - Result(data='c1', kind=ResultKind.CONDITION), - Result(data='c2', kind=ResultKind.CONDITION), - Result(data='o1', kind=ResultKind.OBSERVATION), - Result(data='o2', kind=ResultKind.OBSERVATION), - Result(data='m1', kind=ResultKind.MODEL), - Result(data='m2', kind=ResultKind.MODEL)] - - If we add a new value, like the params object, the updated value is added to the - end of the history: - >>> h = h.update(params={'new': 'param'}) - >>> h.history # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - [..., Result(data={'new': 'param'}, kind=ResultKind.PARAMS)] - - """ - return self.data - - def filter_by(self, kind: Optional[Set[Union[str, ResultKind]]] = None) -> History: - """ - Return a copy of the object with only data belonging to the specified kinds. - - Examples: - >>> h = History(models=['m1', 'm2'], conditions=['c1', 'c2'], - ... observations=['o1', 'o2'], params={'a': 'param'}, - ... variables=VariableCollection(), - ... history=[Result("from history", ResultKind.VARIABLES)]) - - >>> h.filter_by(kind={"MODEL"}) # doctest: +NORMALIZE_WHITESPACE - History([Result(data='m1', kind=ResultKind.MODEL), - Result(data='m2', kind=ResultKind.MODEL)]) - - >>> h.filter_by(kind={ResultKind.OBSERVATION}) # doctest: +NORMALIZE_WHITESPACE - History([Result(data='o1', kind=ResultKind.OBSERVATION), - Result(data='o2', kind=ResultKind.OBSERVATION)]) - - If we don't specify any filter criteria, we get the full history back: - >>> h.filter_by() # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS - History([Result(data='from history', kind=ResultKind.VARIABLES), - Result(data=VariableCollection(...), kind=ResultKind.VARIABLES), - Result(data={'a': 'param'}, kind=ResultKind.PARAMS), - Result(data='c1', kind=ResultKind.CONDITION), - Result(data='c2', kind=ResultKind.CONDITION), - Result(data='o1', kind=ResultKind.OBSERVATION), - Result(data='o2', kind=ResultKind.OBSERVATION), - Result(data='m1', kind=ResultKind.MODEL), - Result(data='m2', kind=ResultKind.MODEL)]) - - """ - if kind is None: - return self - else: - kind_ = {ResultKind(s) for s in kind} - filtered_history = _filter_history(self.data, kind_) - new_object = History(history=filtered_history) - return new_object - - -@dataclass(frozen=True) -class Result(SupportsDataKind): - """ - Container class for data and variables. - - Examples: - >>> Result() - Result(data=None, kind=None) - - >>> Result("a") - Result(data='a', kind=None) - - >>> Result(None, "MODEL") - Result(data=None, kind=ResultKind.MODEL) - - >>> Result(data="b") - Result(data='b', kind=None) - - >>> Result("c", "OBSERVATION") - Result(data='c', kind=ResultKind.OBSERVATION) - """ - - data: Optional[Any] = None - kind: Optional[ResultKind] = None - - def __post_init__(self): - if isinstance(self.kind, str): - object.__setattr__(self, "kind", ResultKind(self.kind)) - - -def _init_result_list( - variables: Optional[VariableCollection] = None, - params: Optional[Dict] = None, - conditions: Optional[Iterable[ArrayLike]] = None, - observations: Optional[Iterable[ArrayLike]] = None, - models: Optional[Iterable[BaseEstimator]] = None, -) -> List[Result]: - """ - Initialize a list of Result objects - - Returns: - - Args: - variables: a single datum to be marked as "variables" - params: a single datum to be marked as "params" - conditions: an iterable of data, each to be marked as "conditions" - observations: an iterable of data, each to be marked as "observations" - models: an iterable of data, each to be marked as "models" - - Examples: - Empty input leads to an empty state: - >>> _init_result_list() - [] - - ... or with values for any or all of the parameters: - >>> from autora.variable import VariableCollection - >>> _init_result_list(variables=VariableCollection()) # doctest: +ELLIPSIS - [Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)] - - >>> _init_result_list(params={"some": "params"}) - [Result(data={'some': 'params'}, kind=ResultKind.PARAMS)] - - >>> _init_result_list(conditions=["a condition"]) - [Result(data='a condition', kind=ResultKind.CONDITION)] - - >>> _init_result_list(observations=["an observation"]) - [Result(data='an observation', kind=ResultKind.OBSERVATION)] - - >>> from sklearn.linear_model import LinearRegression - >>> _init_result_list(models=[LinearRegression()]) - [Result(data=LinearRegression(), kind=ResultKind.MODEL)] - - The input arguments are added to the data in the order `variables`, - `params`, `conditions`, `observations`, `models`: - >>> _init_result_list(variables=VariableCollection(), - ... params={"some": "params"}, - ... conditions=["a condition"], - ... observations=["an observation", "another observation"], - ... models=[LinearRegression()], - ... ) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS - [Result(data=VariableCollection(...), kind=ResultKind.VARIABLES), - Result(data={'some': 'params'}, kind=ResultKind.PARAMS), - Result(data='a condition', kind=ResultKind.CONDITION), - Result(data='an observation', kind=ResultKind.OBSERVATION), - Result(data='another observation', kind=ResultKind.OBSERVATION), - Result(data=LinearRegression(), kind=ResultKind.MODEL)] - - """ - data = [] - - if variables is not None: - data.append(Result(variables, ResultKind.VARIABLES)) - - if params is not None: - data.append(Result(params, ResultKind.PARAMS)) - - for seq, kind in [ - (conditions, ResultKind.CONDITION), - (observations, ResultKind.OBSERVATION), - (models, ResultKind.MODEL), - ]: - if seq is not None: - for i in seq: - data.append(Result(i, kind=kind)) - - return data - - -def _history_to_kind(history: Sequence[Result]) -> Snapshot: - """ - Convert a sequence of results into a Snapshot instance: - - Examples: - History might be empty - >>> history_ = [] - >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS - Snapshot(variables=VariableCollection(...), params={}, - conditions=[], observations=[], models=[]) - - ... or with values for any or all of the parameters: - >>> history_ = _init_result_list(params={"some": "params"}) - >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS - Snapshot(..., params={'some': 'params'}, ...) - - >>> history_ += _init_result_list(conditions=["a condition"]) - >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS - Snapshot(..., params={'some': 'params'}, conditions=['a condition'], ...) - - >>> _history_to_kind(history_).params - {'some': 'params'} - - >>> history_ += _init_result_list(observations=["an observation"]) - >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS - Snapshot(..., params={'some': 'params'}, conditions=['a condition'], - observations=['an observation'], ...) - - >>> from sklearn.linear_model import LinearRegression - >>> history_ = [Result(LinearRegression(), kind=ResultKind.MODEL)] - >>> _history_to_kind(history_) # doctest: +ELLIPSIS - Snapshot(..., models=[LinearRegression()]) - - >>> from autora.variable import VariableCollection, IV - >>> variables = VariableCollection(independent_variables=[IV(name="example")]) - >>> history_ = [Result(variables, kind=ResultKind.VARIABLES)] - >>> _history_to_kind(history_) # doctest: +ELLIPSIS - Snapshot(variables=VariableCollection(independent_variables=[IV(name='example', ... - - >>> history_ = [Result({'some': 'params'}, kind=ResultKind.PARAMS)] - >>> _history_to_kind(history_) # doctest: +ELLIPSIS - Snapshot(..., params={'some': 'params'}, ...) - - """ - namespace = Snapshot( - variables=_get_last_data_with_default( - history, kind={ResultKind.VARIABLES}, default=VariableCollection() - ), - params=_get_last_data_with_default( - history, kind={ResultKind.PARAMS}, default={} - ), - observations=_list_data( - _filter_history(history, kind={ResultKind.OBSERVATION}) - ), - models=_list_data(_filter_history(history, kind={ResultKind.MODEL})), - conditions=_list_data(_filter_history(history, kind={ResultKind.CONDITION})), - ) - return namespace - - -def _list_data(data: Sequence[SupportsDataKind]): - """ - Extract the `.data` attribute of each item in a sequence, and return as a list. - - Examples: - >>> _list_data([]) - [] - - >>> _list_data([Result("a"), Result("b")]) - ['a', 'b'] - """ - return list(r.data for r in data) - - -def _filter_history(data: Iterable[SupportsDataKind], kind: Set[ResultKind]): - return filter(lambda r: r.kind in kind, data) - - -def _get_last(data: Sequence[SupportsDataKind], kind: Set[ResultKind]): - results_new_to_old = reversed(data) - last_of_kind = next(_filter_history(results_new_to_old, kind=kind)) - return last_of_kind - - -def _get_last_data_with_default(data: Sequence[SupportsDataKind], kind, default): - try: - result = _get_last(data, kind).data - except StopIteration: - result = default - return result diff --git a/src/autora/state/param.py b/src/autora/state/param.py deleted file mode 100644 index 1fca3cfc..00000000 --- a/src/autora/state/param.py +++ /dev/null @@ -1,143 +0,0 @@ -""" Functions for handling cycle-state-dependent parameters. """ -from __future__ import annotations - -import copy -import logging -from typing import Dict, Mapping - -import numpy as np - -from autora.state.protocol import SupportsControllerState -from autora.utils.deprecation import deprecate as deprecate -from autora.utils.dictionary import LazyDict - -_logger = logging.getLogger(__name__) - - -def _get_state_dependent_properties(state: SupportsControllerState): - """ - Examples: - Even with an empty data object, we can initialize the dictionary, - >>> from autora.state.snapshot import Snapshot - >>> state_dependent_properties = _get_state_dependent_properties(Snapshot()) - - ... but it will raise an exception if a value isn't yet available when we try to use it - >>> state_dependent_properties["%models[-1]%"] # doctest: +ELLIPSIS - Traceback (most recent call last): - ... - IndexError: list index out of range - - Nevertheless, we can iterate through its keys no problem: - >>> [key for key in state_dependent_properties.keys()] # doctest: +NORMALIZE_WHITESPACE - ['%observations.ivs[-1]%', '%observations.dvs[-1]%', '%observations.ivs%', - '%observations.dvs%', '%experiment_data.conditions[-1]%', - '%experiment_data.observations[-1]%', '%experiment_data.conditions%', - '%experiment_data.observations%', '%models[-1]%', '%models%'] - - """ - - n_ivs = len(state.variables.independent_variables) - n_dvs = len(state.variables.dependent_variables) - state_dependent_property_dict = LazyDict( - { - "%observations.ivs[-1]%": deprecate( - lambda: np.array(state.observations[-1])[:, 0:n_ivs], - "%observations.ivs[-1]% is deprecated, " - "use %experiment_data.conditions[-1]% instead.", - ), - "%observations.dvs[-1]%": deprecate( - lambda: np.array(state.observations[-1])[:, n_ivs:], - "%observations.dvs[-1]% is deprecated, " - "use %experiment_data.observations[-1]% instead.", - ), - "%observations.ivs%": deprecate( - lambda: np.row_stack( - [np.empty([0, n_ivs + n_dvs])] + list(state.observations) - )[:, 0:n_ivs], - "%observations.ivs% is deprecated, use %experiment_data.conditions% instead.", - ), - "%observations.dvs%": deprecate( - lambda: np.row_stack(state.observations)[:, n_ivs:], - "%observations.dvs% is deprecated, " - "use %experiment_data.observations% instead", - ), - "%experiment_data.conditions[-1]%": lambda: np.array( - state.observations[-1] - )[:, 0:n_ivs], - "%experiment_data.observations[-1]%": lambda: np.array( - state.observations[-1] - )[:, n_ivs:], - "%experiment_data.conditions%": lambda: np.row_stack( - [np.empty([0, n_ivs + n_dvs])] + list(state.observations) - )[:, 0:n_ivs], - "%experiment_data.observations%": lambda: np.row_stack(state.observations)[ - :, n_ivs: - ], - "%models[-1]%": lambda: state.models[-1], - "%models%": lambda: state.models, - } - ) - return state_dependent_property_dict - - -def _resolve_properties(params: Dict, state_dependent_properties: Mapping): - """ - Resolve state-dependent properties inside a nested dictionary. - - In this context, a state-dependent-property is a string which is meant to be replaced by its - updated, current value before the dictionary is used. A state-dependent property might be - something like "the last theorist available" or "all the experimental results until now". - - Args: - params: a (nested) dictionary of keys and values, where some values might be - "cycle property names" - state_dependent_properties: a dictionary of "property names" and their "real values" - - Returns: a (nested) dictionary where "property names" are replaced by the "real values" - - Examples: - - >>> params_0 = {"key": "%foo%"} - >>> cycle_properties_0 = {"%foo%": 180} - >>> _resolve_properties(params_0,cycle_properties_0) - {'key': 180} - - >>> params_1 = {"key": "%bar%", "nested_dict": {"inner_key": "%foobar%"}} - >>> cycle_properties_1 = {"%bar%": 1, "%foobar%": 2} - >>> _resolve_properties(params_1,cycle_properties_1) - {'key': 1, 'nested_dict': {'inner_key': 2}} - - >>> params_2 = {"key": "baz"} - >>> _resolve_properties(params_2,cycle_properties_1) - {'key': 'baz'} - - """ - params_ = copy.copy(params) - for key, value in params_.items(): - if isinstance(value, dict): - params_[key] = _resolve_properties(value, state_dependent_properties) - elif isinstance(value, str) and ( - value in state_dependent_properties - ): # value is a key in the cycle_properties dictionary - params_[key] = state_dependent_properties[value] - else: - _logger.debug(f"leaving {params=} unchanged") - - return params_ - - -def resolve_state_params(params: Dict, state: SupportsControllerState) -> Dict: - """ - Returns the `params` attribute of the input, with `cycle properties` resolved. - - Examples: - >>> from autora.state.history import History - >>> params = {"experimentalist": {"source": "%models[-1]%"}} - >>> s = History(models=["the first model", "the second model"]) - >>> resolve_state_params(params, s) - {'experimentalist': {'source': 'the second model'}} - - """ - state_dependent_properties = _get_state_dependent_properties(state) - resolved_params = _resolve_properties(params, state_dependent_properties) - return resolved_params diff --git a/src/autora/state/protocol.py b/src/autora/state/protocol.py deleted file mode 100644 index e1a16be7..00000000 --- a/src/autora/state/protocol.py +++ /dev/null @@ -1,158 +0,0 @@ -from enum import Enum -from typing import ( - Any, - Dict, - Generic, - Mapping, - Optional, - Protocol, - Sequence, - Set, - TypeVar, - Union, - runtime_checkable, -) - -from numpy.typing import ArrayLike -from sklearn.base import BaseEstimator - -from autora.variable import VariableCollection - -State = TypeVar("State") - - -class ResultKind(str, Enum): - """ - Kinds of results which can be held in the Result object. - - Examples: - >>> ResultKind.CONDITION is ResultKind.CONDITION - True - - >>> ResultKind.CONDITION is ResultKind.VARIABLES - False - - >>> ResultKind.CONDITION == "CONDITION" - True - - >>> ResultKind.CONDITION == "VARIABLES" - False - - >>> ResultKind.CONDITION in {ResultKind.CONDITION, ResultKind.PARAMS} - True - - >>> ResultKind.VARIABLES in {ResultKind.CONDITION, ResultKind.PARAMS} - False - """ - - CONDITION = "CONDITION" - OBSERVATION = "OBSERVATION" - MODEL = "MODEL" - PARAMS = "PARAMS" - VARIABLES = "VARIABLES" - - def __repr__(self): - cls_name = self.__class__.__name__ - return f"{cls_name}.{self.name}" - - -class SupportsDataKind(Protocol): - """Object with attributes for `data` and `kind`""" - - data: Optional[Any] - kind: Optional[ResultKind] - - -class SupportsStateParamsField(Protocol): - """Support a state with a params property.""" - - params: Dict - - -class SupportsStateParamsProperty(Protocol): - """Support a state with a params property.""" - - @property - def params(self) -> Dict: - ... - - -SupportsStateParams = Union[SupportsStateParamsField, SupportsStateParamsProperty] - - -class SupportsControllerStateFields(Protocol): - """Support representing snapshots of a controller state as mutable fields.""" - - variables: VariableCollection - params: Dict - conditions: Sequence[ArrayLike] - observations: Sequence[ArrayLike] - models: Sequence[BaseEstimator] - - def update(self: State, **kwargs) -> State: - ... - - -class SupportsControllerStateProperties(Protocol): - """Support representing snapshots of a controller state as immutable properties.""" - - def update(self: State, **kwargs) -> State: - ... - - @property - def variables(self) -> VariableCollection: - ... - - @property - def params(self) -> Dict: - ... - - @property - def conditions(self) -> Sequence[ArrayLike]: - ... - - @property - def observations(self) -> Sequence[ArrayLike]: - ... - - @property - def models(self) -> Sequence[BaseEstimator]: - ... - - -SupportsControllerState = Union[ - SupportsControllerStateFields, SupportsControllerStateProperties -] - - -class SupportsControllerStateHistory(SupportsControllerStateProperties, Protocol): - """Represents controller state as a linear sequence of entries.""" - - def __init__(self, history: Sequence[SupportsDataKind]): - ... - - def filter_by(self: State, kind: Optional[Set[Union[str, ResultKind]]]) -> State: - ... - - @property - def history(self) -> Sequence[SupportsDataKind]: - ... - - -class Executor(Protocol, Generic[State]): - """A Callable which, given some state, and some parameters, returns an updated state.""" - - def __call__(self, __state: State, params: Dict) -> State: - ... - - -ExecutorCollection = Mapping[str, Executor] - - -@runtime_checkable -class SupportsLoadDump(Protocol): - def dump(self, data, file) -> None: - ... - - def load(self, file) -> Any: - ... diff --git a/src/autora/state/snapshot.py b/src/autora/state/snapshot.py deleted file mode 100644 index 21be8171..00000000 --- a/src/autora/state/snapshot.py +++ /dev/null @@ -1,201 +0,0 @@ -""" Classes for storing and passing a cycle's state as an immutable snapshot. """ -from dataclasses import dataclass, field -from typing import Dict, List - -from numpy.typing import ArrayLike -from sklearn.base import BaseEstimator - -from autora.state.delta import Delta -from autora.state.protocol import SupportsControllerStateFields -from autora.variable import VariableCollection - - -@dataclass(frozen=True) -class Snapshot(SupportsControllerStateFields): - """An object passed between and updated by processing steps in the Controller.""" - - # Single values - variables: VariableCollection = field(default_factory=VariableCollection) - params: Dict = field(default_factory=dict) - - # Sequences - conditions: List[ArrayLike] = field(default_factory=list) - observations: List[ArrayLike] = field(default_factory=list) - models: List[BaseEstimator] = field(default_factory=list) - - def update( - self, - variables=None, - params=None, - conditions=None, - observations=None, - models=None, - ): - """ - Create a new object with updated values. - - Examples: - The initial object is empty: - >>> s0 = Snapshot() - >>> s0 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Snapshot(variables=VariableCollection(...), params={}, conditions=[], - observations=[], models=[]) - - We can update the params using the `.update` method: - >>> s0.update(params={'first': 'params'}) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Snapshot(..., params={'first': 'params'}, ...) - - ... but the original object is unchanged: - >>> s0 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Snapshot(..., params={}, ...) - - For params, only one object is returned from the respective property: - >>> s0.update(params={'first': 'params'}).update(params={'second': 'params'}).params - {'second': 'params'} - - ... and the same applies to variables: - >>> from autora.variable import VariableCollection, IV - >>> (s0.update(variables=VariableCollection([IV("1st IV")])) - ... .update(variables=VariableCollection([IV("2nd IV")]))).variables - VariableCollection(independent_variables=[IV(name='2nd IV',...)], ...) - - When we update the conditions, observations or models, the respective list is extended: - >>> s3 = s0.update(models=["1st model"]) - >>> s3 - Snapshot(..., models=['1st model']) - - ... so we can see the history of all the models, for instance. - >>> s3.update(models=["2nd model"]) - Snapshot(..., models=['1st model', '2nd model']) - - The same applies to observations: - >>> s4 = s0.update(observations=["1st observation"]) - >>> s4 - Snapshot(..., observations=['1st observation'], ...) - - >>> s4.update(observations=["2nd observation"]) # doctest: +ELLIPSIS - Snapshot(..., observations=['1st observation', '2nd observation'], ...) - - - The same applies to conditions: - >>> s5 = s0.update(conditions=["1st condition"]) - >>> s5 - Snapshot(..., conditions=['1st condition'], ...) - - >>> s5.update(conditions=["2nd condition"]) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Snapshot(..., conditions=['1st condition', '2nd condition'], ...) - - You can also update with multiple conditions, observations and models: - >>> s0.update(conditions=['c1', 'c2']) - Snapshot(..., conditions=['c1', 'c2'], ...) - - >>> s0.update(models=['m1', 'm2'], variables={'m': 1}) - Snapshot(variables={'m': 1}, ..., models=['m1', 'm2']) - - >>> s0.update(models=['m1'], observations=['o1'], variables={'m': 1}) - Snapshot(variables={'m': 1}, ..., observations=['o1'], models=['m1']) - - - Inputs to models, observations and conditions must be Lists - which can be cast to lists: - >>> s0.update(models='m1') # doctest: +ELLIPSIS - Traceback (most recent call last): - ... - AssertionError: 'm1' must be a list, e.g. `['m1']`?) - - """ - - def _coalesce_lists(old, new): - assert isinstance( - old, List - ), f"{repr(old)} must be a list, e.g. `[{repr(old)}]`?)" - if new is not None: - assert isinstance( - new, List - ), f"{repr(new)} must be a list, e.g. `[{repr(new)}]`?)" - return old + list(new) - else: - return old - - variables_ = variables or self.variables - params_ = params or self.params - conditions_ = _coalesce_lists(self.conditions, conditions) - observations_ = _coalesce_lists(self.observations, observations) - models_ = _coalesce_lists(self.models, models) - return Snapshot(variables_, params_, conditions_, observations_, models_) - - def __add__(self, other: Delta): - """ - Add a delta to the object. - - Examples: - The initial object is empty: - >>> s0 = Snapshot() - >>> s0 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Snapshot(variables=VariableCollection(...), params={}, conditions=[], - observations=[], models=[]) - - We can update the params using the `+` operator: - >>> from autora.state.delta import Delta - >>> s0 + Delta(params={'first': 'params'}) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Snapshot(..., params={'first': 'params'}, ...) - - ... but the original object is unchanged: - >>> s0 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Snapshot(..., params={}, ...) - - For params, only one object is returned from the respective property: - >>> (s0 + Delta(params={'first': 'params'}) + Delta(params={'second':'params'})).params - {'second': 'params'} - - ... and the same applies to variables: - >>> from autora.variable import VariableCollection, IV - >>> (s0 + Delta(variables=VariableCollection([IV("1st IV")])) + - ... Delta(variables=VariableCollection([IV("2nd IV")]))).variables - VariableCollection(independent_variables=[IV(name='2nd IV',...)], ...) - - When we update the conditions, observations or models, the respective list is extended: - >>> s3 = s0 + Delta(models=["1st model"]) - >>> s3 - Snapshot(..., models=['1st model']) - - ... so we can see the history of all the models, for instance. - >>> s3 + Delta(models=["2nd model"]) - Snapshot(..., models=['1st model', '2nd model']) - - The same applies to observations: - >>> s4 = s0 + Delta(observations=["1st observation"]) - >>> s4 - Snapshot(..., observations=['1st observation'], ...) - - >>> s4 + Delta(observations=["2nd observation"]) # doctest: +ELLIPSIS - Snapshot(..., observations=['1st observation', '2nd observation'], ...) - - - The same applies to conditions: - >>> s5 = s0 + Delta(conditions=["1st condition"]) - >>> s5 - Snapshot(..., conditions=['1st condition'], ...) - - >>> s5 + Delta(conditions=["2nd condition"]) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Snapshot(..., conditions=['1st condition', '2nd condition'], ...) - - You can also update with multiple conditions, observations and models: - >>> s0 + Delta(conditions=['c1', 'c2']) - Snapshot(..., conditions=['c1', 'c2'], ...) - - >>> s0 + Delta(models=['m1', 'm2'], variables={'m': 1}) - Snapshot(variables={'m': 1}, ..., models=['m1', 'm2']) - - >>> s0 + Delta(models=['m1'], observations=['o1'], variables={'m': 1}) - Snapshot(variables={'m': 1}, ..., observations=['o1'], models=['m1']) - - - Inputs to models, observations and conditions must be Lists - which can be cast to lists: - >>> s0 + Delta(models='m1') # doctest: +ELLIPSIS - Traceback (most recent call last): - ... - AssertionError: 'm1' must be a list, e.g. `['m1']`?) - """ - return self.update(**other) diff --git a/src/autora/state/wrapper.py b/src/autora/state/wrapper.py deleted file mode 100644 index 74ecbade..00000000 --- a/src/autora/state/wrapper.py +++ /dev/null @@ -1,89 +0,0 @@ -"""Utilities to wrap common theorist, experimentalist and experiment runners as `f(State)` -so that $n$ processes $f_i$ on states $S$ can be represented as -$$f_n(...(f_1(f_0(S))))$$ - -These are special cases of the [autora.state.delta.wrap_to_use_state][] function. -""" -from __future__ import annotations - -from typing import Callable, Iterable, TypeVar - -import numpy as np -import pandas as pd -from sklearn.base import BaseEstimator - -from autora.experimentalist.pipeline import Pipeline -from autora.state.delta import Delta, State, wrap_to_use_state -from autora.variable import VariableCollection - -S = TypeVar("S") -X = TypeVar("X") -Y = TypeVar("Y") -XY = TypeVar("XY") -Executor = Callable[[State], State] - - -def theorist_from_estimator(estimator: BaseEstimator) -> Executor: - """ - Convert a scikit-learn compatible estimator into a function on a `State` object. - - Supports passing additional `**kwargs` which are used to update the estimator's params - before fitting. - """ - - @wrap_to_use_state - def theorist( - experiment_data: pd.DataFrame, variables: VariableCollection, **kwargs - ): - ivs = [v.name for v in variables.independent_variables] - dvs = [v.name for v in variables.dependent_variables] - X, y = experiment_data[ivs], experiment_data[dvs] - new_model = estimator.set_params(**kwargs).fit(X, y) - return Delta(model=new_model) - - return theorist - - -def experiment_runner_from_x_to_y_function(f: Callable[[X], Y]) -> Executor: - """Wrapper for experiment_runner of the form $f(x) \rarrow y$, where `f` returns just the $y$ - values""" - - @wrap_to_use_state - def experiment_runner(conditions: pd.DataFrame, **kwargs): - x = conditions - y = f(x, **kwargs) - experiment_data = pd.DataFrame.merge(x, y, left_index=True, right_index=True) - return Delta(experiment_data=experiment_data) - - return experiment_runner - - -def experiment_runner_from_x_to_xy_function(f: Callable[[X], XY]) -> Executor: - """Wrapper for experiment_runner of the form $f(x) \rarrow (x,y)$, where `f` - returns both $x$ and $y$ values in a complete dataframe.""" - - @wrap_to_use_state - def experiment_runner(conditions: pd.DataFrame, **kwargs): - x = conditions - experiment_data = f(x, **kwargs) - return Delta(experiment_data=experiment_data) - - return experiment_runner - - -def experimentalist_from_pipeline(pipeline: Pipeline) -> Executor: - """Wrapper for experimentalists of the form $f() \rarrow x$, where `f` - returns both $x$ and $y$ values in a complete dataframe.""" - - @wrap_to_use_state - def experimentalist(params): - conditions = pipeline(**params) - if isinstance(conditions, (pd.DataFrame, np.ndarray, np.recarray)): - conditions_ = conditions - elif isinstance(conditions, Iterable): - conditions_ = np.array(list(conditions)) - else: - raise NotImplementedError("type `%s` is not supported" % (type(conditions))) - return Delta(conditions=conditions_) - - return experimentalist diff --git a/tests/test_experimentalist_pipeline.py b/tests/test_experimentalist_pipeline.py index a02bfa85..08daf529 100644 --- a/tests/test_experimentalist_pipeline.py +++ b/tests/test_experimentalist_pipeline.py @@ -279,7 +279,6 @@ def test_params_parser_one_level(): def test_params_parser_recurse_one(): - params = { "filter_pipeline__step1__n_samples": 100, } @@ -309,7 +308,6 @@ def test_params_parser_recurse_one_n_levels_alternative_divider(): def test_params_parser_recurse(): - params = { "pool__ivs": "%%independent_variables%%", "filter_pipeline__step1__n_samples": 100, diff --git a/tests/test_experimentalist_random.py b/tests/test_experimentalist_random.py deleted file mode 100644 index a81ad483..00000000 --- a/tests/test_experimentalist_random.py +++ /dev/null @@ -1,153 +0,0 @@ -from functools import partial - -import numpy as np -import pytest - -from autora.experimentalist.pipeline import make_pipeline -from autora.experimentalist.pooler.grid import grid_pool -from autora.experimentalist.pooler.random_pooler import random_pool -from autora.experimentalist.sampler.random_sampler import random_sample -from autora.variable import DV, IV, ValueType, VariableCollection - - -def weber_filter(values): - return filter(lambda s: s[0] <= s[1], values) - - -def test_random_pooler_experimentalist(metadata): - """ - Tests the implementation of a random pooler. - """ - num_samples = 10 - - conditions = random_pool(metadata.independent_variables, num_samples=num_samples) - - conditions = np.array(list(conditions)) - - assert conditions.shape[0] == num_samples - assert conditions.shape[1] == len(metadata.independent_variables) - for condition in conditions: - for idx, value in enumerate(condition): - assert value in metadata.independent_variables[idx].allowed_values - - -def test_random_sampler_experimentalist(metadata): - """ - Tests the implementation of the experimentalist pipeline with an exhaustive pool of discrete - values, Weber filter, random selector. Tests two different implementations of the pool function - as a callable and passing in as interator/generator. - - """ - - n_trials = 25 # Number of trails for sampler to select - - # ---Implementation 1 - Pool using Callable via partial function---- - # Set up pipeline functions with partial - pooler_callable = partial(grid_pool, ivs=metadata.independent_variables) - sampler = partial(random_sample, num_samples=n_trials) - pipeline_random_samp = make_pipeline( - [pooler_callable, weber_filter, sampler], - ) - - results = pipeline_random_samp.run() - - # ***Checks*** - # Gridsearch pool is working as expected - _, pool = pipeline_random_samp.steps[0] - pool_len = len(list(pool())) - pool_len_expected = np.prod( - [len(s.allowed_values) for s in metadata.independent_variables] - ) - assert pool_len == pool_len_expected - - # Is sampling the number of trials we expect - assert len(results) == n_trials - - # Filter is selecting where IV1 >= IV2 - assert all([s[0] <= s[1] for s in results]) - - # Is sampling randomly. Runs 10 times and checks if consecutive runs are equal. - # Assert will fail if all 9 pairs return equal. - l_results = [pipeline_random_samp.run() for s in range(10)] - assert not np.all( - [ - np.array_equal(l_results[i], l_results[i + 1]) - for i, s in enumerate(l_results) - if i < len(l_results) - 1 - ] - ) - - -def test_random_experimentalist_generator(metadata): - n_trials = 25 # Number of trails for sampler to select - - pooler_generator = grid_pool(metadata.independent_variables) - sampler = partial(random_sample, num_samples=n_trials) - pipeline_random_samp_poolgen = make_pipeline( - [pooler_generator, weber_filter, sampler] - ) - - results_poolgen = list(pipeline_random_samp_poolgen.run()) - - # Is sampling the number of trials we expect - assert len(results_poolgen) == n_trials - - # Filter is selecting where IV1 >= IV2 - assert all([s[0] <= s[1] for s in results_poolgen]) - - # This will fail - # The Generator is exhausted after the first run and the pool is not regenerated when pipeline - # is run again. The pool should be set up as a callable if the pipeline is to be rerun. - results_poolgen2 = pipeline_random_samp_poolgen.run() - assert len(results_poolgen2) == 0 - - -@pytest.fixture -def metadata(): - # Specify independent variables - iv1 = IV( - name="S1", - allowed_values=np.linspace(0, 5, 5), - units="intensity", - variable_label="Stimulus 1 Intensity", - ) - - iv2 = IV( - name="S2", - allowed_values=np.linspace(0, 5, 5), - units="intensity", - variable_label="Stimulus 2 Intensity", - ) - - iv3 = IV( - name="S3", - allowed_values=[0, 1], - units="binary", - variable_label="Stimulus 3 Binary", - ) - - # Specify dependent variable with type - # The experimentalist pipeline doesn't actually use DVs, they are just specified here for - # example. - dv1 = DV( - name="difference_detected", - value_range=(0, 1), - units="probability", - variable_label="P(difference detected)", - type=ValueType.SIGMOID, - ) - - dv2 = DV( - name="difference_detected_sample", - value_range=(0, 1), - units="response", - variable_label="difference detected", - type=ValueType.PROBABILITY_SAMPLE, - ) - # Variable collection with ivs and dvs - metadata = VariableCollection( - independent_variables=[iv1, iv2, iv3], - dependent_variables=[dv1, dv2], - ) - - return metadata