diff --git a/demo.ipynb b/demo.ipynb index 578b298..379a263 100755 --- a/demo.ipynb +++ b/demo.ipynb @@ -229,11 +229,11 @@ "text/plain": [ "{'_id': 2,\n", " 'experiment': {'name': 'example',\n", - " 'base_dir': '/home/rbusche/repos/incense/example_experiment',\n", - " 'sources': [['conduct.py', ObjectId('5cacad2f4a476636331faef1')]],\n", - " 'dependencies': ['matplotlib==3.0.3',\n", + " 'base_dir': '/home/jarno/projects/incense/example_experiment',\n", + " 'sources': [['conduct.py', ObjectId('5caf94233bd29849e342a7e2')]],\n", + " 'dependencies': ['matplotlib==3.0.2',\n", " 'numpy==1.16.2',\n", - " 'pandas==0.24.2',\n", + " 'pandas==0.24.1',\n", " 'sacred==0.7.4-onurgu',\n", " 'scikit-learn==0.20.3',\n", " 'seaborn==0.9.0',\n", @@ -242,52 +242,53 @@ " 'mainfile': 'conduct.py'},\n", " 'format': 'MongoObserver-0.7.0',\n", " 'command': 'conduct',\n", - " 'host': {'hostname': 'rbusche-pc',\n", - " 'os': ['Linux', 'Linux-4.9.0-8-amd64-x86_64-with-debian-9.8'],\n", - " 'python_version': '3.6.7',\n", - " 'cpu': 'Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz',\n", + " 'host': {'hostname': 'work',\n", + " 'os': ['Linux', 'Linux-4.18.0-17-generic-x86_64-with-debian-buster-sid'],\n", + " 'python_version': '3.6.8',\n", + " 'cpu': 'Intel(R) Core(TM) i7-4800MQ CPU @ 2.70GHz',\n", " 'ENV': {}},\n", - " 'start_time': datetime.datetime(2019, 4, 9, 14, 34, 45, 785000),\n", + " 'start_time': datetime.datetime(2019, 4, 11, 19, 23, 23, 890000),\n", " 'config': {'epochs': 3, 'optimizer': 'sgd', 'seed': 0},\n", " 'meta': {'command': 'conduct',\n", - " 'options': {'--loglevel': None,\n", - " '--print_config': False,\n", - " '--file_storage': None,\n", + " 'options': {'--sql': None,\n", + " '--mongo_db': None,\n", " '--name': None,\n", - " '--tiny_db': None,\n", - " '--enforce_clean': False,\n", - " '--sql': None,\n", - " '--pdb': False,\n", + " '--file_storage': None,\n", " '--capture': None,\n", + " '--loglevel': None,\n", " '--queue': False,\n", - " '--comment': None,\n", - " '--debug': False,\n", + " '--enforce_clean': False,\n", + " '--pdb': False,\n", " '--beat_interval': None,\n", - " '--force': False,\n", + " '--comment': None,\n", + " '--print_config': False,\n", " '--priority': None,\n", - " '--mongo_db': None,\n", + " '--tiny_db': None,\n", + " '--force': False,\n", " '--unobserved': False,\n", + " '--debug': False,\n", " '--help': False}},\n", " 'status': 'COMPLETED',\n", " 'resources': [],\n", " 'artifacts': [{'name': 'predictions_df',\n", - " 'file_id': ObjectId('5cacad964a476638296b37b3')},\n", - " {'name': 'predictions', 'file_id': ObjectId('5cacad964a476638296b37b5')},\n", + " 'file_id': ObjectId('5caf943d3bd29849e342a7fe')},\n", + " {'name': 'predictions', 'file_id': ObjectId('5caf943d3bd29849e342a800')},\n", " {'name': 'confusion_matrix',\n", - " 'file_id': ObjectId('5cacad974a476638296b37b7')},\n", - " {'name': 'confusion_matrix_pdf',\n", - " 'file_id': ObjectId('5cacad974a476638296b37b9')},\n", - " {'name': 'accuracy_movie', 'file_id': ObjectId('5cacad984a476638296b37bb')},\n", - " {'name': 'history', 'file_id': ObjectId('5cacad984a476638296b37bd')}],\n", - " 'captured_out': 'INFO - example - Running command \\'conduct\\'\\nINFO - example - Started run with ID \"2\"\\nFailed to detect content-type automatically for artifact /home/rbusche/repos/incense/example_experiment/predictions_df.pickle.\\nAdded text/csv as content-type of artifact /home/rbusche/repos/incense/example_experiment/predictions.csv.\\nAdded image/png as content-type of artifact /home/rbusche/repos/incense/example_experiment/confusion_matrix.png.\\nAdded application/pdf as content-type of artifact /home/rbusche/repos/incense/example_experiment/confusion_matrix.pdf.\\nINFO - matplotlib.animation - MovieWriter.run: running command: [\\'ffmpeg\\', \\'-f\\', \\'rawvideo\\', \\'-vcodec\\', \\'rawvideo\\', \\'-s\\', \\'3840x2880\\', \\'-pix_fmt\\', \\'rgba\\', \\'-r\\', \\'1\\', \\'-loglevel\\', \\'quiet\\', \\'-i\\', \\'pipe:\\', \\'-vcodec\\', \\'h264\\', \\'-pix_fmt\\', \\'yuv420p\\', \\'-y\\', \\'accuracy_movie.mp4\\']\\nAdded video/mp4 as content-type of artifact /home/rbusche/repos/incense/example_experiment/accuracy_movie.mp4.\\nAdded text/plain as content-type of artifact /home/rbusche/repos/incense/example_experiment/history.txt.\\nFinal test results\\n{\\'loss\\': 0.24425735404789448, \\'acc\\': 0.9315}\\nINFO - example - Result: 0.9315000176429749\\nINFO - example - Completed after 0:00:19\\n',\n", - " 'info': {'metrics': [{'id': '5cacad8fb1afb3c3384bd404',\n", + " 'file_id': ObjectId('5caf943d3bd29849e342a802')},\n", + " {'name': 'confusion_matrix.pdf',\n", + " 'file_id': ObjectId('5caf943d3bd29849e342a804')},\n", + " {'name': 'accuracy_movie', 'file_id': ObjectId('5caf943e3bd29849e342a806')},\n", + " {'name': 'history', 'file_id': ObjectId('5caf943e3bd29849e342a808')},\n", + " {'name': 'model.hdf5', 'file_id': ObjectId('5caf943e3bd29849e342a80a')}],\n", + " 'captured_out': 'INFO - example - Running command \\'conduct\\'\\nINFO - example - Started run with ID \"2\"\\nFailed to detect content-type automatically for artifact /home/jarno/projects/incense/predictions_df.pickle.\\nAdded text/csv as content-type of artifact /home/jarno/projects/incense/predictions.csv.\\nAdded image/png as content-type of artifact /home/jarno/projects/incense/confusion_matrix.png.\\nAdded application/pdf as content-type of artifact /home/jarno/projects/incense/confusion_matrix.pdf.\\nINFO - matplotlib.animation - MovieWriter.run: running command: [\\'ffmpeg\\', \\'-f\\', \\'rawvideo\\', \\'-vcodec\\', \\'rawvideo\\', \\'-s\\', \\'3840x2880\\', \\'-pix_fmt\\', \\'rgba\\', \\'-r\\', \\'1\\', \\'-loglevel\\', \\'quiet\\', \\'-i\\', \\'pipe:\\', \\'-vcodec\\', \\'h264\\', \\'-pix_fmt\\', \\'yuv420p\\', \\'-y\\', \\'accuracy_movie.mp4\\']\\nAdded video/mp4 as content-type of artifact /home/jarno/projects/incense/accuracy_movie.mp4.\\nAdded text/plain as content-type of artifact /home/jarno/projects/incense/history.txt.\\nFailed to detect content-type automatically for artifact /home/jarno/projects/incense/model.hdf5.\\nINFO - example - Result: 0.9315000176429749\\nINFO - example - Completed after 0:00:19\\n',\n", + " 'info': {'metrics': [{'id': '5caf9435eeb8baa519c5a8af',\n", " 'name': 'training_loss'},\n", - " {'id': '5cacad8fb1afb3c3384bd406', 'name': 'training_acc'},\n", - " {'id': '5cacad98b1afb3c3384bd42b', 'name': 'test_loss'},\n", - " {'id': '5cacad98b1afb3c3384bd42d', 'name': 'test_acc'}]},\n", - " 'heartbeat': datetime.datetime(2019, 4, 9, 14, 35, 4, 493000),\n", + " {'id': '5caf9435eeb8baa519c5a8b1', 'name': 'training_acc'},\n", + " {'id': '5caf943feeb8baa519c5a8e8', 'name': 'test_loss'},\n", + " {'id': '5caf943feeb8baa519c5a8ea', 'name': 'test_acc'}]},\n", + " 'heartbeat': datetime.datetime(2019, 4, 11, 19, 23, 43, 148000),\n", " 'result': 0.9315000176429749,\n", - " 'stop_time': datetime.datetime(2019, 4, 9, 14, 35, 4, 492000)}" + " 'stop_time': datetime.datetime(2019, 4, 11, 19, 23, 43, 146000)}" ] }, "execution_count": 10, @@ -334,7 +335,7 @@ { "data": { "text/plain": [ - "datetime.datetime(2019, 4, 9, 14, 34, 45, 785000)" + "datetime.datetime(2019, 4, 11, 19, 23, 23, 890000)" ] }, "execution_count": 12, @@ -377,15 +378,14 @@ "text": [ "INFO - example - Running command 'conduct'\n", "INFO - example - Started run with ID \"2\"\n", - "Failed to detect content-type automatically for artifact /home/rbusche/repos/incense/example_experiment/predictions_df.pickle.\n", - "Added text/csv as content-type of artifact /home/rbusche/repos/incense/example_experiment/predictions.csv.\n", - "Added image/png as content-type of artifact /home/rbusche/repos/incense/example_experiment/confusion_matrix.png.\n", - "Added application/pdf as content-type of artifact /home/rbusche/repos/incense/example_experiment/confusion_matrix.pdf.\n", + "Failed to detect content-type automatically for artifact /home/jarno/projects/incense/predictions_df.pickle.\n", + "Added text/csv as content-type of artifact /home/jarno/projects/incense/predictions.csv.\n", + "Added image/png as content-type of artifact /home/jarno/projects/incense/confusion_matrix.png.\n", + "Added application/pdf as content-type of artifact /home/jarno/projects/incense/confusion_matrix.pdf.\n", "INFO - matplotlib.animation - MovieWriter.run: running command: ['ffmpeg', '-f', 'rawvideo', '-vcodec', 'rawvideo', '-s', '3840x2880', '-pix_fmt', 'rgba', '-r', '1', '-loglevel', 'quiet', '-i', 'pipe:', '-vcodec', 'h264', '-pix_fmt', 'yuv420p', '-y', 'accuracy_movie.mp4']\n", - "Added video/mp4 as content-type of artifact /home/rbusche/repos/incense/example_experiment/accuracy_movie.mp4.\n", - "Added text/plain as content-type of artifact /home/rbusche/repos/incense/example_experiment/history.txt.\n", - "Final test results\n", - "{'loss': 0.24425735404789448, 'acc': 0.9315}\n", + "Added video/mp4 as content-type of artifact /home/jarno/projects/incense/accuracy_movie.mp4.\n", + "Added text/plain as content-type of artifact /home/jarno/projects/incense/history.txt.\n", + "Failed to detect content-type automatically for artifact /home/jarno/projects/incense/model.hdf5.\n", "INFO - example - Result: 0.9315000176429749\n", "INFO - example - Completed after 0:00:19\n", "\n" @@ -495,9 +495,10 @@ "{'predictions_df': Artifact(name=predictions_df),\n", " 'predictions': CSVArtifact(name=predictions),\n", " 'confusion_matrix': ImageArtifact(name=confusion_matrix),\n", - " 'confusion_matrix_pdf': PDFArtifact(name=confusion_matrix_pdf),\n", + " 'confusion_matrix.pdf': PDFArtifact(name=confusion_matrix.pdf),\n", " 'accuracy_movie': MP4Artifact(name=accuracy_movie),\n", - " 'history': Artifact(name=history)}" + " 'history': Artifact(name=history),\n", + " 'model.hdf5': Artifact(name=model.hdf5)}" ] }, "execution_count": 18, @@ -523,7 +524,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "" ] @@ -640,7 +641,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/rbusche/miniconda3/envs/incense-dev/lib/python3.6/site-packages/ipykernel_launcher.py:1: DeprecationWarning: `show` is deprecated in favor of `render` and will removed in a future release.\n", + "/home/jarno/.miniconda/envs/incense-dev/lib/python3.6/site-packages/ipykernel_launcher.py:1: DeprecationWarning: `show` is deprecated in favor of `render` and will removed in a future release.\n", " \"\"\"Entry point for launching an IPython kernel.\n" ] }, @@ -879,7 +880,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 26, @@ -888,7 +889,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -911,7 +912,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 27, @@ -920,7 +921,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -941,7 +942,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Projecting onto Pandas\n", + "## Projecting onto DataFrames\n", "Often you want to pull experiment attributes and metrics into a dataframe. Either just to get and overview or do a custom analysis. You can easily transform a `QuerySet` of experiments by calling `project` on it. Pass a list of dot separated paths that point to some value in the experiement model to the `on` parameter. By default the columns will be named as the last element in the path." ] }, @@ -1078,7 +1079,7 @@ " 2\n", " example\n", " sgd\n", - " 0.345013\n", + " 0.345012\n", " \n", " \n", " 3\n", @@ -1094,7 +1095,7 @@ " name optimizer training_loss_median\n", "exp_id \n", "1 example sgd 0.637839\n", - "2 example sgd 0.345013\n", + "2 example sgd 0.345012\n", "3 example adam 0.218707" ] }, @@ -1107,6 +1108,43 @@ "exps.project(on=[\"experiment.name\", \"config.optimizer\", {\"metrics.training_loss\": np.median}])" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Saving mulitple artifacts at once\n", + "`QuerySet`s mimick the API of single artifacts, so you can also get the artifacts and save all of them. This has the advantage that the download will happen in a multithreaded fashion, which should make things faster for large number of bigger artifacts." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "loader.find_all().artifacts[\"confusion_matrix\"].save(to_dir=\"artifacts\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To match more than one artifact per experiment you can use globbing patterns to `filter` the artifacts. However, you will not get an error if no artifacts are matched for different experiments." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "(loader\n", + " .find_all()\n", + " .artifacts\n", + " .filter(\"*matrix*\")\n", + " .save(to_dir=\"artifacts\"))" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1117,7 +1155,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -1133,7 +1171,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -1142,7 +1180,7 @@ "{'epochs'}" ] }, - "execution_count": 31, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -1162,7 +1200,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -1172,9 +1210,9 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mStdinNotImplementedError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mexp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloader\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfind_by_id\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mexp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdelete\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/repos/incense/incense/experiment.py\u001b[0m in \u001b[0;36mdelete\u001b[0;34m(self, confirmed)\u001b[0m\n\u001b[1;32m 76\u001b[0m \"\"\"\n\u001b[1;32m 77\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mconfirmed\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 78\u001b[0;31m \u001b[0mconfirmed\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Are you sure you want to delete {self}? [y/N]\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"y\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 79\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mconfirmed\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 80\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_delete\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/incense-dev/lib/python3.6/site-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mraw_input\u001b[0;34m(self, prompt)\u001b[0m\n\u001b[1;32m 846\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_allow_stdin\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 847\u001b[0m raise StdinNotImplementedError(\n\u001b[0;32m--> 848\u001b[0;31m \u001b[0;34m\"raw_input was called, but this frontend does not support input requests.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 849\u001b[0m )\n\u001b[1;32m 850\u001b[0m return self._input_request(str(prompt),\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mexp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloader\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfind_by_id\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mexp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdelete\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/projects/incense/incense/experiment.py\u001b[0m in \u001b[0;36mdelete\u001b[0;34m(self, confirmed)\u001b[0m\n\u001b[1;32m 76\u001b[0m \"\"\"\n\u001b[1;32m 77\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mconfirmed\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 78\u001b[0;31m \u001b[0mconfirmed\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Are you sure you want to delete {self}? [y/N]\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"y\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 79\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mconfirmed\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 80\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_delete\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.miniconda/envs/incense-dev/lib/python3.6/site-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mraw_input\u001b[0;34m(self, prompt)\u001b[0m\n\u001b[1;32m 846\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_allow_stdin\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 847\u001b[0m raise StdinNotImplementedError(\n\u001b[0;32m--> 848\u001b[0;31m \u001b[0;34m\"raw_input was called, but this frontend does not support input requests.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 849\u001b[0m )\n\u001b[1;32m 850\u001b[0m return self._input_request(str(prompt),\n", "\u001b[0;31mStdinNotImplementedError\u001b[0m: raw_input was called, but this frontend does not support input requests." ] } @@ -1208,7 +1246,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.6.8" } }, "nbformat": 4, diff --git a/example_experiment/conduct.py b/example_experiment/conduct.py index 43da4b1..e20a0ce 100755 --- a/example_experiment/conduct.py +++ b/example_experiment/conduct.py @@ -1,14 +1,16 @@ # -*- coding: future_fstrings -*- -import matplotlib.pyplot as plt import pandas as pd import seaborn as sns import tensorflow as tf +from tensorflow.python.keras.callbacks import Callback + +import matplotlib.pyplot as plt +import numpy as np from matplotlib.animation import FFMpegWriter from sacred import Experiment from sacred.observers import MongoObserver from sacred.utils import apply_backspaces_and_linefeeds from sklearn.metrics import confusion_matrix -from tensorflow.python.keras.callbacks import Callback class MetricsLogger(Callback): @@ -23,7 +25,7 @@ def on_epoch_end(self, epoch, logs): self._run.log_scalar("training_acc", float(logs["acc"]), step=epoch) -def plot_confusion_matrix(confusion_matrix, class_names, figsize=(15, 12), fontsize=14): +def plot_confusion_matrix(confusion_matrix, class_names, figsize=(15, 12)): """Prints a confusion matrix, as returned by sklearn.metrics.confusion_matrix, as a heatmap. Based on https://gist.github.com/shaypal5/94c53d765083101efc0240d776a23823 @@ -141,15 +143,17 @@ def conduct(epochs, optimizer, _run): filename = "confusion_matrix.pdf" fig.savefig(filename) - _run.add_artifact(filename, name="confusion_matrix_pdf") + _run.add_artifact(filename) plot_accuracy_development(history, _run) write_csv_as_text(history, _run) - scalar_results = model.evaluate(x_test, y_test, verbose=0) + filename = "model.hdf5" + model.save(filename) + _run.add_artifact(filename) + + scalar_results = model.evaluate(x_test, y_test, verbose=0) results = dict(zip(model.metrics_names, scalar_results)) - print("Final test results") - print(results) for metric, value in results.items(): _run.log_scalar(f"test_{metric}", value) diff --git a/incense/artifact.py b/incense/artifact.py index 4a42595..30c87f5 100755 --- a/incense/artifact.py +++ b/incense/artifact.py @@ -3,6 +3,7 @@ import pickle import warnings from copy import copy +from typing import * import pandas as pd from IPython import display @@ -18,7 +19,7 @@ def __init__(self, name: str, file, content_type: str = None): self.name = name self.file = file self.content_type = content_type - self.extension = None if self.content_type is None else self.content_type.split("/")[-1] + self.extension = "" if self.content_type is None else self.content_type.split("/")[-1] self._content = None self._rendered = None @@ -43,12 +44,20 @@ def show(self): ) return self.render() - def save(self, save_dir: str = ""): - """Save artifact to disk.""" - with open(os.path.join(save_dir, self._make_filename()), "wb") as file: + def save(self, to_dir: str = "") -> None: + """ + Save artifact to disk. + + Args: + to_dir: Directory in which to save the artifact. Defaults to the current working directory. + + """ + if to_dir: + os.makedirs(str(to_dir), exist_ok=True) + with open(os.path.join(str(to_dir), self._make_filename()), "wb") as file: file.write(self.content) - def as_content_type(self, content_type): + def as_content_type(self, content_type) -> "Artifact": """Interpret artifact as being of content-type.""" try: artifact_type = content_type_to_artifact_cls[content_type] @@ -57,7 +66,7 @@ def as_content_type(self, content_type): else: return self.as_type(artifact_type) - def as_type(self, artifact_type): + def as_type(self, artifact_type) -> "Artifact": self.file.seek(0) return artifact_type(self.name, self.file) @@ -69,8 +78,8 @@ def content(self): return self._content def _make_filename(self): - parts = self.file.filename.split("/") - return f"{parts[-2]}_{parts[-1]}.{self.extension}" + exp_id, artifact_name = self.file.filename.split("/")[-2:] + return f"{exp_id}_{artifact_name}" + ("" if artifact_name.endswith(self.extension) else f".{self.extension}") class ImageArtifact(Artifact): @@ -133,9 +142,6 @@ class PDFArtifact(Artifact): content_type_to_artifact_cls = {} for cls in copy(locals()).values(): - # print(cls) if isinstance(cls, type) and issubclass(cls, Artifact): for content_type in cls.can_render: content_type_to_artifact_cls[content_type] = cls - -# print(content_type_to_artifact_cls) diff --git a/incense/query_set.py b/incense/query_set.py index ab29538..029ef5a 100644 --- a/incense/query_set.py +++ b/incense/query_set.py @@ -1,6 +1,8 @@ # -*- coding: future_fstrings -*- from collections import OrderedDict, UserList, defaultdict +from concurrent.futures import ThreadPoolExecutor from copy import copy +from fnmatch import fnmatch from functools import reduce from typing import * @@ -87,3 +89,42 @@ def _get(self, o, name): return getattr(o, name) except AttributeError: return o[name] + + @property + def artifacts(self): + return ArtifactIndexer(self) + + +class ArtifactIndexer: + def __init__(self, experiments: QuerySet): + self._experiments = experiments + + def filter(self, pattern): + """ + Get all artifacts that match a name of pattern. + + This method does not indicate whether the requested artifacts could be found + only on some artifacts. + + Args: + pattern: glob pattern, that is matched against artifact name. + + Returns: + + """ + return ArtifactSet( + artifact + for exp in self._experiments + for artifact_name, artifact in exp.artifacts.items() + if fnmatch(artifact_name, pattern) + ) + + def __getitem__(self, item): + return ArtifactSet(exp.artifacts[item] for exp in self._experiments) + + +class ArtifactSet(UserList): + def save(self, to_dir, n_threads=None): + with ThreadPoolExecutor(max_workers=n_threads) as executer: + for artifact in self.data: + executer.submit(artifact.save, to_dir=to_dir) diff --git a/tests/test_artifact.py b/tests/test_artifact.py index 65c4191..26ba7c1 100644 --- a/tests/test_artifact.py +++ b/tests/test_artifact.py @@ -27,13 +27,12 @@ def test_png_artifact_render(loader): assert isinstance(png_artifact.render(), IPython.core.display.Image) -def test_png_artifact_save(loader): +def test_png_artifact_save(loader, tmpdir): exp = loader.find_by_id(3) - exp.artifacts["confusion_matrix"].save() - filename = "3_confusion_matrix.png" - assert os.path.isfile(filename) - assert imghdr.what(filename) == "png" - os.remove(filename) + exp.artifacts["confusion_matrix"].save(to_dir=tmpdir) + filepath = str(tmpdir / "3_confusion_matrix.png") + assert os.path.isfile(filepath) + assert imghdr.what(filepath) == "png" def test_csv_artifact_render(loader): @@ -43,7 +42,7 @@ def test_csv_artifact_render(loader): assert isinstance(csv_artifact.render(), pd.DataFrame) -def test_csv_artifact_show_warning(loader): +def test_csv_artifact_render_warning(loader): exp = loader.find_by_id(3) csv_artifact = exp.artifacts["predictions"] assert isinstance(csv_artifact, artifact.CSVArtifact) @@ -51,12 +50,11 @@ def test_csv_artifact_show_warning(loader): assert isinstance(csv_artifact.show(), pd.DataFrame) -def test_mp4_artifact_save(loader): +def test_mp4_artifact_save(loader, tmpdir): exp = loader.find_by_id(2) - exp.artifacts["accuracy_movie"].save() - filename = "2_accuracy_movie.mp4" - assert os.path.isfile(filename) - os.remove(filename) + exp.artifacts["accuracy_movie"].save(to_dir=tmpdir) + filepath = str(tmpdir / "2_accuracy_movie.mp4") + assert os.path.isfile(filepath) def test_mp4_artifact_render(loader): @@ -67,13 +65,12 @@ def test_mp4_artifact_render(loader): os.remove("2_accuracy_movie.mp4") -def test_csv_artifact_save(loader): +def test_csv_artifact_save(loader, tmpdir): exp = loader.find_by_id(3) - exp.artifacts["predictions"].save() - filename = "3_predictions.csv" - assert os.path.isfile(filename) - assert isinstance(pd.read_csv(filename), pd.DataFrame) - os.remove(filename) + exp.artifacts["predictions"].save(to_dir=tmpdir) + filepath = str(tmpdir / "3_predictions.csv") + assert os.path.isfile(filepath) + assert isinstance(pd.read_csv(filepath), pd.DataFrame) def test_pickle_artifact_render(loader): @@ -85,23 +82,21 @@ def test_pickle_artifact_render(loader): assert isinstance(pickle_artifact.render(), pd.DataFrame) -def test_pickle_artifact_save(loader): +def test_pickle_artifact_save(loader, tmpdir): exp = loader.find_by_id(3) pickle_artifact = exp.artifacts["predictions_df"].as_type(artifact.PickleArtifact) - pickle_artifact.save() - filename = "3_predictions_df.pickle" + pickle_artifact.save(to_dir=tmpdir) + filename = str(tmpdir / "3_predictions_df.pickle") assert os.path.isfile(filename) assert isinstance(pickle.load(open(filename, "rb")), pd.DataFrame) - os.remove(filename) -def test_pdf_artifact_save(loader): +def test_pdf_artifact_save(loader, tmpdir): exp = loader.find_by_id(2) - pdf_artifact = exp.artifacts["confusion_matrix_pdf"] - pdf_artifact.save() - filename = "2_confusion_matrix_pdf.pdf" - assert os.path.isfile(filename) - os.remove(filename) + pdf_artifact = exp.artifacts["confusion_matrix.pdf"] + pdf_artifact.save(to_dir=tmpdir) + filepath = str(tmpdir / "2_confusion_matrix.pdf") + assert os.path.isfile(filepath) def test_as_type(loader): @@ -129,7 +124,14 @@ def test_as_content_type_with_unkwown_content_type(loader): text_artifact_as_something_strange = exp.artifacts["history"].as_content_type("something/strange") -def test_artifact_render(loader): +def test_artifact_render_with_unknown_content_type(loader): exp = loader.find_by_id(3) with raises(NotImplementedError): exp.artifacts["predictions_df"].render() + + +def test_artifact_save_with_unknown_content_type(loader, tmpdir): + exp = loader.find_by_id(3) + exp.artifacts["predictions_df"].save(to_dir=tmpdir) + filepath = str(tmpdir / "3_predictions_df") + assert os.path.isfile(filepath) diff --git a/tests/test_set_save.py b/tests/test_set_save.py new file mode 100644 index 0000000..6e293da --- /dev/null +++ b/tests/test_set_save.py @@ -0,0 +1,22 @@ +# -*- coding: future_fstrings -*- +import os + + +def test_single_save(loader, tmpdir): + exp_ids = [1, 2, 3] + exps = loader.find_by_ids(exp_ids) + exps.artifacts["confusion_matrix"].save(to_dir=tmpdir) + for exp_id in exp_ids: + filepath = tmpdir / f"{exp_id}_confusion_matrix.png" + assert os.path.isfile(str(filepath)) + + +def test_glob_save(loader, tmpdir): + exp_ids = [1, 2, 3] + exps = loader.find_by_ids(exp_ids) + exps.artifacts.filter("confusion_matrix*").save(to_dir=tmpdir) + for exp_id in exp_ids: + filepath = str(tmpdir / f"{exp_id}_confusion_matrix.png") + assert os.path.isfile(filepath) + filepath = str(tmpdir / f"{exp_id}_confusion_matrix.pdf") + assert os.path.isfile(filepath)