From 0cb8da0286f874c187a7064bbb594fa66a738c36 Mon Sep 17 00:00:00 2001 From: heyarne Date: Mon, 8 Mar 2021 14:50:04 +0000 Subject: [PATCH] Finish section 02 --- sources/02b NDVI.ipynb | 24 +-- sources/02b Timeseries.ipynb | 300 +++++++++++++++------------ sources/02c Corrupted Zip File.ipynb | 2 +- sources/02c Multithreading.ipynb | 202 +++++++++--------- sources/02e Spectral Indices.ipynb | 147 +++---------- 5 files changed, 309 insertions(+), 366 deletions(-) diff --git a/sources/02b NDVI.ipynb b/sources/02b NDVI.ipynb index 05982c7..711ec4f 100644 --- a/sources/02b NDVI.ipynb +++ b/sources/02b NDVI.ipynb @@ -103,15 +103,16 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.38 s, sys: 82.1 ms, total: 1.46 s\n", - "Wall time: 538 ms\n" + "EPSG:32633\n", + "CPU times: user 1.37 s, sys: 68 ms, total: 1.43 s\n", + "Wall time: 513 ms\n" ] }, { @@ -144,6 +145,8 @@ " return (np.clip(v, 0, 10_000) / 10_000).astype('f4') # ← four-byte-float / float32\n", "\n", "with r.open(b04_path, 'r') as b04, r.open(b08_path, 'r') as b08:\n", + " print(b04.crs)\n", + " \n", " # we want to only write the bare minimum data necessary to disk\n", " out_meta = b04.meta.copy()\n", " \n", @@ -172,10 +175,6 @@ " \n", " # we take only the part out of our source raster that we actually need\n", " # crop=True clips off the borders\n", - " \n", - " # TODO: Probably there is an issue with resampling here.\n", - " # The cloud mask has a shape o\n", - " \n", " b04, transform_b04 = rasterio.mask.mask(b04, shapes=[mask], filled=False, crop=True)\n", " b08, _ = rasterio.mask.mask(b08, shapes=[mask], filled=False, crop=True) # we ignore the returned transform because it's identical to the previous one\n", " \n", @@ -281,7 +280,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -290,13 +289,13 @@ "Text(0.5, 1.0, 'Grass NDVI')" ] }, - "execution_count": 5, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -308,13 +307,14 @@ } ], "source": [ + "bins=20\n", "fig, axs = plt.subplots(1, 2, sharey=True, tight_layout=True)\n", "fig.suptitle('Histogram Comparison', fontsize=18)\n", "\n", - "axs[0].hist(runway_extracted.flatten())\n", + "axs[0].hist(runway_extracted.flatten(), bins=bins)\n", "axs[0].set_title('Runway NDVI')\n", "\n", - "axs[1].hist(grass_extracted.flatten())\n", + "axs[1].hist(grass_extracted.flatten(), bins=bins)\n", "axs[1].set_title('Grass NDVI')" ] }, diff --git a/sources/02b Timeseries.ipynb b/sources/02b Timeseries.ipynb index e5900ff..dc14585 100644 --- a/sources/02b Timeseries.ipynb +++ b/sources/02b Timeseries.ipynb @@ -4,7 +4,50 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Calculating Spectral Indices Over a Long Time Span" + "# Time Series\n", + "\n", + "Based on the preparation done in [](02b NDVI.ipynb), this section will contain calculations of the NDVI for an entire year and compare value developments in the different subsections of the area as previously defined." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas as gpd\n", + "from multiprocessing import Pool\n", + "import numpy as np\n", + "from numpy import ma\n", + "from os import unlink\n", + "from pathlib import Path\n", + "import rasterio as r\n", + "from rasterio.features import geometry_window\n", + "import rasterio.mask\n", + "import rasterio.plot as rplt\n", + "from sentinel_helpers import scihub_band_paths, scihub_cloud_mask\n", + "from zipfile import BadZipFile\n", + "\n", + "base_path = Path('resources/tempelhofer_feld/')\n", + "input_files = list(base_path.glob('*.zip'))\n", + "area_of_interest = gpd.read_file(base_path / 'tempelhofer_feld.geojson')\n", + "ndvi_path = base_path / 'ndvi'\n", + "\n", + "# uncomment to remove previous calculations\n", + "# ! rm -rf {ndvi_path / '*.tif'}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Due to an unexpected failure of the Copernicus Open Access Hub API, several of the downloaded products were unusable due to data corruption.[^data_corruption] This is considered in the processing code by excluding the corrupted files.\n", + "\n", + "Additionally, even though acceptable products were restricted [](02a Area of Interest Definition and Product Download.ipynb) to only those with a low cloud coverage, in some products clouds might still obscure the particular area of interest inside the products. If less than 50% of the area of interest is visible inside a particular product, the product is deemed to not contain enough usable data and skipped as well.\n", + "\n", + "[^data_corruption]: See [](02c Corrupted Zip File.ipynb) for details.\n", + "\n", + "## Data Processing" ] }, { @@ -12,47 +55,6 @@ "execution_count": 2, "metadata": {}, "outputs": [], - "source": [ - "from pathlib import Path\n", - "from multiprocessing import Pool\n", - "import geopandas as gpd\n", - "from sentinel_helpers import scihub_band_paths\n", - "\n", - "base_path = Path('resources/tempelhofer_feld/')\n", - "input_files = list(base_path.glob('*.zip'))\n", - "area_of_interest = gpd.read_file(base_path / 'tempelhofer_feld.geojson')\n", - "ndvi_path = Path('output') / 'ndvi'" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "import rasterio as r\n", - "import rasterio.mask\n", - "import rasterio.plot as rplt\n", - "import numpy as np\n", - "from sentinel_helpers import scihub_cloud_mask\n", - "from zipfile import BadZipFile" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# uncomment this cell to remove previous calculations\n", - "# ! rm -rf {ndvi_path / '*.tif'}" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], "source": [ "def normalize(v):\n", " return (np.clip(v, 0, 10_000) / 10_000).astype('f4') # ← four-byte-float / float32\n", @@ -62,7 +64,7 @@ " \n", " try:\n", " b04_path, b08_path = scihub_band_paths(product_path, ['B04', 'B08'], '10m')\n", - " cloud_mask = scihub_cloud_mask(product_path)\n", + " cloud_mask, _ = scihub_cloud_mask(product_path, area=area_of_interest)\n", " except BadZipFile:\n", " # This is due to a problem of Scihub\n", " print(f'{product_path}: Problem reading product, skipping it')\n", @@ -74,63 +76,74 @@ "\n", " # we reproject the geojson file we fetched above and convert it so that rasterio\n", " # can use it as a mask; we subtract the cloud mask to avoid irregularities\n", - " reprojected = area_of_interest.to_crs(out_meta['crs']).iloc[0].geometry\n", - " mask = reprojected.difference(cloud_mask)\n", - " \n", - " if mask.area / reprojected.area < 0.25:\n", - " print(f'{product_path}: Area is covered by clouds, skipping it')\n", - " return\n", - " \n", - " miny, minx, maxy, maxx = mask.bounds\n", + " mask = area_of_interest.to_crs(out_meta['crs']).iloc[0].geometry\n", + " window = geometry_window(b04, [mask])\n", " \n", " # update the dimensions and save as geotiff, not jp2\n", " out_meta.update({\n", - " 'width': maxx - minx,\n", - " 'height': maxy - miny,\n", + " 'width': window.width,\n", + " 'height': window.height,\n", " 'driver': 'GTiff',\n", - " 'dtype': 'float32'\n", + " 'dtype': 'float32',\n", + " 'nodata': -999\n", " }) \n", " \n", " out_name = Path(b04_path).name.replace('B04', 'NDVI').replace('.jp2', '.tif')\n", - "\n", " ndvi_path.mkdir(exist_ok=True, parents=True)\n", + " \n", + " # we need this to delete unusable files\n", + " skip_file = False\n", " with r.open(ndvi_path / out_name, 'w+', **out_meta) as dst:\n", " # we take only the part out of our source raster that we actually need\n", " # crop=True clips off the borders\n", - " b04, transform_b04 = rasterio.mask.mask(b04, shapes=[mask], crop=True, nodata=-999)\n", - " b08, _ = rasterio.mask.mask(b08, shapes=[mask], crop=True, nodata=-999) # we ignore the returned transform because it's identical to the previous one\n", + " b04, transform_b04 = rasterio.mask.mask(b04, shapes=[mask], filled=False, crop=True)\n", + " b08, _ = rasterio.mask.mask(b08, shapes=[mask], filled=False, crop=True)\n", + " \n", + " # calculate area covered by clouds\n", + " cloud_mask = cloud_mask[:,:b04.shape[1],:b04.shape[2]]\n", + " unmasked_area = ~b04.mask\n", + " clouds_on_unmasked_area = (cloud_mask & unmasked_area).sum()\n", + " if clouds_on_unmasked_area > 0.5 * unmasked_area.sum():\n", + " print(f'{product_path}: Area of interest covered by clouds, skipping it')\n", + " skip_file = True\n", + " else:\n", + " b04 = normalize(b04)\n", + " b08 = normalize(b08)\n", "\n", - " b04 = normalize(b04) # <- f4 = float32\n", - " b08 = normalize(b08)\n", + " # uncomment the following line to see if your masked shape looks correct\n", + " #rplt.show(b04, transform=transform_b04)\n", + " #rplt.show(b08, transform=transform_b04)\n", "\n", - " # uncomment the following line to see if your masked shape looks correct\n", - " #rplt.show(b04, transform=transform_b04)\n", - " #rplt.show(b08, transform=transform_b04)\n", + " # we want to be able to ignore divide by zero errors so the formula is nicer to write\n", + " np.seterr(divide='ignore', invalid='ignore')\n", + " ndvi = (b08 - b04) / (b08 + b04)\n", + " ndvi.mask = b04.mask | cloud_mask\n", "\n", - " # we want to be able to ignore divide by zero errors so the formula is nicer to write\n", - " np.seterr(divide='ignore', invalid='ignore')\n", - " ndvi = (b08 - b04) / (b08 + b04)\n", + " # uncomment the following line to see if we calculated the index correctly\n", + " # rplt.show(ndvi, transform=transform_b04)\n", "\n", - " # uncomment the following line to see if we calculated the index correctly\n", - " # rplt.show(ndvi, transform=transform_b04)\n", - "\n", - " dst.write(ndvi)" + " # write with explicit nodata value for masked pixels\n", + " dst.write(ndvi.filled(out_meta['nodata']))\n", + " if skip_file:\n", + " # file has been created with r.open(..., 'w+'), so it needs to be\n", + " # deleted explicitly\n", + " unlink(ndvi_path / out_name)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5a94deac202b4ff3ad9ecb350267dfc3", + "model_id": "e89f92fbf3fb47d3965bef1883ce0120", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=36.0), HTML(value='')))" + "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=40.0), HTML(value='')))" ] }, "metadata": {}, @@ -140,7 +153,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "resources/tempelhofer_feld/S2A_MSIL2A_20190626T102031_N0212_R065_T33UUU_20190626T125319.zip: Area is covered by clouds, skipping it\n", "resources/tempelhofer_feld/S2A_MSIL2A_20190603T101031_N0212_R022_T33UUU_20190603T114652.zip: Problem reading product, skipping it\n", "resources/tempelhofer_feld/S2A_MSIL2A_20190404T101031_N0211_R022_T32UQD_20190404T174806.zip: Problem reading product, skipping it\n", "resources/tempelhofer_feld/S2A_MSIL2A_20190216T102111_N0211_R065_T33UUU_20190216T130428.zip: Problem reading product, skipping it\n", @@ -151,21 +163,21 @@ "resources/tempelhofer_feld/S2A_MSIL2A_20190424T101031_N0211_R022_T32UQD_20190424T162325.zip: Problem reading product, skipping it\n", "resources/tempelhofer_feld/S2A_MSIL2A_20190822T101031_N0213_R022_T32UQD_20190822T143621.zip: Problem reading product, skipping it\n", "resources/tempelhofer_feld/S2A_MSIL2A_20190623T101031_N0212_R022_T33UUU_20190623T132509.zip: Problem reading product, skipping it\n", - "resources/tempelhofer_feld/S2B_MSIL2A_20190320T101029_N0211_R022_T33UUU_20190320T195148.zip: Area is covered by clouds, skipping it\n", "\n", - "CPU times: user 226 ms, sys: 151 ms, total: 377 ms\n", - "Wall time: 24.2 s\n" + "CPU times: user 231 ms, sys: 191 ms, total: 422 ms\n", + "Wall time: 11.7 s\n" ] } ], "source": [ "%%time\n", "from tqdm.notebook import tqdm\n", + "from multiprocessing import Pool\n", "\n", "# we parallelize the NDVI calculation using a Python threadpool\n", "with Pool() as pool:\n", " for _ in tqdm(pool.imap_unordered(calculate_ndvi, input_files), total=len(input_files)):\n", - " # this loop is only here so we can get the progress bar\n", + " # this loop is only here so we can display a progress bar\n", " pass" ] }, @@ -173,19 +185,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "How many files could we process?" + "How many files could be processed?" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "25\n" + "41\n" ] } ], @@ -197,80 +209,85 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Plot the NDVI\n", - "\n", - "See [02c Multithreading.ipynb](./02c Multithreading.ipynb) for a performance comparison of single vs multi-threaded iteration to average the ndvi." + "In order to be able to re-use designated subsections, the `rio` command-line-tool provided by `rasterio` is used to unify the target CRS." ] }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "from numpy import ma\n", - "output_files = list(ndvi_path.glob('*.tif'))" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def average(file_path):\n", - " with r.open(file_path) as src:\n", - " # masked=True makes sure to respect the nodata value and reads the data\n", - " # as a numpy MaskedArray, which lets us use `numpy.ma`'s methods\n", - " data = src.read(1, masked=True)\n", - " return file_path, ma.average(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "metadata": {}, "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d29e20cc277a4897b076e0a275161fa5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=24.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "CPU times: user 59.6 ms, sys: 104 ms, total: 164 ms\n", - "Wall time: 703 ms\n" + "CPU times: user 306 ms, sys: 424 ms, total: 729 ms\n", + "Wall time: 34.9 s\n" ] } ], "source": [ "%%time\n", - "with Pool() as pool:\n", - " averages = [avg for avg in tqdm(pool.map(average, output_files), total=len(output_files))]" + "\n", + "for file_name in ndvi_path.glob('*.tif'):\n", + " if 'T33UUU' in file_name.name:\n", + " continue\n", + " \n", + " # crs from the previous notebook to re-use the designated areas\n", + " out_name = str(file_name).replace(\"T32UQD\", \"T33UUU\")\n", + " ! rio warp --dst-crs EPSG:32633 --overwrite {file_name} {out_name} && rm {file_name}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We use the pandas library to plot the year-long NDVI development:" + "## Average NDVI\n", + "\n", + "The average NDVI over the area is calculated using a multiprocessing pool.[^performance_comparison]\n", + "\n", + "[^performance_comparison]: [02c Multithreading.ipynb](./02c Multithreading.ipynb) contains a performance benchmark to that shows that multiprocessing does not bring any real performance for this particular calculation." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 167 ms, sys: 40.7 ms, total: 208 ms\n", + "Wall time: 205 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "output_files = list(ndvi_path.glob('*.tif'))\n", + "\n", + "def average(file_path):\n", + " with r.open(file_path) as src:\n", + " # masked=True makes sure to respect the nodata value and reads the data\n", + " # as a numpy MaskedArray, which lets us use `numpy.ma`'s methods\n", + " data = src.read(1, masked=True)\n", + " avg = ma.average(data)\n", + " return file_path, avg\n", + " \n", + "averages = list(map(average, output_files))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The pandas data-processing library is used to plot the NDVI over the whole year:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -279,15 +296,15 @@ "" ] }, - "execution_count": 14, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -299,13 +316,20 @@ "source": [ "import pandas as pd\n", "\n", - "paths, vals = zip(*averages)\n", - "dates = map(lambda p: p.name.split('_')[1], paths)\n", - "df = pd.DataFrame(\n", - " {'NDVI': vals}, index=pd.DatetimeIndex(dates)\n", - ")\n", + "paths, ndvi_avg = zip(*averages)\n", "\n", - "df.plot()" + "# parse capture date from file name\n", + "dates = map(lambda p: p.name.split('_')[1], paths)\n", + "\n", + "df = pd.DataFrame({'NDVI': ndvi_avg}).set_index(pd.DatetimeIndex(dates))\n", + "df.plot(figsize=(12,9))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "While there seems to be a dip following the summer months, interpretation is prone to errors by looking at this data alone. There is no information on local fauna, on weather phenomena, or other factors besides cloud cover and spectral band reflectivity. This alone can for example not explain the difference in values at the beginning and at the end of the time span, both of which are during winter. It is therefore important to note that while the data may be useful, it can not be adequately explained in its entirety without any expertise on the field." ] }, { diff --git a/sources/02c Corrupted Zip File.ipynb b/sources/02c Corrupted Zip File.ipynb index 5339870..0be3c2b 100644 --- a/sources/02c Corrupted Zip File.ipynb +++ b/sources/02c Corrupted Zip File.ipynb @@ -6,7 +6,7 @@ "source": [ "# ZIP-File Corruption Issues\n", "\n", - "The Scihub platform has a policy that moves data into a Long-Term-Archive after a certain period of time.[^lta]\n", + "The Copernicus Open Access Hub has a policy of moving data into a Long-Term-Archive after a certain period of time.[^lta]\n", "Retrieval of files from this offline archive is a two step process:\n", "\n", "1. A request to the URL that initializes the download for online products (`https://scihub.copernicus.eu/dhus/odata/v1/Products('$UUID')/$value`) instead initializes a data retrieval request which moves the archived file from offline to online storage.\n", diff --git a/sources/02c Multithreading.ipynb b/sources/02c Multithreading.ipynb index 17f1ec0..996960f 100644 --- a/sources/02c Multithreading.ipynb +++ b/sources/02c Multithreading.ipynb @@ -4,11 +4,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Multi-Threading Performance Benchmark\n", + "# Multi-Processing Performance Benchmark\n", "\n", - "This notebook contains a performance comparison of different methods to process the NDVI calculations.\n", + "This section contains a performance comparison of single- and multiprocess-based calculation methods used in [](02b Timeseries.ipynb).\n", "\n", - "The `%%timeit` cell magic runs the cell content multiple times and outputs statistics on those multiple runs, thereby reducing factors such as garbage collection pauses etc." + "The `%%timeit` cell magic runs the cell content multiple times and prints statistics on those multiple runs. This reduces factors such as garbage collection pauses which influence the runtime performance and can be used to verify performance assumptions." ] }, { @@ -32,12 +32,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Number of files: 27\n" + "Number of files: 30\n" ] } ], "source": [ - "test_files = list(Path('output/ndvi').glob('*.tif'))\n", + "test_files = list(Path('resources/tempelhofer_feld/ndvi').glob('*.tif'))\n", "print(f'Number of files: {len(test_files)}')" ] }, @@ -45,7 +45,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The function we test with:" + "The performance is tested with the following function call:" ] }, { @@ -64,91 +64,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## In a single process\n", - "### Time to process a single file" + "The function receives a string or `pathlib.Path`, reads the data using `rasterio`, and calculates the average value inside the data using the `ma.average` function provided by `numpy`.\n", + "\n", + "The benchmark is performed on 4 CPUs:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "36.2 ms ± 42.6 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" - ] - } - ], - "source": [ - "%%timeit\n", - "average(test_files[0])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Time to process all files" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "980 ms ± 7.38 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - } - ], - "source": [ - "%%timeit\n", - "averages = [avg for avg in map(average, test_files)]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Increasing the list size" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4.86 s ± 10.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - } - ], - "source": [ - "%%timeit\n", - "averages = [avg for avg in map(average, test_files * 5)]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Time when using a worker pool\n", - "\n", - "Number of CPUs the multiprocessing pools can access:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, "outputs": [ { "data": { @@ -156,7 +80,7 @@ "4" ] }, - "execution_count": 7, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -169,19 +93,45 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### On One element" + "## Single File\n", + "### In a Single Process" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "277 ms ± 3.92 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "4.35 ms ± 24.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "average(test_files[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multiprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "187 ms ± 5.09 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] } ], @@ -195,52 +145,104 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### On the complete list" + "## All Files in Folder\n", + "### In a Single Process" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "630 ms ± 8.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "131 ms ± 366 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] } ], "source": [ "%%timeit\n", - "with Pool() as pool:\n", - " averages = [avg for avg in pool.map(average, test_files)]" + "averages = list(map(average, test_files))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Increasing the list size" + "### With Multiprocessing" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2.1 s ± 20 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "248 ms ± 10 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] } ], "source": [ "%%timeit\n", "with Pool() as pool:\n", - " averages = [avg for avg in pool.map(average, test_files * 5)]" + " averages = list(pool.map(average, test_files))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## All Files Multiple Times\n", + "### In a Single Process" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "654 ms ± 952 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "averages = list(map(average, test_files * 5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### With Multiprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "434 ms ± 16.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "with Pool() as pool:\n", + " averages = list(pool.map(average, test_files * 5))" ] }, { @@ -250,9 +252,9 @@ "## Result\n", "\n", "As we can see when processing a single element, multiprocessing comes with an overhead.\n", - "When the list to be processed is sufficiently large, we get a reduction in processing time of roughly 30%-50%, depending on list size.\n", + "When the list to be processed is sufficiently large, we get a slight reduction in processing time, that, even with a higher standard deviation, manages to be faster than the single-process version.\n", "\n", - "Averaging the masked array is a fairly simple operation that scales in $O(N)$ with the size of the input array.\n", + "Averaging the masked array is an operation that can be implemented to scale in $O(N)$ with the size of the input array.\n", "The time reduction should be even higher for more complex tasks." ] }, diff --git a/sources/02e Spectral Indices.ipynb b/sources/02e Spectral Indices.ipynb index 2424ac4..4cb988c 100644 --- a/sources/02e Spectral Indices.ipynb +++ b/sources/02e Spectral Indices.ipynb @@ -6,7 +6,10 @@ "source": [ "# Spectral Index Pipeline\n", "\n", - "Before running this notebook the files have to be downloaded. See [01a Download Process.ipynb](01a Download Process.ipynb) for further information.\n", + "Elaborating on the work done in previous sections, this section contains a complete implementation of the calculation of various spectral indicators.\n", + "\n", + "It does not contain code to download products from the Open Access Hub[^download_process].\n", + "It is rather a re-usable notebook that can be re-used for the calculation of indices only.\n", "\n", "The calculation in this notebook depends on three parameters:\n", "\n", @@ -18,51 +21,21 @@ " - ndwi -- normalized difference in water\n", "- `fill_value`, the value which is used to represent invalid pixels to handle division by zero.\n", "\n", - "Change the values below and select _Kernel → Restart and Run All Cells_ to re-evaluate all cells in this notebook.\n", - "The path of the output file will be printed below the last cell." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[PosixPath('resources/forest_fires/S2A_MSIL2A_20180807T101021_N0208_R022_T33UUT_20180809T112302.zip'),\n", - " PosixPath('resources/forest_fires/S2A_MSIL2A_20180919T102021_N0208_R065_T33UUT_20180919T132226.zip'),\n", - " PosixPath('resources/forest_fires/S2A_MSIL2A_20190603T101031_N0212_R022_T33UUT_20190603T114652.zip'),\n", - " PosixPath('resources/forest_fires/S2A_MSIL2A_20190613T101031_N0212_R022_T33UUT_20190614T125329.zip'),\n", - " PosixPath('resources/forest_fires/S2A_MSIL2A_20190626T102031_N0212_R065_T33UUT_20190626T125319.zip'),\n", - " PosixPath('resources/forest_fires/S2A_MSIL2A_20190629T103031_N0212_R108_T32UPE_20190629T135351.zip'),\n", - " PosixPath('resources/forest_fires/S2A_MSIL2A_20190726T102031_N0213_R065_T32UPE_20190726T125507.zip'),\n", - " PosixPath('resources/forest_fires/S2B_MSIL2A_20180822T101019_N0208_R022_T33UUT_20180822T161243.zip'),\n", - " PosixPath('resources/forest_fires/S2B_MSIL2A_20190701T102029_N0212_R065_T32UPE_20190701T134657.zip')]" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#downloads = ['input/forest_fires/S2A_MSIL2A_20190726T102031_N0213_R065_T32UPE_20190726T125507.zip',\n", - "# 'input/forest_fires/S2B_MSIL2A_20190701T102029_N0212_R065_T32UPE_20190701T134657.zip',\n", - "# 'input/forest_fires/S2A_MSIL2A_20190629T103031_N0212_R108_T32UPE_20190629T135351.zip']\n", + "When running this notebook interactively, _Kernel → Restart and Run All Cells_ can be used to re-evaluate all cells in this notebook after configuring the pipeline.\n", + "The path of the output file containing the processed values will be printed below the last cell.\n", "\n", - "from pathlib import Path\n", - "sources = list(sorted(Path('resources/forest_fires').glob('*.zip')))\n", - "sources" + "[^download_process]: See [](01 Download Process.ipynb) for details" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "product_path = Path(sources[0])\n", + "from pathlib import Path\n", + "\n", + "product_path = Path('resources/forest_fires/S2A_MSIL2A_20180807T101021_N0208_R022_T33UUT_20180809T112302.zip')\n", "index_to_calculate = 'nbr'" ] }, @@ -77,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -95,8 +68,8 @@ "source": [ "## Define Formulas\n", "\n", - "We define the formulas as data so we can substitute the bands with actual values later on and execute the operations when needed.\n", - "We use a lisp-like language with prefix notation for this.\n", + "Formulas are defined as data so that the bands can be substituted with actual values later on. By declaratively expressing the formula calculations computations can be executed lazily and only when needed. \n", + "This is done so the formulas can be defined independent from actual data, which is needed only much later.\n", "\n", "### Operators\n", "\n", @@ -106,12 +79,12 @@ "\\text{NDVI} = \\frac{\\text{B08} - \\text{B04}}{\\text{B08} + \\text{B04}}\n", "$$\n", "\n", - "To define the index calculation formulas in this way, first the the basic arithmetic operations `+`, `-`, `*` and `/` are wrapped in functions taking variadic arguments:" + "To define the index calculation formulas in this way, first the basic arithmetic operations `+`, `-`, `*` and `/` are wrapped in functions taking variadic arguments:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -141,21 +114,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "These function are used to define formulas for a selection of indices.\n", - "These definitions are not exhaustive - there are many spectral indices which are not implemented in this notebook - however the general shape of theses formulas allows for enough flexibility to implement other indices as well.\n", + "These function are used to define formulas for the selection of indices mentioned in the introduction.\n", + "These indices are not exhaustive - there are many spectral indices which are not implemented in this notebook. The general shape of theses formulas however allows for enough flexibility to implement other indices as well.\n", "\n", "The formulas are defined in a lisp-like prefix notation: `(add, 1, 2, 3)` translates to `1 + 2 + 3`.\n", - "Each element in a formula can be either a function, a string or a tuple.\n", + "Each element in a formula can be either a function, a string or a tuple. Tuples are delimited using `()`. The first element of these tuples is one of the operations defined above. It is followed by at least one other element, which can be any of the following:\n", "\n", - "This is done so the formulas can be defined independent from actual data.\n", - "The data is passed in much later.\n", - "\n", - "Instead they are defined using tuples, which are delimited using `()`. These tuples have as their first element one of the operations defined above and continue with a flexible amount of other tuples (allowing the recursive expression of formulas), strings, which encode band numbers, or constants:" + "- Tuples, allowing the recursive expression of formulas.\n", + "- Strings, which encode band numbers.\n", + "- Constants, i.e. integers or floats." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -176,12 +148,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "An error is thrown if `index_to_calculate` did not define an implemented index:" + "An error is thrown if `index_to_calculate` does not mach any of the implements indices above:" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -201,7 +173,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -221,7 +193,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The resolving process needs a `band_map` in the form of `band_num` → `numpy.array`:" + "The resolving process needs a `band_map` in the form of `band_num` → `numpy.array`. By defining the arithmetic operations like above, it can be treated like any other python function - read from the formula and called using `op(args)`:" ] }, { @@ -250,7 +222,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Because the prefix-notation is not commonly used to define mathematical formula, a function is given that converts prefix a formula from above to infix notation. This should help to avoid errors when transcribing the index formulas, which are usually given in common infix notation:" + "Because the prefix-notation is not commonly used to define mathematical formula, a function is defined that converts prefix a formula from above to infix notation. This should help to avoid errors when transcribing the index formulas, which are usually given in common infix notation:" ] }, { @@ -294,7 +266,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Test Case" + "#### Test Cases" ] }, { @@ -372,7 +344,8 @@ "source": [ "## Extraction of Relevant Band File Paths\n", "\n", - "The index calculation starts with the list of bands are referenced by the index formula given by `index_to_calculate`:" + "Subsections from here on below contain the actual calculations.\n", + "They start with the list of bands are referenced by the index formula given by `index_to_calculate`:" ] }, { @@ -480,58 +453,6 @@ "These are encoded as metadata in the raster file:" ] }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "PosixPath('zip+file:/home/jovyan/sources/resources/forest_fires/S2A_MSIL2A_20180807T101021_N0208_R022_T33UUT_20180809T112302.zip!/S2A_MSIL2A_20180807T101021_N0208_R022_T33UUT_20180809T112302.SAFE/GRANULE/L2A_T33UUT_A016321_20180807T101024/IMG_DATA/R10m/T33UUT_20180807T101021_B08_10m.jp2')" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from sentinel_helpers import scihub_cloud_mask\n", - "import rasterio as r\n", - "import matplotlib.pyplot as plt\n", - "\n", - "highres_raster_path = [band_path for band_path in highest_resolution_band_paths if resolution(band_path) == target_resolution][0]\n", - "highres_raster_path" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "((10980, 10980),\n", - " Affine(10.0, 0.0, 300000.0,\n", - " 0.0, -10.0, 5800020.0))" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "with r.open(highres_raster_path) as src:\n", - " target_transform = src.transform\n", - " target_shape = src.shape\n", - "\n", - "# shape is height and width of a 2d-array, target_transform is an affine matrix\n", - "target_shape, target_transform" - ] - }, { "cell_type": "code", "execution_count": 19, @@ -562,11 +483,7 @@ ], "source": [ "# pixels with clouds are True, pixels without are False\n", - "raster_cloud_mask = scihub_cloud_mask(product_path,\n", - " rasterize=True,\n", - " target_shape=target_shape,\n", - " # the affine matrix is used to calculate array indices from world coordinates\n", - " target_transform=target_transform)\n", + "raster_cloud_mask = scihub_cloud_mask(product_path)\n", "\n", "plt.imshow(raster_cloud_mask)" ]