diff --git a/notebooks/HF-API-Ax.ipynb b/notebooks/HF-API-Ax.ipynb index a43b7d1..7205fab 100644 --- a/notebooks/HF-API-Ax.ipynb +++ b/notebooks/HF-API-Ax.ipynb @@ -258,8 +258,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "[INFO 09-21 11:39:23] ax.utils.notebook.plotting: Injecting Plotly library into cell. Do not overwrite or delete cell.\n", - "[INFO 09-21 11:39:23] ax.utils.notebook.plotting: Please see\n", + "[INFO 10-06 18:03:38] ax.utils.notebook.plotting: Injecting Plotly library into cell. Do not overwrite or delete cell.\n", + "[INFO 10-06 18:03:38] ax.utils.notebook.plotting: Please see\n", " (https://ax.dev/tutorials/visualizations.html#Fix-for-plots-that-are-not-rendering)\n", " if visualizations are not rendering.\n" ] @@ -297,7 +297,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Loaded as API: https://accelerationconsortium-crabnet-hyperparameter.hf.space ✔\n" + "Using your existing Space: https://hf.space/lyuyizhi/crabnet-hyperparameter 🤗\n", + "\n", + "Loaded as API: https://lyuyizhi-crabnet-hyperparameter.hf.space ✔\n" ] } ], @@ -309,13 +311,16 @@ "import numpy as np\n", "import pandas as pd\n", "from ax.service.ax_client import AxClient, ObjectiveProperties\n", - "import time\n", - "\n", "round = 50\n", "init_notebook_plotting()\n", + "\n", + "# we duplicate the Advanced Optimization from AC huggingface for private use, to avoid rate limit\n", + "# need to pass your HF token, get your HF token (write access) from https://huggingface.co/settings/tokens\n", + "\n", "# load the Advanced Optimization from AC huggingface\n", + "from my_secret import get_my_hf_token\n", "from gradio_client import Client\n", - "client = Client(\"AccelerationConsortium/crabnet-hyperparameter\")" + "client = Client.duplicate(\"AccelerationConsortium/crabnet-hyperparameter\", hf_token=get_my_hf_token())" ] }, { @@ -1044,7 +1049,7 @@ } ], "source": [ - "#random_seed_list = [23, 28, 42, 87, 99, 131, 518, 1047, 1598, 2024]\n", + "# random_seed_list = [23, 28, 42, 87, 99, 131, 518, 1047, 1598, 2024]\n", "random_seed_list = [1598, 2024]\n", "result_list = []\n", "for exp_i in range(len(random_seed_list)): \n", @@ -1115,42 +1120,11 @@ "\n", " results = adv_opt(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, c1, c2, c3)\n", " ax_client.complete_trial(trial_index=trial_index, raw_data=results) \n", - " time.sleep(20) # sleep for 20 seconds to avoid the rate limit of the hugging face API\n", "\n", " df = ax_client.get_trials_data_frame()\n", " result_list.append(df['y1'].values) " ] }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(result_list)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# save result_list to a csv file \n", - "df = pd.DataFrame(result_list)" - ] - }, { "cell_type": "code", "execution_count": 13, @@ -1276,6 +1250,8 @@ } ], "source": [ + "# save result_list to a csv file \n", + "df = pd.DataFrame(result_list)\n", "df" ] }, @@ -1620,6 +1596,8 @@ } ], "source": [ + "# if experiemnt not run in same day, need to read the csv from yesterday\n", + "\n", "# read the csv\n", "yesterday = pd.read_csv('yesterday_Ax.csv')\n", "\n", @@ -1694,310 +1672,6 @@ "ax.set_ylim(0.18, 0.58)\n", "ax.legend()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(49,\n", - " {'x2': 0.843617661699682,\n", - " 'x3': 0.8848322551603883,\n", - " 'x4': 0.5138101708090401,\n", - " 'x5': 0.5032631800217858,\n", - " 'x6': 0.5901684134654586,\n", - " 'x7': 0.39256395948698575,\n", - " 'x8': 0.3027655919073459,\n", - " 'x9': 0.47676099240883674,\n", - " 'x11': 0.2074045945980981,\n", - " 'x12': 0.1736463100279958,\n", - " 'x13': 0.7123592839535469,\n", - " 'x14': 0.5470960398716934,\n", - " 'x15': 0.2163937319784434,\n", - " 'x16': 0.2861183216520867,\n", - " 'x17': 0.5616695495431285,\n", - " 'x18': 0.6837430074838851,\n", - " 'c1': 'c1_1',\n", - " 'c2': 'c2_0',\n", - " 'c3': 'c3_1'},\n", - " ({'y1': 0.31660899247362645}, {'y1': {'y1': 5.403464758733553e-05}}))" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "best_paramters, metrics = ax_client.get_best_parameters()\n", - "ax_client.get_best_trial()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[WARNING 09-08 22:00:07] ax.service.utils.report_utils: Column reason missing for all trials. Not appending column.\n" - ] - } - ], - "source": [ - "df = ax_client.get_trials_data_frame()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "fig, ax = plt.subplots(figsize=(6,4), dpi=120)\n", - "\n", - "ax.plot(df.y1, ls='None', marker='o', mfc='None', mec='k', label='Observed')\n", - "\n", - "best_to_trial = np.minimum.accumulate(df.y1.values)\n", - "ax.plot(best_to_trial, color='#0033FF', lw=2, label='Best to Trial')\n", - "\n", - "plt.xticks(range(len(df)))\n", - "plt.xlabel('Trial Number')\n", - "plt.ylabel('y1 value (Lower is Better)')\n", - "plt.title('Advanced Optimization, Ax')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\MF\\AppData\\Local\\Temp\\ipykernel_22304\\2118524986.py:36: AxParameterWarning:\n", - "\n", - "`is_ordered` is not specified for `ChoiceParameter` \"c1\". Defaulting to `True` since there are exactly two choices.. To override this behavior (or avoid this warning), specify `is_ordered` during `ChoiceParameter` construction. Note that choice parameters with exactly 2 choices are always considered ordered and that the user-supplied `is_ordered` has no effect in this particular case.\n", - "\n", - "C:\\Users\\MF\\AppData\\Local\\Temp\\ipykernel_22304\\2118524986.py:36: AxParameterWarning:\n", - "\n", - "`sort_values` is not specified for `ChoiceParameter` \"c1\". Defaulting to `False` for parameters of `ParameterType` STRING. To override this behavior (or avoid this warning), specify `sort_values` during `ChoiceParameter` construction.\n", - "\n", - "C:\\Users\\MF\\AppData\\Local\\Temp\\ipykernel_22304\\2118524986.py:37: AxParameterWarning:\n", - "\n", - "`is_ordered` is not specified for `ChoiceParameter` \"c2\". Defaulting to `True` since there are exactly two choices.. To override this behavior (or avoid this warning), specify `is_ordered` during `ChoiceParameter` construction. Note that choice parameters with exactly 2 choices are always considered ordered and that the user-supplied `is_ordered` has no effect in this particular case.\n", - "\n", - "C:\\Users\\MF\\AppData\\Local\\Temp\\ipykernel_22304\\2118524986.py:37: AxParameterWarning:\n", - "\n", - "`sort_values` is not specified for `ChoiceParameter` \"c2\". Defaulting to `False` for parameters of `ParameterType` STRING. To override this behavior (or avoid this warning), specify `sort_values` during `ChoiceParameter` construction.\n", - "\n", - "C:\\Users\\MF\\AppData\\Local\\Temp\\ipykernel_22304\\2118524986.py:38: AxParameterWarning:\n", - "\n", - "`is_ordered` is not specified for `ChoiceParameter` \"c3\". Defaulting to `False` since the parameter is a string with more than 2 choices.. To override this behavior (or avoid this warning), specify `is_ordered` during `ChoiceParameter` construction. Note that choice parameters with exactly 2 choices are always considered ordered and that the user-supplied `is_ordered` has no effect in this particular case.\n", - "\n", - "C:\\Users\\MF\\AppData\\Local\\Temp\\ipykernel_22304\\2118524986.py:38: AxParameterWarning:\n", - "\n", - "`sort_values` is not specified for `ChoiceParameter` \"c3\". Defaulting to `False` for parameters of `ParameterType` STRING. To override this behavior (or avoid this warning), specify `sort_values` during `ChoiceParameter` construction.\n", - "\n", - "C:\\Users\\MF\\AppData\\Local\\Temp\\ipykernel_22304\\2118524986.py:39: AxParameterWarning:\n", - "\n", - "`is_ordered` is not specified for `ChoiceParameter` \"Task\". Defaulting to `True` since there are exactly two choices.. To override this behavior (or avoid this warning), specify `is_ordered` during `ChoiceParameter` construction. Note that choice parameters with exactly 2 choices are always considered ordered and that the user-supplied `is_ordered` has no effect in this particular case.\n", - "\n", - "C:\\Users\\MF\\AppData\\Local\\Temp\\ipykernel_22304\\2118524986.py:39: AxParameterWarning:\n", - "\n", - "`sort_values` is not specified for `ChoiceParameter` \"Task\". Defaulting to `False` for parameters of `ParameterType` STRING. To override this behavior (or avoid this warning), specify `sort_values` during `ChoiceParameter` construction.\n", - "\n", - "[WARNING 09-08 22:00:07] ax.service.ax_client: Random seed set to 42. Note that this setting only affects the Sobol quasi-random generator and BoTorch-powered Bayesian optimization models. For the latter models, setting random seed to the same number for two optimizations will make the generated trials similar, but not exactly the same, and over time the trials will diverge more.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x1. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x2. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x3. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x4. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x5. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x6. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x7. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x8. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x9. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x10. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x11. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x12. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x13. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x14. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x15. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x16. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x17. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x18. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x19. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.FLOAT for parameter x20. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Inferred value type of ParameterType.STRING for parameter Task. If that is not the expected value type, you can explicitly specify 'value_type' ('int', 'float', 'bool' or 'str') in parameter dict.\n", - "c:\\Users\\MF\\anaconda3\\envs\\BayBE\\lib\\site-packages\\ax\\service\\utils\\instantiation.py:244: AxParameterWarning:\n", - "\n", - "`is_ordered` is not specified for `ChoiceParameter` \"Task\". Defaulting to `True` since there are exactly two choices.. To override this behavior (or avoid this warning), specify `is_ordered` during `ChoiceParameter` construction. Note that choice parameters with exactly 2 choices are always considered ordered and that the user-supplied `is_ordered` has no effect in this particular case.\n", - "\n", - "c:\\Users\\MF\\anaconda3\\envs\\BayBE\\lib\\site-packages\\ax\\service\\utils\\instantiation.py:244: AxParameterWarning:\n", - "\n", - "`sort_values` is not specified for `ChoiceParameter` \"Task\". Defaulting to `False` for parameters of `ParameterType` STRING. To override this behavior (or avoid this warning), specify `sort_values` during `ChoiceParameter` construction.\n", - "\n", - "[INFO 09-08 22:00:07] ax.service.utils.instantiation: Created search space: SearchSpace(parameters=[RangeParameter(name='x1', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x2', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x3', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x4', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x5', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x6', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x7', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x8', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x9', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x10', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x11', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x12', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x13', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x14', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x15', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x16', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x17', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x18', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x19', parameter_type=FLOAT, range=[0.0, 1.0]), RangeParameter(name='x20', parameter_type=FLOAT, range=[0.0, 1.0]), ChoiceParameter(name='Task', parameter_type=STRING, values=['y1', 'y2'], is_ordered=True, is_task=True, sort_values=False, target_value='y2')], parameter_constraints=[OrderConstraint(x19 <= x20), ParameterConstraint(1.0*x15 + 1.0*x6 <= 1.0)]).\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "from ax.core.observation import ObservationFeatures\n", - "from ax.modelbridge.generation_strategy import GenerationStep, GenerationStrategy\n", - "from ax.modelbridge.registry import Models\n", - "from ax.modelbridge.transforms.task_encode import TaskEncode\n", - "from ax.modelbridge.transforms.unit_x import UnitX\n", - "from ax.service.ax_client import AxClient, ObjectiveProperties\n", - "\n", - "from ax import SearchSpace, ParameterType, RangeParameter, ChoiceParameter\n", - "from ax.modelbridge.transforms.unit_x import UnitX\n", - "from ax.modelbridge.transforms.task_encode import TaskEncode\n", - "\n", - "# Define the search space\n", - "search_space = SearchSpace(\n", - " parameters=[\n", - " RangeParameter(name=\"x1\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x2\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x3\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x4\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x5\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x6\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x7\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x8\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x9\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x10\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x11\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x12\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x13\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x14\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x15\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x16\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x17\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x18\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x19\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " RangeParameter(name=\"x20\", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0),\n", - " ChoiceParameter(name=\"c1\", parameter_type=ParameterType.STRING, values=[\"c1_0\", \"c1_1\"]),\n", - " ChoiceParameter(name=\"c2\", parameter_type=ParameterType.STRING, values=[\"c2_0\", \"c2_1\"]),\n", - " ChoiceParameter(name=\"c3\", parameter_type=ParameterType.STRING, values=[\"c3_0\", \"c3_1\", \"c3_2\"]),\n", - " ChoiceParameter(\n", - " name=\"Task\", \n", - " parameter_type=ParameterType.STRING, \n", - " values=[\"y1\", \"y2\"], \n", - " is_task=True, \n", - " target_value=\"y2\" # Specify the target value\n", - " ),\n", - " ]\n", - ")\n", - "\n", - "# Create the transforms\n", - "transforms = [TaskEncode, UnitX]\n", - "\n", - "# Generation strategy with the transforms\n", - "gs = GenerationStrategy(\n", - " name=\"MultiTaskOp\", \n", - " steps=[\n", - " GenerationStep(\n", - " model=Models.SOBOL, \n", - " num_trials=5,\n", - " model_kwargs={\"deduplicate\": True, \"transforms\": transforms},\n", - " ),\n", - " GenerationStep(\n", - " model=Models.BOTORCH_MODULAR,\n", - " num_trials=-1, \n", - " model_kwargs={\"transforms\": transforms},\n", - " ),\n", - " ],\n", - ")\n", - "\n", - "# Create the Ax client with the generation strategy\n", - "ax_client = AxClient(generation_strategy=gs, random_seed=42, verbose_logging=False)\n", - "\n", - "# Create the experiment\n", - "ax_client.create_experiment(\n", - " name=\"MultiTaskOp\", \n", - " parameters=[\n", - " {\"name\": \"x1\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x2\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x3\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x4\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x5\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x6\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x7\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x8\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x9\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x10\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x11\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x12\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x13\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x14\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x15\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x16\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x17\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x18\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x19\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " {\"name\": \"x20\", \"type\": \"range\", \"bounds\": [0.0, 1.0]},\n", - " # Add all other parameters similarly...\n", - " {\"name\": \"Task\", \"type\": \"choice\", \"values\": [\"y1\", \"y2\"], \"is_task\": True, \"target_value\": \"y2\"},\n", - " ],\n", - " parameter_constraints=[\n", - " \"x19 <= x20\",\n", - " \"x6 + x15 <= 1.0\",\n", - " ],\n", - " objectives={\n", - " \"Objective\": ObjectiveProperties(minimize=False),\n", - " },\n", - ")\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": {