From f14fed59126aaa7a8f3d6c183730ef8ed0716337 Mon Sep 17 00:00:00 2001 From: Robert Jordens Date: Sat, 30 Jan 2016 18:56:28 -0700 Subject: [PATCH] examples: add an IPython notebook showcase This is a small example on how to use the artiq functionality in an IPython notebook. This can be expanded and provides a much more powerful shell than the one integrated in the GUI. Potentially, some shared functionality between this and artiq_client could be factored out. --- .gitignore | 1 + examples/artiq_ipython_notebook.ipynb | 341 ++++++++++++++++++++++++++ 2 files changed, 342 insertions(+) create mode 100644 examples/artiq_ipython_notebook.ipynb diff --git a/.gitignore b/.gitignore index c30828063..78b404c96 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,7 @@ __pycache__/ *.bin *.elf *.fbi +.ipynb_checkpoints /doc/manual/_build /build /dist diff --git a/examples/artiq_ipython_notebook.ipynb b/examples/artiq_ipython_notebook.ipynb new file mode 100644 index 000000000..e4a58d237 --- /dev/null +++ b/examples/artiq_ipython_notebook.ipynb @@ -0,0 +1,341 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline\n", + "\n", + "import os\n", + "import logging\n", + "import time\n", + "import asyncio\n", + "import datetime\n", + "import glob\n", + "\n", + "import numpy as np\n", + "np.set_printoptions(precision=3)\n", + "import matplotlib.pyplot as plt\n", + "import seaborn\n", + "seaborn.set_style(\"whitegrid\")\n", + "import pandas as pd\n", + "import h5py\n", + "\n", + "from artiq.protocols.pc_rpc import (Client, AsyncioClient,\n", + " BestEffortClient, AutoTarget)\n", + "from artiq.master.databases import DeviceDB\n", + "from artiq.master.worker_db import DeviceManager" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# let's assume artiq_master and artiq_ctlmgr are already running\n", + "# move to a location where we have our artiq setup\n", + "os.chdir(os.path.expanduser(\"~/work/nist/artiq/run\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# you can directly use the artiq controller infrastructure\n", + "# and access any artiq device\n", + "\n", + "# you can have artiq prepare that for you:\n", + "\n", + "ddb = DeviceDB(\"device_db.pyon\")\n", + "devmgr = DeviceManager(ddb)\n", + "lda = devmgr.get(\"lda\")\n", + "lda.set_attenuation(42)\n", + "assert lda.get_attenuation() == 42\n", + "\n", + "# ... or you can wire it up yourself if you know where it is\n", + "assert ddb.get(\"lda\")[\"host\"] == \"::1\"\n", + "assert ddb.get(\"lda\")[\"port\"] == 3253\n", + "\n", + "# synchronous\n", + "lda = Client(\"::1\", 3253)\n", + "assert lda.get_attenuation() == 42\n", + "\n", + "# asyncio\n", + "lda = AsyncioClient()\n", + "async def test_lda():\n", + " await lda.connect_rpc(\"::1\", 3253, AutoTarget)\n", + " return await lda.get_attenuation()\n", + "assert asyncio.get_event_loop().run_until_complete(test_lda()) == 42\n", + "\n", + "# best effort\n", + "lda = BestEffortClient(\"::1\", 3253, AutoTarget)\n", + "assert lda.get_attenuation() == 42" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "current schedule {}\n", + "experiments ['__pycache__/', 'flopping_f_simulation.py', 'notebook_test.py', '.git/', 'idle.elf', 'transport.py', 'idle.py', 'speed_benchmark.py', 'test_raise.py']\n" + ] + } + ], + "source": [ + "# let's connect to the master\n", + "\n", + "schedule, exps, datasets = [\n", + " Client(\"::1\", 3251, \"master_\" + i) for i in\n", + " \"schedule experiment_db dataset_db\".split()]\n", + "\n", + "print(\"current schedule\", schedule.get_status())\n", + "print(\"experiments\", exps.list_directory(\"repository\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "current schedule {131: {'priority': 0, 'status': 'preparing', 'repo_msg': None, 'pipeline': 'main', 'due_date': None, 'flush': False, 'expid': {'file': 'repository/flopping_f_simulation.py', 'arguments': {'noise_amplitude': 0.1, 'F0': 1500}, 'log_level': 30, 'class_name': 'FloppingF'}}}\n" + ] + } + ], + "source": [ + "# we can submit experiments to be run:\n", + "\n", + "expid = dict(\n", + " file=\"repository/flopping_f_simulation.py\",\n", + " class_name=\"FloppingF\",\n", + " log_level=logging.WARNING,\n", + " arguments=dict(\n", + " F0=1500,\n", + " noise_amplitude=.1,\n", + " ),\n", + ")\n", + "if not schedule.get_status():\n", + " rid = schedule.submit(pipeline_name=\"main\", expid=expid,\n", + " priority=0, due_date=None, flush=False)\n", + "print(\"current schedule\", schedule.get_status())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# wait for experiment to finish\n", + "# this can be written nicer by subscribing and reacting to scheduler changes\n", + "while rid in schedule.get_status():\n", + " time.sleep(.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "flopping_f 1499.996784076909\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAecAAAFVCAYAAADVDycqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMxERkWAYzkRERIJhOBMREQnm/wMjA6onfM82FQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# now that the experiment has completed, we can get the\n", + "# current value of the (live) dataset and plot it\n", + "# had we done this earlier, the dataset would have been incomplete\n", + "fig, ax = plt.subplots()\n", + "d = datasets.get(\"flopping_f_brightness\")\n", + "ax.plot(d)\n", + "print(\"flopping_f\", datasets.get(\"flopping_freq\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# this is how you would clear all pipelines\n", + "for i in schedule.get_status():\n", + " schedule.delete(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "available datasets ['artiq_version', 'flopping_f_brightness']\n" + ] + } + ], + "source": [ + "# we can easily find and use the data that was saved as part\n", + "# of the experiment\n", + "\n", + "t = datetime.datetime.now()\n", + "f = os.path.join(\n", + " \"results\", t.strftime(\"%Y-%m-%d\"), #t.strftime(\"%H-%M\"),\n", + " \"*\", \"{:09d}-FloppingF.h5\".format(rid))\n", + "\n", + "# we would usually like to use pandas but our data doe not comply\n", + "# with the pandas metadata\n", + "#d = pd.HDFStore(glob.glob(f)[0])\n", + "\n", + "with h5py.File(glob.glob(f)[0]) as f:\n", + " print(\"available datasets\", list(f))\n", + " assert np.allclose(f[\"flopping_f_brightness\"], d)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overwriting repository/notebook_test.py\n" + ] + } + ], + "source": [ + "%%writefile repository/notebook_test.py\n", + "\n", + "# we can also write experiments in the notebook ans submit them\n", + "# we don't have submit-by-content yet (and there would be questions\n", + "# about other modules that would need to be imported) so we just export\n", + "# this cell and submit it by filename\n", + "\n", + "from artiq.experiment import *\n", + "\n", + "class Hello(EnvExperiment):\n", + " def build(self):\n", + " pass\n", + " \n", + " def run(self):\n", + " print(\"Hello world!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "133\n" + ] + } + ], + "source": [ + "expid = dict(\n", + " file=\"repository/notebook_test.py\",\n", + " class_name=\"Hello\",\n", + " log_level=logging.WARNING,\n", + " arguments=dict(),\n", + ")\n", + "rid = schedule.submit(pipeline_name=\"misc\", expid=expid,\n", + " priority=1, due_date=None, flush=False)\n", + "print(rid)\n", + "# on the master you should see the message." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "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.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}