Real-timeScoringOfNNModel.ipynb

{"cells": [{"metadata": {}, "cell_type": "markdown", "source": "# Build and score a neural network model in real time with PyBrain and\u00a0IBM Streams\n\nIf you have a neural network model and would like to score it on real time data, follow this notebook to see how to use the IBM Streams Python API to do so.\n\nThis Python notebook creates a sample data set and then creates a model for the sample data using [PyBrain](http://pybrain.org/).\nNext, it creates a streaming application to score the model on a stream of simulated data. The application can run in the Streaming Analytics service in the IBM Cloud or in IBM Cloud Pak for Data.\n\nFinally, the notebook connects to the running application to visualize the results of scoring the model on the stream of data.\n\n\nFamiliarity with Python and Jupyter Notebooks is recommended. \nThis notebook runs on Python 3.6."}, {"metadata": {}, "cell_type": "markdown", "source": "## Table of contents\n***\n1.\t[Setup](#setup)\n1.  [Create a sample data set](#create_data)\n1.  [Create a model for sample data](#create_model)\n1.  [Use the model in a real-time streaming application](#use_model)\n1.\t[Define and submit the streaming application](#build)\n1.\t[View the streaming data](#visualize)\n1.\t[Summary and next steps](#summary)\n***"}, {"metadata": {}, "cell_type": "markdown", "source": "<a id=\"setup\"></a>\n## 1. Setup\n<br/>\n\nBefore you can use the example Python code in this notebook, complete these steps:\n1.\t[Install Python library](#install)\n1.\t[(Optional) Start the Streaming Analytics service](#start)\n1.\t[Set up access to the service](#access)"}, {"metadata": {}, "cell_type": "markdown", "source": "<a id=\"install\"></a>\n### 1.1. Install PyBrain\n\nRun the following cell to install the latest package from <a href=\"http://www.pybrain.org/docs/\" target=\"_blank\" rel=\"noopener noreferrer\">PyBrain</a>. PyBrain is a machine learning library for Python and it's required to:\n\n - Create sample data that shows the average temperature of an engine for a given period of time, and calculates the engine's probability of failure.\n - Create a data model that reads the temperature of an engine and calculates the engine's probability of failure based on temperature readings.   \n - Use the data model in a streaming application.\n \n**Note:** this notebook uses the `pybrain3` wrapper for pybrain."}, {"metadata": {}, "cell_type": "code", "source": "#!pip install pybrain3", "execution_count": null, "outputs": []}, {"metadata": {}, "cell_type": "markdown", "source": "### 1.1.1 Check  the version of the Streams Python API\nThe `streamsx` package should be at least version 1.13.14.\n\nVerify using the cell below, "}, {"metadata": {}, "cell_type": "code", "source": "!pip show streamsx", "execution_count": 1, "outputs": [{"output_type": "stream", "text": "Name: streamsx\r\nVersion: 1.13.14\r\nSummary: IBM Streams Python Support\r\nHome-page: https://github.com/IBMStreams/pypi.streamsx\r\nAuthor: IBM Streams @ github.com\r\nAuthor-email: debrunne@us.ibm.com\r\nLicense: Apache License - Version 2.0\r\nLocation: /opt/conda/envs/Python36/lib/python3.6/site-packages\r\nRequires: future, requests, dill\r\nRequired-by: \r\n", "name": "stdout"}]}, {"metadata": {}, "cell_type": "markdown", "source": "#### Upgrade if needed\nIf the version is older than 1.13.14,  uncomment the cell below to upgrade the package. You may have to restart the kernel after the upgrade to use the newly installed version."}, {"metadata": {}, "cell_type": "code", "source": "#!pip install --upgrade streamsx ", "execution_count": 2, "outputs": []}, {"metadata": {}, "cell_type": "markdown", "source": "<a id=\"start\"></a>\n### 1.2 (Optional) Start the Streaming Analytics service\n\n<div class=\"alert alert-block alert-success\">You can skip this section and go to step 1.3 if you already set up the Streaming Analytics service, or if you are using IBM Cloud Pak for Data.</div>\n\n\nOpen the IBM Cloud web portal and <a href=\"https://cloud.ibm.com/registration\" target=\"_blank\" rel=\"noopener noreferrer\">log in or sign up for a free IBM Cloud account</a>.\n\nEnsure that your Streaming Analytics service is running in IBM Cloud.\n\n**If you don\u2019t have a service,** you can create one as follows:  \n1. Click **Catalog** or **Create Service**, browse for the `Streaming Analytics` and then click it. <br>\n1. Follow the instructions on the  Streaming Analytics catalog page. You can keep the default name, or type the *Service name* to set up your service.\n\n1. Click **Create** to open the Streaming Analytics service dashboard.<br> Your service starts automatically."}, {"metadata": {}, "cell_type": "markdown", "source": "<a id=\"access\"></a>\n### 1.3 Set up access to the service\n\nTo submit the application for execution, you have to connect to the Streams instance. The application is always the same, but the information required to connect to the instance depends on the target installation of Streams.\n\n- [I'm running the notebook from an IBM Cloud for Data project](#cpd)\n- [I'm using IBM Watson Studio, Jupyter Notebooks, or any other development environment](#notcpd)\n\n    \n"}, {"metadata": {}, "cell_type": "markdown", "source": "\n<a name=\"cpd\"></a>\n\n### 1.3a Connect to a Streams instance from an IBM Cloud Pak for Data  project\n\n1. From the navigation menu, click **My instances**.\n2. Click the **Provisioned Instances** tab.\n3. Update the value of `streams_instance_name` in the cell below according to your Streams instance name\n4. Run the cell and skip to section 1.2\n\nThe cell below defines a function called `submit_topology` that will be used later on to submit the application in [step 5](#build)\n"}, {"metadata": {}, "cell_type": "code", "source": "from icpd_core import icpd_util\nfrom streamsx.topology import context\n\nstreams_instance_name = \"Streaming-Analytics-7z\" ## Change this to Streams instance\ncfg=icpd_util.get_service_instance_details(name=streams_instance_name)\n\ndef submit_topology(topo):\n    global cfg\n    # Disable SSL certificate verification if necessary\n    cfg[context.ConfigParams.SSL_VERIFY] = False\n    # Topology wil be deployed as a distributed app\n    contextType = context.ContextTypes.DISTRIBUTED\n    return context.submit (contextType, topo, config = cfg)", "execution_count": null, "outputs": []}, {"metadata": {}, "cell_type": "markdown", "source": "<a name=\"notcpd\"></a>\n### 1.3b Connect to a Streams instance from IBM Watson Studio and other envrionments\n\n1. Visit the development guide to get <a target=\"blank\" href=\"https://ibmstreams.github.io/streamsx.documentation/docs/python/1.6/python-appapi-devguide-3/#1-set-up-a-connection-to-the-streams-instance\"> connection instructions</a> for Watson Studio.\n\n2. Choose the tab that best matches your environment. Copy the code under the heading **Copy this code snippet**.\n3. Paste it in the cell below.\n\nThe snippet you copy will define a function called `submit_topology` that will be used in on to submit the Streams application once it is created.    \n\n"}, {"metadata": {}, "cell_type": "code", "source": "## Paste snippet from development guide\nfrom streamsx.topology.context import ConfigParams\nfrom streamsx.topology import context\nimport json\nimport getpass\n        \n        \nservice_cfg  = {}\n        \nSA_credentials=getpass.getpass('Streaming Analytics credentials:')\nservice_cfg[ConfigParams.SERVICE_DEFINITION] = json.loads(SA_credentials)\n\ndef submit_topology(topo):\n    global service_cfg\n    service_cfg[context.ConfigParams.SSL_VERIFY] = False\n\n    # This specifies how the application will be deployed\n\n    contextType = context.ContextTypes.STREAMING_ANALYTICS_SERVICE\n\n    return context.submit (contextType, topo, config = service_cfg) ", "execution_count": 5, "outputs": [{"output_type": "stream", "name": "stdout", "text": "Streaming Analytics credentials:\u00b7\u00b7\u00b7\u00b7\u00b7\u00b7\u00b7\u00b7\n"}]}, {"metadata": {}, "cell_type": "markdown", "source": "<a id=\"create_data\"></a>\n## 2. Create a sample data set\n\nRun the following cell to create a sample data set. The x-axis shows the average temperature of an engine over the past two hours, and the y-axis shows the probability that the engine will fail in the next 30 minutes."}, {"metadata": {"scrolled": false}, "cell_type": "code", "source": "%matplotlib inline\n\nimport numpy as np, math\nimport matplotlib.pyplot as plt\nfrom pybrain3.datasets import SupervisedDataSet\nfrom pybrain3.structure import SigmoidLayer, LinearLayer\nfrom pybrain3.tools.shortcuts import buildNetwork\nfrom pybrain3.supervised.trainers import BackpropTrainer\n\n# Create sample dataset\nxvalues = np.linspace(20,100, 100)\nyvalues = np.array([((np.cos((x-50)/100)*100 + np.sin(x/100)*100 + np.random.normal(0, 13, 1)[0])/150.0) for x in xvalues])\nyvalues = [y - np.amin(yvalues) for y in yvalues]\n\nCHART_TITLE = \"Engine Temp Vs. Probability of Failure\"\nX_AXIS_LABEL = \"Engine Temp in Degrees Celsius\"\nY_AXIS_LABEL = \"Probability of Failure\"\n# Plot dataset\ndef create_plot(xvalues, yvalues, title=None, xlabel=None, ylabel=None, xlim=None, ylim=None):\n    fig, ax = plt.subplots()\n    plt.title(CHART_TITLE)\n    plt.ylabel(Y_AXIS_LABEL)\n    plt.xlabel(X_AXIS_LABEL)\n    ax.set_xlim(*xlim)\n    ax.set_ylim(*ylim)\n    ax.plot(xvalues,\n            yvalues, \"ro\", linewidth = 2, color = 'red', label = 'target')\n    return fig,ax\n\ncreate_plot(xvalues, yvalues, title=CHART_TITLE, xlabel = X_AXIS_LABEL, \n            ylabel = Y_AXIS_LABEL, xlim = (20,100), ylim = (0,1))", "execution_count": 4, "outputs": [{"output_type": "execute_result", "execution_count": 4, "data": {"text/plain": "(<Figure size 432x288 with 1 Axes>,\n <matplotlib.axes._subplots.AxesSubplot at 0x7fef4781c198>)"}, "metadata": {}}, {"output_type": "display_data", "data": {"text/plain": "<Figure size 432x288 with 1 Axes>", "image/png": "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\n"}, "metadata": {"needs_background": "light"}}]}, {"metadata": {}, "cell_type": "markdown", "source": "<a id=\"create_model\"></a>\n## 3. Create a model for sample data\n\nYou can now create a model which takes an engine's temperature reading, and provides an approximate probability of failure. To create this model, use the PyBrain library which trains a feedforward neural network (FFN) to predict failure probability of the engine. \n\nRun the following cell to see the model improving itself interactively. The blue line shows the model's fit to the data."}, {"metadata": {"scrolled": false}, "cell_type": "code", "source": "# The neural net to be trained\nnet = buildNetwork(1,100,100,100,1, bias = True, hiddenclass = SigmoidLayer, outclass = LinearLayer)\n\n# Construct a data set of the training data\nds = SupervisedDataSet(1, 1)\nfor x, y in zip(xvalues, yvalues):\n    ds.addSample((x,), (y,))\n\n# The training harness. Used to train the model.\ntrainer = BackpropTrainer(net, ds, learningrate = 0.0001, momentum=0, verbose = False, batchlearning=False)\n\n# Train the model. Display the model in the plot on each iteration.\nfig, ax = create_plot(xvalues, yvalues, title=CHART_TITLE, xlabel = X_AXIS_LABEL ,\n            ylabel = Y_AXIS_LABEL, xlim = (20,100), ylim = (0,1))\n\nax.plot(xvalues, [net.activate([x]) for x in xvalues], linewidth = 2, color = 'blue', label = 'NN output')\n\nfor i in range(50):\n    trainer.train()\n    new_yvalues = [net.activate([x]) for x in xvalues]\n    ax.lines[1].set_ydata(new_yvalues)\n    fig.canvas.draw()   ", "execution_count": 6, "outputs": [{"output_type": "display_data", "data": {"text/plain": "<Figure size 432x288 with 1 Axes>", "image/png": "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\n"}, "metadata": {"needs_background": "light"}}]}, {"metadata": {}, "cell_type": "markdown", "source": "<a id=\"use_model\"></a>\n## 4. Use the model in a real-time streaming application\n\nIn the above cell, you trained a model to predict failure given a temperature reading. This model is represented as a Python object called `net`.\n\nNow, you can score the model in real time using the streamsx.topology Python API.\n\nFirst, define two classes that will create and score the streaming data. These classes will be used in the next section when we create the streaming application.\n\n\nThe `periodicSource` class simulate sample temperature readings by submitting a random number between 20 and 100 every 0.1 seconds. \n\nThe `neural_net_model` class scores the model on each data item, or tuple in the stream produced by the `periodicSource` class.\nIt feeds each tuple it receives to the neural net, and returns the output from the neural net onto a stream.\n\n"}, {"metadata": {}, "cell_type": "code", "source": "# The source of our data. Every 0.1 seconds, a number between 20-100 will be inserted into the stream\n# INPUT: None\n# OUTPUT: A float with range [20,100]\nclass periodicSource(object):\n    def __call__(self):\n        while True:\n            time.sleep(0.1)\n            yield random.uniform(20,100)\n\n# A class which runs the neural net on data it is passed.\n# INPUT: the input to the neural net, in this case a floating point number\n# OUTPUT: an array containing the output of the neural net, as well as the input to the neural net.\nclass neural_net_model(object):\n    def __init__(self, net):\n        self.my_net = net\n    def __call__(self, num):\n        return dict(temp=num, probability=self.my_net.activate([num])[0])", "execution_count": 7, "outputs": []}, {"metadata": {}, "cell_type": "markdown", "source": "<a id=\"build\"></a>\n## 5. Define and submit the streaming application\n\n\nWe want to create an application that will use the PyBrain model we just created to score a stream of temperature readings. For each incoming temperature reading, it will produce a probability of engine failure at that temperature.\n\n\nHere is the graph of the application we want to create:\n<img src='https://developer.ibm.com/streamsdev/wp-content/uploads/sites/15/2019/10/PyBrainPredictions.png'/>\n\n\n<h2>How it works</h2>\n\nThe preceeding graph represents our Streams application, which is also called a `Topology`. \n\nEach node in the graph is a transform that processes and/or produces data. The arrows between each node are [`Streams`](https://streamsxtopology.readthedocs.io/en/stable/streamsx.topology.topology.html#stream). \n\nA `Stream` is a potentially infinite sequence of data to analyze.\n\n- The **`Source`** transform produces a `Stream` uses the  `periodicSource` class to produce a `Stream` of temperature readings.\n\n\n- The **`ScoreModel`** transform uses the `neural_net_model` class to score the model on the stream of temperature readings. It produces a new `Stream` that contains the probability of failure calculations. \n\n\n- The **`print`** transform prints the results to the console, while the **`PublishPredictions`**  publishes the results so [other Streams applications can access it](https://streamsxtopology.readthedocs.io/en/stable/streamsx.topology.html#microservices).  \n\n\n- Each tuple on the `Stream` has the format `{'temp': 46.21446887679611, 'probability': 0.3277399741231406}`.\n\n\n- A [`View`](https://streamsxtopology.readthedocs.io/en/stable/streamsx.topology.topology.html#streamsx.topology.topology.View) of the results stream is also is created to access the contents of the `probability_stream` from this notebook or any other application.\n\n\nFinally, you run the application using the `submit_topology` function we defined earlier.  It will be submitted to the Streams instance you specified.\n\n\n"}, {"metadata": {"scrolled": true}, "cell_type": "code", "source": "from streamsx.topology import topology, context\nimport random\nimport json \nimport time\n\n# Define operator\nperiodic_src = periodicSource()\nmodel_scorer = neural_net_model(net)\n\n# Build Graph\ntopo = topology.Topology(\"EngineFailurePrediction\")\n\ninputStream = topo.source(periodic_src, name=\"inputStream\")\n\n#score the model on the input stream, using Stream.map() and the neural_net_model class\n# this creates a new stream of results called probability_stream\n\nprobability_stream = inputStream.map(model_scorer, name=\"ScoreModel\")\n\n#Various ways to use the stream: \n#1. Print the results to stdout\n\nprobability_stream.print()\n\n\n#2.publish it so that other Streams applications can connect to it\nprobability_stream.publish(topic=\"PublishPredictions\", name=\"PublishPredictions\") \n\n# 3.create a view so that we can analyze the data right in the notebook\nview = probability_stream.view(name=\"Predictions\")\n\n# Next steps, comment out these lines for more examples\n#  \n# 4. Filter out only those tuples with a high probablity of failure and print the results to stdout\nfailure_likely = probability_stream.filter(lambda x: x['probability'] > 75)\nfailure_likely.print()\n\n# 5. Visualize only those temperatures that will fail soon \nview = failure_likely.view()\n\ntopo.add_pip_package(\"pybrain3\")\ntopo.add_pip_package(\"structure\")\n\n#Submit\nprint(\"Submitting Topology to Streams for execution..\")\nsubmission_result = submit_topology(topo)\n\nif submission_result.job:\n    streams_job = submission_result.job\n    print (\"JobId: \", streams_job.id , \"\\nJob name: \", streams_job.name)\nelse:\n    print(\"Submission failed: \"   + str(submssion_result))\n", "execution_count": 10, "outputs": [{"output_type": "stream", "text": "2019-12-23 13:06:02,417 - __PROJECT_LIB__ - ERROR - ProjectHandle: Project ID neither provided nor found in the environment.\nERROR:__PROJECT_LIB__:ProjectHandle: Project ID neither provided nor found in the environment.\n", "name": "stderr"}, {"output_type": "stream", "text": "Submitting Topology to Streams for execution..\n", "name": "stdout"}, {"output_type": "display_data", "data": {"text/plain": "IntProgress(value=0, bar_style='info', description='Initializing', max=10, style=ProgressStyle(description_wid\u2026", "application/vnd.jupyter.widget-view+json": {"version_major": 2, "version_minor": 0, "model_id": "b11fe2ea7c17449bb9dbfc2a93f4a306"}}, "metadata": {}}, {"output_type": "stream", "text": "JobId:  1 \nJob name:  notebook::EngineFailurePrediction_1\n", "name": "stdout"}]}, {"metadata": {}, "cell_type": "markdown", "source": "<a id=\"visualize\"></a>\n## 6. View the streaming data\n\nYou can now visualize the model in Jupyter by calling the `start_data_fetch` method of the view. This method opens a connection to the running Streams application so that we can retrieve the stream of results from the view.\n\nThe result stream is used to create a graph plotting the engine temperatures to its probability of failure as predicted by the model.\n\nAfter running this cell, you should see output like this:\n<img src=\"https://developer.ibm.com/streamsdev/wp-content/uploads/sites/15/2019/11/engine-failure.gif\" alt=\"graph updating\"></img>"}, {"metadata": {}, "cell_type": "code", "source": "%matplotlib notebook\n\n\n    \ntry:\n    queue = view.start_data_fetch()\n    fig, ax = create_plot([], [], title=CHART_TITLE, xlabel = X_AXIS_LABEL, \n            ylabel = Y_AXIS_LABEL, xlim = (20,100), ylim = (0,1))\n    xdata = []\n    ydata = []\n    for i in range(100):\n            line = queue.get()\n            xdata.append(line[\"temp\"])\n            ydata.append(float(line[\"probability\"]))\n            ax.lines[0].set_xdata(xdata)\n            ax.lines[0].set_ydata(ydata)\n            fig.canvas.draw()\nexcept:\n    raise\nfinally:\n    view.stop_data_fetch()\n    print(\"Done updating graph\")", "execution_count": null, "outputs": [{"output_type": "display_data", "data": {"text/plain": "<IPython.core.display.Javascript object>", "application/javascript": "/* Put everything inside the global mpl namespace */\nwindow.mpl = {};\n\n\nmpl.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('Your browser does not have WebSocket support.' +\n              'Please try Chrome, Safari or Firefox \u2265 6. ' +\n              'Firefox 4 and 5 are also supported but you ' +\n              'have to enable WebSockets in about:config.');\n    };\n}\n\nmpl.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 = $('<div/>');\n    this._root_extra_style(this.root)\n    this.root.attr('style', 'display: inline-block');\n\n    $(parent_element).append(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 (mpl.ratio != 1) {\n                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\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\nmpl.figure.prototype._init_header = function() {\n    var titlebar = $(\n        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n        'ui-helper-clearfix\"/>');\n    var titletext = $(\n        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n        'text-align: center; padding: 3px;\"/>');\n    titlebar.append(titletext)\n    this.root.append(titlebar);\n    this.header = titletext[0];\n}\n\n\n\nmpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n\n}\n\n\nmpl.figure.prototype._root_extra_style = function(canvas_div) {\n\n}\n\nmpl.figure.prototype._init_canvas = function() {\n    var fig = this;\n\n    var canvas_div = $('<div/>');\n\n    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n\n    function canvas_keyboard_event(event) {\n        return fig.key_event(event, event['data']);\n    }\n\n    canvas_div.keydown('key_press', canvas_keyboard_event);\n    canvas_div.keyup('key_release', canvas_keyboard_event);\n    this.canvas_div = canvas_div\n    this._canvas_extra_style(canvas_div)\n    this.root.append(canvas_div);\n\n    var canvas = $('<canvas/>');\n    canvas.addClass('mpl-canvas');\n    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n\n    this.canvas = canvas[0];\n    this.context = canvas[0].getContext(\"2d\");\n\n    var backingStore = this.context.backingStorePixelRatio ||\n\tthis.context.webkitBackingStorePixelRatio ||\n\tthis.context.mozBackingStorePixelRatio ||\n\tthis.context.msBackingStorePixelRatio ||\n\tthis.context.oBackingStorePixelRatio ||\n\tthis.context.backingStorePixelRatio || 1;\n\n    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n\n    var rubberband = $('<canvas/>');\n    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n\n    var pass_mouse_events = true;\n\n    canvas_div.resizable({\n        start: function(event, ui) {\n            pass_mouse_events = false;\n        },\n        resize: function(event, ui) {\n            fig.request_resize(ui.size.width, ui.size.height);\n        },\n        stop: function(event, ui) {\n            pass_mouse_events = true;\n            fig.request_resize(ui.size.width, ui.size.height);\n        },\n    });\n\n    function mouse_event_fn(event) {\n        if (pass_mouse_events)\n            return fig.mouse_event(event, event['data']);\n    }\n\n    rubberband.mousedown('button_press', mouse_event_fn);\n    rubberband.mouseup('button_release', mouse_event_fn);\n    // Throttle sequential mouse events to 1 every 20ms.\n    rubberband.mousemove('motion_notify', mouse_event_fn);\n\n    rubberband.mouseenter('figure_enter', mouse_event_fn);\n    rubberband.mouseleave('figure_leave', mouse_event_fn);\n\n    canvas_div.on(\"wheel\", function (event) {\n        event = event.originalEvent;\n        event['data'] = 'scroll'\n        if (event.deltaY < 0) {\n            event.step = 1;\n        } else {\n            event.step = -1;\n        }\n        mouse_event_fn(event);\n    });\n\n    canvas_div.append(canvas);\n    canvas_div.append(rubberband);\n\n    this.rubberband = rubberband;\n    this.rubberband_canvas = rubberband[0];\n    this.rubberband_context = rubberband[0].getContext(\"2d\");\n    this.rubberband_context.strokeStyle = \"#000000\";\n\n    this._resize_canvas = function(width, height) {\n        // Keep the size of the canvas, canvas container, and rubber band\n        // canvas in synch.\n        canvas_div.css('width', width)\n        canvas_div.css('height', height)\n\n        canvas.attr('width', width * mpl.ratio);\n        canvas.attr('height', height * mpl.ratio);\n        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n\n        rubberband.attr('width', width);\n        rubberband.attr('height', height);\n    }\n\n    // Set the figure to an initial 600x600px, this will subsequently be updated\n    // upon first draw.\n    this._resize_canvas(600, 600);\n\n    // Disable right mouse context menu.\n    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\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\nmpl.figure.prototype._init_toolbar = function() {\n    var fig = this;\n\n    var nav_element = $('<div/>')\n    nav_element.attr('style', 'width: 100%');\n    this.root.append(nav_element);\n\n    // Define a callback function for later on.\n    function toolbar_event(event) {\n        return fig.toolbar_button_onclick(event['data']);\n    }\n    function toolbar_mouse_event(event) {\n        return fig.toolbar_button_onmouseover(event['data']);\n    }\n\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            // put a spacer in here.\n            continue;\n        }\n        var button = $('<button/>');\n        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n                        'ui-button-icon-only');\n        button.attr('role', 'button');\n        button.attr('aria-disabled', 'false');\n        button.click(method_name, toolbar_event);\n        button.mouseover(tooltip, toolbar_mouse_event);\n\n        var icon_img = $('<span/>');\n        icon_img.addClass('ui-button-icon-primary ui-icon');\n        icon_img.addClass(image);\n        icon_img.addClass('ui-corner-all');\n\n        var tooltip_span = $('<span/>');\n        tooltip_span.addClass('ui-button-text');\n        tooltip_span.html(tooltip);\n\n        button.append(icon_img);\n        button.append(tooltip_span);\n\n        nav_element.append(button);\n    }\n\n    var fmt_picker_span = $('<span/>');\n\n    var fmt_picker = $('<select/>');\n    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n    fmt_picker_span.append(fmt_picker);\n    nav_element.append(fmt_picker_span);\n    this.format_dropdown = fmt_picker[0];\n\n    for (var ind in mpl.extensions) {\n        var fmt = mpl.extensions[ind];\n        var option = $(\n            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n        fmt_picker.append(option)\n    }\n\n    // Add hover states to the ui-buttons\n    $( \".ui-button\" ).hover(\n        function() { $(this).addClass(\"ui-state-hover\");},\n        function() { $(this).removeClass(\"ui-state-hover\");}\n    );\n\n    var status_bar = $('<span class=\"mpl-message\"/>');\n    nav_element.append(status_bar);\n    this.message = status_bar[0];\n}\n\nmpl.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\nmpl.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\nmpl.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\nmpl.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\nmpl.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]);\n        fig.send_message(\"refresh\", {});\n    };\n}\n\nmpl.figure.prototype.handle_rubberband = function(fig, msg) {\n    var x0 = msg['x0'] / mpl.ratio;\n    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n    var x1 = msg['x1'] / mpl.ratio;\n    var y1 = (fig.canvas.height - msg['y1']) / mpl.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, 0, fig.canvas.width, fig.canvas.height);\n\n    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n}\n\nmpl.figure.prototype.handle_figure_label = function(fig, msg) {\n    // Updates the figure title.\n    fig.header.textContent = msg['label'];\n}\n\nmpl.figure.prototype.handle_cursor = function(fig, msg) {\n    var cursor = msg['cursor'];\n    switch(cursor)\n    {\n    case 0:\n        cursor = 'pointer';\n        break;\n    case 1:\n        cursor = 'default';\n        break;\n    case 2:\n        cursor = 'crosshair';\n        break;\n    case 3:\n        cursor = 'move';\n        break;\n    }\n    fig.rubberband_canvas.style.cursor = cursor;\n}\n\nmpl.figure.prototype.handle_message = function(fig, msg) {\n    fig.message.textContent = msg['message'];\n}\n\nmpl.figure.prototype.handle_draw = function(fig, msg) {\n    // Request the server to send over a new figure.\n    fig.send_draw_message();\n}\n\nmpl.figure.prototype.handle_image_mode = function(fig, msg) {\n    fig.image_mode = msg['mode'];\n}\n\nmpl.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.\nmpl.figure.prototype._make_on_message_function = function(fig) {\n    return function socket_on_message(evt) {\n        if (evt.data instanceof Blob) {\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            evt.data.type = \"image/png\";\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            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n                evt.data);\n            fig.updated_canvas_event();\n            fig.waiting = false;\n            return;\n        }\n        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\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(\"No handler for the '\" + msg_type + \"' message type: \", msg);\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(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n            }\n        }\n    };\n}\n\n// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\nmpl.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    if (e.target)\n        targ = e.target;\n    else if (e.srcElement)\n        targ = e.srcElement;\n    if (targ.nodeType == 3) // defeat Safari bug\n        targ = targ.parentNode;\n\n    // jQuery normalizes the pageX and pageY\n    // pageX,Y are the mouse positions relative to the document\n    // offset() returns the position of the element relative to the document\n    var x = e.pageX - $(targ).offset().left;\n    var y = e.pageY - $(targ).offset().top;\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 * http://stackoverflow.com/a/24161582/3208463\n */\nfunction simpleKeys (original) {\n  return Object.keys(original).reduce(function (obj, key) {\n    if (typeof original[key] !== 'object')\n        obj[key] = original[key]\n    return obj;\n  }, {});\n}\n\nmpl.figure.prototype.mouse_event = function(event, name) {\n    var canvas_pos = mpl.findpos(event)\n\n    if (name === 'button_press')\n    {\n        this.canvas.focus();\n        this.canvas_div.focus();\n    }\n\n    var x = canvas_pos.x * mpl.ratio;\n    var y = canvas_pos.y * mpl.ratio;\n\n    this.send_message(name, {x: x, y: y, button: event.button,\n                             step: event.step,\n                             guiEvent: simpleKeys(event)});\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\nmpl.figure.prototype._key_event_extra = function(event, name) {\n    // Handle any extra behaviour associated with a key event\n}\n\nmpl.figure.prototype.key_event = function(event, name) {\n\n    // Prevent repeat events\n    if (name == 'key_press')\n    {\n        if (event.which === this._key)\n            return;\n        else\n            this._key = event.which;\n    }\n    if (name == 'key_release')\n        this._key = null;\n\n    var value = '';\n    if (event.ctrlKey && event.which != 17)\n        value += \"ctrl+\";\n    if (event.altKey && event.which != 18)\n        value += \"alt+\";\n    if (event.shiftKey && event.which != 16)\n        value += \"shift+\";\n\n    value += 'k';\n    value += event.which.toString();\n\n    this._key_event_extra(event, name);\n\n    this.send_message(name, {key: value,\n                             guiEvent: simpleKeys(event)});\n    return false;\n}\n\nmpl.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\nmpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n    this.message.textContent = tooltip;\n};\nmpl.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\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n\nmpl.default_extension = \"png\";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.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        // Pass the mpl event to the overridden (by mpl) onmessage function.\n        ws.onmessage(msg['content']['data'])\n    });\n    return ws;\n}\n\nmpl.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 = $(\"#\" + id);\n    var ws_proxy = comm_websocket_adapter(comm)\n\n    function ondownload(figure, format) {\n        window.open(figure.imageObj.src);\n    }\n\n    var fig = new mpl.figure(id, ws_proxy,\n                           ondownload,\n                           element.get(0));\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.get(0);\n    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n    if (!fig.cell_info) {\n        console.error(\"Failed to find cell for figure\", id, fig);\n        return;\n    }\n\n    var output_index = fig.cell_info[2]\n    var cell = fig.cell_info[0];\n\n};\n\nmpl.figure.prototype.handle_close = function(fig, msg) {\n    var width = fig.canvas.width/mpl.ratio\n    fig.root.unbind('remove')\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).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n    fig.close_ws(fig, msg);\n}\n\nmpl.figure.prototype.close_ws = function(fig, msg){\n    fig.send_message('closing', msg);\n    // fig.ws.close()\n}\n\nmpl.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/mpl.ratio\n    var dataURL = this.canvas.toDataURL();\n    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n}\n\nmpl.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 () { fig.push_to_output() }, 1000);\n}\n\nmpl.figure.prototype._init_toolbar = function() {\n    var fig = this;\n\n    var nav_element = $('<div/>')\n    nav_element.attr('style', 'width: 100%');\n    this.root.append(nav_element);\n\n    // Define a callback function for later on.\n    function toolbar_event(event) {\n        return fig.toolbar_button_onclick(event['data']);\n    }\n    function toolbar_mouse_event(event) {\n        return fig.toolbar_button_onmouseover(event['data']);\n    }\n\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) { continue; };\n\n        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n        button.click(method_name, toolbar_event);\n        button.mouseover(tooltip, toolbar_mouse_event);\n        nav_element.append(button);\n    }\n\n    // Add the status bar.\n    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n    nav_element.append(status_bar);\n    this.message = status_bar[0];\n\n    // Add the close button to the window.\n    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n    button.click(function (evt) { fig.handle_close(fig, {}); } );\n    button.mouseover('Stop Interaction', toolbar_mouse_event);\n    buttongrp.append(button);\n    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n    titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n    var fig = this\n    el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n    });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n    // this is important to make the div 'focusable\n    el.attr('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    }\n    else {\n        // location in version 2\n        IPython.keyboard_manager.register_events(el);\n    }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n    var manager = IPython.notebook.keyboard_manager;\n    if (!manager)\n        manager = IPython.keyboard_manager;\n\n    // Check for shift+enter\n    if (event.shiftKey && event.which == 13) {\n        this.canvas_div.blur();\n        event.shiftKey = false;\n        // Send a \"J\" for go to next cell\n        event.which = 74;\n        event.keyCode = 74;\n        manager.command_mode();\n        manager.handle_keydown(event);\n    }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n    fig.ondownload(fig, null);\n}\n\n\nmpl.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.\nif (IPython.notebook.kernel != null) {\n    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n"}, "metadata": {}}, {"output_type": "display_data", "data": {"text/plain": "<IPython.core.display.HTML object>", "text/html": "<div id='f16eede6-3c82-4889-ae89-2b4cd48254a0'></div>"}, "metadata": {}}]}, {"metadata": {}, "cell_type": "markdown", "source": "## 6.1 (Optional) Manage the running job\nIf you have a problem, or if you would like to view job logs and metrics, open the Streams Console. This information is also available in the Job Graph in IBM Cloud Pak for Data.\n\nThe steps to access the Console depend on your Streams instance.\n[See the development guide for details](http://ibmstreams.github.io/streamsx.documentation/docs/python/1.6/python-appapi-devguide-3/#42-see-job-status).\n\n## 6.1 Stop the running job\nThe Streams job will run indefinitely until it is cancelled.\nUse `submission_result.job.cancel()` to cancel it."}, {"metadata": {}, "cell_type": "code", "source": "if submission_result.job.cancel():\n    print(\"Cancelled job\")\n", "execution_count": null, "outputs": []}, {"metadata": {"collapsed": true}, "cell_type": "markdown", "source": "<a id=\"summary\"></a>\n## 7. Summary and next steps\n\nYou learned how to create a sample data set, create a model for the sample data, and use that data model in a streaming application. You also learned how to visualize the streaming data, and then submit the streaming application to the Streaming Analytics service on IBM Cloud. \n\n\n\n\n- Try the <a href=\"https://github.com/IBMStreams/sample.starter_notebooks/blob/master/Streams-RollingAverageSample.ipynb\" target=\"_blank\" rel=\"noopener noreferrer\">Rolling average sample notebook</a> to see other features of the Streams Python API.\n- Visit the <a href=\"https://github.com/IBMStreams/sample.starter_notebooks/\">sample notebooks repository on GitHub</a> for more samples.\n\n### Dig deeper:\n - <a href=\"http://ibmstreams.github.io/streamsx.documentation/docs/latest/python/python-appapi-devguide/#developing-ibm-streams-applications-with-python\" target=\"_blank\" rel=\"noopener noreferrer\">Developing IBM Streams applications with Python</a>\n - <a href=\"https://www.ibm.com/support/knowledgecenter/SSCRJU/SSCRJU_welcome.html\" target=\"_blank\" rel=\"noopener noreferrer\">IBM Streams documentation</a> \n \n### Authors\n Will Marshall is a software developer who specializes in streaming technology and cloud solutions. \n "}, {"metadata": {"collapsed": true}, "cell_type": "markdown", "source": "Copyright \u00a9 2017-2019 IBM. This notebook and its source code are released under the terms of the MIT License."}, {"metadata": {}, "cell_type": "markdown", "source": "<div style=\"background:#F5F7FA; height:110px; padding: 2em; font-size:14px;\">\n<span style=\"font-size:18px;color:#152935;\">Love this notebook? </span>\n<span style=\"font-size:15px;color:#152935;float:right;margin-right:40px;\">Don't have an account yet?</span><br>\n<span style=\"color:#5A6872;\">Share it with your colleagues and help them discover the power of Watson Studio!</span>\n<span style=\"border: 1px solid #3d70b2;padding:8px;float:right;margin-right:40px; color:#3d70b2;\"><a href=\"https://ibm.co/wsnotebooks\" target=\"_blank\" style=\"color: #3d70b2;text-decoration: none;\">Sign Up</a></span><br>\n</div>"}], "metadata": {"anaconda-cloud": {}, "kernelspec": {"name": "python3", "display_name": "Python 3.6", "language": "python"}, "language_info": {"name": "python", "version": "3.6.8", "mimetype": "text/x-python", "codemirror_mode": {"name": "ipython", "version": 3}, "pygments_lexer": "ipython3", "nbconvert_exporter": "python", "file_extension": ".py"}}, "nbformat": 4, "nbformat_minor": 1}