NDVI_train_sen1_sen2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "099199ce-e268-4a9e-9c58-ecc0d53e09dc",
   "metadata": {},
   "source": [
    "# Using Sentinel-1 and -2 data to build a land use classification model/ Ứng dụng ảnh viễn thám Sentinel 1 và Sentinel-2  trong phân loại hiện trạng sử dụng đất (thí điểm tại xã Thuận Hòa, huyện Châu Thành, tỉnh Sóc Trăng)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a2286cb-986b-4762-8d07-559351ad286a",
   "metadata": {},
   "source": [
    "## Overview/Tổng quan\n",
    "This notebook will take you through a workflow for processing Sentinel-1 and -2 data./ Phần này hướng dẫn quy trình xử lý ảnh Sentinel 1 và 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "751b99d9-16a4-4219-969e-8dc2bb7a8231",
   "metadata": {},
   "source": [
    "## Required datafiles/Các dữ liệu yêu cầu\n",
    "This notebook requires three files:/ Trong phần này, các dữ liệu được yêu cầu bao gồm:\n",
    "- A shapefile that contains land use information/Dữ liệu điểm khảo sát thực địa: `ST_training data_updated_1130points.shp`\n",
    "- A raster sentinel-1 vv file (single VV polarisation)/Dữ liệu ảnh Sentinel 1 phân cực VV định dạng raster: `vv-0922_0923-full_ST.tif`\n",
    "- A raster sentinel-1 vh file (single VH polarisation) )/Dữ liệu ảnh Sentinel 1 phân cực VH định dạng raster: `vh-0922_0923-full_ST.tif`\n",
    "[Sentinel-1](https://sentinels.copernicus.eu/web/sentinel/user-guides/sentinel-1-sar/product-overview/polarimetry) can collect several different images from the same series of pulses by using its antenna to receive specific polarisations simultaneously. Sentinel-1 is a phase-preserving dual polarisation SAR system. It can transmit a signal in either horizontal (H) or vertical (V) polarisation, and then receive in both H and V polarisations./ Sentinel 1 là vệ tinh RADAR khẩu độ tổng hợp có thể thu thập các ảnh khác nhau từ một chuỗi ảnh bằng việc sử dụng ăng ten thu nhận đồng thời các phân cực (VH, VV). Sentinel 1 là ảnh SAR với phân cực kép, có thể truyền tín hiệu theo phân cực ngang (H), phân cực dọc (V), sau đó nhận tín hiệu ở cả phân cực H và V."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26a458ed-e2ce-4612-aeb8-c23ec0a8bb1f",
   "metadata": {},
   "source": [
    "## Setting up your notebook/Cài đặt notebook của bạn\n",
    "\n",
    "We will now setup your notebook so that you have all of the required python modules to query, analyse and plot the data./Chúng tôi sẽ thiết lập Notebook để người dùng có tất cả các mô-đun cần thiết cho truy vấn, phân tích và vẽ biểu đồ dữ liệu"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9211f1a0-a886-49c5-a59c-426ad96c9829",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Import modules/Nhập các mô-đun"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5cc4a2e-a76b-45af-85b2-9b180b9f0341",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "# Basic plots\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "# plt.rcParams['figure.figsize'] = [12, 8]\n",
    "\n",
    "# Common imports and settings\n",
    "import os, sys\n",
    "os.environ['USE_PYGEOS'] = '0'\n",
    "from IPython.display import Markdown\n",
    "import pandas as pd\n",
    "pd.set_option(\"display.max_rows\", None)\n",
    "import xarray as xr\n",
    "\n",
    "# Datacube\n",
    "import datacube\n",
    "from datacube.utils.rio import configure_s3_access\n",
    "from datacube.utils import masking\n",
    "from datacube.utils.cog import write_cog\n",
    "# https://github.com/GeoscienceAustralia/dea-notebooks/tree/develop/Tools\n",
    "from dea_tools.plotting import display_map, rgb\n",
    "from dea_tools.datahandling import mostcommon_crs\n",
    "\n",
    "# EASI defaults\n",
    "easinotebooksrepo = '/home/jovyan/easi-notebooks'\n",
    "if easinotebooksrepo not in sys.path: sys.path.append(easinotebooksrepo)\n",
    "from easi_tools import EasiDefaults, xarray_object_size, notebook_utils, unset_cachingproxy\n",
    "from easi_tools.load_s2l2a import load_s2l2a_with_offset\n",
    "\n",
    "# Data tools\n",
    "import numpy as np\n",
    "from datetime import datetime\n",
    "\n",
    "# Datacube\n",
    "from datacube.utils import masking  # https://github.com/opendatacube/datacube-core/blob/develop/datacube/utils/masking.py\n",
    "from odc.algo import enum_to_bool   # https://github.com/opendatacube/odc-algo/blob/main/odc/algo/_masking.py\n",
    "from odc.algo import xr_reproject   # https://github.com/opendatacube/odc-algo/blob/main/odc/algo/_warp.py\n",
    "from datacube.utils.geometry import GeoBox, box  # https://github.com/opendatacube/datacube-core/blob/develop/datacube/utils/geometry/_base.py\n",
    "\n",
    "# Holoviews, Datashader and Bokeh\n",
    "import hvplot.pandas\n",
    "import hvplot.xarray\n",
    "import holoviews as hv\n",
    "import panel as pn\n",
    "import colorcet as cc\n",
    "import cartopy.crs as ccrs\n",
    "from datashader import reductions\n",
    "from holoviews import opts\n",
    "from utils import load_data_geo\n",
    "import rasterio\n",
    "import os\n",
    "import rioxarray\n",
    "# import geoviews as gv\n",
    "# from holoviews.operation.datashader import rasterize\n",
    "hv.extension('bokeh', logo=False)\n",
    "\n",
    "from deafrica_tools.bandindices import calculate_indices\n",
    "import numpy as np\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "import joblib"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bd3db48-6165-464b-b6ef-2154eb47c31d",
   "metadata": {},
   "source": [
    "### Setting up dask/Thiết lập dask\n",
    "We will now set up a dask cluster. The below code sets up a 'dask gateway' which allows processing of up to 10 worker nodes (cores) for fast parallel processing./Chúng ta sẽ thiết lập cụm dask. Đoạn code dưới đây cho phép thiết lập một “cổng dask” với việc xử lý tối đa 10 lõi chạy song song.\n",
    "The below code usually takes about 3 minutes to run while dask starts up a new cluster. Once the cluser has initiliased, you can click Launch dashboard in JupyterLab to monitor the cluster acitivity./Code này mất 3 phút để chạy khi dask khởi tạo một cụm mới. Khởi chạy bảng điều khiển trong JupyterLan để theo dõi hoạt động của cụm vừa được tạo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "895a3fe1-0595-4505-9c71-657b811902f0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "# Dask gateway\n",
    "cluster, client = notebook_utils.initialize_dask(use_gateway=True, workers=(1,10))\n",
    "client"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "286f1c3d-5373-4436-b8ee-d7c0bd5db0f3",
   "metadata": {},
   "source": [
    "### Loading the datacube/Tải khối dữ liệu\n",
    "Next we load the datacube object. This datacube is what we will use to read the satellite data into memory. We must also configure s3 access to the Sentinel-2 data which is available in the cloud./Datacube chính là khối dữ liệu chứa các ảnh viễn thám. Trong đó, chúng ta cần cấu hình quyền truy cập vào dữ liệu Sentinel 2 có sẵn trên đám mây."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "064d32ec-0731-4af2-8404-517239d01ef7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Initialise a datacube object\n",
    "dc = datacube.Datacube()\n",
    "\n",
    "# Configure s3 access\n",
    "configure_s3_access(aws_unsigned=False, requester_pays=True, client=client)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93fe5130-062a-4da1-bb40-5e20b598cfe4",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Defining a search query/Truy vấn dữ liệu\n",
    "We now need to query the sentinel-2 cloud database on EASI. To extract data we define a query dictionary that contains search criteria such as spatial and temporal limits./ Bây giờ chúng ta cần truy vấn cơ sở dữ liệu đám mây Sentinel-2 trên EASI. Để trích xuất dữ liệu, xác định các tiêu chí, điều kiện truy vấn như giới hạn không gian (khu vực nghiên cứu), thời gian (giai đoạn nghiên cứu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f9e762f-ce8d-4542-9838-46494b1c5ca8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Specify the start and end times \n",
    "min_date = '2022-09-01' # Thời gian bắt đầu lấy data cho quá trình train\n",
    "max_date = '2023-10-01' # Thời gian kết thúc lấy data cho quá trình train\n",
    "# Just do 1 month for testing\n",
    "# max_date = '2022-10-01' # Thời gian kết thúc lấy data cho quá trình train\n",
    "\n",
    "# Specify a spatail region to search using latitude/longitude cooridinates\n",
    "min_longitude, max_longitude = (105.5, 106.4)\n",
    "min_latitude, max_latitude = (9.2, 10.0)\n",
    "\n",
    "# Specify the product. In this case we want to use Sentinel-2 Level-2A data\n",
    "product = 's2_l2a'\n",
    "\n",
    "# Construct the search query dictionary\n",
    "query = {\n",
    "    'product': product,                     # Product name\n",
    "    'x': (min_longitude, max_longitude),    # \"x\" axis bounds\n",
    "    'y': (min_latitude, max_latitude),      # \"y\" axis bounds\n",
    "    'time': (min_date, max_date),           # Any parsable date strings\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71346d66-d50b-4a97-93b8-79f795236fac",
   "metadata": {},
   "source": [
    "### Most common CRS/Hệ quy chiếu, phép chiếu phổ biến\n",
    "We can select the most appropriate CRS projection using the notebook_utils helper function. This function takes into account the data product and spatial location and determines the most common CRS for that region. It generally takes 1-2 seconds to find the most common CRS./ Chúng ta có thể chọn phép chiếu CRS phù hợp nhất ứng dụng hàm trợ giúp notebook_utils. Hàm này xem xét cả về dữ liệu và vị trí không gian, xác định CRS phổ biến nhất cho khu vực quan sát. Thông thường sẽ mất 1-2 giây để tìm CRS phổ biến nhất."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "621fa104-d1fd-45bf-a048-f6c7d4efd073",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Most common CRS\n",
    "native_crs = notebook_utils.mostcommon_crs(dc, query)\n",
    "print(f'Most common native CRS: {native_crs}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "651f198b-78a6-4bbb-8dff-581586c3353f",
   "metadata": {},
   "source": [
    "### Target xarray parameters/Các thông số xarray mục tiêu\n",
    "Next we can define which target parameters we would like to load into our xarray object. In general we need to:/ Tiếp theo, chúng ta xác định tham số nào cần tải về cho đối tượng xrray. Cụ thể:\n",
    "- Select a set of measurements to load/Chọn một tập hợp các kênh ảnh cần tải \n",
    "- Define an appropriate output CRS and resolution/Xác định hệ quy chiếu và độ phân giải ảnh\n",
    "- Decide on how we group the data (usually we groupby input scenes on the same day to a single time layer)./Xác định các nhóm dữ liệu (thông thường các dữ liệu cùng ngày sẽ được nhóm vào cùng 1 lớp dữ liệu thời gian)\n",
    "- Select a reasonable Dask chunk size (this should be adjusted depending on the spatial and resolution parameters you choose/Chọn kích thước Chun dask phù hợp (nó được điều chỉnh phụ thuộc vào thông số thời gian và không gian)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6122b1f8-299e-4f34-839e-47ef288748e5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Specify the spectral band measurements we want to use for a classification algorithm\n",
    "measurements = ['blue', 'green', 'red', 'nir', 'scl']\n",
    "\n",
    "load_params = {\n",
    "    'measurements': measurements,                   # Selected measurement or alias names\n",
    "    'output_crs': native_crs,                       # Target EPSG code\n",
    "    'resolution': (-10, 10),                        # Target resolution\n",
    "    'group_by': 'solar_day',                        # Scene grouping\n",
    "    'dask_chunks': {'x': 2048, 'y': 2048},          # Dask chunks\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48033fbb-364a-482c-a12d-567bd6389410",
   "metadata": {},
   "source": [
    "### Loading the data/Tải dữ liệu\n",
    "We are now read to load the data into our datacube object. For sentinel-2 data we can use the **load_s2l2a_with_offset** helper function so that the sentinel-2 scale and offset coefficients are applied correctly. More information on this issue is discussed here./ Chúng ta đang đọc để tải dữ liệu vào datacube của bản thân. Đối với dữ liệu Sentinel-2, chúng ta có thể sử dụng hàm trợ giúp **Load_s2l2a_with_offset** để thang đo Sentinel-2 và các hệ số bù được áp dụng chính xác. Thông tin thêm về vấn đề này được thảo luận ở đây."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c15449f3-e7a6-47fb-a19f-3b7b25b4dcc7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "# The replacement \"dc.load()\" function for this product\n",
    "data = load_s2l2a_with_offset(\n",
    "    dc,\n",
    "    query | load_params   # Combine the two dicts that contain our search and load parameters\n",
    ")\n",
    "\n",
    "# This line prints the total size of the dataset hat was loaded\n",
    "notebook_utils.heading(notebook_utils.xarray_object_size(data))\n",
    "\n",
    "display(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a696f39e-b6b5-4b35-8cb3-bafb0a7fcdf9",
   "metadata": {},
   "source": [
    "### Masking\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a854986c-6088-48d7-940b-a8fd54a9cf42",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# # Get the scale factor and offset from the measurement metadata\n",
    "# measurement_info = dc.list_measurements().loc[query1['product']].loc[query1['measurements']]  # Pandas dataframe\n",
    "# display(measurement_info)\n",
    "\n",
    "# The \"SCL\" band contains quality flags and information. The details can also be found in the metadata.\n",
    "flag_name = 'scl'\n",
    "flag_desc = masking.describe_variable_flags(data[flag_name])  # Pandas dataframe\n",
    "display(flag_desc)\n",
    "display(flag_desc.loc['qa'].values[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f158cdaa-26f5-42d4-a17f-558a130bddf7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Create a \"data quality\" Mask layer\n",
    "flags_def = flag_desc.loc['qa'].values[1]\n",
    "good_pixel_flags = [flags_def[str(i)] for i in [2, 4, 5, 6]]  # To pass strings to enum_to_bool()\n",
    "\n",
    "# enum_to_bool calculates the pixel-wise \"or\" of each set of pixels given by good_pixel_flags\n",
    "# 1 = good data\n",
    "# 0 = \"bad\" data\n",
    "\n",
    "good_pixel_mask = enum_to_bool(data[flag_name], good_pixel_flags)  # -> DataArray\n",
    "# display(good_pixel_mask)  # Type: bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b05c9700-7e21-4375-bace-97981b504607",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data_layer_names = [x for x in data.data_vars if x != 'scl']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4b6cf86-24e8-48ae-9e47-28dbd834092b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data_layer_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87a1cf88-35de-403f-ac6a-d9da8fa86c40",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from dask.distributed import progress\n",
    "\n",
    "# Apply good pixel mask to blue, green, red and nir.\n",
    "result = data[data_layer_names].where(good_pixel_mask).persist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cc0eb46-7725-4b6b-89e7-dd42ab5092b5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This computation can take 5 minutes\n",
    "progress(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df934caf-7863-4175-b95a-3c198486f29e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ds1 = calculate_indices(result, index='NDVI', satellite_mission='s2')\n",
    "ndvi = ds1[\"NDVI\"]\n",
    "average_ndvi = ndvi.resample(time='1M').mean().persist()  ## tính mean cho từng tháng -> time = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "070ad733-2f73-4f90-98d5-33d058920ad8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This takes 48.8s\n",
    "progress(average_ndvi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2908bb77-4a3f-4a84-9e1f-8c03337bdb36",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "average_ndvi = average_ndvi.compute()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09f8ba5f-4f85-41b5-abc6-282bc7dcdd84",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "plt.imshow(average_ndvi.isel(time=5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f82aa94f-f9df-4f4e-b8b0-ea757ced2197",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "filled_ds = average_ndvi.bfill(dim='time')\n",
    "filled_ds = filled_ds.ffill(dim='time')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2270864f-a49b-42b5-9e9a-c14a93ec106b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "plt.imshow(filled_ds.isel(time=5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb5dbf9a-fb43-4fab-a4d5-65e79eb12d75",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "train_path = \"train/ST_training data_updated_1130points.shp\"  # đường dẫn shp file train\n",
    "train = load_data_geo(train_path)\n",
    "train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42505741-bf58-443e-8eb4-df7dd61743b8",
   "metadata": {},
   "source": [
    "## Downloading Sentinel-1 data/Tải ảnh Sentinel 1\n",
    "The sentinel-1 data files are available via an s3 bucket. To download the files locally we will use the aws client. First, check the files are available on the s3 bucket:/ Các dữ liệu ảnh Sentinel-1 có sẵn thông qua S3 (dịch vụ lưu trữ và truy xuất của Amazon). Để tải xuống các tệp cục bộ, chúng tôi sẽ sử dụng ứng dụng khách của aws. Trước tiên, kiểm tra các tệp có sẵn trên s3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cde28519-eb78-4c9e-9265-e8f3057e66dc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "# The downloads take 2-3 minutes to complete.\n",
    "import os\n",
    "if not os.path.exists(\"vh-0922_0923-full_ST.tif\"):\n",
    "    !aws s3 cp s3://easi-asia-dc-data/staging/ctu/sentinel-1/vh-0922_0923-full_ST.tif vh-0922_0923-full_ST.tif\n",
    "if not os.path.exists(\"vv-0922_0923-full_ST.tif\"):\n",
    "    !aws s3 cp s3://easi-asia-dc-data/staging/ctu/sentinel-1/vv-0922_0923-full_ST.tif vv-0922_0923-full_ST.tif"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6047930-2e50-4504-8831-536605f85cc2",
   "metadata": {},
   "source": [
    "### Load Sentinel-1 data/ Tải dữ liệu Senttinel từ S3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4fdebb4-ee52-45ff-9487-be191cb0c813",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "vvpath = 'vv-0922_0923-full_ST.tif'\n",
    "vhpath = 'vh-0922_0923-full_ST.tif'\n",
    "\n",
    "dsvv = rioxarray.open_rasterio(vvpath)\n",
    "dsvh = rioxarray.open_rasterio(vhpath)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "031323c0-8b11-4dc4-9321-979386e0a06d",
   "metadata": {},
   "source": [
    "### Label the training data/ Thống nhất nhãn dữ liệu thực địa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "701d82b1-ff6c-438d-a8a3-6cdc37f64b85",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "# Takes 1 minute to complete.\n",
    "loaded_datasets = {}\n",
    "for idx, point in train.iterrows():\n",
    "    key = f\"point_{idx + 1}\"\n",
    "    try:\n",
    "        ndvi_data = filled_ds.sel(x=point.geometry.x, y=point.geometry.y, method='nearest').values\n",
    "        vh_data = dsvh.sel(x=point.geometry.x, y=point.geometry.y, method='nearest').values\n",
    "        vv_data = dsvv.sel(x=point.geometry.x, y=point.geometry.y, method='nearest').values\n",
    "        loaded_datasets[key] = {\n",
    "            \"data\": np.concatenate((ndvi_data, vh_data, vv_data)),\n",
    "            \"label\": point.HT_code\n",
    "                               }\n",
    "    except Exception as e:\n",
    "        # loaded_datasets[key] = None\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "496b3b9d-1ab4-41da-800d-dffeb86e2b1e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "label_mapping = {\n",
    "    \"Lua tom\": \"0\",\n",
    "    \"Lua\": \"1\",\n",
    "    \"CHN\": \"2\",\n",
    "    \"CLN\": \"3\",\n",
    "    \"TS\": \"4\",\n",
    "    \"Song\": \"5\",\n",
    "    \"Dat xay dung\": \"6\",\n",
    "    \"Rung\": \"7\"\n",
    "}\n",
    "label_encoder = LabelEncoder()\n",
    "\n",
    "# Fit and transform the labels\n",
    "labels = train.Hientrang.values\n",
    "numeric_labels = label_encoder.fit_transform([label_mapping[label] for label in labels])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "212ca1f6-1d98-407c-ac4f-456e1783ba58",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "X = []\n",
    "x_new = []\n",
    "lb_new = []\n",
    "for k, v in loaded_datasets.items():\n",
    "    X.append(v)\n",
    "for i in range(len(X)):\n",
    "    if X[i] is not None:\n",
    "        x_new.append(X[i][\"data\"])\n",
    "        lb_new.append(numeric_labels[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7fa45bc-1728-45ae-ac46-9759fd16419e",
   "metadata": {},
   "source": [
    "### Split training data / Chia tập dữ liệu huấn luyện"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9502c7a1-77d6-4eab-8fc5-45a1c38d104f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "X_train, X_temp, y_train, y_temp= train_test_split(x_new, lb_new, test_size=0.4, random_state=42)\n",
    "X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4815c17-0b64-4acf-94c6-8ed00940928b",
   "metadata": {},
   "source": [
    "### Model training pipeline/ huấn luyện mô hình và đánh giá trên tập validate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f148a6ce-b3b3-4052-ae86-587b6ba44d0b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "# Takes 1-2 minutes to complete\n",
    "\n",
    "# Tạo RandomForestClassifier mặc định để sử dụng làm mô hình ban đầu trong pipeline\n",
    "base_model = RandomForestClassifier(random_state=42, n_jobs=-1)\n",
    "\n",
    "# Tạo pipeline\n",
    "pipeline = Pipeline([\n",
    "    # ('imputer', SimpleImputer(strategy='mean')),\n",
    "    ('scaler', StandardScaler()),\n",
    "    ('classifier', base_model),\n",
    "])\n",
    "# Thiết lập các tham số bạn muốn tối ưu hóa\n",
    "param_grid = {\n",
    "    'classifier__n_estimators': [100, 300, 500, 700, 1000],\n",
    "    'classifier__max_depth': [6, 8, 10, 15, 20],\n",
    "    'classifier__criterion': ['gini', 'entropy'],\n",
    "}\n",
    "\n",
    "# Sử dụng GridSearchCV để tìm bộ tham số tốt nhất\n",
    "grid_search = GridSearchCV(pipeline, param_grid, cv=5, scoring='accuracy', n_jobs=-1)\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "# In ra bộ tham số tốt nhất\n",
    "best_params = grid_search.best_params_\n",
    "print(\"Best Parameters:\", best_params)\n",
    "\n",
    "# Dự đoán trên tập kiểm tra\n",
    "y_pred = grid_search.predict(X_val)\n",
    "\n",
    "# Đánh giá kết quả\n",
    "accuracy = accuracy_score(y_val, y_pred)\n",
    "print(f\"Accuracy: {round(accuracy, 2)*100} %\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f064a26-f111-41a9-b87f-1558800d6901",
   "metadata": {},
   "source": [
    "### Accuracy on the test data/ Độ chính xác trên tập dữ liệu kiểm tra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "771342ee-30b7-49d3-89ac-46ec656efa6f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "## check accuracy score\n",
    "\n",
    "y_pred_test = grid_search.predict(X_test)\n",
    "test_accuracy = accuracy_score(y_test, y_pred_test)\n",
    "print(f\"Accuracy for test data {round(test_accuracy, 2)*100} %\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cd3b771-3c2e-440c-b577-89fd366755de",
   "metadata": {},
   "source": [
    "### Save train model/ Lưu trữ mô hình huấn luyện"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76300308-7c4a-408d-b504-5332bc76ea55",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dir_save_model = \"model_train\"\n",
    "if not os.path.exists(dir_save_model):\n",
    "    os.mkdir(dir_save_model)\n",
    "joblib.dump(grid_search, os.path.join(dir_save_model, \"model.joblib\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f0fca51-bbe2-42d0-8d35-4a13563d0908",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "client.close()\n",
    "cluster.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}