use adaptive-scheduler

58300e6b · Bas Nijholt · 8f53026d · 58300e6b
Commit 58300e6b authored 5 years ago by Bas Nijholt
--- a/phase_diagram.ipynb
+++ b/phase_diagram.ipynb
@@ -6,17 +6,10 @@
   "metadata": {},
   "outputs": [],
   "source": [
+    "%%writefile learners_file.py\n",
+    "\n",
+    "import phase_diagram\n",
    "import adaptive\n",
-    "adaptive.notebook_extension()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import phase_diagram as funcs\n",
    "\n",
    "lead_pars = dict(\n",
    "    a=10, r1=50, r2=70, coverage_angle=135, angle=45, with_shell=True, which_lead=\"\"\n",
@@ -43,36 +36,40 @@
    "    r1=None,\n",
    "    sigma=None,\n",
    "    x0=None,\n",
-    "    **funcs.constants.__dict__\n",
+    "    **phase_diagram.constants.__dict__\n",
    ")\n",
    "\n",
    "\n",
    "def pf(xy, params=params, lead_pars=lead_pars):\n",
-    "    import phase_diagram as funcs\n",
+    "    import phase_diagram \n",
    "\n",
    "    params[\"B_x\"], params[\"mu_lead\"] = xy\n",
-    "    lead = funcs.make_lead(**lead_pars).finalized()\n",
-    "    return funcs.calculate_pfaffian(lead, params)\n",
+    "    lead = phase_diagram.make_lead(**lead_pars).finalized()\n",
+    "    return phase_diagram.calculate_pfaffian(lead, params)\n",
    "\n",
    "\n",
    "def smallest_gap(xy, params=params, lead_pars=lead_pars):\n",
-    "    import phase_diagram as funcs\n",
+    "    import phase_diagram\n",
    "\n",
    "    params[\"B_x\"], params[\"mu_lead\"] = xy\n",
-    "    lead = funcs.make_lead(**lead_pars).finalized()\n",
-    "    pf = funcs.calculate_pfaffian(lead, params)\n",
-    "    gap = funcs.gap_from_modes(lead, params)\n",
-    "    return pf * gap"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "learner = adaptive.Learner2D(smallest_gap, bounds=[(0, 2), (0, 35)])\n",
-    "# learner.load('phase_diagram.pickle')"
+    "    lead = phase_diagram.make_lead(**lead_pars).finalized()\n",
+    "    pf = phase_diagram.calculate_pfaffian(lead, params)\n",
+    "    gap = phase_diagram.gap_from_modes(lead, params)\n",
+    "    return pf * gap\n",
+    "\n",
+    "fname = 'phase_diagram_gap.pickle'\n",
+    "f = smallest_gap\n",
+    "\n",
+    "# fname = 'phase_diagram.pickle'\n",
+    "# f = pf\n",
+    "\n",
+    "loss = adaptive.learner.learnerND.curvature_loss_function()\n",
+    "learner = adaptive.LearnerND(smallest_gap, bounds=[(0, 2), (0, 35)], loss_per_simplex=loss)\n",
+    "\n",
+    "# learner.load(fname)\n",
+    "\n",
+    "learners = [learner]\n",
+    "fnames = [fname]"
   ]
  },
  {
@@ -81,7 +78,10 @@
   "metadata": {},
   "outputs": [],
   "source": [
-    "runner = adaptive.Runner(learner, goal=lambda l: l.npoints > 60000)"
+    "import adaptive\n",
+    "adaptive.notebook_extension()\n",
+    "runner = adaptive.Runner(learner, goal=lambda l: l.npoints > 60000)\n",
+    "runner.live_info()"
   ]
  },
  {
@@ -90,7 +90,8 @@
   "metadata": {},
   "outputs": [],
   "source": [
-    "runner.live_info()"
+    "%%output size=100\n",
+    "learner.plot(tri_alpha=0.4, n=None)"
   ]
  },
  {
@@ -99,8 +100,7 @@
   "metadata": {},
   "outputs": [],
   "source": [
-    "%%output size=100\n",
-    "learner.plot(tri_alpha=0.4, n=None)"
+    "learner.save(fname)"
   ]
  },
  {
@@ -109,7 +109,24 @@
   "metadata": {},
   "outputs": [],
   "source": [
-    "learner.save('phase_diagram.pickle')"
+    "import adaptive_scheduler\n",
+    "\n",
+    "def goal(learner):\n",
+    "    return learner.npoints > 100_000\n",
+    "\n",
+    "scheduler = adaptive_scheduler.scheduler.PBS(\n",
+    "    cores=13*10,\n",
+    "    cores_per_node=10,\n",
+    ")  # every learner get this many cores\n",
+    "\n",
+    "run_manager = adaptive_scheduler.server_support.RunManager(\n",
+    "    scheduler=scheduler,\n",
+    "    learners_file=\"learners_file.py\",\n",
+    "    goal=goal,\n",
+    "    log_interval=30,\n",
+    "    save_interval=300,\n",
+    ")\n",
+    "run_manager.start()\n"
   ]
  },
  {

 %% Cell type:code id: tags:

 ``` 
-import adaptive
-adaptive.notebook_extension()
-```
+%%writefile learners_file.py

-%% Cell type:code id: tags:
-
-``` 
-import phase_diagram as funcs
+import phase_diagram
+import adaptive

 lead_pars = dict(
    a=10, r1=50, r2=70, coverage_angle=135, angle=45, with_shell=True, which_lead=""
 )

 params = dict(
    alpha=20,
    B_x=0,
    B_y=0,
    B_z=0,
    Delta=110,
    g=50,
    orbital=True,
    mu_sc=100,
    c_tunnel=3 / 4,
    V_r=-50,
    intrinsic_sc=False,
    mu_=lambda x0, sigma, mu_lead, mu_wire: mu_lead,
    V_=lambda z, V_0, V_r, V_l, x0, sigma, r1: 0,
    V_0=None,
    V_l=None,
    mu_lead=10,
    mu_wire=None,
    r1=None,
    sigma=None,
    x0=None,
-    **funcs.constants.__dict__
+    **phase_diagram.constants.__dict__
 )


 def pf(xy, params=params, lead_pars=lead_pars):
-    import phase_diagram as funcs
+    import phase_diagram

    params["B_x"], params["mu_lead"] = xy
-    lead = funcs.make_lead(**lead_pars).finalized()
-    return funcs.calculate_pfaffian(lead, params)
+    lead = phase_diagram.make_lead(**lead_pars).finalized()
+    return phase_diagram.calculate_pfaffian(lead, params)


 def smallest_gap(xy, params=params, lead_pars=lead_pars):
-    import phase_diagram as funcs
+    import phase_diagram

    params["B_x"], params["mu_lead"] = xy
-    lead = funcs.make_lead(**lead_pars).finalized()
-    pf = funcs.calculate_pfaffian(lead, params)
-    gap = funcs.gap_from_modes(lead, params)
+    lead = phase_diagram.make_lead(**lead_pars).finalized()
+    pf = phase_diagram.calculate_pfaffian(lead, params)
+    gap = phase_diagram.gap_from_modes(lead, params)
    return pf * gap
-```

-%% Cell type:code id: tags:
+fname = 'phase_diagram_gap.pickle'
+f = smallest_gap

-``` 
-learner = adaptive.Learner2D(smallest_gap, bounds=[(0, 2), (0, 35)])
-# learner.load('phase_diagram.pickle')
+# fname = 'phase_diagram.pickle'
+# f = pf
+
+loss = adaptive.learner.learnerND.curvature_loss_function()
+learner = adaptive.LearnerND(smallest_gap, bounds=[(0, 2), (0, 35)], loss_per_simplex=loss)
+
+# learner.load(fname)
+
+learners = [learner]
+fnames = [fname]
 ```

 %% Cell type:code id: tags:

 ``` 
+import adaptive
+adaptive.notebook_extension()
 runner = adaptive.Runner(learner, goal=lambda l: l.npoints > 60000)
+runner.live_info()
 ```

 %% Cell type:code id: tags:

 ``` 
-runner.live_info()
+%%output size=100
+learner.plot(tri_alpha=0.4, n=None)
 ```

 %% Cell type:code id: tags:

 ``` 
-%%output size=100
-learner.plot(tri_alpha=0.4, n=None)
+learner.save(fname)
 ```

 %% Cell type:code id: tags:

 ``` 
-learner.save('phase_diagram.pickle')
+import adaptive_scheduler
+
+def goal(learner):
+    return learner.npoints > 100_000
+
+scheduler = adaptive_scheduler.scheduler.PBS(
+    cores=13*10,
+    cores_per_node=10,
+)  # every learner get this many cores
+
+run_manager = adaptive_scheduler.server_support.RunManager(
+    scheduler=scheduler,
+    learners_file="learners_file.py",
+    goal=goal,
+    log_interval=30,
+    save_interval=300,
+)
+run_manager.start()
 ```

 %% Cell type:code id: tags:

 ``` 
 ```