From 706426a3078df3a2f7a8bb3618db4a088f007378 Mon Sep 17 00:00:00 2001 From: PLAYERiv65 Date: Sat, 31 Aug 2024 11:20:49 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BC=98=E5=8C=96jupyter=E6=98=BE=E7=A4=BA?= =?UTF-8?q?=E6=95=88=E6=9E=9C=EF=BC=8C=E4=BC=98=E5=8C=96=E9=83=A8=E5=88=86?= =?UTF-8?q?=E4=BB=A3=E7=A0=81=E5=AE=9E=E7=8E=B0=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...346\225\260\346\215\256\351\233\206.ipynb" | 2104 +----------- ...347\235\243\345\255\246\344\271\240.ipynb" | 2958 +---------------- ...344\271\240\345\256\236\346\210\230.ipynb" | 1029 +----- .../6.5-GAN-Digits/main_CNN.py" | 7 +- .../7.5-poetryGen/poetryDataset.py" | 2 +- .../7.5-poetryGen/poetryTest.py" | 47 +- .../7.5-poetryGen/poetryTrain.py" | 4 +- 7 files changed, 155 insertions(+), 5996 deletions(-) diff --git "a/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.3 \347\244\272\344\276\213\346\225\260\346\215\256\351\233\206.ipynb" "b/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.3 \347\244\272\344\276\213\346\225\260\346\215\256\351\233\206.ipynb" index 597cedf..41ada3e 100644 --- "a/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.3 \347\244\272\344\276\213\346\225\260\346\215\256\351\233\206.ipynb" +++ "b/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.3 \347\244\272\344\276\213\346\225\260\346\215\256\351\233\206.ipynb" @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 36, "id": "10f06b12", "metadata": {}, "outputs": [], @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 37, "id": "ca914511", "metadata": {}, "outputs": [ @@ -55,6 +55,7 @@ "text/plain": [ "['DESCR',\n", " 'data',\n", + " 'data_module',\n", " 'feature_names',\n", " 'filename',\n", " 'frame',\n", @@ -62,7 +63,7 @@ " 'target_names']" ] }, - "execution_count": 3, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -83,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 38, "id": "581c8d95", "metadata": {}, "outputs": [ @@ -93,7 +94,7 @@ "text": [ "['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'] ['setosa' 'versicolor' 'virginica']\n", "(150, 4) (150,)\n", - "D:\\anaconda\\lib\\site-packages\\sklearn\\datasets\\data\\iris.csv\n", + "iris.csv\n", ".. _iris_dataset:\n", "\n", "Iris plants dataset\n", @@ -101,34 +102,34 @@ "\n", "**Data Set Characteristics:**\n", "\n", - " :Number of Instances: 150 (50 in each of three classes)\n", - " :Number of Attributes: 4 numeric, predictive attributes and the class\n", - " :Attribute Information:\n", - " - sepal length in cm\n", - " - sepal width in cm\n", - " - petal length in cm\n", - " - petal width in cm\n", - " - class:\n", - " - Iris-Setosa\n", - " - Iris-Versicolour\n", - " - Iris-Virginica\n", - " \n", - " :Summary Statistics:\n", + ":Number of Instances: 150 (50 in each of three classes)\n", + ":Number of Attributes: 4 numeric, predictive attributes and the class\n", + ":Attribute Information:\n", + " - sepal length in cm\n", + " - sepal width in cm\n", + " - petal length in cm\n", + " - petal width in cm\n", + " - class:\n", + " - Iris-Setosa\n", + " - Iris-Versicolour\n", + " - Iris-Virginica\n", "\n", - " ============== ==== ==== ======= ===== ====================\n", - " Min Max Mean SD Class Correlation\n", - " ============== ==== ==== ======= ===== ====================\n", - " sepal length: 4.3 7.9 5.84 0.83 0.7826\n", - " sepal width: 2.0 4.4 3.05 0.43 -0.4194\n", - " petal length: 1.0 6.9 3.76 1.76 0.9490 (high!)\n", - " petal width: 0.1 2.5 1.20 0.76 0.9565 (high!)\n", - " ============== ==== ==== ======= ===== ====================\n", + ":Summary Statistics:\n", "\n", - " :Missing Attribute Values: None\n", - " :Class Distribution: 33.3% for each of 3 classes.\n", - " :Creator: R.A. Fisher\n", - " :Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)\n", - " :Date: July, 1988\n", + "============== ==== ==== ======= ===== ====================\n", + " Min Max Mean SD Class Correlation\n", + "============== ==== ==== ======= ===== ====================\n", + "sepal length: 4.3 7.9 5.84 0.83 0.7826\n", + "sepal width: 2.0 4.4 3.05 0.43 -0.4194\n", + "petal length: 1.0 6.9 3.76 1.76 0.9490 (high!)\n", + "petal width: 0.1 2.5 1.20 0.76 0.9565 (high!)\n", + "============== ==== ==== ======= ===== ====================\n", + "\n", + ":Missing Attribute Values: None\n", + ":Class Distribution: 33.3% for each of 3 classes.\n", + ":Creator: R.A. Fisher\n", + ":Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)\n", + ":Date: July, 1988\n", "\n", "The famous Iris database, first used by Sir R.A. Fisher. The dataset is taken\n", "from Fisher's paper. Note that it's the same as in R, but not as in the UCI\n", @@ -141,22 +142,27 @@ "type of iris plant. One class is linearly separable from the other 2; the\n", "latter are NOT linearly separable from each other.\n", "\n", - ".. topic:: References\n", + "|details-start|\n", + "**References**\n", + "|details-split|\n", + "\n", + "- Fisher, R.A. \"The use of multiple measurements in taxonomic problems\"\n", + " Annual Eugenics, 7, Part II, 179-188 (1936); also in \"Contributions to\n", + " Mathematical Statistics\" (John Wiley, NY, 1950).\n", + "- Duda, R.O., & Hart, P.E. (1973) Pattern Classification and Scene Analysis.\n", + " (Q327.D83) John Wiley & Sons. ISBN 0-471-22361-1. See page 218.\n", + "- Dasarathy, B.V. (1980) \"Nosing Around the Neighborhood: A New System\n", + " Structure and Classification Rule for Recognition in Partially Exposed\n", + " Environments\". IEEE Transactions on Pattern Analysis and Machine\n", + " Intelligence, Vol. PAMI-2, No. 1, 67-71.\n", + "- Gates, G.W. (1972) \"The Reduced Nearest Neighbor Rule\". IEEE Transactions\n", + " on Information Theory, May 1972, 431-433.\n", + "- See also: 1988 MLC Proceedings, 54-64. Cheeseman et al\"s AUTOCLASS II\n", + " conceptual clustering system finds 3 classes in the data.\n", + "- Many, many more ...\n", "\n", - " - Fisher, R.A. \"The use of multiple measurements in taxonomic problems\"\n", - " Annual Eugenics, 7, Part II, 179-188 (1936); also in \"Contributions to\n", - " Mathematical Statistics\" (John Wiley, NY, 1950).\n", - " - Duda, R.O., & Hart, P.E. (1973) Pattern Classification and Scene Analysis.\n", - " (Q327.D83) John Wiley & Sons. ISBN 0-471-22361-1. See page 218.\n", - " - Dasarathy, B.V. (1980) \"Nosing Around the Neighborhood: A New System\n", - " Structure and Classification Rule for Recognition in Partially Exposed\n", - " Environments\". IEEE Transactions on Pattern Analysis and Machine\n", - " Intelligence, Vol. PAMI-2, No. 1, 67-71.\n", - " - Gates, G.W. (1972) \"The Reduced Nearest Neighbor Rule\". IEEE Transactions\n", - " on Information Theory, May 1972, 431-433.\n", - " - See also: 1988 MLC Proceedings, 54-64. Cheeseman et al\"s AUTOCLASS II\n", - " conceptual clustering system finds 3 classes in the data.\n", - " - Many, many more ...\n" + "|details-end|\n", + "\n" ] } ], @@ -177,15 +183,15 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 39, "id": "713d3c33", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -193,15 +199,29 @@ } ], "source": [ + "%matplotlib inline\n", "from sklearn.datasets import load_digits\n", - "from matplotlib import pyplot as plt # 导入绘图模块\n", - "digit = load_digits() # 加载手写数字数据集\n", - "plt.subplots(5,10) # 5行10列子图\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 加载手写数字数据集\n", + "digit = load_digits()\n", + "\n", + "# 创建一个图形对象和子图\n", + "f = plt.figure(figsize=(10, 5))\n", + "f.suptitle(\"Handwritten Digits\")\n", + "\n", + "# 5行10列子图\n", "for i, data in enumerate(zip(digit.data[:50], digit.target[:50])):\n", - " plt.subplot(5, 10, i + 1, title=str(data[1])) # 设置子图标题为标签\n", - " plt.xticks([]) # 不显示横坐标\n", - " plt.yticks([]) # 不显示总坐标\n", - " plt.imshow(data[0].reshape((8, 8)), cmap=plt.cm.gray_r) # 灰度图形显示" + " image = data[0].reshape((8, 8))\n", + " sub = f.add_subplot(5, 10, i + 1)\n", + " sub.imshow(image, cmap=plt.cm.gray_r)\n", + " plt.xticks([]) # 不显示横坐标\n", + " plt.yticks([]) # 不显示纵坐标\n", + " sub.set_title(str(data[1])) # 设置子图标题为标签\n", + "\n", + "plt.subplots_adjust(wspace=0.5, hspace=0.5)\n", + "\n", + "plt.show()" ] }, { @@ -220,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 40, "id": "cba7c76f", "metadata": {}, "outputs": [ @@ -230,7 +250,7 @@ "['DESCR', 'data', 'images', 'target']" ] }, - "execution_count": 6, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -251,7 +271,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 41, "id": "b550b800", "metadata": {}, "outputs": [ @@ -277,982 +297,15 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 42, "id": "19e8aba8", "metadata": {}, "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_device_pixel_ratio', {\n", - " device_pixel_ratio: fig.ratio,\n", - " });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'dblclick',\n", - " on_mouse_event_closure('dblclick')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " fig.rubberband_canvas.style.cursor = msg['cursor'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " var img = evt.data;\n", - " if (img.type !== 'image/png') {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " img.type = 'image/png';\n", - " }\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " img\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * https://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.key === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.key;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.key !== 'Control') {\n", - " value += 'ctrl+';\n", - " }\n", - " else if (event.altKey && event.key !== 'Alt') {\n", - " value += 'alt+';\n", - " }\n", - " else if (event.shiftKey && event.key !== 'Shift') {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k' + event.key;\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.binaryType = comm.kernel.ws.binaryType;\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " function updateReadyState(_event) {\n", - " if (comm.kernel.ws) {\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " } else {\n", - " ws.readyState = 3; // Closed state.\n", - " }\n", - " }\n", - " comm.kernel.ws.addEventListener('open', updateReadyState);\n", - " comm.kernel.ws.addEventListener('close', updateReadyState);\n", - " comm.kernel.ws.addEventListener('error', updateReadyState);\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " var data = msg['content']['data'];\n", - " if (data['blob'] !== undefined) {\n", - " data = {\n", - " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", - " };\n", - " }\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(data);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -1260,7 +313,7 @@ } ], "source": [ - "%matplotlib notebook\n", + "%matplotlib inline\n", "from matplotlib import pyplot as plt\n", "plt.subplots(3, 5) # 图像包含3行5列，共15个子图，每个子图显示一张人脸图像\n", "for i, comp in enumerate(faces.data[:15]): # 显示前15张人脸,其中前10张为同一人\n", @@ -1284,1000 +337,33 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 43, "id": "bb1cc218", "metadata": {}, "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_device_pixel_ratio', {\n", - " device_pixel_ratio: fig.ratio,\n", - " });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'dblclick',\n", - " on_mouse_event_closure('dblclick')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " fig.rubberband_canvas.style.cursor = msg['cursor'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " var img = evt.data;\n", - " if (img.type !== 'image/png') {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " img.type = 'image/png';\n", - " }\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " img\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * https://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.key === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.key;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.key !== 'Control') {\n", - " value += 'ctrl+';\n", - " }\n", - " else if (event.altKey && event.key !== 'Alt') {\n", - " value += 'alt+';\n", - " }\n", - " else if (event.shiftKey && event.key !== 'Shift') {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k' + event.key;\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.binaryType = comm.kernel.ws.binaryType;\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " function updateReadyState(_event) {\n", - " if (comm.kernel.ws) {\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " } else {\n", - " ws.readyState = 3; // Closed state.\n", - " }\n", - " }\n", - " comm.kernel.ws.addEventListener('open', updateReadyState);\n", - " comm.kernel.ws.addEventListener('close', updateReadyState);\n", - " comm.kernel.ws.addEventListener('error', updateReadyState);\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " var data = msg['content']['data'];\n", - " if (data['blob'] !== undefined) {\n", - " data = {\n", - " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", - " };\n", - " }\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(data);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], "text/plain": [ - "" + "" ] }, + "execution_count": 43, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" }, { "data": { - "text/html": [ - "" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, "metadata": {}, "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "%matplotlib notebook\n", + "%matplotlib inline\n", "from sklearn import datasets\n", "from matplotlib import pyplot as plt\n", "fig = plt.figure()\n", @@ -2294,14 +380,6 @@ "ax = fig.add_subplot(224) # 右下角子图\n", "ax.scatter(X4[:, 0], X4[:, 1], marker=\".\", c=y4, s=35, edgecolor=\"r\")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "100286e9", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -2320,7 +398,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.11.9" } }, "nbformat": 4, diff --git "a/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.5 \346\227\240\347\233\221\347\235\243\345\255\246\344\271\240.ipynb" "b/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.5 \346\227\240\347\233\221\347\235\243\345\255\246\344\271\240.ipynb" index 10d946b..8a23baf 100644 --- "a/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.5 \346\227\240\347\233\221\347\235\243\345\255\246\344\271\240.ipynb" +++ "b/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.5 \346\227\240\347\233\221\347\235\243\345\255\246\344\271\240.ipynb" @@ -42,6 +42,7 @@ "from sklearn import datasets\n", "from sklearn.decomposition import PCA\n", "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n", + "\n", "iris = datasets.load_iris()\n", "X, y, target_names = iris.data, iris.target, iris.target_names\n", "titles=['PCA','LDA']\n", @@ -68,976 +69,9 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_device_pixel_ratio', {\n", - " device_pixel_ratio: fig.ratio,\n", - " });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'dblclick',\n", - " on_mouse_event_closure('dblclick')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " fig.rubberband_canvas.style.cursor = msg['cursor'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " var img = evt.data;\n", - " if (img.type !== 'image/png') {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " img.type = 'image/png';\n", - " }\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " img\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * https://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.key === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.key;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.key !== 'Control') {\n", - " value += 'ctrl+';\n", - " }\n", - " else if (event.altKey && event.key !== 'Alt') {\n", - " value += 'alt+';\n", - " }\n", - " else if (event.shiftKey && event.key !== 'Shift') {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k' + event.key;\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.binaryType = comm.kernel.ws.binaryType;\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " function updateReadyState(_event) {\n", - " if (comm.kernel.ws) {\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " } else {\n", - " ws.readyState = 3; // Closed state.\n", - " }\n", - " }\n", - " comm.kernel.ws.addEventListener('open', updateReadyState);\n", - " comm.kernel.ws.addEventListener('close', updateReadyState);\n", - " comm.kernel.ws.addEventListener('error', updateReadyState);\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " var data = msg['content']['data'];\n", - " if (data['blob'] !== undefined) {\n", - " data = {\n", - " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", - " };\n", - " }\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(data);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], + "image/png": "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", "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -1045,8 +79,8 @@ } ], "source": [ - "%matplotlib notebook\n", - "from matplotlib import pyplot as plt\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", "fig, ax = plt.subplots(1,2, figsize=(9,4))\n", "colors = [\"navy\", \"turquoise\", \"darkorange\"] # 设置类别颜色颜色\n", "for title, X_r, k in zip(titles, X_rs, [0, 1]):\n", @@ -1082,7 +116,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "17a1e723", "metadata": {}, "outputs": [ @@ -1115,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "54866608", "metadata": {}, "outputs": [ @@ -1123,9 +157,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "[5 7 7 1 0 3 9 4 3 3 5 6 8 1 0 2 9 4 7 3 5 6 8 1 6 2 9 4 7 3 5 3 2 2 9 2 5\n", - " 3 7 3 7 0 6 4 4 1 2 6 5 5 7 7 4 7 4 5 6 7 9 1 1 4 1 1 0 9 9 9 0 7 6 2 5 3\n", - " 2 6 7 6 5 5 6 4 9 1 8 6 4 0 9 1 6 1 1 7 4 7 7 0 1 7]\n", + "[6 2 2 1 0 7 5 3 1 7 6 9 8 1 0 4 5 3 2 7 6 9 8 1 0 4 5 3 2 7 6 7 4 4 5 4 6\n", + " 7 2 7 2 0 9 3 3 1 4 9 6 6 2 2 3 2 3 6 9 2 5 1 1 3 1 1 0 5 5 5 0 2 9 4 6 7\n", + " 4 9 2 9 6 6 9 3 5 1 8 9 3 0 5 1 9 1 7 2 3 2 2 0 1 2]\n", "(10, 64)\n" ] } @@ -1149,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "id": "ec4c90e3", "metadata": {}, "outputs": [], @@ -1169,982 +203,15 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "id": "8b424c2b", "metadata": {}, "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_device_pixel_ratio', {\n", - " device_pixel_ratio: fig.ratio,\n", - " });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'dblclick',\n", - " on_mouse_event_closure('dblclick')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " fig.rubberband_canvas.style.cursor = msg['cursor'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " var img = evt.data;\n", - " if (img.type !== 'image/png') {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " img.type = 'image/png';\n", - " }\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " img\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * https://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.key === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.key;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.key !== 'Control') {\n", - " value += 'ctrl+';\n", - " }\n", - " else if (event.altKey && event.key !== 'Alt') {\n", - " value += 'alt+';\n", - " }\n", - " else if (event.shiftKey && event.key !== 'Shift') {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k' + event.key;\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.binaryType = comm.kernel.ws.binaryType;\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " function updateReadyState(_event) {\n", - " if (comm.kernel.ws) {\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " } else {\n", - " ws.readyState = 3; // Closed state.\n", - " }\n", - " }\n", - " comm.kernel.ws.addEventListener('open', updateReadyState);\n", - " comm.kernel.ws.addEventListener('close', updateReadyState);\n", - " comm.kernel.ws.addEventListener('error', updateReadyState);\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " var data = msg['content']['data'];\n", - " if (data['blob'] !== undefined) {\n", - " data = {\n", - " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", - " };\n", - " }\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(data);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -2186,7 +253,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "id": "b376cb60", "metadata": {}, "outputs": [ @@ -2197,11 +264,11 @@ "_____________________________________________________________________\n", "init\t\ttime\tinertia\thomo\tcompl\tv-meas\tARI\tAMI\n", "_____________________________________________________________________\n", - "k-means++(1)\t0.015s\t70413\t0.667\t0.724\t0.694\t0.550\t0.691\n", - "k-means++(4)\t0.056s\t69697\t0.669\t0.709\t0.689\t0.554\t0.685\n", - "random(1)\t0.009s\t70668\t0.681\t0.710\t0.695\t0.568\t0.692\n", - "random(4)\t0.045s\t70629\t0.596\t0.655\t0.624\t0.470\t0.620\n", - "PCA \t0.021s\t72686\t0.636\t0.658\t0.647\t0.521\t0.643\n", + "k-means++(1)\t0.008s\t69417\t0.604\t0.653\t0.627\t0.467\t0.624\n", + "k-means++(4)\t0.026s\t69417\t0.604\t0.653\t0.627\t0.467\t0.624\n", + "random(1)\t0.004s\t71303\t0.546\t0.616\t0.579\t0.415\t0.574\n", + "random(4)\t0.016s\t70741\t0.659\t0.688\t0.673\t0.545\t0.670\n", + "PCA \t0.007s\t69513\t0.600\t0.647\t0.622\t0.468\t0.618\n", "_____________________________________________________________________\n" ] } @@ -2261,982 +328,15 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "id": "6e9efd40", "metadata": {}, "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_device_pixel_ratio', {\n", - " device_pixel_ratio: fig.ratio,\n", - " });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'dblclick',\n", - " on_mouse_event_closure('dblclick')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " fig.rubberband_canvas.style.cursor = msg['cursor'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " var img = evt.data;\n", - " if (img.type !== 'image/png') {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " img.type = 'image/png';\n", - " }\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " img\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * https://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.key === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.key;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.key !== 'Control') {\n", - " value += 'ctrl+';\n", - " }\n", - " else if (event.altKey && event.key !== 'Alt') {\n", - " value += 'alt+';\n", - " }\n", - " else if (event.shiftKey && event.key !== 'Shift') {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k' + event.key;\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.binaryType = comm.kernel.ws.binaryType;\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " function updateReadyState(_event) {\n", - " if (comm.kernel.ws) {\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " } else {\n", - " ws.readyState = 3; // Closed state.\n", - " }\n", - " }\n", - " comm.kernel.ws.addEventListener('open', updateReadyState);\n", - " comm.kernel.ws.addEventListener('close', updateReadyState);\n", - " comm.kernel.ws.addEventListener('error', updateReadyState);\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " var data = msg['content']['data'];\n", - " if (data['blob'] !== undefined) {\n", - " data = {\n", - " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", - " };\n", - " }\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(data);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -3287,19 +387,11 @@ "source": [ "可以看出ICA可以较好的分离出各个成分信号，需要注意的是，ICA分离出的信号顺序与初始的源信号顺序不对应，另外分离出的信号幅值与原始源信号也不对应，但在形态域上具备相似性。" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f53b44e1", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "learning", "language": "python", "name": "python3" }, @@ -3313,7 +405,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.11.9" } }, "nbformat": 4, diff --git "a/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.6 \345\215\212\347\233\221\347\235\243\345\255\246\344\271\240\345\256\236\346\210\230.ipynb" "b/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.6 \345\215\212\347\233\221\347\235\243\345\255\246\344\271\240\345\256\236\346\210\230.ipynb" index 02a3e78..dd379c5 100644 --- "a/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.6 \345\215\212\347\233\221\347\235\243\345\255\246\344\271\240\345\256\236\346\210\230.ipynb" +++ "b/chap3-\346\234\272\345\231\250\345\255\246\344\271\240\345\267\245\345\205\267\345\214\205sklearn\345\256\236\350\267\265/3.6 \345\215\212\347\233\221\347\235\243\345\255\246\344\271\240\345\256\236\346\210\230.ipynb" @@ -139,976 +139,9 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_device_pixel_ratio', {\n", - " device_pixel_ratio: fig.ratio,\n", - " });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'dblclick',\n", - " on_mouse_event_closure('dblclick')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " fig.rubberband_canvas.style.cursor = msg['cursor'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " var img = evt.data;\n", - " if (img.type !== 'image/png') {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " img.type = 'image/png';\n", - " }\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " img\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * https://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.key === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.key;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.key !== 'Control') {\n", - " value += 'ctrl+';\n", - " }\n", - " else if (event.altKey && event.key !== 'Alt') {\n", - " value += 'alt+';\n", - " }\n", - " else if (event.shiftKey && event.key !== 'Shift') {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k' + event.key;\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.binaryType = comm.kernel.ws.binaryType;\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " function updateReadyState(_event) {\n", - " if (comm.kernel.ws) {\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " } else {\n", - " ws.readyState = 3; // Closed state.\n", - " }\n", - " }\n", - " comm.kernel.ws.addEventListener('open', updateReadyState);\n", - " comm.kernel.ws.addEventListener('close', updateReadyState);\n", - " comm.kernel.ws.addEventListener('error', updateReadyState);\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " var data = msg['content']['data'];\n", - " if (data['blob'] !== undefined) {\n", - " data = {\n", - " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", - " };\n", - " }\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(data);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], + "image/png": "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", "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -1116,7 +149,7 @@ } ], "source": [ - "%matplotlib notebook\n", + "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "error_index = np.where(pred_labels-true_labels != 0)[0] # 得到所有错误结果的索引\n", "f = plt.figure(figsize=(7, 5)) # 画图\n", @@ -1152,31 +185,31 @@ "text": [ " precision recall f1-score support\n", "\n", - " 0 0.97 0.85 0.90 176\n", - " 1 0.54 0.84 0.66 177\n", - " 2 0.89 0.32 0.47 175\n", - " 3 0.91 0.38 0.54 182\n", - " 4 0.48 0.99 0.64 173\n", - " 5 0.69 0.89 0.78 176\n", - " 6 0.74 0.98 0.84 173\n", - " 7 0.84 0.78 0.81 176\n", - " 8 0.94 0.09 0.17 173\n", - " 9 0.71 0.78 0.74 176\n", + " 0 0.96 0.82 0.89 176\n", + " 1 0.54 0.73 0.62 177\n", + " 2 0.85 0.29 0.43 175\n", + " 3 0.94 0.48 0.64 182\n", + " 4 0.43 0.98 0.59 173\n", + " 5 0.72 0.88 0.79 176\n", + " 6 0.74 0.97 0.84 173\n", + " 7 0.89 0.70 0.78 176\n", + " 8 0.93 0.14 0.25 173\n", + " 9 0.69 0.81 0.74 176\n", "\n", - " accuracy 0.69 1757\n", - " macro avg 0.77 0.69 0.66 1757\n", - "weighted avg 0.77 0.69 0.66 1757\n", + " accuracy 0.68 1757\n", + " macro avg 0.77 0.68 0.66 1757\n", + "weighted avg 0.77 0.68 0.66 1757\n", "\n", - "[[149 0 0 0 12 0 6 0 0 9]\n", - " [ 0 149 0 0 23 1 0 1 0 3]\n", - " [ 0 84 56 1 19 0 12 3 0 0]\n", - " [ 1 16 7 70 2 30 8 17 0 31]\n", - " [ 0 0 0 0 172 0 0 1 0 0]\n", - " [ 0 1 0 0 5 157 4 0 0 9]\n", - " [ 0 3 0 0 1 0 169 0 0 0]\n", - " [ 0 0 0 0 31 8 0 137 0 0]\n", - " [ 3 18 0 3 84 16 27 3 16 3]\n", - " [ 1 5 0 3 12 14 1 2 1 137]]\n" + "[[145 0 0 0 14 0 6 0 0 11]\n", + " [ 0 130 0 0 36 0 7 0 0 4]\n", + " [ 1 80 51 1 21 4 11 2 1 3]\n", + " [ 1 10 8 88 2 34 3 8 0 28]\n", + " [ 0 0 0 0 170 0 2 1 0 0]\n", + " [ 1 0 0 0 5 154 2 0 0 14]\n", + " [ 0 3 0 0 2 0 168 0 0 0]\n", + " [ 0 0 0 0 50 3 0 123 0 0]\n", + " [ 1 17 1 1 87 8 26 3 25 4]\n", + " [ 2 1 0 4 12 12 1 1 1 142]]\n" ] } ], @@ -1188,14 +221,6 @@ "print(classification_report(y[labeled_points:], pred)) #打印性能指标\n", "print(confusion_matrix(y[labeled_points:], pred)) # 打印混淆矩阵" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c98221d3", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -1214,7 +239,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.11.9" } }, "nbformat": 4, diff --git "a/chap6-Pytorch\345\256\236\350\267\265-\350\256\241\347\256\227\346\234\272\350\247\206\350\247\211/6.5-GAN-Digits/main_CNN.py" "b/chap6-Pytorch\345\256\236\350\267\265-\350\256\241\347\256\227\346\234\272\350\247\206\350\247\211/6.5-GAN-Digits/main_CNN.py" index 9ac9270..45c6309 100644 --- "a/chap6-Pytorch\345\256\236\350\267\265-\350\256\241\347\256\227\346\234\272\350\247\206\350\247\211/6.5-GAN-Digits/main_CNN.py" +++ "b/chap6-Pytorch\345\256\236\350\267\265-\350\256\241\347\256\227\346\234\272\350\247\206\350\247\211/6.5-GAN-Digits/main_CNN.py" @@ -62,12 +62,11 @@ def dloss(scores_real, scores_fake): loss = 0.5 * ((scores_real - 1) ** 2).mean() + 0.5 * (scores_fake ** 2).mean() return loss -def setKeyObj(generator, discriminator): - device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') +def setKeyObj(generator, discriminator, device): loss = nn.BCELoss().to(device) # 将损失函数置入合适的计算环境 optim_G = torch.optim.Adam(generator.parameters(), lr=3e-4, betas=(0.5, 0.999)) optim_D = torch.optim.Adam(discriminator.parameters(),lr=3e-4,betas=(0.5, 0.999)) - return device, loss, optim_G, optim_D + return loss, optim_G, optim_D def getDataLoader(batch_size): @@ -105,7 +104,7 @@ if __name__ == '__main__': os.makedirs('imgs', exist_ok=True) # 建立生成图像的存储目录 - device, loss, optim_G, optim_D = setKeyObj(generator, discriminator) + loss, optim_G, optim_D = setKeyObj(generator, discriminator, device) data_loader = getDataLoader(batch_size) for epoch in range(EPOCH): diff --git "a/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryDataset.py" "b/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryDataset.py" index 594bd3d..7591f47 100644 --- "a/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryDataset.py" +++ "b/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryDataset.py" @@ -47,7 +47,7 @@ def getPeotryData(pklfile, path, maxlen): # 得到文件名以'poet.tang'开头的json文件中的所有唐朝诗词内容 data = _parseRawData(path=path, category='poet.tang') - # 得到诗词中包含的左右的字符 + # 得到诗词中包含的所有的字符 words = {_word for _sentence in data for _word in _sentence} # 得到每个字符和其编号(id)的对应字典 word2id = {_word: _id for _id, _word in enumerate(words)} diff --git "a/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryTest.py" "b/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryTest.py" index 6e4d921..60ddf39 100644 --- "a/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryTest.py" +++ "b/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryTest.py" @@ -1,7 +1,7 @@ -import torch as t +import torch import torch.nn as nn import numpy as np - +from poetryTrain import PoetryModel # 提供模型定义 class Config(object): max_gen_len = 50 # 生成诗歌最长长度 @@ -28,7 +28,7 @@ def gen_acrostic(model, start_words, ix2word, word2ix, prefix_words=None): """ results = [] start_word_len = len(start_words) - input = (t.Tensor([word2ix['[START]']]).view(1, 1).long()) + input = torch.Tensor([word2ix['[START]']]).view(1, 1).long() input = input.to(opt.device) hidden = None @@ -46,7 +46,7 @@ def gen_acrostic(model, start_words, ix2word, word2ix, prefix_words=None): top_index = output.data[0].topk(1)[1][0].item() w = ix2word[top_index] - if (pre_word in {u'，', u'。', u'！', '[START]'}): + if (pre_word in {'，', '。', '！', '[START]'}): # 如果遇到句号，藏头的词送进去生成 if index == start_word_len: @@ -64,41 +64,6 @@ def gen_acrostic(model, start_words, ix2word, word2ix, prefix_words=None): pre_word = w return results - -class PoetryModel(nn.Module): - """ - 诗词模型，核心层为双层单向LSTM，前面是嵌入层，后面是全连接层 - """ - - def __init__(self, voc_size, emb_dim, hid_dim): - """ - 模型初始化： - @voc_size: 此表大小 - @emb_dim: 词嵌入长度 - @hid_dim: RNN隐藏数量 - """ - super(PoetryModel, self).__init__() - self.hid_dim = hid_dim # 隐层数量 - self.embeddings = nn.Embedding(voc_size, emb_dim) # 嵌入层 - self.rnn = nn.LSTM(emb_dim, self.hid_dim, num_layers=2) # RNN层 - self.linear = nn.Linear(self.hid_dim, voc_size) # 全连接层 - - def forward(self, input, hidden=None): - seq_len, batch_size = input.size() # 得到句子长度L和每批次处理的句子数N - if hidden is None: # 初始化2层LSTM短时记忆隐状态和长时记忆隐状态, [2, N, H] - h_0 = input.data.new(2, batch_size, self.hid_dim).fill_(0).float() - c_0 = input.data.new(2, batch_size, self.hid_dim).fill_(0).float() - else: - h_0, c_0 = hidden - # 经过嵌入层, [L, N]->[L, N, E], E:emb_dim - embeds = self.embeddings(input) # - # 经过RNN层, [L, N, E]->[L, N, H], H:hid_dim - output, hidden = self.rnn(embeds, (h_0, c_0)) - # 经过全连接层, [L*N, H]->[L*N, V], V:voc_size - output = self.linear(output.view(seq_len * batch_size, -1)) - return output, hidden - - def processWord(words, defword): if words.isprintable(): new_words = words if words else defword @@ -121,10 +86,10 @@ def gen(**kwargs): _, word2id, id2word = getData("poetry.npz") - model = t.load("poetry_model.pth", map_location=lambda s, l: s) + model = torch.load("poetry_model.pth", map_location=lambda s, l: s) model.eval() - opt.device = t.device('cuda' if t.cuda.is_available() else 'cpu') + opt.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model.to(opt.device) start_words = processWord( opt.start_words, defword='我') prefix_words = processWord( opt.prefix_words, defword=None) diff --git "a/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryTrain.py" "b/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryTrain.py" index 02a27d1..694140c 100644 --- "a/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryTrain.py" +++ "b/chap7-PyTorch\345\256\236\350\267\265-\350\207\252\347\204\266\350\257\255\350\250\200\345\244\204\347\220\206/7.5-poetryGen/poetryTrain.py" @@ -25,7 +25,7 @@ class PoetryModel(nn.Module): @emb_dim: 词嵌入长度 @hid_dim: RNN隐藏数量 """ - super(PoetryModel, self).__init__() + super().__init__() self.hid_dim = hid_dim # 隐层数量 self.embeddings = nn.Embedding(voc_size, emb_dim) # 嵌入层 self.rnn = nn.LSTM(emb_dim, self.hid_dim, num_layers=2) # RNN层 @@ -74,7 +74,7 @@ def train(): model.to(device) for epoch in range(epochs): loss_avg = 0 - for ii, data in tqdm.tqdm(enumerate(dataloader)): + for _, data in tqdm.tqdm(enumerate(dataloader)): # 训练 data = data.long().transpose(1, 0).contiguous() data = data.to(device) -- Gitee