heartpredictor.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><h1> Predict heart failure with Watson Machine Learning</h1></center>\n",
    "![alt text](https://www.cdc.gov/dhdsp/images/heart_failure.jpg \"Heart failure\")\n",
    "<p>This notebook contains steps and code to create a predictive model to predict heart failure and then deploy that model to Watson Machine Learning so it can be used in an application.</p>\n",
    "## Learning Goals\n",
    "The learning goals of this notebook are:\n",
    "* Load a CSV file into the  Object Storage Service linked to your Data Science Experience \n",
    "* Create an Apache® Spark machine learning model\n",
    "* Train and evaluate a model\n",
    "* Persist a model in a Watson Machine Learning repository\n",
    "\n",
    "## 1. Setup\n",
    "\n",
    "Before you use the sample code in this notebook, you must perform the following setup tasks:\n",
    "* Create a Watson Machine Learning Service instance (a free plan is offered) and associate it with your project\n",
    "* Upload heart failure  data to the Object Store service that is part of your data Science Experience trial\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Load and explore data\n",
    "<p>In this section you will load the data as an Apache® Spark DataFrame and perform a basic exploration.</p>\n",
    "\n",
    "<p>Load the data to the Spark DataFrame from your associated Object Storage instance.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# insert SparkSession Data frame\n",
    "# add .option('inferSchema','True')\\\n",
    "import ibmos2spark\n",
    "\n",
    "# @hidden_cell\n",
    "credentials = {\n",
    "    'auth_url': 'https://identity.open.softlayer.com',\n",
    "    'project_id': '252f58cc9be54ba881761ce04f935c2f',\n",
    "    'region': 'dallas',\n",
    "    'user_id': '444acfc66d804d14a8506ccaeb1c5181',\n",
    "    'username': 'member_0c304d3186672732988603034c6aa019f1de7c2e',\n",
    "    'password': 'rdl.IbW=B1{fffq1'\n",
    "}\n",
    "\n",
    "configuration_name = 'os_e2badca4b014407683e2cfc0b1de8ce5_configs'\n",
    "bmos = ibmos2spark.bluemix(sc, credentials, configuration_name)\n",
    "\n",
    "from pyspark.sql import SparkSession\n",
    "spark = SparkSession.builder.getOrCreate()\n",
    "df_data = spark.read\\\n",
    "  .format('org.apache.spark.sql.execution.datasources.csv.CSVFileFormat')\\\n",
    "  .option('header', 'true')\\\n",
    "  .option('inferSchema','True')\\\n",
    "  .load(bmos.url('Airpay', 'patientdataV6.csv'))\n",
    "df_data.take(5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explore the loaded data by using the following Apache® Spark DataFrame methods:\n",
    "* print schema\n",
    "* print top ten records\n",
    "* count all records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df_data.printSchema()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the data contains ten  fields. The  HEARTFAILURE field is the one we would like to predict (label)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "df_data.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df_data.describe().show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df_data.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the data set contains 10800 records."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Interactive Visualizations w/PixieDust"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# To confirm you have the latest version of PixieDust on your system, run this cell\n",
    "!pip install --user pixiedust==1.1.2\n",
    "!pip install scikit-learn==0.18"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If indicated by the installer, restart the kernel and rerun the notebook until here and continue with the workshop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import pixiedust"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple visualization using bar charts\n",
    "With PixieDust display(), you can visually explore the loaded data using built-in charts, such as, bar charts, line charts, scatter plots, or maps.\n",
    "To explore a data set: choose the desired chart type from the drop down, configure chart options, configure display options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pixiedust": {
     "displayParams": {
      "aggregation": "AVG",
      "chartsize": "78",
      "handlerId": "scatterPlot",
      "keyFields": "AGE",
      "kind": "kde",
      "mpld3": "false",
      "rendererId": "seaborn",
      "rowCount": "500",
      "title": "Explore",
      "valueFields": "BMI"
     }
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "display(df_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Create an Apache® Spark machine learning model\n",
    "In this section you will learn how to prepare data, create and train an Apache® Spark machine learning model.\n",
    "\n",
    "### 4.1: Prepare data\n",
    "In this subsection you will split your data into: train and  test  data sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "split_data = df_data.randomSplit([0.8, 0.20], 24)\n",
    "train_data = split_data[0]\n",
    "test_data = split_data[1]\n",
    "\n",
    "\n",
    "print \"Number of training records: \" + str(train_data.count())\n",
    "print \"Number of testing records : \" + str(test_data.count())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see our data has been successfully split into two data sets:\n",
    "* The train data set, which is the largest group, is used for training.\n",
    "* The test data set will be used for model evaluation and is used to test the assumptions of the model.\n",
    "\n",
    "### 4.2: Create pipeline and train a model\n",
    "In this section you will create an Apache® Spark machine learning pipeline and then train the model.\n",
    "In the first step you need to import the Apache® Spark machine learning packages that will be needed in the subsequent steps.\n",
    "\n",
    "A sequence of data processing is called a _data pipeline_.  Each step in the pipeline processes the data and passes the result to the next step in the pipeline, this allows you to transform and fit your model with the raw input data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from pyspark.ml.feature import StringIndexer, IndexToString, VectorAssembler\n",
    "from pyspark.ml.classification import RandomForestClassifier\n",
    "from pyspark.ml.evaluation import MulticlassClassificationEvaluator\n",
    "from pyspark.ml import Pipeline, Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following step, convert all the string fields to numeric ones by using the StringIndexer transformer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "stringIndexer_label = StringIndexer(inputCol=\"HEARTFAILURE\", outputCol=\"label\").fit(df_data)\n",
    "stringIndexer_sex = StringIndexer(inputCol=\"SEX\", outputCol=\"SEX_IX\")\n",
    "stringIndexer_famhist = StringIndexer(inputCol=\"FAMILYHISTORY\", outputCol=\"FAMILYHISTORY_IX\")\n",
    "stringIndexer_smoker = StringIndexer(inputCol=\"SMOKERLAST5YRS\", outputCol=\"SMOKERLAST5YRS_IX\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "In the following step, create a feature vector by combining all features together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "vectorAssembler_features = VectorAssembler(inputCols=[\"AVGHEARTBEATSPERMIN\",\"PALPITATIONSPERDAY\",\"CHOLESTEROL\",\"BMI\",\"AGE\",\"SEX_IX\",\"FAMILYHISTORY_IX\",\"SMOKERLAST5YRS_IX\",\"EXERCISEMINPERWEEK\"], outputCol=\"features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, define estimators you want to use for classification. Random Forest is used in the following example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "rf = RandomForestClassifier(labelCol=\"label\", featuresCol=\"features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, indexed labels back to original labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "labelConverter = IndexToString(inputCol=\"prediction\", outputCol=\"predictedLabel\", labels=stringIndexer_label.labels)\n",
    "print (df_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "transform_df_pipeline = Pipeline(stages=[stringIndexer_label, stringIndexer_sex, stringIndexer_famhist, stringIndexer_smoker, vectorAssembler_features])\n",
    "transformed_df = transform_df_pipeline.fit(df_data).transform(df_data)\n",
    "transformed_df.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's build the pipeline now. A pipeline consists of transformers and an estimator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pipeline_rf = Pipeline(stages=[stringIndexer_label, stringIndexer_sex, stringIndexer_famhist, stringIndexer_smoker, vectorAssembler_features, rf, labelConverter])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you can train your Random Forest model by using the previously defined **pipeline** and **training data**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model_rf = pipeline_rf.fit(train_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check your **model accuracy** now. To evaluate the model, use **test data**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "predictions = model_rf.transform(test_data)\n",
    "evaluatorRF = MulticlassClassificationEvaluator(labelCol=\"label\", predictionCol=\"prediction\", metricName=\"accuracy\")\n",
    "accuracy = evaluatorRF.evaluate(predictions)\n",
    "print(\"Accuracy = %g\" % accuracy)\n",
    "print(\"Test Error = %g\" % (1.0 - accuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can tune your model now to achieve better accuracy. For simplicity of this example tuning section is omitted.\n",
    "## 5. Persist model\n",
    "In this section you will learn how to store your pipeline and model in Watson Machine Learning repository by using Python client libraries.\n",
    "First, you must import client libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from repository.mlrepositoryclient import MLRepositoryClient\n",
    "from repository.mlrepositoryartifact import MLRepositoryArtifact"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Authenticate to Watson Machine Learning service on IBM Cloud.\n",
    "\n",
    "## **STOP here !!!!:** \n",
    "Put authentication information (username and password)  from your instance of Watson Machine Learning service here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "wml_url = 'https://ibm-watson-ml.mybluemix.net'\n",
    "username = 'c976ddb2-943d-4ca8-92f0-7cfd34d8e56f'\n",
    "password = '44436bbd-f730-43cd-8e68-2a5f52b53f8f'\n",
    "instance_id= \"c2822f68-9e0c-40bd-a837-a0f86248bd57\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tip:** service_path, username and password can be found on Service Credentials tab of the Watson Machine Learning service instance created on the IBM Cloud."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ml_repository_client = MLRepositoryClient(wml_url)\n",
    "ml_repository_client.authorize(username, password)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create model artifact (abstraction layer)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pipeline_artifact = MLRepositoryArtifact(pipeline_rf, name=\"pipeline\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model_artifact = MLRepositoryArtifact(model_rf, training_data=train_data, name=\"Heart Failure Prediction Model\", pipeline_artifact=pipeline_artifact)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tip:** The MLRepositoryArtifact method expects a trained model object, training data, and a model name. (It is this model name that is displayed by the Watson Machine Learning service).\n",
    "## 5.1: Save pipeline and model¶\n",
    "In this subsection you will learn how to save pipeline and model artifacts to your Watson Machine Learning instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "saved_model = ml_repository_client.models.save(model_artifact)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get saved model metadata from Watson Machine Learning.\n",
    "**Tip:** Use *meta.availableProps* to get the list of available props."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "saved_model.meta.available_props()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print \"modelType: \" + saved_model.meta.prop(\"modelType\")\n",
    "print \"trainingDataSchema: \" + str(saved_model.meta.prop(\"trainingDataSchema\"))\n",
    "print \"creationTime: \" + str(saved_model.meta.prop(\"creationTime\"))\n",
    "print \"modelVersionHref: \" + saved_model.meta.prop(\"modelVersionHref\")\n",
    "print \"label: \" + saved_model.meta.prop(\"label\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 5.2 Load model to verify that it was saved correctly\n",
    "You can load your model  to make sure that it was saved  correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "loadedModelArtifact = ml_repository_client.models.get(saved_model.uid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print the  model name to make sure that model artifact has been loaded correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print str(loadedModelArtifact.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations. You've sucessfully created a predictive model and saved it in the Watson Machine Learning service. You can now switch to the Watson Machine Learning console to deploy the model and then test it in application.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.0 Accessing Watson ML Models and Deployments through API\n",
    "Instead of jumping from your notebook into a web browser manage your model and delopyment through a set of APIs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recap of deploying an existing ML model through using a Python SDK\n",
    "\n",
    "\n",
    "`pip install watson-machine-learning-client`\n",
    "\n",
    "[SDK Documentation](https://watson-ml-staging-libs.mybluemix.net/repository-python/index.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.1 Get the Watson ML API Token\n",
    "The Watson ML API authenticates all requests through a token, start by requesting the token from our Watson ML Service."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import json\n",
    "import requests\n",
    "from base64 import b64encode\n",
    "\n",
    "token_url = wml_url + \"/v3/identity/token\"\n",
    "\n",
    "headers = {'authorization': \"Basic {}\".format(b64encode(username + \":\" + password).decode(\"ascii\"))}\n",
    "\n",
    "response = requests.request(\"GET\", token_url, headers=headers)\n",
    "\n",
    "watson_ml_token = json.loads(response.text)['token']\n",
    "print(watson_ml_token)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2 Preview currenly published models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "model_url = wml_url + \"/v3/wml_instances/\" + instance_id + \"/published_models\"\n",
    "\n",
    "headers = {'authorization': 'Bearer ' + watson_ml_token }\n",
    "response = requests.request(\"GET\", model_url, headers=headers)\n",
    "\n",
    "published_models = json.loads(response.text)\n",
    "print(json.dumps(published_models, indent=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Read the details of any returned models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a new deployment of the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model_id = '78726bbd-2e0b-429a-a92f-17351cc83b26'\n",
    "\n",
    "deployment_url = wml_url + \"/v3/wml_instances/\" + instance_id + \"/published_models/\" + model_id + \"/deployments\"\n",
    "\n",
    "payload = \"{\\\"name\\\": \\\"Heart Failure Prediction Model \\\", \\\"description\\\": \\\"First deployment of Heart Failure Prediction Model\\\", \\\"type\\\": \\\"online\\\"}\"\n",
    "headers = {'authorization': 'Bearer ' + watson_ml_token, 'content-type': \"application/json\" }\n",
    "\n",
    "response = requests.request(\"POST\", deployment_url, data=payload, headers=headers)\n",
    "\n",
    "print(response.text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "deployment = json.loads(response.text)\n",
    "\n",
    "print('Model {} deployed.'.format(model_id))\n",
    "print('\\tname: {}'.format(deployment['entity']['name']))\n",
    "print('\\tdeployment_id: {}'.format(deployment['metadata']['guid']))\n",
    "print('\\tstatus: {}'.format(deployment['entity']['status']))\n",
    "print('\\tscoring url: {}'.format(deployment['entity']['scoring_url']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Monitor the status of deployment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "deployment_id = \"af1ae551-cdd5-4b28-96c9-066d4e0a9b19\"\n",
    "deployment_details_url = wml_url + \"/v3/wml_instances/\" + instance_id + \"/published_models/\" + model_id + \"/deployments/\" + deployment_id\n",
    "\n",
    "headers = {'authorization': 'Bearer ' + watson_ml_token, 'content-type': \"application/json\" }\n",
    "\n",
    "response = requests.request(\"GET\", deployment_url, headers=headers)\n",
    "print(response.text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "deployment_details = json.loads(response.text)\n",
    "\n",
    "for resources in deployment_details['resources']:\n",
    "    print('name: {}'.format(resources['entity']['name']))\n",
    "    print('status: {}'.format(resources['entity']['status']))\n",
    "    print('scoring url: {}'.format(resources['entity']['scoring_url']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.3 Invoke prediction model deployment\n",
    "Define a method to call scoring url. Replace the **scoring_url** in the method below with the scoring_url returned from above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def get_prediction_ml(ahb, ppd, chol, bmi, age, sex, fh, smoker, exercise_minutes ):\n",
    "    scoring_url = 'https://ibm-watson-ml.mybluemix.net/v3/wml_instances/c2822f68-9e0c-40bd-a837-a0f86248bd57/published_models/78726bbd-2e0b-429a-a92f-17351cc83b26/deployments/7b089296-9c81-4a1d-b059-908435a0c199/online'\n",
    "    scoring_payload = { \"fields\":[\"AVGHEARTBEATSPERMIN\",\"PALPITATIONSPERDAY\",\"CHOLESTEROL\",\"BMI\",\"AGE\",\"SEX\",\"FAMILYHISTORY\",\"SMOKERLAST5YRS\",\"EXERCISEMINPERWEEK\"],\"values\":[[ahb, ppd, chol, bmi, age, sex, fh, smoker, exercise_minutes]]}\n",
    "    header = {'authorization': 'Bearer ' + watson_ml_token, 'content-type': \"application/json\" }\n",
    "    scoring_response = requests.post(scoring_url, json=scoring_payload, headers=header)\n",
    "    print(scoring_response.text)\n",
    "    return (json.loads(scoring_response.text).get(\"values\")[0][12])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Call get_prediction_ml method exercising our prediction model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print('Is a 44 year old female that smokes with a low BMI at risk of Heart Failure?: {}'.format(get_prediction_ml(100,85,242,24,44,\"F\",\"Y\",\"Y\",125)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print('Is a 42 year old male that smokes with a low BMI at risk of Heart Failure?: {}'.format(get_prediction_ml(100,85,178,22,42,\"M\",\"N\",\"N\",45)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 2 with Spark 2.1",
   "language": "python",
   "name": "python2-spark21"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}