toy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.path.append(\"D:\\project\\AutoML\\tabular_nn\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ultraopt.hdl import hdl2cs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "HDL = {\n",
    "            \"model(choice)\": {\n",
    "                \"linearsvc\": {\n",
    "                    \"max_iter\": {\"_type\": \"int_quniform\", \"_value\": [300, 3000, 100], \"_default\": 600},\n",
    "                    \"penalty\": {\"_type\": \"choice\", \"_value\": [\"l1\", \"l2\"], \"_default\": \"l2\"},\n",
    "                    \"dual\": {\"_type\": \"choice\", \"_value\": [True, False], \"_default\": False},\n",
    "                    \"loss\": {\"_type\": \"choice\", \"_value\": [\"hinge\", \"squared_hinge\"], \"_default\": \"squared_hinge\"},\n",
    "                    \"C\": {\"_type\": \"loguniform\", \"_value\": [0.01, 10000], \"_default\": 1.0},\n",
    "                    \"multi_class\": \"ovr\",\n",
    "                    \"random_state\": 42,\n",
    "                    \"__forbidden\": [\n",
    "                        {\"penalty\": \"l1\", \"loss\": \"hinge\"},\n",
    "                        {\"penalty\": \"l2\", \"dual\": False, \"loss\": \"hinge\"},\n",
    "                        {\"penalty\": \"l1\", \"dual\": False},\n",
    "                        {\"penalty\": \"l1\", \"dual\": True, \"loss\": \"squared_hinge\"},\n",
    "                    ]\n",
    "                },\n",
    "                \"svc\": {\n",
    "                    \"C\": {\"_type\": \"loguniform\", \"_value\": [0.01, 10000], \"_default\": 1.0},\n",
    "                    \"kernel\": {\"_type\": \"choice\", \"_value\": [\"rbf\", \"poly\", \"sigmoid\"], \"_default\": \"rbf\"},\n",
    "                    \"degree\": {\"_type\": \"int_uniform\", \"_value\": [2, 5], \"_default\": 3},\n",
    "                    \"gamma\": {\"_type\": \"loguniform\", \"_value\": [1e-05, 8], \"_default\": 0.1},\n",
    "                    \"coef0\": {\"_type\": \"quniform\", \"_value\": [-1, 1], \"_default\": 0},\n",
    "                    \"shrinking\": {\"_type\": \"choice\", \"_value\": [True, False], \"_default\": True},\n",
    "                    \"class_weight\": None,\n",
    "                    \"probability\": True,\n",
    "                    \"decision_function_shape\": \"ovr\",\n",
    "                    \"__activate\": {\n",
    "                        \"kernel\": {\n",
    "                            \"rbf\": [\"gamma\"],\n",
    "                            \"sigmoid\": [\"gamma\", \"coef0\"],\n",
    "                            \"poly\": [\"degree\", \"gamma\", \"coef0\"]\n",
    "                        }\n",
    "                    },\n",
    "                    \"random_state\": 42\n",
    "                },\n",
    "            }\n",
    "        }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "CS = hdl2cs(HDL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Configuration space object:\n",
       "  Hyperparameters:\n",
       "    model:__choice__, Type: Categorical, Choices: {linearsvc, svc}, Default: linearsvc\n",
       "    model:linearsvc:C, Type: UniformFloat, Range: [0.01, 10000.0], Default: 1.0, on log-scale\n",
       "    model:linearsvc:dual, Type: Categorical, Choices: {True:bool, False:bool}, Default: True:bool\n",
       "    model:linearsvc:loss, Type: Categorical, Choices: {hinge, squared_hinge}, Default: squared_hinge\n",
       "    model:linearsvc:max_iter, Type: UniformInteger, Range: [300, 3000], Default: 600, Q: 100\n",
       "    model:linearsvc:multi_class, Type: Constant, Value: ovr\n",
       "    model:linearsvc:penalty, Type: Categorical, Choices: {l1, l2}, Default: l2\n",
       "    model:linearsvc:random_state, Type: Constant, Value: 42:int\n",
       "    model:svc:C, Type: UniformFloat, Range: [0.01, 10000.0], Default: 1.0, on log-scale\n",
       "    model:svc:class_weight, Type: Constant, Value: None:NoneType\n",
       "    model:svc:coef0, Type: UniformFloat, Range: [-1.0, 1.0], Default: 0.0, Q: 1.0\n",
       "    model:svc:decision_function_shape, Type: Constant, Value: ovr\n",
       "    model:svc:degree, Type: UniformInteger, Range: [2, 5], Default: 3\n",
       "    model:svc:gamma, Type: UniformFloat, Range: [1e-05, 8.0], Default: 0.1, on log-scale\n",
       "    model:svc:kernel, Type: Categorical, Choices: {rbf, poly, sigmoid}, Default: rbf\n",
       "    model:svc:probability, Type: Constant, Value: True:bool\n",
       "    model:svc:random_state, Type: Constant, Value: 42:int\n",
       "    model:svc:shrinking, Type: Categorical, Choices: {True:bool, False:bool}, Default: True:bool\n",
       "  Conditions:\n",
       "    model:linearsvc:C | model:__choice__ == 'linearsvc'\n",
       "    model:linearsvc:dual | model:__choice__ == 'linearsvc'\n",
       "    model:linearsvc:loss | model:__choice__ == 'linearsvc'\n",
       "    model:linearsvc:max_iter | model:__choice__ == 'linearsvc'\n",
       "    model:linearsvc:multi_class | model:__choice__ == 'linearsvc'\n",
       "    model:linearsvc:penalty | model:__choice__ == 'linearsvc'\n",
       "    model:linearsvc:random_state | model:__choice__ == 'linearsvc'\n",
       "    model:svc:C | model:__choice__ == 'svc'\n",
       "    model:svc:class_weight | model:__choice__ == 'svc'\n",
       "    model:svc:coef0 | model:svc:kernel in {'sigmoid', 'poly'}\n",
       "    model:svc:decision_function_shape | model:__choice__ == 'svc'\n",
       "    model:svc:degree | model:svc:kernel == 'poly'\n",
       "    model:svc:gamma | model:__choice__ == 'svc'\n",
       "    model:svc:kernel | model:__choice__ == 'svc'\n",
       "    model:svc:probability | model:__choice__ == 'svc'\n",
       "    model:svc:random_state | model:__choice__ == 'svc'\n",
       "    model:svc:shrinking | model:__choice__ == 'svc'\n",
       "  Forbidden Clauses:\n",
       "    (Forbidden: model:linearsvc:penalty == 'l1' && Forbidden: model:linearsvc:loss == 'hinge')\n",
       "    (Forbidden: model:linearsvc:penalty == 'l2' && Forbidden: model:linearsvc:dual == 'False:bool' && Forbidden: model:linearsvc:loss == 'hinge')\n",
       "    (Forbidden: model:linearsvc:penalty == 'l1' && Forbidden: model:linearsvc:dual == 'False:bool')\n",
       "    (Forbidden: model:linearsvc:penalty == 'l1' && Forbidden: model:linearsvc:dual == 'True:bool' && Forbidden: model:linearsvc:loss == 'squared_hinge')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from hyperopt import hp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hyperopt.pyll.stochastic\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "cs={\n",
    "    \"model\":hp.choice(\"model\", [\n",
    "        {\n",
    "            \"linearsvc\":{\n",
    "                \"model:linearsvc:C\": hp.normal(\"model:linearsvc:C\", 1, 10),\n",
    "                \"model:linearsvc:loss\": hp.choice(\"model:linearsvc:C\", [\"hinge\", \"squared_hinge\"]),\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"svc\":{\n",
    "                \"model:svc:C\": hp.normal(\"model:linearsvc:C\", 1, 10),\n",
    "                \"model:svc:loss\": hp.choice(\"model:linearsvc:C\", [\"hinge\", \"squared_hinge\"]),\n",
    "            }\n",
    "        },\n",
    "    ])\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'model': {'linearsvc': {'model:linearsvc:C': -0.10059242692035486,\n",
       "   'model:linearsvc:loss': 'squared_hinge'}}}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hyperopt.pyll.stochastic.sample(cs)"
   ]
  },
  {
   "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": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}