From 80a986c9507cf7fb21950979e4d3fc1317e1c1ec Mon Sep 17 00:00:00 2001 From: hannah-rae Date: Thu, 30 Nov 2023 12:06:43 -0700 Subject: [PATCH 1/5] Use closest year available for each map --- maps/Tigray_2020/intercomparison.ipynb | 195 +++++++++++++------------ maps/Tigray_2021/intercomparison.ipynb | 173 +++++++++++----------- src/compare_covermaps.py | 62 +++++++- 3 files changed, 247 insertions(+), 183 deletions(-) diff --git a/maps/Tigray_2020/intercomparison.ipynb b/maps/Tigray_2020/intercomparison.ipynb index cd01b828..c4aab7a2 100644 --- a/maps/Tigray_2020/intercomparison.ipynb +++ b/maps/Tigray_2020/intercomparison.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "62f2a2e4", + "id": "d4de5d42", "metadata": {}, "source": [ "# Intercomparison\n", @@ -18,8 +18,8 @@ }, { "cell_type": "code", - "execution_count": 1, - "id": "7f609c57", + "execution_count": null, + "id": "6afae379", "metadata": {}, "outputs": [], "source": [ @@ -28,8 +28,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "98ddd95c", + "execution_count": 1, + "id": "7acdaedf", "metadata": {}, "outputs": [], "source": [ @@ -44,12 +44,12 @@ "sys.path.append(\"../..\")\n", "\n", "from src.compare_covermaps import TARGETS, filter_by_bounds, generate_report, CLASS_COL, COUNTRY_COL\n", - "from src.compare_covermaps import TEST_COUNTRIES, TEST_CODE" + "from src.compare_covermaps import TEST_COUNTRIES, TEST_CODE, TEST_YEARS" ] }, { "cell_type": "markdown", - "id": "09b2f8c5", + "id": "95c2d844", "metadata": {}, "source": [ "## 2. Read in evaluation set" @@ -57,8 +57,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "6de51e9f", + "execution_count": 2, + "id": "836f84ee", "metadata": {}, "outputs": [], "source": [ @@ -69,10 +69,19 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "343ab85a", + "execution_count": 3, + "id": "e6d43ebd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hkerner/anaconda3/envs/landcover-mapping/lib/python3.8/site-packages/geopandas/array.py:275: ShapelyDeprecationWarning: The array interface is deprecated and will no longer work in Shapely 2.0. Convert the '.coords' to a numpy array instead.\n", + " return GeometryArray(vectorized.points_from_xy(x, y, z), crs=crs)\n" + ] + } + ], "source": [ "df = pd.read_csv(dataset_path)[[\"lat\", \"lon\", \"class_probability\", \"subset\"]]\n", "df = df[(df[\"class_probability\"] != 0.5)].copy()\n", @@ -87,7 +96,7 @@ }, { "cell_type": "markdown", - "id": "5bbca5d0", + "id": "ffa704d7", "metadata": {}, "source": [ "## 3. Run intercomparison" @@ -95,8 +104,8 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "c47ba5d1", + "execution_count": 4, + "id": "5967f092", "metadata": {}, "outputs": [], "source": [ @@ -105,8 +114,8 @@ }, { "cell_type": "code", - "execution_count": 6, - "id": "7cac8859", + "execution_count": 5, + "id": "c784a32f", "metadata": {}, "outputs": [ { @@ -114,12 +123,15 @@ "output_type": "stream", "text": [ "[Tigray2020] sampling copernicus...\n", + "using closest map year (2019) to test year (2020)\n", "[Tigray2020] sampling worldcover-v100...\n", "[Tigray2020] sampling worldcover-v200...\n", "[Tigray2020] sampling worldcereal-v100...\n", "[Tigray2020] sampling glad...\n", + "using closest map year (2019) to test year (2020)\n", "[Tigray2020] sampling asap...\n", "[Tigray2020] sampling dynamicworld...\n", + "using closest map year (2020) to test year (2020)\n", "[Tigray2020] sampling gfsad-gcep...\n", "[Tigray2020] sampling gfsad-lgrip...\n", "[Tigray2020] sampling digital-earth-africa...\n", @@ -127,6 +139,7 @@ "[Tigray2020] sampling globcover-v23...\n", "[Tigray2020] sampling globcover-v22...\n", "[Tigray2020] sampling esri-lulc...\n", + "using closest map year (2020) to test year (2020)\n", "[Tigray2020] sampling nabil-etal-2021...\n", "[Tigray2020] sampling harvest-dev...\n" ] @@ -137,52 +150,52 @@ " if country not in cropmap.countries:\n", " continue\n", " print(f\"[{country}] sampling \" + cropmap.title + \"...\")\n", - " map_sampled = cropmap.extract_test(gdf).copy()\n", + " map_sampled = cropmap.extract_test(gdf, TEST_YEARS[country]).copy()\n", " gdf = pd.merge(gdf, map_sampled, on=[\"lat\", \"lon\"], how=\"left\")\n", " gdf.drop_duplicates(inplace=True) # TODO find why points get duplicated" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "ced5cce0", + "execution_count": 6, + "id": "2d57edc5", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ensemble maps: ['glad', 'worldcover-v200', 'esri-lulc']\n" + ] + }, { "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/Caskroom/miniconda/base/envs/landcover-mapping/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/Users/hkerner/anaconda3/envs/landcover-mapping/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/Caskroom/miniconda/base/envs/landcover-mapping/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/Users/hkerner/anaconda3/envs/landcover-mapping/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/Caskroom/miniconda/base/envs/landcover-mapping/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/Users/hkerner/anaconda3/envs/landcover-mapping/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2020/../../src/area_utils.py:362: RuntimeWarning: invalid value encountered in divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2020/../../src/area_utils.py:364: RuntimeWarning: invalid value encountered in divide\n", " area_matrix = (w_j * cm) / n_dotj\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2020/../../src/area_utils.py:383: RuntimeWarning: invalid value encountered in divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2020/../../src/area_utils.py:385: RuntimeWarning: invalid value encountered in divide\n", " u_j = p_jjs / p_dotjs\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2020/../../src/area_utils.py:452: RuntimeWarning: invalid value encountered in divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2020/../../src/area_utils.py:454: RuntimeWarning: invalid value encountered in divide\n", " n_i_px = ((a_j / cm.sum(axis=0) * cm).sum(axis=1)).astype(np.uint64)\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2020/../../src/area_utils.py:452: RuntimeWarning: invalid value encountered in cast\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2020/../../src/area_utils.py:454: RuntimeWarning: invalid value encountered in cast\n", " n_i_px = ((a_j / cm.sum(axis=0) * cm).sum(axis=1)).astype(np.uint64)\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2020/../../src/area_utils.py:461: RuntimeWarning: invalid value encountered in divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2020/../../src/area_utils.py:463: RuntimeWarning: invalid value encountered in divide\n", " cm_div = cm / n_j_su\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2020/../../src/area_utils.py:474: RuntimeWarning: divide by zero encountered in divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2020/../../src/area_utils.py:476: RuntimeWarning: divide by zero encountered in divide\n", " expr_3 = 1 / n_i_px**2\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2020/../../src/compare_covermaps.py:431: RuntimeWarning: invalid value encountered in scalar divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2020/../../src/compare_covermaps.py:469: RuntimeWarning: invalid value encountered in scalar divide\n", " expr1 = 2 * (r * dp + p * dr) / (p + r)\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2020/../../src/compare_covermaps.py:432: RuntimeWarning: invalid value encountered in scalar divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2020/../../src/compare_covermaps.py:470: RuntimeWarning: invalid value encountered in scalar divide\n", " expr2 = ((2 * p * r) * (dp + dr)) / ((p + r) * (p + r))\n" ] }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Ensemble maps: ['glad', 'worldcover-v200', 'esri-lulc']\n" - ] - }, { "data": { "text/html": [ @@ -383,24 +396,24 @@ " \n", " dynamicworld\n", " Tigray2020\n", - " 0.48\n", + " 0.50\n", " 0.11\n", - " 0.77\n", + " 0.78\n", " 0.02\n", - " 0.35\n", + " 0.37\n", " 0.03\n", " 0.95\n", " 0.01\n", - " 0.74\n", - " 0.06\n", - " 0.77\n", + " 0.76\n", + " 0.05\n", + " 0.78\n", " 0.02\n", " 127\n", " 298\n", - " 282\n", - " 16\n", - " 82\n", - " 45\n", + " 283\n", + " 15\n", + " 80\n", + " 47\n", " \n", " \n", " gfsad-gcep\n", @@ -537,24 +550,24 @@ " \n", " esri-lulc\n", " Tigray2020\n", - " 0.43\n", - " 0.11\n", + " 0.40\n", + " 0.10\n", " 0.76\n", " 0.02\n", - " 0.30\n", - " 0.03\n", - " 0.96\n", + " 0.27\n", + " 0.02\n", + " 0.97\n", " 0.01\n", - " 0.76\n", + " 0.77\n", " 0.06\n", " 0.76\n", " 0.02\n", " 127\n", " 298\n", - " 286\n", - " 12\n", - " 89\n", - " 38\n", + " 288\n", + " 10\n", + " 93\n", + " 34\n", " \n", " \n", " nabil-etal-2021\n", @@ -603,24 +616,24 @@ " \n", " ensemble-subset\n", " Tigray2020\n", - " 0.57\n", + " 0.60\n", " 0.10\n", - " 0.81\n", + " 0.82\n", " 0.02\n", - " 0.43\n", + " 0.46\n", " 0.03\n", " 0.97\n", " 0.01\n", - " 0.86\n", + " 0.87\n", " 0.04\n", - " 0.80\n", + " 0.81\n", " 0.02\n", " 127\n", " 298\n", " 289\n", " 9\n", - " 73\n", - " 54\n", + " 69\n", + " 58\n", " \n", " \n", "\n", @@ -635,17 +648,17 @@ "worldcereal-v100 Tigray2020 0.62 0.11 0.82 0.02 \n", "glad Tigray2020 0.51 0.11 0.78 0.02 \n", "asap Tigray2020 0.45 0.12 0.72 0.02 \n", - "dynamicworld Tigray2020 0.48 0.11 0.77 0.02 \n", + "dynamicworld Tigray2020 0.50 0.11 0.78 0.02 \n", "gfsad-gcep Tigray2020 0.00 NaN 0.70 0.02 \n", "gfsad-lgrip Tigray2020 0.54 0.12 0.75 0.02 \n", "digital-earth-africa Tigray2020 0.66 0.12 0.81 0.02 \n", "esa-cci-africa Tigray2020 0.53 0.11 0.68 0.02 \n", "globcover-v23 Tigray2020 0.42 0.11 0.61 0.02 \n", "globcover-v22 Tigray2020 0.49 0.11 0.66 0.02 \n", - "esri-lulc Tigray2020 0.43 0.11 0.76 0.02 \n", + "esri-lulc Tigray2020 0.40 0.10 0.76 0.02 \n", "nabil-etal-2021 Tigray2020 0.58 0.11 0.72 0.02 \n", "harvest-dev Tigray2020 0.69 0.11 0.83 0.02 \n", - "ensemble-subset Tigray2020 0.57 0.10 0.81 0.02 \n", + "ensemble-subset Tigray2020 0.60 0.10 0.82 0.02 \n", "\n", " crop_recall_pa std_crop_pa noncrop_recall_pa \\\n", "dataset \n", @@ -655,17 +668,17 @@ "worldcereal-v100 0.49 0.03 0.96 \n", "glad 0.38 0.03 0.96 \n", "asap 0.39 0.03 0.86 \n", - "dynamicworld 0.35 0.03 0.95 \n", + "dynamicworld 0.37 0.03 0.95 \n", "gfsad-gcep 0.00 0.00 1.00 \n", "gfsad-lgrip 0.48 0.03 0.87 \n", "digital-earth-africa 0.61 0.03 0.90 \n", "esa-cci-africa 0.61 0.04 0.70 \n", "globcover-v23 0.47 0.04 0.67 \n", "globcover-v22 0.55 0.04 0.70 \n", - "esri-lulc 0.30 0.03 0.96 \n", + "esri-lulc 0.27 0.02 0.97 \n", "nabil-etal-2021 0.63 0.04 0.76 \n", "harvest-dev 0.65 0.03 0.91 \n", - "ensemble-subset 0.43 0.03 0.97 \n", + "ensemble-subset 0.46 0.03 0.97 \n", "\n", " std_noncrop_pa crop_precision_ua std_crop_ua \\\n", "dataset \n", @@ -675,17 +688,17 @@ "worldcereal-v100 0.01 0.84 0.04 \n", "glad 0.01 0.79 0.05 \n", "asap 0.01 0.54 0.05 \n", - "dynamicworld 0.01 0.74 0.06 \n", + "dynamicworld 0.01 0.76 0.05 \n", "gfsad-gcep 0.00 0.00 -0.00 \n", "gfsad-lgrip 0.01 0.61 0.05 \n", "digital-earth-africa 0.01 0.72 0.04 \n", "esa-cci-africa 0.02 0.47 0.04 \n", "globcover-v23 0.02 0.38 0.04 \n", "globcover-v22 0.02 0.44 0.04 \n", - "esri-lulc 0.01 0.76 0.06 \n", + "esri-lulc 0.01 0.77 0.06 \n", "nabil-etal-2021 0.02 0.53 0.04 \n", "harvest-dev 0.01 0.75 0.04 \n", - "ensemble-subset 0.01 0.86 0.04 \n", + "ensemble-subset 0.01 0.87 0.04 \n", "\n", " noncrop_precision_ua std_noncrop_ua crop_support \\\n", "dataset \n", @@ -695,7 +708,7 @@ "worldcereal-v100 0.81 0.02 127 \n", "glad 0.78 0.02 127 \n", "asap 0.77 0.02 127 \n", - "dynamicworld 0.77 0.02 127 \n", + "dynamicworld 0.78 0.02 127 \n", "gfsad-gcep 0.70 0.02 127 \n", "gfsad-lgrip 0.80 0.02 127 \n", "digital-earth-africa 0.85 0.02 127 \n", @@ -705,7 +718,7 @@ "esri-lulc 0.76 0.02 127 \n", "nabil-etal-2021 0.83 0.02 127 \n", "harvest-dev 0.86 0.02 127 \n", - "ensemble-subset 0.80 0.02 127 \n", + "ensemble-subset 0.81 0.02 127 \n", "\n", " noncrop_support tn fp fn tp \n", "dataset \n", @@ -715,20 +728,20 @@ "worldcereal-v100 298 286 12 65 62 \n", "glad 298 285 13 79 48 \n", "asap 298 255 43 77 50 \n", - "dynamicworld 298 282 16 82 45 \n", + "dynamicworld 298 283 15 80 47 \n", "gfsad-gcep 298 298 0 127 0 \n", "gfsad-lgrip 298 259 39 66 61 \n", "digital-earth-africa 298 268 30 49 78 \n", "esa-cci-africa 298 209 89 49 78 \n", "globcover-v23 298 199 99 67 60 \n", "globcover-v22 298 210 88 57 70 \n", - "esri-lulc 298 286 12 89 38 \n", + "esri-lulc 298 288 10 93 34 \n", "nabil-etal-2021 298 227 71 47 80 \n", "harvest-dev 298 270 28 45 82 \n", - "ensemble-subset 298 289 9 73 54 " + "ensemble-subset 298 289 9 69 58 " ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -757,13 +770,13 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "9ee40aad", + "execution_count": 7, + "id": "f93f4cac", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -794,7 +807,7 @@ }, { "cell_type": "markdown", - "id": "27ace5b0", + "id": "2a4230cf", "metadata": {}, "source": [ "## 4. Visualize best available map" @@ -802,8 +815,8 @@ }, { "cell_type": "code", - "execution_count": 9, - "id": "70fcdc2a", + "execution_count": 8, + "id": "e1b03cd4", "metadata": {}, "outputs": [ { @@ -862,14 +875,6 @@ " skipEmptyTiles: true\n", "}});\"\"\")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6c365075", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -888,7 +893,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.8.15" } }, "nbformat": 4, diff --git a/maps/Tigray_2021/intercomparison.ipynb b/maps/Tigray_2021/intercomparison.ipynb index a82cc363..0bf9fb0e 100644 --- a/maps/Tigray_2021/intercomparison.ipynb +++ b/maps/Tigray_2021/intercomparison.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "352a94bb", + "id": "52082f37", "metadata": {}, "source": [ "# Intercomparison\n", @@ -19,7 +19,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "629d3a40", + "id": "f0facf19", "metadata": {}, "outputs": [], "source": [ @@ -28,8 +28,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "0fcf2de8", + "execution_count": 1, + "id": "8a336ddf", "metadata": {}, "outputs": [], "source": [ @@ -44,12 +44,12 @@ "sys.path.append(\"../..\")\n", "\n", "from src.compare_covermaps import TARGETS, filter_by_bounds, generate_report, CLASS_COL, COUNTRY_COL\n", - "from src.compare_covermaps import TEST_COUNTRIES, TEST_CODE" + "from src.compare_covermaps import TEST_COUNTRIES, TEST_CODE, TEST_YEARS" ] }, { "cell_type": "markdown", - "id": "c023e978", + "id": "28eb40dc", "metadata": {}, "source": [ "## 2. Read in evaluation set" @@ -57,8 +57,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "17eef755", + "execution_count": 2, + "id": "a6d85ab3", "metadata": {}, "outputs": [], "source": [ @@ -69,10 +69,19 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "67511a76", + "execution_count": 3, + "id": "267998c7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hkerner/anaconda3/envs/landcover-mapping/lib/python3.8/site-packages/geopandas/array.py:275: ShapelyDeprecationWarning: The array interface is deprecated and will no longer work in Shapely 2.0. Convert the '.coords' to a numpy array instead.\n", + " return GeometryArray(vectorized.points_from_xy(x, y, z), crs=crs)\n" + ] + } + ], "source": [ "df = pd.read_csv(dataset_path)[[\"lat\", \"lon\", \"class_probability\", \"subset\"]]\n", "df = df[(df[\"class_probability\"] != 0.5)].copy()\n", @@ -87,7 +96,7 @@ }, { "cell_type": "markdown", - "id": "cc36d8e2", + "id": "8f84e5fd", "metadata": {}, "source": [ "## 3. Run intercomparison" @@ -95,8 +104,8 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "2ab747cb", + "execution_count": 4, + "id": "e2c9f81f", "metadata": {}, "outputs": [], "source": [ @@ -105,8 +114,8 @@ }, { "cell_type": "code", - "execution_count": 6, - "id": "2d7b6bd5", + "execution_count": 5, + "id": "3d646936", "metadata": {}, "outputs": [ { @@ -114,12 +123,15 @@ "output_type": "stream", "text": [ "[Tigray2021] sampling copernicus...\n", + "using closest map year (2019) to test year (2021)\n", "[Tigray2021] sampling worldcover-v100...\n", "[Tigray2021] sampling worldcover-v200...\n", "[Tigray2021] sampling worldcereal-v100...\n", "[Tigray2021] sampling glad...\n", + "using closest map year (2019) to test year (2021)\n", "[Tigray2021] sampling asap...\n", "[Tigray2021] sampling dynamicworld...\n", + "using closest map year (2021) to test year (2021)\n", "[Tigray2021] sampling gfsad-gcep...\n", "[Tigray2021] sampling gfsad-lgrip...\n", "[Tigray2021] sampling digital-earth-africa...\n", @@ -127,6 +139,7 @@ "[Tigray2021] sampling globcover-v23...\n", "[Tigray2021] sampling globcover-v22...\n", "[Tigray2021] sampling esri-lulc...\n", + "using closest map year (2021) to test year (2021)\n", "[Tigray2021] sampling nabil-etal-2021...\n", "[Tigray2021] sampling harvest-dev...\n" ] @@ -137,51 +150,51 @@ " if country not in cropmap.countries:\n", " continue\n", " print(f\"[{country}] sampling \" + cropmap.title + \"...\")\n", - " map_sampled = cropmap.extract_test(gdf).copy()\n", + " map_sampled = cropmap.extract_test(gdf, TEST_YEARS[country]).copy()\n", " gdf = pd.merge(gdf, map_sampled, on=[\"lat\", \"lon\"], how=\"left\") " ] }, { "cell_type": "code", - "execution_count": 7, - "id": "b92e04a2", + "execution_count": 6, + "id": "6f92bf23", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ensemble maps: ['glad', 'worldcover-v200', 'esri-lulc']\n" + ] + }, { "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/Caskroom/miniconda/base/envs/landcover-mapping/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/Users/hkerner/anaconda3/envs/landcover-mapping/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/Caskroom/miniconda/base/envs/landcover-mapping/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/Users/hkerner/anaconda3/envs/landcover-mapping/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/Caskroom/miniconda/base/envs/landcover-mapping/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/Users/hkerner/anaconda3/envs/landcover-mapping/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2021/../../src/area_utils.py:362: RuntimeWarning: invalid value encountered in divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2021/../../src/area_utils.py:364: RuntimeWarning: invalid value encountered in divide\n", " area_matrix = (w_j * cm) / n_dotj\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2021/../../src/area_utils.py:383: RuntimeWarning: invalid value encountered in divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2021/../../src/area_utils.py:385: RuntimeWarning: invalid value encountered in divide\n", " u_j = p_jjs / p_dotjs\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2021/../../src/area_utils.py:452: RuntimeWarning: invalid value encountered in divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2021/../../src/area_utils.py:454: RuntimeWarning: invalid value encountered in divide\n", " n_i_px = ((a_j / cm.sum(axis=0) * cm).sum(axis=1)).astype(np.uint64)\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2021/../../src/area_utils.py:452: RuntimeWarning: invalid value encountered in cast\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2021/../../src/area_utils.py:454: RuntimeWarning: invalid value encountered in cast\n", " n_i_px = ((a_j / cm.sum(axis=0) * cm).sum(axis=1)).astype(np.uint64)\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2021/../../src/area_utils.py:461: RuntimeWarning: invalid value encountered in divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2021/../../src/area_utils.py:463: RuntimeWarning: invalid value encountered in divide\n", " cm_div = cm / n_j_su\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2021/../../src/area_utils.py:474: RuntimeWarning: divide by zero encountered in divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2021/../../src/area_utils.py:476: RuntimeWarning: divide by zero encountered in divide\n", " expr_3 = 1 / n_i_px**2\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2021/../../src/compare_covermaps.py:431: RuntimeWarning: invalid value encountered in scalar divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2021/../../src/compare_covermaps.py:469: RuntimeWarning: invalid value encountered in scalar divide\n", " expr1 = 2 * (r * dp + p * dr) / (p + r)\n", - "/Users/izvonkov/nasaharvest/crop-mask/maps/Tigray_2021/../../src/compare_covermaps.py:432: RuntimeWarning: invalid value encountered in scalar divide\n", + "/Users/hkerner/src/crop-mask/maps/Tigray_2021/../../src/compare_covermaps.py:470: RuntimeWarning: invalid value encountered in scalar divide\n", " expr2 = ((2 * p * r) * (dp + dr)) / ((p + r) * (p + r))\n" ] }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Ensemble maps: ['glad', 'worldcover-v200', 'esri-lulc']\n" - ] - }, { "data": { "text/html": [ @@ -382,24 +395,24 @@ " \n", " dynamicworld\n", " Tigray2021\n", - " 0.52\n", + " 0.53\n", " 0.11\n", - " 0.74\n", + " 0.75\n", " 0.03\n", " 0.39\n", " 0.03\n", " 0.95\n", " 0.01\n", - " 0.81\n", - " 0.06\n", + " 0.83\n", + " 0.05\n", " 0.73\n", " 0.03\n", " 109\n", " 188\n", - " 178\n", - " 10\n", - " 67\n", - " 42\n", + " 179\n", + " 9\n", + " 66\n", + " 43\n", " \n", " \n", " gfsad-gcep\n", @@ -536,24 +549,24 @@ " \n", " esri-lulc\n", " Tigray2021\n", - " 0.43\n", + " 0.47\n", " 0.12\n", - " 0.71\n", + " 0.72\n", " 0.03\n", - " 0.30\n", + " 0.34\n", " 0.03\n", " 0.94\n", " 0.01\n", - " 0.75\n", - " 0.07\n", - " 0.70\n", + " 0.77\n", + " 0.06\n", + " 0.71\n", " 0.03\n", " 109\n", " 188\n", " 177\n", " 11\n", - " 76\n", - " 33\n", + " 72\n", + " 37\n", " \n", " \n", " nabil-etal-2021\n", @@ -606,11 +619,11 @@ " 0.12\n", " 0.75\n", " 0.03\n", - " 0.43\n", + " 0.44\n", " 0.03\n", " 0.93\n", " 0.02\n", - " 0.78\n", + " 0.79\n", " 0.05\n", " 0.74\n", " 0.03\n", @@ -618,8 +631,8 @@ " 188\n", " 175\n", " 13\n", - " 62\n", - " 47\n", + " 61\n", + " 48\n", " \n", " \n", "\n", @@ -634,14 +647,14 @@ "worldcereal-v100 Tigray2021 0.53 0.12 0.74 0.03 \n", "glad Tigray2021 0.51 0.12 0.72 0.03 \n", "asap Tigray2021 0.49 0.13 0.67 0.03 \n", - "dynamicworld Tigray2021 0.52 0.11 0.74 0.03 \n", + "dynamicworld Tigray2021 0.53 0.11 0.75 0.03 \n", "gfsad-gcep Tigray2021 0.00 NaN 0.63 0.03 \n", "gfsad-lgrip Tigray2021 0.50 0.13 0.68 0.03 \n", "digital-earth-africa Tigray2021 0.56 0.13 0.70 0.03 \n", "esa-cci-africa Tigray2021 0.60 0.12 0.67 0.03 \n", "globcover-v23 Tigray2021 0.50 0.13 0.62 0.03 \n", "globcover-v22 Tigray2021 0.49 0.12 0.60 0.03 \n", - "esri-lulc Tigray2021 0.43 0.12 0.71 0.03 \n", + "esri-lulc Tigray2021 0.47 0.12 0.72 0.03 \n", "nabil-etal-2021 Tigray2021 0.55 0.13 0.67 0.03 \n", "harvest-dev Tigray2021 0.78 0.11 0.84 0.02 \n", "ensemble-subset Tigray2021 0.56 0.12 0.75 0.03 \n", @@ -661,10 +674,10 @@ "esa-cci-africa 0.68 0.04 0.67 \n", "globcover-v23 0.52 0.04 0.68 \n", "globcover-v22 0.52 0.04 0.65 \n", - "esri-lulc 0.30 0.03 0.94 \n", + "esri-lulc 0.34 0.03 0.94 \n", "nabil-etal-2021 0.56 0.04 0.73 \n", "harvest-dev 0.76 0.03 0.88 \n", - "ensemble-subset 0.43 0.03 0.93 \n", + "ensemble-subset 0.44 0.03 0.93 \n", "\n", " std_noncrop_pa crop_precision_ua std_crop_ua \\\n", "dataset \n", @@ -674,17 +687,17 @@ "worldcereal-v100 0.02 0.77 0.06 \n", "glad 0.02 0.71 0.06 \n", "asap 0.02 0.58 0.06 \n", - "dynamicworld 0.01 0.81 0.06 \n", + "dynamicworld 0.01 0.83 0.05 \n", "gfsad-gcep 0.00 0.00 -0.00 \n", "gfsad-lgrip 0.02 0.59 0.06 \n", "digital-earth-africa 0.02 0.61 0.05 \n", "esa-cci-africa 0.02 0.54 0.04 \n", "globcover-v23 0.02 0.48 0.05 \n", "globcover-v22 0.02 0.46 0.05 \n", - "esri-lulc 0.01 0.75 0.07 \n", + "esri-lulc 0.01 0.77 0.06 \n", "nabil-etal-2021 0.02 0.54 0.05 \n", "harvest-dev 0.02 0.79 0.04 \n", - "ensemble-subset 0.02 0.78 0.05 \n", + "ensemble-subset 0.02 0.79 0.05 \n", "\n", " noncrop_precision_ua std_noncrop_ua crop_support \\\n", "dataset \n", @@ -701,7 +714,7 @@ "esa-cci-africa 0.78 0.03 109 \n", "globcover-v23 0.71 0.03 109 \n", "globcover-v22 0.70 0.03 109 \n", - "esri-lulc 0.70 0.03 109 \n", + "esri-lulc 0.71 0.03 109 \n", "nabil-etal-2021 0.74 0.03 109 \n", "harvest-dev 0.86 0.02 109 \n", "ensemble-subset 0.74 0.03 109 \n", @@ -714,20 +727,20 @@ "worldcereal-v100 188 175 13 65 44 \n", "glad 188 170 18 65 44 \n", "asap 188 154 34 63 46 \n", - "dynamicworld 188 178 10 67 42 \n", + "dynamicworld 188 179 9 66 43 \n", "gfsad-gcep 188 188 0 109 0 \n", "gfsad-lgrip 188 155 33 62 47 \n", "digital-earth-africa 188 152 36 53 56 \n", "esa-cci-africa 188 126 62 35 74 \n", "globcover-v23 188 127 61 52 57 \n", "globcover-v22 188 122 66 52 57 \n", - "esri-lulc 188 177 11 76 33 \n", + "esri-lulc 188 177 11 72 37 \n", "nabil-etal-2021 188 137 51 48 61 \n", "harvest-dev 188 166 22 26 83 \n", - "ensemble-subset 188 175 13 62 47 " + "ensemble-subset 188 175 13 61 48 " ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -756,13 +769,13 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "7f8ac3e2", + "execution_count": 7, + "id": "6ad8bfa6", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -793,7 +806,7 @@ }, { "cell_type": "markdown", - "id": "fb2d6833", + "id": "1fdc06a9", "metadata": {}, "source": [ "## 4. Visualize best available map" @@ -801,8 +814,8 @@ }, { "cell_type": "code", - "execution_count": 9, - "id": "754eb625", + "execution_count": 8, + "id": "8cba4f1c", "metadata": {}, "outputs": [ { @@ -885,14 +898,6 @@ " skipEmptyTiles: true\n", "}});\"\"\")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "94789e93", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -911,7 +916,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.8.15" } }, "nbformat": 4, diff --git a/src/compare_covermaps.py b/src/compare_covermaps.py index 21c6fda4..23bf6aea 100644 --- a/src/compare_covermaps.py +++ b/src/compare_covermaps.py @@ -76,6 +76,30 @@ "Zambia2019": DATA_PATH + "Zambia_CEO_2019.csv", } +# Hold year of test files +TEST_YEARS = { + "Kenya": 2019, + "Togo": 2019, + "Tanzania": 2019, + "Malawi": 2020, + "Mali": 2019, + "Namibia": 2020, + "Rwanda": 2019, + "Uganda": 2019, + "Zambia": 2019, + "Senegal": 2022, + "Hawaii": 2020, + "BlueNile2020": 2020, + "BlueNile2019": 2019, + "AlGadaref2019": 2019, + "GedarefDarfurAlJazirah2022": 2022, + "BureJimma2019": 2019, + "BureJimma2020": 2020, + "Tigray2021": 2021, + "Tigray2020": 2020, + "Zambia2019": 2019, +} + REDUCER = ee.Reducer.mode() # MAP_COLUMN = "extracted" REDUCER_STR = "mode" @@ -108,12 +132,14 @@ def __init__( countries=None, probability=None, crop_labels=None, + years_covered=[], ) -> None: self.title = title self.title_safe = title.replace("-", "_") self.ee_asset_str = ee_asset_str self.ee_asset = eval(ee_asset_str.replace("\n", "").replace(" ", "")) self.resolution = resolution + self.years_covered = years_covered assert (probability is None) ^ ( crop_labels is None @@ -174,13 +200,25 @@ def ee_script(self, country: str, include_export: bool = True, include_prefix: b }});""" return script - def extract_test(self, test: gpd.GeoDataFrame) -> gpd.GeoDataFrame: + def extract_test(self, test: gpd.GeoDataFrame, year: int) -> gpd.GeoDataFrame: # Extract from countries that are covered by map test_points = test.loc[test[COUNTRY_COL].isin(self.countries)].copy() test_coll = ee.FeatureCollection( test_points.apply(lambda x: create_point(x), axis=1).to_list() ) + + if len(self.years_covered) > 1: + year_diff = [abs(y - year) for y in self.years_covered] + nearest_year_idx = min(enumerate(year_diff), key=lambda x: x[1])[0] + nearest_year = self.years_covered[nearest_year_idx] + self.ee_asset_str = self.ee_asset_str.replace("2019-01-01", + "%s-01-01" % nearest_year) + self.ee_asset_str = self.ee_asset_str.replace("2019-12-31", + "%s-12-31" % nearest_year) + self.ee_asset = eval(self.ee_asset_str.replace("\n", "").replace(" ", "")) + print('using closest map year (%s) to test year (%s)' % (nearest_year, year)) + sampled = extract_points(ic=self.ee_asset, fc=test_coll, resolution=self.resolution) if len(sampled) != len(test_points): print( @@ -270,7 +308,7 @@ def extract_covermaps(self, test_df): if country in map.countries: print(f"[{country}] sampling " + map.title + "...") - map_sampled = map.extract_test(country_test).copy() + map_sampled = map.extract_test(country_test, TEST_YEARS[country]).copy() country_test = pd.merge(country_test, map_sampled, on=[LAT, LON], how="left") country_test.drop_duplicates( inplace=True @@ -489,18 +527,21 @@ def generate_report(dataset_name: str, country: str, true, pred) -> pd.DataFrame .filterDate("2019-01-01", "2019-12-31")""", resolution=100, crop_labels=[40], + years_covered=[2015, 2016, 2017, 2018, 2019], ), "worldcover-v100": Covermap( "worldcover-v100", 'ee.ImageCollection("ESA/WorldCover/v100")', resolution=10, crop_labels=[40], + years_covered=[2020], ), "worldcover-v200": Covermap( "worldcover-v200", 'ee.ImageCollection("ESA/WorldCover/v200")', resolution=10, crop_labels=[40], + years_covered=[2021], ), "worldcereal-v100": Covermap( "worldcereal-v100", @@ -512,18 +553,21 @@ def generate_report(dataset_name: str, country: str, true, pred) -> pd.DataFrame )""", resolution=10, crop_labels=[100], + years_covered=[2020], ), "glad": Covermap( "glad", 'ee.ImageCollection("users/potapovpeter/Global_cropland_2019")', resolution=30, probability=0.5, + years_covered=[2003, 2007, 2011, 2015, 2019], ), # "gfsad": Covermap( # "gfsad", # ee.ImageCollection(ee.Image("USGS/GFSAD1000_V1")), # resolution=1000, # crop_labels=[1, 2, 3, 4, 5], + # years_covered=[2010], # ), "asap": Covermap( "asap", @@ -531,29 +575,33 @@ def generate_report(dataset_name: str, country: str, true, pred) -> pd.DataFrame resolution=1000, probability=100, countries=[country for country in TEST_COUNTRIES.keys() if country != "Hawaii"], + years_covered=[2017], ), "dynamicworld": Covermap( "dynamicworld", """ee.ImageCollection( ee.ImageCollection("GOOGLE/DYNAMICWORLD/V1") - .filter(ee.Filter.date("2019-01-01", "2020-01-01")) + .filter(ee.Filter.date("2019-01-01", "2019-12-31")) .select(["label"]) .mode() )""", resolution=10, crop_labels=[4], + years_covered=[2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023], ), "gfsad-gcep": Covermap( "gfsad-gcep", 'ee.ImageCollection("projects/sat-io/open-datasets/GFSAD/GCEP30")', resolution=30, crop_labels=[2], + years_covered=[2015], ), "gfsad-lgrip": Covermap( "gfsad-lgrip", 'ee.ImageCollection("projects/sat-io/open-datasets/GFSAD/LGRIP30")', resolution=30, crop_labels=[2, 3], + years_covered=[2015], ), "digital-earth-africa": Covermap( "digital-earth-africa", @@ -561,6 +609,7 @@ def generate_report(dataset_name: str, country: str, true, pred) -> pd.DataFrame resolution=10, crop_labels=[1], countries=[country for country in TEST_COUNTRIES.keys() if country != "Hawaii"], + years_covered=[2019], ), "esa-cci-africa": Covermap( "esa-cci-africa", @@ -570,6 +619,7 @@ def generate_report(dataset_name: str, country: str, true, pred) -> pd.DataFrame resolution=20, crop_labels=[4], countries=[country for country in TEST_COUNTRIES.keys() if country != "Hawaii"], + years_covered=[2016], ), "globcover-v23": Covermap( "globcover-v23", @@ -578,6 +628,7 @@ def generate_report(dataset_name: str, country: str, true, pred) -> pd.DataFrame )""", resolution=300, crop_labels=[11, 14, 20, 30], + years_covered=[2009], ), "globcover-v22": Covermap( "globcover-v22", @@ -586,14 +637,16 @@ def generate_report(dataset_name: str, country: str, true, pred) -> pd.DataFrame )""", resolution=300, crop_labels=[11, 14, 20, 30], + years_covered=[2005], ), "esri-lulc": Covermap( "esri-lulc", """ee.ImageCollection( "projects/sat-io/open-datasets/landcover/ESRI_Global-LULC_10m_TS" - ).filter(ee.Filter.date("2019-01-01", "2020-01-01"))""", + ).filter(ee.Filter.date("2019-01-01", "2019-12-31"))""", resolution=10, crop_labels=[5], + years_covered=[2017, 2018, 2019, 2020, 2021, 2022], ), "nabil-etal-2021": Covermap( "nabil-etal-2021", @@ -603,6 +656,7 @@ def generate_report(dataset_name: str, country: str, true, pred) -> pd.DataFrame resolution=30, crop_labels=[2], countries=[country for country in TEST_COUNTRIES.keys() if country != "Hawaii"], + years_covered=[2016], ), "harvest-crop-maps": Covermap( "harvest-crop-maps", From ac6cf35cea23235619bbd6901424b3b43ab16276 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 30 Nov 2023 19:09:01 +0000 Subject: [PATCH 2/5] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/compare_covermaps.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/compare_covermaps.py b/src/compare_covermaps.py index 23bf6aea..2fe04a60 100644 --- a/src/compare_covermaps.py +++ b/src/compare_covermaps.py @@ -212,12 +212,10 @@ def extract_test(self, test: gpd.GeoDataFrame, year: int) -> gpd.GeoDataFrame: year_diff = [abs(y - year) for y in self.years_covered] nearest_year_idx = min(enumerate(year_diff), key=lambda x: x[1])[0] nearest_year = self.years_covered[nearest_year_idx] - self.ee_asset_str = self.ee_asset_str.replace("2019-01-01", - "%s-01-01" % nearest_year) - self.ee_asset_str = self.ee_asset_str.replace("2019-12-31", - "%s-12-31" % nearest_year) + self.ee_asset_str = self.ee_asset_str.replace("2019-01-01", "%s-01-01" % nearest_year) + self.ee_asset_str = self.ee_asset_str.replace("2019-12-31", "%s-12-31" % nearest_year) self.ee_asset = eval(self.ee_asset_str.replace("\n", "").replace(" ", "")) - print('using closest map year (%s) to test year (%s)' % (nearest_year, year)) + print("using closest map year (%s) to test year (%s)" % (nearest_year, year)) sampled = extract_points(ic=self.ee_asset, fc=test_coll, resolution=self.resolution) if len(sampled) != len(test_points): From ee62741dffaad53e863ad0997d2dc32c5d41997b Mon Sep 17 00:00:00 2001 From: hannah-rae Date: Wed, 24 Jan 2024 08:33:46 -0700 Subject: [PATCH 3/5] Update tigray results with matching year --- maps/Tigray_2020/intercomparison.ipynb | 26 ++++++++++---------- maps/Tigray_2021/intercomparison.ipynb | 34 +++++++++++++------------- 2 files changed, 30 insertions(+), 30 deletions(-) diff --git a/maps/Tigray_2020/intercomparison.ipynb b/maps/Tigray_2020/intercomparison.ipynb index c4aab7a2..8fff9277 100644 --- a/maps/Tigray_2020/intercomparison.ipynb +++ b/maps/Tigray_2020/intercomparison.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "d4de5d42", + "id": "f1e93491", "metadata": {}, "source": [ "# Intercomparison\n", @@ -19,7 +19,7 @@ { "cell_type": "code", "execution_count": null, - "id": "6afae379", + "id": "801fe977", "metadata": {}, "outputs": [], "source": [ @@ -29,7 +29,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "7acdaedf", + "id": "48393c18", "metadata": {}, "outputs": [], "source": [ @@ -49,7 +49,7 @@ }, { "cell_type": "markdown", - "id": "95c2d844", + "id": "f47bdf42", "metadata": {}, "source": [ "## 2. Read in evaluation set" @@ -58,7 +58,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "836f84ee", + "id": "0a453845", "metadata": {}, "outputs": [], "source": [ @@ -70,7 +70,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "e6d43ebd", + "id": "b2893737", "metadata": {}, "outputs": [ { @@ -96,7 +96,7 @@ }, { "cell_type": "markdown", - "id": "ffa704d7", + "id": "44eb17fa", "metadata": {}, "source": [ "## 3. Run intercomparison" @@ -105,7 +105,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "5967f092", + "id": "b7a4ff2b", "metadata": {}, "outputs": [], "source": [ @@ -115,7 +115,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "c784a32f", + "id": "327acce1", "metadata": {}, "outputs": [ { @@ -158,7 +158,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "2d57edc5", + "id": "60f77f35", "metadata": {}, "outputs": [ { @@ -771,7 +771,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "f93f4cac", + "id": "4fd0dbeb", "metadata": {}, "outputs": [ { @@ -807,7 +807,7 @@ }, { "cell_type": "markdown", - "id": "2a4230cf", + "id": "9b7608b0", "metadata": {}, "source": [ "## 4. Visualize best available map" @@ -816,7 +816,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "e1b03cd4", + "id": "1204636e", "metadata": {}, "outputs": [ { diff --git a/maps/Tigray_2021/intercomparison.ipynb b/maps/Tigray_2021/intercomparison.ipynb index 0bf9fb0e..b3e43fb6 100644 --- a/maps/Tigray_2021/intercomparison.ipynb +++ b/maps/Tigray_2021/intercomparison.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "52082f37", + "id": "c42533f7", "metadata": {}, "source": [ "# Intercomparison\n", @@ -19,7 +19,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "f0facf19", + "id": "124b3a15", "metadata": {}, "outputs": [], "source": [ @@ -28,8 +28,8 @@ }, { "cell_type": "code", - "execution_count": 1, - "id": "8a336ddf", + "execution_count": 2, + "id": "a79b2425", "metadata": {}, "outputs": [], "source": [ @@ -49,7 +49,7 @@ }, { "cell_type": "markdown", - "id": "28eb40dc", + "id": "e7882a77", "metadata": {}, "source": [ "## 2. Read in evaluation set" @@ -57,8 +57,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "a6d85ab3", + "execution_count": 3, + "id": "8b7182b3", "metadata": {}, "outputs": [], "source": [ @@ -69,8 +69,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "267998c7", + "execution_count": 4, + "id": "c8776d17", "metadata": {}, "outputs": [ { @@ -86,7 +86,7 @@ "df = pd.read_csv(dataset_path)[[\"lat\", \"lon\", \"class_probability\", \"subset\"]]\n", "df = df[(df[\"class_probability\"] != 0.5)].copy()\n", "# use only test data because validation points used for harvest-dev map\n", - "df = df[df[\"subset\"] == \"testing\"].copy()\n", + "df = df[df[\"subset\"] == \"validation\"].copy()\n", "df[CLASS_COL] = (df[\"class_probability\"] > 0.5).astype(int)\n", "df[COUNTRY_COL] = country\n", "\n", @@ -96,7 +96,7 @@ }, { "cell_type": "markdown", - "id": "8f84e5fd", + "id": "bbc4369d", "metadata": {}, "source": [ "## 3. Run intercomparison" @@ -105,7 +105,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "e2c9f81f", + "id": "c1387b1b", "metadata": {}, "outputs": [], "source": [ @@ -115,7 +115,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "3d646936", + "id": "30ba54bc", "metadata": {}, "outputs": [ { @@ -157,7 +157,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "6f92bf23", + "id": "cec25c8f", "metadata": {}, "outputs": [ { @@ -770,7 +770,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "6ad8bfa6", + "id": "bcec7210", "metadata": {}, "outputs": [ { @@ -806,7 +806,7 @@ }, { "cell_type": "markdown", - "id": "1fdc06a9", + "id": "6ca6bbd8", "metadata": {}, "source": [ "## 4. Visualize best available map" @@ -815,7 +815,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "8cba4f1c", + "id": "2f23f6de", "metadata": {}, "outputs": [ { From 03fd6cefe752a872d54714038183856d643f2b08 Mon Sep 17 00:00:00 2001 From: adebowaledaniel Date: Thu, 2 May 2024 05:30:47 -0400 Subject: [PATCH 4/5] updates --- notebooks/Demo-notebook.ipynb | 1132 +++++++++++++++++++++++++++++++++ src/compare_covermaps.py | 50 +- 2 files changed, 1153 insertions(+), 29 deletions(-) create mode 100644 notebooks/Demo-notebook.ipynb diff --git a/notebooks/Demo-notebook.ipynb b/notebooks/Demo-notebook.ipynb new file mode 100644 index 00000000..e25775b4 --- /dev/null +++ b/notebooks/Demo-notebook.ipynb @@ -0,0 +1,1132 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "778ff440", + "metadata": { + "id": "778ff440" + }, + "source": [ + "# Intercomparison\n", + "\n", + "**Author:** Adebowale Adebayo\n", + "\n", + "**Last updated:** May 2, 2024\n", + "\n", + "**Description:** Runs intercomparison for Rwanda 2019\n", + "\n", + "## 1. Setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fb42d13c", + "metadata": { + "id": "fb42d13c" + }, + "outputs": [], + "source": [ + "# !earthengine authenticate" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "hZ8qzSlB75kl", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hZ8qzSlB75kl", + "outputId": "ef86cf07-d86d-447f-b329-ba594aac6e9c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cloning into 'crop-mask'...\n", + "remote: Enumerating objects: 12278, done.\u001b[K\n", + "remote: Counting objects: 100% (1689/1689), done.\u001b[K\n", + "remote: Compressing objects: 100% (506/506), done.\u001b[K\n", + "remote: Total 12278 (delta 1238), reused 1439 (delta 1155), pack-reused 10589\u001b[K\n", + "Receiving objects: 100% (12278/12278), 127.61 MiB | 12.31 MiB/s, done.\n", + "Resolving deltas: 100% (7960/7960), done.\n", + "Updating files: 100% (215/215), done.\n" + ] + } + ], + "source": [ + "!git clone https://github.com/nasaharvest/crop-mask.git" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1fe-6D3f8LTb", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1fe-6D3f8LTb", + "outputId": "353820e6-e57b-48f2-9d7d-03fdca241ce3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/content/crop-mask\n" + ] + } + ], + "source": [ + "%cd crop-mask/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "gEUyxHk9MEU2", + "metadata": { + "id": "gEUyxHk9MEU2" + }, + "outputs": [], + "source": [ + "!pip install cartopy -qq\n", + "!pip install rasterio -qq\n", + "!pip install dvc[gs] -qq" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "V-RT5I2kXJt4", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "V-RT5I2kXJt4", + "outputId": "94bad4b9-9a96-4126-bc5e-e6eb36120488" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "M\tsrc/compare_covermaps.py\n", + "Already on 'intercomparison-year'\n", + "Your branch is up to date with 'origin/intercomparison-year'.\n" + ] + } + ], + "source": [ + "!git checkout intercomparison-year" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "9907f9a5", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 17 + }, + "id": "9907f9a5", + "outputId": "d4738e50-7544-4718-b8d1-72bbb8c9e813" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import ee\n", + "import geemap\n", + "import sys\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "import geopandas as gpd\n", + "from pathlib import Path\n", + "\n", + "ee.Authenticate()\n", + "ee.Initialize(project=\"bsos-geog-harvest1\")\n", + "\n", + "sys.path.append(\"../..\")\n", + "\n", + "from src.compare_covermaps import TARGETS, filter_by_bounds, generate_report, CLASS_COL, COUNTRY_COL\n", + "from src.compare_covermaps import TEST_COUNTRIES, TEST_CODE" + ] + }, + { + "cell_type": "markdown", + "id": "c61ea4f8", + "metadata": { + "id": "c61ea4f8" + }, + "source": [ + "## 2. Read in evaluation set" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8PEZckm3kHLC", + "metadata": { + "id": "8PEZckm3kHLC" + }, + "outputs": [], + "source": [ + "!dvc pull data/datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "7f75e567", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 17 + }, + "id": "7f75e567", + "outputId": "a0a3c543-3aa7-4f1b-a040-8f3ce2053eed" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "country = \"Rwanda\"\n", + "test_year = 2019\n", + "\n", + "if country not in TEST_CODE:\n", + " print(f\"WARNING: {country} not found in TEST_CODE in src/compare_covermaps.py\")\n", + "if country not in TEST_COUNTRIES:\n", + " print(f\"WARNING: {country} not found in TEST_COUNTRIES in src/compare_covermaps.py\")\n", + "if country not in TEST_CODE or country not in TEST_COUNTRIES:\n", + " print(\"Please update src/compare_covermaps.py and restart the notebook.\")\n", + "else:\n", + " country_code = TEST_CODE[country]\n", + " dataset_path = TEST_COUNTRIES[country]" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "cPNeiKYFZaIG", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 17 + }, + "id": "cPNeiKYFZaIG", + "outputId": "a3339b8f-bde5-4283-e37b-8746272505e5" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if not Path(dataset_path).exists():\n", + " print(f\"WARNING: Dataset: {dataset_path} not found, run `dvc pull data/datasets from root.\")\n", + "else:\n", + " df = pd.read_csv(dataset_path)[[\"lat\", \"lon\", \"class_probability\", \"subset\"]]\n", + " df = df[(df[\"class_probability\"] != 0.5)].copy()\n", + " # use only test data because validation points used for harvest-dev map\n", + " df = df[df[\"subset\"] == \"testing\"].copy()\n", + " df[CLASS_COL] = (df[\"class_probability\"] > 0.5).astype(int)\n", + " df[COUNTRY_COL] = country\n", + "\n", + " gdf = gpd.GeoDataFrame(df, geometry=gpd.points_from_xy(df.lon, df.lat), crs=\"epsg:4326\")\n", + " gdf = filter_by_bounds(country_code=country_code, gdf=gdf)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "QXMdHSHVauqV", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 17 + }, + "id": "QXMdHSHVauqV", + "outputId": "4549bb58-b592-4dac-aa24-f7810ea32cc9" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gdf = filter_by_bounds(country_code=country_code, gdf=gdf)" + ] + }, + { + "cell_type": "markdown", + "id": "31341d98", + "metadata": { + "id": "31341d98" + }, + "source": [ + "## 3. Run intercomparison" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "ImkKe6cEB4aB", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "ImkKe6cEB4aB", + "outputId": "48d0ddd5-45de-43ee-966b-c40fba8e6981" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"gdf\",\n \"rows\": 199,\n \"fields\": [\n {\n \"column\": \"lat\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.40580891127152935,\n \"min\": -2.81041876,\n \"max\": -1.07754097,\n \"num_unique_values\": 194,\n \"samples\": [\n -1.49886104,\n -1.39165183,\n -1.50227347\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"lon\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.49762610519012174,\n \"min\": 28.90944267,\n \"max\": 30.80191399,\n \"num_unique_values\": 190,\n \"samples\": [\n 29.90328129,\n 30.17246763,\n 30.54009383\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"class_probability\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.3817294375245474,\n \"min\": 0.0,\n \"max\": 1.0,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.0,\n 0.6666666666666666,\n 0.3333333333333333\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"subset\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"testing\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"binary\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"country\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"Rwanda\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"geometry\",\n \"properties\": {\n \"dtype\": \"geometry\",\n \"num_unique_values\": 199,\n \"samples\": [\n \"POINT (29.69184887 -1.39237027)\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "gdf" + }, + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
latlonclass_probabilitysubsetbinarycountrygeometry
12-2.39391430.1652810.333333testing0RwandaPOINT (30.16528 -2.39391)
18-2.28622130.5926380.000000testing0RwandaPOINT (30.59264 -2.28622)
22-2.18013629.6974181.000000testing1RwandaPOINT (29.69742 -2.18014)
35-2.76350029.6403830.666667testing1RwandaPOINT (29.64038 -2.76350)
38-1.96902229.6954420.333333testing0RwandaPOINT (29.69544 -1.96902)
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n" + ], + "text/plain": [ + " lat lon class_probability subset binary country \\\n", + "12 -2.393914 30.165281 0.333333 testing 0 Rwanda \n", + "18 -2.286221 30.592638 0.000000 testing 0 Rwanda \n", + "22 -2.180136 29.697418 1.000000 testing 1 Rwanda \n", + "35 -2.763500 29.640383 0.666667 testing 1 Rwanda \n", + "38 -1.969022 29.695442 0.333333 testing 0 Rwanda \n", + "\n", + " geometry \n", + "12 POINT (30.16528 -2.39391) \n", + "18 POINT (30.59264 -2.28622) \n", + "22 POINT (29.69742 -2.18014) \n", + "35 POINT (29.64038 -2.76350) \n", + "38 POINT (29.69544 -1.96902) " + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gdf.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "5eLDrTRgnxD5", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 17 + }, + "id": "5eLDrTRgnxD5", + "outputId": "07931ac1-df0f-4ffa-f18b-a253fabf44ec" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# filter maps within +/- 1 of the test year\n", + "TARGETS = {k:v for k,v in TARGETS.items() if any(y in range(test_year - 1, test_year + 2) for y in v.years_covered)}" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "s_6ic76IeiJk", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 213 + }, + "id": "s_6ic76IeiJk", + "outputId": "94fe6516-232e-49ce-d791-594670d3a2bc" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Rwanda] sampling copernicus...\n", + "using closest map year (2019) to test year (2019)\n", + "[Rwanda] sampling worldcover-v100...\n", + "[Rwanda] sampling worldcereal-v100...\n", + "[Rwanda] sampling glad...\n", + "using closest map year (2019) to test year (2019)\n", + "[Rwanda] sampling dynamicworld...\n", + "using closest map year (2019) to test year (2019)\n", + "[Rwanda] sampling digital-earth-africa...\n", + "[Rwanda] sampling esri-lulc...\n", + "using closest map year (2019) to test year (2019)\n" + ] + } + ], + "source": [ + "for cropmap in TARGETS.values():\n", + " if country not in cropmap.countries:\n", + " continue\n", + " print(f\"[{country}] sampling \" + cropmap.title + \"...\")\n", + " map_sampled = cropmap.extract_test(gdf, test_year).copy()\n", + " gdf = pd.merge(gdf, map_sampled, on=[\"lat\", \"lon\"], how=\"left\")\n", + " gdf.drop_duplicates(inplace=True) # TODO find why points get duplicated" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "95a0f536", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 267 + }, + "id": "95a0f536", + "outputId": "09e0071f-dcab-43dc-8574-0376c42519c5" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Rwanda] calculating pixel area for copernicus...\n", + "Export task started for copernicus, Rwanda. Returning null for now.\n", + "[Rwanda] calculating pixel area for worldcover-v100...\n", + "Export task started for worldcover-v100, Rwanda. Returning null for now.\n", + "[Rwanda] calculating pixel area for worldcereal-v100...\n", + "Export task started for worldcereal-v100, Rwanda. Returning null for now.\n", + "[Rwanda] calculating pixel area for glad...\n", + "Export task started for glad, Rwanda. Returning null for now.\n", + "[Rwanda] calculating pixel area for dynamicworld...\n", + "Export task started for dynamicworld, Rwanda. Returning null for now.\n", + "[Rwanda] calculating pixel area for digital-earth-africa...\n", + "Export task started for digital-earth-africa, Rwanda. Returning null for now.\n", + "[Rwanda] calculating pixel area for esri-lulc...\n", + "Export task started for esri-lulc, Rwanda. Returning null for now.\n" + ] + } + ], + "source": [ + "a_j = {}\n", + "for cropmap in TARGETS.values():\n", + " if country not in cropmap.countries:\n", + " continue\n", + " print(f\"[{country}] calculating pixel area for \" + cropmap.title + \"...\")\n", + " a_j[cropmap.title] = cropmap.compute_map_area(country, export=True, dataset_name=cropmap.title).copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "5fJPzvOeUo9G", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 17 + }, + "id": "5fJPzvOeUo9G", + "outputId": "52f5a181-76e5-4404-c690-666b7981a826" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# update a_j values with exported values\n", + "for cropmap in a_j.keys():\n", + " try:\n", + " area_df = pd.read_csv(f'./Crop_NonCrop_Area_Sum_Export-{country}-{cropmap}.csv')\n", + " except:\n", + " continue\n", + " crop_area = int(area_df['crop_sum'][0])\n", + " noncrop_area = int(area_df['noncrop_sum'][0])\n", + " a_j[cropmap] = np.array([noncrop_area, crop_area])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "wF1Wz-d7lmwo", + "metadata": { + "id": "wF1Wz-d7lmwo" + }, + "outputs": [], + "source": [ + "comparisons = []\n", + "for cropmap in TARGETS.keys():\n", + " if cropmap not in gdf.columns:\n", + " continue\n", + " temp = gdf[[CLASS_COL, cropmap]].dropna()\n", + " comparison = generate_report(cropmap, country, temp[CLASS_COL], temp[cropmap], a_j[cropmap], area_weighted=True)\n", + " comparisons.append(comparison)\n", + "\n", + "results = pd.concat(comparisons).set_index([\"dataset\"])\n", + "\n", + "results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fraQjcTMpTwp", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "fraQjcTMpTwp", + "outputId": "914a654c-2f5c-42ea-c520-ae6467f32580" + }, + "outputs": [], + "source": [ + "crop_proportion = round(gdf[CLASS_COL].value_counts(normalize=True)[1], 4) * 100\n", + "ax = results.sort_values(\"crop_f1\").plot(\n", + " y=[\"accuracy\", \"crop_recall_pa\", \"crop_precision_ua\", \"crop_f1\"],\n", + " xerr=\"std_crop_f1\",\n", + " kind=\"barh\",\n", + " figsize=(6, 14),\n", + " width=0.8,\n", + " title=f\"{country}: {len(gdf)} points (crop proportion: {crop_proportion}%)\",\n", + ");\n", + "\n", + "for c in ax.containers[1::2]:\n", + " ax.bar_label(c)\n", + "\n", + "for border in [\"top\", \"right\", \"bottom\", \"left\"]:\n", + " ax.spines[border].set_visible(False)\n", + "\n", + "ax.legend(bbox_to_anchor=(1, 1), reverse=True);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "gfTIBg6cwwAZ", + "metadata": { + "id": "gfTIBg6cwwAZ" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.8.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/compare_covermaps.py b/src/compare_covermaps.py index b8f0b6e9..aa2ce3cb 100644 --- a/src/compare_covermaps.py +++ b/src/compare_covermaps.py @@ -1,6 +1,7 @@ __author__ = "Adam Yang, Hannah Kerner" from pathlib import Path +import re import cartopy.io.shapereader as shpreader import ee @@ -55,13 +56,13 @@ # Hold directories of test files TEST_COUNTRIES = { "Kenya": DATA_PATH + "KenyaCEO2019.csv", - "Togo": DATA_PATH + "Togo.csv", + "Togo": DATA_PATH + "Togo_2019.csv", "Tanzania": DATA_PATH + "Tanzania_CEO_2019.csv", "Malawi": DATA_PATH + "Malawi_CEO_2020.csv", "Mali": DATA_PATH + "MaliStratifiedCEO2019.csv", "Namibia": DATA_PATH + "Namibia_CEO_2020.csv", - "Rwanda": DATA_PATH + "Rwanda.csv", - "Uganda": DATA_PATH + "Uganda.csv", + "Rwanda": DATA_PATH + "Rwanda_2019.csv", + "Uganda": DATA_PATH + "Uganda_2019.csv", "Zambia": DATA_PATH + "Zambia_CEO_2019.csv", "Senegal": DATA_PATH + "Senegal_CEO_2022.csv", "Hawaii": DATA_PATH + "Hawaii_CEO_2020.csv", @@ -76,30 +77,6 @@ "Zambia2019": DATA_PATH + "Zambia_CEO_2019.csv", } -# Hold year of test files -TEST_YEARS = { - "Kenya": 2019, - "Togo": 2019, - "Tanzania": 2019, - "Malawi": 2020, - "Mali": 2019, - "Namibia": 2020, - "Rwanda": 2019, - "Uganda": 2019, - "Zambia": 2019, - "Senegal": 2022, - "Hawaii": 2020, - "BlueNile2020": 2020, - "BlueNile2019": 2019, - "AlGadaref2019": 2019, - "GedarefDarfurAlJazirah2022": 2022, - "BureJimma2019": 2019, - "BureJimma2020": 2020, - "Tigray2021": 2021, - "Tigray2020": 2020, - "Zambia2019": 2019, -} - REDUCER = ee.Reducer.mode() # MAP_COLUMN = "extracted" REDUCER_STR = "mode" @@ -385,6 +362,19 @@ def get_test_points(self, targets=None) -> gpd.GeoDataFrame: return test + def get_test_years(self): + """ + Returns a dictionary containing the test years for each test file. + """ + test_years = {} + for country in TEST_COUNTRIES.keys(): + match = re.search(r"\d{4}", TEST_COUNTRIES[country]) + if match: + test_years[country] = match.group(0) + else: + test_years[country] = None + return test_years + def extract_covermaps(self, test_df): """ Groups testing points by country then extracts from each map. If map does not include @@ -392,6 +382,8 @@ def extract_covermaps(self, test_df): each country then added to sampled_maps, where key = country and value = a dataframe of extracted points from maps. """ + test_years = self.get_test_years() + for country in self.test_countries: country_test = test_df.loc[test_df[COUNTRY_COL] == country].copy() @@ -401,7 +393,7 @@ def extract_covermaps(self, test_df): if country in map.countries: print(f"[{country}] sampling " + map.title + "...") - map_sampled = map.extract_test(country_test, TEST_YEARS[country]).copy() + map_sampled = map.extract_test(country_test, test_years[country]).copy() country_test = pd.merge(country_test, map_sampled, on=[LAT, LON], how="left") country_test.drop_duplicates( inplace=True @@ -824,7 +816,7 @@ def generate_report( 'ee.ImageCollection("users/potapovpeter/Global_cropland_2019")', resolution=30, probability=0.5, - years_covered=[2003, 2007, 2011, 2015, 2019], + years_covered=[2019], ), # "gfsad": Covermap( # "gfsad", From 31ddb760b8fffa4340b37702eac9352a317c30c4 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 2 May 2024 09:31:12 +0000 Subject: [PATCH 5/5] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/compare_covermaps.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compare_covermaps.py b/src/compare_covermaps.py index aa2ce3cb..d06ea24b 100644 --- a/src/compare_covermaps.py +++ b/src/compare_covermaps.py @@ -1,7 +1,7 @@ __author__ = "Adam Yang, Hannah Kerner" -from pathlib import Path import re +from pathlib import Path import cartopy.io.shapereader as shpreader import ee