demos/02 Supervised Classification/02d Interactive Deployment with Dynamic Compute.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "70216c5c-7467-4cf1-b8aa-41be2fbefca1",
   "metadata": {},
   "source": [
    "## Supervised ML on Descartes Labs Platform:  Interactive Deployment with Dynamic Compute\n",
    "__________________\n",
    "This notebook will demonstrate a typical example of how to interact with the results of a supervised machine learning model using Descartes Labs Platform APIs and define new AOIs to analyze on-the-fly.\n",
    "\n",
    "The general steps covered in this notebook are:\n",
    "* Retrieve a running [`Function`](https://docs.descarteslabs.com/descarteslabs/compute/readme.html#descarteslabs.compute.Function)\n",
    "* Display results overlain on input imagery in a web map with [`Dynamic Compute`](https://docs.descarteslabs.com/api/dynamic-compute.html)\n",
    "* Specify new areas to apply our model over with interactive [widgets](https://ipywidgets.readthedocs.io/en/stable/)\n",
    "\n",
    "_**Note:**_ In order to run this example you must first complete the steps outlined in [02a Generate Training Data.ipynb](02a%20Generate%20Training%20Data.ipynb), [02b Training a Supervised Classifier.ipynb](02b%20Training%20a%20Supervised%20Classifier.ipynb), and [02c Deploying a Supervised Classifier.ipynb](02c%20Deploying%20a%20Supervised%20Classifier.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50981f41-8ec2-456a-a16a-0fb69f6402fb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import yaml\n",
    "\n",
    "import descarteslabs as dl\n",
    "import descarteslabs.compute\n",
    "import descarteslabs.dynamic_compute as dc\n",
    "import descarteslabs.vector as dl_vector\n",
    "import geopandas as gpd\n",
    "import ipyleaflet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e09bd44-0d93-4ebe-b9e1-c213b79f213c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "with open(\"config.yaml\", \"r\") as file:\n",
    "    config = yaml.load(file, yaml.FullLoader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f1a8d3b-170a-4299-b326-bca491622269",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "user_hash = dl.auth.Auth().namespace\n",
    "org = dl.auth.Auth().payload['org']\n",
    "\n",
    "result_product_id = f\"{org or user_hash}:rfc-results-{user_hash}\"\n",
    "result_product_id"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e660523f-9868-4af1-976b-f97c9ce4af82",
   "metadata": {},
   "source": [
    "## Retrieving an Active Compute Function \n",
    "\n",
    "If you lost your ID, you can retrieve it at [app.descarteslabs.com/compute](https://app.descarteslabs.com/compute) or search the latest created Function with that name as below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efc59e34-874c-4941-82a0-376315765ea1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "func_search = (\n",
    "    dl.compute.Function.search()\n",
    "    .filter(dl.catalog.properties.name.startswith(config[\"pred_func_name\"]))\n",
    "    .filter(dl.compute.Function.status == dl.compute.FunctionStatus.READY)\n",
    "    .sort(-dl.compute.Function.creation_date)\n",
    "    .limit(1)\n",
    ").collect()\n",
    "\n",
    "async_func = func_search[0]\n",
    "async_func.id"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a196a0a5-8366-4b5f-b087-3bc5b63ef9ef",
   "metadata": {},
   "source": [
    "## Setting Up Dynamic Compute\n",
    "\n",
    "Here we will set  up the interactive map components to visualize our study area. \n",
    "\n",
    "First we set up a map frame alongside center coordinates and zoom level:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84d4b6f2-bbb4-4ab0-a87b-42f8a6b75501",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "m = dc.map\n",
    "m.center = 30.2653, -97.7483\n",
    "m.zoom = 15"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5063c42-7911-4d1e-b050-5252432c4e29",
   "metadata": {},
   "source": [
    "Next create a and visualize a NAIP [`Mosaic`](https://docs.descarteslabs.com/api/dynamic-compute.html#descarteslabs.dynamic_compute.Mosaic) for our time period:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4b6e5fb-3743-44b6-ae30-f3a60fae95e0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "naip_mosaic = dc.Mosaic.from_product_bands(\n",
    "    config[\"product_id\"],\n",
    "    config[\"bands\"],\n",
    "    start_datetime=config[\"start\"],\n",
    "    end_datetime=config[\"end\"],\n",
    ")\n",
    "naip_mosaic.visualize(\"FCC\", m)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d99c07ae-9aa6-44a5-aad5-7fcfd718cab6",
   "metadata": {},
   "source": [
    "And overlay our input training features as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7403f45d-1edd-440f-8019-b985f96672fd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "table = dl_vector.Table.get(config[\"training_table_name\"])\n",
    "table.visualize(\"Training Data\", m)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc7c05d4-c038-4235-9866-8d1c4977feb7",
   "metadata": {},
   "source": [
    "Here we define a simple [`DrawControl`](https://ipyleaflet.readthedocs.io/en/latest/controls/draw_control.html) widget which will keep track of drawn polygons:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e15fa480-6f09-4ade-91bd-560dbe015c53",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This is some interactivity with the map we'll embed below:\n",
    "draw_control = ipyleaflet.DrawControl()\n",
    "# Drawn polygon styling\n",
    "draw_control.polygon = {\n",
    "    \"shapeOptions\": {\"fillColor\": \"green\", \"color\": \"blue\", \"fillOpacity\": 0.5},\n",
    "    \"drawError\": {\"color\": \"red\", \"message\": \"Oops!\"},\n",
    "    \"allowIntersection\": False,\n",
    "}\n",
    "\n",
    "# Setting empty feature collection to track as we draw polys:\n",
    "feature_collection = {\"type\": \"FeatureCollection\", \"features\": []}\n",
    "\n",
    "# Define this handle_draw function for the Draw Control widget\n",
    "def handle_draw(target, action, geo_json):\n",
    "    # Clears feature collection on each new polygon with new geojson\n",
    "    feature_collection[\"features\"] = [geo_json]\n",
    "\n",
    "\n",
    "# Adding the handle_draw function to the Draw Control widget\n",
    "draw_control.on_draw(handle_draw)\n",
    "m.add_control(draw_control)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9df1bea3-88fb-4d9e-ac3d-13640b3e5372",
   "metadata": {},
   "source": [
    "**_Note on Updating Tile Layers_**\n",
    "\n",
    "Our results mosaic will \"refresh\" its tile layers upon re-instantiation of it's class, as shown in the cell below. \n",
    "\n",
    "If you are waiting for your function to process in real time you will need to re-run the following cell to update your imagery as each job completes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37c63a9b-a6df-40e0-bc84-6e8382115e96",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "rfc_mosaic = dc.Mosaic.from_product_bands(result_product_id, \"class\")\n",
    "rfc_mosaic.visualize(\"RFC Results\", m, colormap=\"terrain\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "062eacbf-abf3-45a0-bdcc-fe3c1de3212b",
   "metadata": {},
   "source": [
    "And display our map:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "020fe91e-a3fa-4506-aac6-3f6bd4ee5b49",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "218a42e5-c609-4311-83aa-6329aa48f153",
   "metadata": {},
   "source": [
    "## Interacting with the Results\n",
    "\n",
    "Notice that we now have the option embedded in our mapframe to draw new polygons. When you complete a new polygon on the map, run the following cell to format a new list of arguments to pass to the currently running asynchronous function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1745b81-5290-4bbc-80c0-d4c7b872406b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "drawn_gdf = gpd.GeoDataFrame.from_features(feature_collection, crs=4326)\n",
    "# Create a new set of DLTiles for this new AOI\n",
    "geocontext_geom = drawn_gdf[\"geometry\"][0]\n",
    "# You could also pass the map's geocontext as a WKT\n",
    "# geocontext_geom = sgeom.box(*dc.map.geocontext().bounds)\n",
    "dltiles = dl.geo.DLTile.from_shape(\n",
    "    geocontext_geom, resolution=config[\"resolution_m\"], tilesize=2048, pad=0\n",
    ")\n",
    "args = [(dltile.key, result_product_id) for dltile in dltiles]\n",
    "len(args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30bafd42-e64c-45ef-a459-8ba586b9616e",
   "metadata": {},
   "source": [
    "We can submit those arguments to our running function to process at any time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0745913-cd6f-4fa3-b2c8-769e08c0772b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "jobs = async_func.map(args)\n",
    "len(jobs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf427aaf-75b0-4d44-b460-1ae970e04eaf",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Cleaning Up\n",
    "It is always best practice to clean up after ourselves, including both Function results and unused Products:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9d7df8a-8ea7-4923-8709-59d8ebaa21bf",
   "metadata": {
    "tags": []
   },
   "source": [
    "Deleting Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8982ac3f-3761-414e-9520-9c2131cf6e15",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "async_func.delete_jobs(delete_results=True)\n",
    "async_func.delete()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64ef4bff-d362-478f-897f-412c2336d1f5",
   "metadata": {},
   "source": [
    "Deleting Product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70061361-4381-4a95-a4a1-2ebf4c9c033c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "rfc_prod = dl.catalog.Product.get(result_product_id)\n",
    "status = rfc_prod.delete_related_objects()\n",
    "if status:\n",
    "    status.wait_for_completion()\n",
    "rfc_prod.delete()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5c344dd-630b-47ad-a6a1-2ff50d151641",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}