diff --git a/.gitignore b/.gitignore index 6c809bb..6c872e9 100644 --- a/.gitignore +++ b/.gitignore @@ -130,3 +130,6 @@ dmypy.json # Mac file system .DS_Store + +# IDE / PyCharm +.idea/ diff --git a/evaluation/evaluate.ipynb b/evaluation/evaluate.ipynb new file mode 100644 index 0000000..db2786a --- /dev/null +++ b/evaluation/evaluate.ipynb @@ -0,0 +1,545 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.core.interactiveshell import InteractiveShell\n", + "InteractiveShell.ast_node_interactivity = 'all' # default is ‘last_expr’\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append('/Source/repos/GitHub_MSFT/landcover-orinoquiaa')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "import pickle\n", + "from collections import defaultdict\n", + "\n", + "import rasterio\n", + "from tqdm import tqdm\n", + "import numpy as np\n", + "from sklearn.metrics import confusion_matrix, accuracy_score\n", + "from sklearn.calibration import calibration_curve\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "\n", + "from geospatial.visualization.raster_label_visualizer import RasterLabelVisualizer\n", + "\n", + "plt.rcParams['figure.figsize'] = (10.0, 10.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# from data/tile_and_mask.py - which needs to be run in the Solaris env\n", + "\n", + "def get_lon_lat_from_tile_name(tile_name):\n", + " \"\"\"Returns _lon_lat\"\"\"\n", + " parts = tile_name.split('_')\n", + " lon_lat = f'_{parts[-2]}_{parts[-1].split(\".tif\")[0]}'\n", + " return lon_lat" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Evaluate a tiles of model predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "viz_util= RasterLabelVisualizer('../constants/class_lists/wcs_coarse_label_map.json')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Empty of data',\n", + " 'Urban and infrastructure',\n", + " 'Agriculture',\n", + " 'Arboreal and forestry crops',\n", + " 'Pasture',\n", + " 'Vegetation',\n", + " 'Forest',\n", + " 'Savanna',\n", + " 'Sand, rocks and bare land',\n", + " 'Unavailable',\n", + " 'Swamp',\n", + " 'Water',\n", + " 'Seasonal savanna',\n", + " 'Seasonally flooded savanna']" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "label_names = sorted(viz_util.num_to_name.items(), key=lambda x: int(x[0]))\n", + "label_names = [i[1] for i in label_names]\n", + "label_names" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "output_paths = '/Data/WCS_land_use/delivered/20200701/results_coarse_baseline_201314'\n", + "\n", + "mask_paths = '/Data/WCS_land_use/train_full_region_median/tiles_masks_coarse'\n", + "\n", + "eval_saved_to = '/Data/WCS_land_use/train_full_region_median/result_val_analysis_coarse_baseline'\n", + "\n", + "num_classes = viz_util.num_classes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tile_accuracies = {}\n", + "\n", + "cm = np.zeros((num_classes, num_classes), dtype=np.int64)\n", + "\n", + "true_counts = np.zeros((num_classes), dtype=np.int64)\n", + "pred_counts = np.zeros((num_classes), dtype=np.int64)\n", + "\n", + "classes_present_in_gt = set()\n", + "\n", + "for output_tile_fn in os.listdir(output_paths):\n", + " if not output_tile_fn.endswith('.tif'):\n", + " continue\n", + "# for output_tile_fn in ['res_wcs_orinoquia_sr_median_2013_2014-0000000000-0000022272_-68.962_6.593.tif']:\n", + " \n", + " output_tile_path = os.path.join(output_paths, output_tile_fn)\n", + " out_reader = rasterio.open(output_tile_path)\n", + " output_tile = np.array(Image.open(output_tile_path), dtype=np.uint8)\n", + " \n", + " # mask_-68.423_6.054.png\n", + " lon_lat = get_lon_lat_from_tile_name(output_tile_path)\n", + " label_mask_path = os.path.join(mask_paths, f'mask{lon_lat}.tif')\n", + " label_mask = np.array(Image.open(label_mask_path), dtype=np.uint8)\n", + " \n", + " output = output_tile.flatten()\n", + " labels = label_mask.flatten()\n", + " \n", + " # mask out where labels is 0, which is outside of boundary of region\n", + " # and also where output is 0, which is where no imagery is available on the tile\n", + " # now get rid of such entries\n", + " labels_masked = labels * (output != 0)\n", + " no_label_entries = np.where(labels_masked == 0)\n", + " \n", + " labels = np.delete(labels, no_label_entries)\n", + " output = np.delete(output, no_label_entries)\n", + " \n", + " classes_present_in_gt.update(labels)\n", + " \n", + " tile_accuracy = accuracy_score(labels, output, normalize=True)\n", + " tile_accuracies[lon_lat] = tile_accuracy\n", + "\n", + " for y_true, y_pred in tqdm(zip(labels, output)):\n", + " cm[y_true][y_pred] += 1\n", + " true_counts[y_true] += 1\n", + " pred_counts[y_pred] += 1\n", + " \n", + "overall_accuracy = sum(tile_accuracies.values())/len(tile_accuracies)\n", + "print(f'Overall accuracy is {overall_accuracy}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tile_accuracies" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accurate distribution of land types\n", + "The shapefile's area attribute did not look correct" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "true_counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Confusion matrix" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# normalize by ground truth label counts\n", + "cm_norm = np.zeros((num_classes, num_classes), dtype=np.float)\n", + "for y_true in range(num_classes):\n", + " for y_pred in range(num_classes):\n", + " if true_counts[y_true] == 0:\n", + " cm_norm[y_true][y_pred] = 0.0\n", + " else:\n", + " cm_norm[y_true][y_pred] = cm[y_true][y_pred] / true_counts[y_true]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# docs: https://matplotlib.org/3.1.3/gallery/images_contours_and_fields/image_annotated_heatmap.html#sphx-glr-gallery-images-contours-and-fields-image-annotated-heatmap-py\n", + "\n", + "cm_to_plot = cm_norm\n", + "\n", + "\n", + "fig = plt.figure(figsize=(10, 10), dpi=200) # set dpi to 300 to look good\n", + "ax = fig.add_axes([0.0, 0.0, 1.0, 1.0])\n", + "im = ax.matshow(cm_to_plot, cmap=plt.cm.YlGnBu)\n", + "_ = ax.set_xticks(np.array(range(num_classes)))\n", + "_ = ax.set_yticks(np.array(range(num_classes)))\n", + "_ = ax.set_xticklabels(label_names)\n", + "_ = ax.set_yticklabels(label_names)\n", + "_ = ax.set_ylabel('Provided labels')\n", + "_ = ax.set_xlabel('Predicted by model')\n", + "ax.xaxis.tick_top()\n", + "\n", + "# Rotate the tick labels\n", + "_ = plt.setp(ax.get_xticklabels(), rotation=90)\n", + "\n", + "_ = ax.set_xticks(np.array(range(num_classes)) - 0.5, minor=True)\n", + "_ = ax.set_yticks(np.array(range(num_classes)) - 0.5, minor=True)\n", + "ax.grid(which='minor', color='white', linestyle='-', linewidth=3)\n", + "\n", + "cbar = ax.figure.colorbar(im, ax=ax)\n", + "\n", + "# no border\n", + "for edge, spine in ax.spines.items():\n", + " spine.set_visible(False)\n", + "\n", + "# right-click save - layout isn't right otherwise\n", + " \n", + "#fig.tight_layout()\n", + "#plt.savefig('/Users/siyuyang/Source/temp_data/WCS_land_use/train_200218/result_val/evaluation/cm.png')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cm_norm[32][32]\n", + "cm_norm[33][33]\n", + "\n", + "cm_norm[30, 33] # row, col - ground truth, predicted\n", + "cm_norm[33][30] " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Side by side label and output counts, in log scale" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Per-class accuracy, precision and recall" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# per-class accuracy\n", + "total_obs = cm.sum()\n", + "\n", + "per_class_accuracy = {}\n", + "per_class_recall = {}\n", + "per_class_precision = {}\n", + "\n", + "for cls in range(num_classes):\n", + " if cls not in classes_present_in_gt:\n", + " continue\n", + " \n", + " true_pos = cm[cls, cls]\n", + " \n", + " true_neg = total_obs - cm[cls, :].sum() - cm[:, cls].sum() + true_pos\n", + " \n", + " false_pos = cm[:, cls].sum() - true_pos\n", + " \n", + " false_neg = cm[cls, :].sum() - true_pos\n", + " \n", + " per_class_accuracy[cls] = (true_pos + true_neg) / total_obs\n", + " \n", + " per_class_precision[cls] = true_pos / (true_pos + false_pos)\n", + " \n", + " per_class_recall[cls] = true_pos / (true_pos + false_neg)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print('Category, Accuracy, Precision, Recall')\n", + "for cls, acc in per_class_accuracy.items():\n", + " prec = per_class_precision[cls]\n", + " recall = per_class_recall[cls]\n", + " print(f'{cls} {viz_util.num_to_name[str(cls)]},{acc},{prec},{recall}')\n", + " \n", + "# paste the result into Pages, and fix the row for \"27 Lakes, lagoons, and natural cienaga\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the dataset is so unbalanced (mostly 12 - dense forest) and accuracy counts \"true negatives\" as a win, this is not a good measure of performance." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Save the evaluation findings - not yet done" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "saved = {\n", + " 'overall_accuracy': overall_accuracy,\n", + " 'per_class_accuracy': per_class_accuracy,\n", + " # 'calibration_summary': calibration_summary\n", + "}\n", + "\n", + "with open(eval_saved_to, 'w') as f:\n", + " json.dump(saved, f, indent=4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Is the model well-calibrated?\n", + "\n", + "We can also just record a 2D shape - each cell is the confidence of the most confident class?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with open(output_scores_path, 'rb') as f:\n", + " dict_scores = pickle.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "classes_to_plot = [0, 11, 12, 17, 19, 26, 32]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "y_true = defaultdict(list)\n", + "y_prob = defaultdict(list)\n", + "\n", + "for window, chip_scores in tqdm(dict_scores.items()):\n", + " # rasterio window is (col_off x, row_off y, width, height)\n", + " \n", + " chip_scores = chip_scores.squeeze() # chip_scores have shape (1, 33, 256, 256)\n", + " chip_scores = chip_scores.reshape((33, -1))\n", + "\n", + " chip_labels = label_mask[window[0]:window[0] + 256, window[1]:window[1] + 256]\n", + " chip_labels = chip_labels.reshape((1, -1))\n", + " # we pad 0 to the end of chips after the tile ends\n", + " chip_labels = np.pad(chip_labels, ((0, 0), (0, 256*256 - chip_labels.shape[1]))).squeeze()\n", + " \n", + " assert chip_scores.shape == (33, 256*256), chip_scores.shape\n", + " assert chip_labels.shape == (256*256,), chip_labels.shape\n", + " \n", + " for cls in classes_to_plot:\n", + " cls_y_true = chip_labels == cls\n", + " cls_y_prob = chip_scores[cls]\n", + " assert len(list(cls_y_true)) == len(list(cls_y_prob)), '{}, {}'.format(\n", + " len(list(cls_y_true)), len(list(cls_y_prob))\n", + " )\n", + " y_true[cls].extend(list(cls_y_true))\n", + " y_prob[cls].extend(list(cls_y_prob))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(y_true[12])\n", + "len(y_prob[12])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "_ = plt.plot([0.0, 1.0], color='grey', linestyle=':')\n", + "\n", + "for cls in classes_to_plot:\n", + " _ = frac_positives, mean_prob_in_bin = calibration_curve(y_true[cls], y_prob[cls], n_bins=10)\n", + " _ = plt.plot(mean_prob_in_bin, frac_positives, label=cls, color=viz_util.num_to_color[str(cls)])\n", + "_ = plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mean_prob_in_bin\n", + "frac_positives" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Expected number of pixels for the whole validation area" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "probability_sum = np.zeros(num_classes, dtype=np.float)\n", + "\n", + "for window, chip_scores in dict_scores.items():\n", + " # print(chip_scores.shape) # (1, 33, 256, 256)\n", + " chip_scores = chip_scores.squeeze()\n", + " chip_scores = chip_scores.sum(axis=(1, 2)) # height and width dims\n", + " probability_sum += chip_scores" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "calibration_summary = {}\n", + "\n", + "for cls, (prob_sum, label_sum) in enumerate(zip(probability_sum, true_counts)):\n", + " calibration_summary[cls] = {\n", + " 'prediction_probability_sum': prob_sum,\n", + " 'label_sum': int(label_sum)\n", + " }\n", + " print('Class {} - {}, prob_sum {}, label_sum {}'.format(cls, viz_util.num_to_name[str(cls)], round(prob_sum), label_sum))\n", + " if label_sum > 0:\n", + " print(' diff is {}%'.format(100 * round((prob_sum - label_sum)/label_sum, 3)))\n", + " calibration_summary[cls]['difference_wrt_label_sum'] = (prob_sum - label_sum)/label_sum" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:wcs] *", + "language": "python", + "name": "conda-env-wcs-py" + }, + "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.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/finetuning/ModelSessionOrinoquia.py b/finetuning/ModelSessionOrinoquia.py new file mode 100644 index 0000000..481ac01 --- /dev/null +++ b/finetuning/ModelSessionOrinoquia.py @@ -0,0 +1,294 @@ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +""" +Implementation of ModelSessionAbstract for the Orinoquia land cover mapping project. Heavily references +wildlife-conservation-society.orinoquia-land-use/training/inference.py + +"wildlife-conservation-society.orinoquia-land-use" and "ai4eutils" need to be on the PYTHONPATH. +""" + +import importlib +import logging +import sys +import os +import math + +import numpy as np +import torch +import torch.nn as nn +import torch.optim as optim + +from web_tool.ModelSessionAbstract import ModelSession + +LOGGER = logging.getLogger("server") + + +class TorchFineTuningOrinoquia(ModelSession): + + def __init__(self, gpu_id, **kwargs): + # setting up device to use + LOGGER.debug(f"TorchFineTuningOrinoquia init, gpu_id is {gpu_id}") + self.device = torch.device(f"cuda:{gpu_id}" if torch.cuda.is_available() and gpu_id is not None else "cpu") + + # load experiment configuration as a module + config_module_path = kwargs["config_module_path"] + try: + module_name = "config" + spec = importlib.util.spec_from_file_location(module_name, config_module_path) + self.config = importlib.util.module_from_spec(spec) + sys.modules[module_name] = self.config + spec.loader.exec_module(self.config) + except Exception as e: + LOGGER.error(f"Failed to import experiment and model configuration. Exception: {e}") + sys.exit(1) + LOGGER.info(f"config is for experiment {self.config.experiment_name}") + + # check that the necessary fields are present in the config + assert self.config.num_classes > 1 # this is the number of classes the initial model supports + self.num_classes = self.config.num_classes # self.num_classes can evolve during a session + + assert self.config.chip_size > 1 + assert self.config.feature_scale in [1, 2] + + chip_size = self.config.chip_size + self.prediction_window_size = self.config.prediction_window_size if self.config.prediction_window_size else 128 + self.prediction_window_offset = int((chip_size - self.prediction_window_size) / 2) + print((f"Using chip_size {chip_size} and window_size {self.prediction_window_size}. " + f"So window_offset is {self.prediction_window_offset}")) + + # obtain the model that the config has initialized + self.checkpoint_path = kwargs["fn"] + assert os.path.exists(self.checkpoint_path), f"Checkpoint at {self.checkpoint_path} does not exist." + self.model = self.config.model + self._init_model() + + # other instance variables + self._last_tile = None + + # recording the current feature map (before final layer), and the corrections made + self.current_features = None + self.corr_features = [] + self.corr_labels = [] + + def _init_model(self): + checkpoint = torch.load(self.checkpoint_path, map_location=self.device) + self.model.load_state_dict(checkpoint["state_dict"]) + print(f"Using checkpoint at epoch {checkpoint['epoch']}, step {checkpoint['step']}, " + f"val accuracy is {checkpoint.get('val_acc', 'Not Available')}") + self.model = self.model.to(device=self.device) + self.model.eval() + + @property + def last_tile(self): + return self._last_tile + + def run(self, tile, inference_mode=False): + assert tile.shape[2] == 11 # 10 Landsat bands + DEM + height = tile.shape[0] # tile is of dims (height, width, channels) + width = tile.shape[1] + self._last_tile = tile + prediction_window_offset = self.prediction_window_offset + prediction_window_size = self.prediction_window_size + + # apply the preprocessing of bands to the tile + data_array = self.config.preprocess_tile(tile) # dim is (6, H, W) + + LOGGER.debug(f"run, tile shape is {tile.shape}") + LOGGER.debug(f"run, data_array shape is {data_array.shape}") + + # pad by mirroring at the edges to predict only on the center crop + data_array = np.pad(data_array, + [ + (0, 0), # only pad height and width + (prediction_window_offset, prediction_window_offset), # height / rows + (prediction_window_offset, prediction_window_offset) # width / cols + ], + mode="symmetric") + + # form batches + batch_size = self.config.batch_size if self.config.batch_size is not None else 32 + batch = [] + batch_indices = [] # cache these to save recalculating when filling in model predictions + + chip_size = self.config.chip_size + + num_rows = math.ceil(height / prediction_window_size) + num_cols = math.ceil(width / prediction_window_size) + + for col_idx in range(num_cols): + col_start = col_idx * prediction_window_size + col_end = col_start + chip_size + + for row_idx in range(num_rows): + row_start = row_idx * prediction_window_size + row_end = row_start + chip_size + + chip = data_array[:, row_start:row_end, col_start: col_end] + # pad to (chip_size, chip_size) + chip = np.pad(chip, + [(0, 0), (0, chip_size - chip.shape[1]), (0, chip_size - chip.shape[2])]) + + # processing it as the dataset loader _get_chip does + chip = np.nan_to_num(chip, nan=0.0, posinf=1.0, neginf=-1.0) + sat_mask = chip[0].squeeze() > 0.0 # mask out DEM data where there's no satellite data + chip = chip * sat_mask + + batch.append(chip) + + valid_row_end = row_start + min(prediction_window_size, height - row_idx * prediction_window_size) + valid_col_end = col_start + min(prediction_window_size, width - col_idx * prediction_window_size) + batch_indices.append( + (row_start, valid_row_end, col_start, valid_col_end)) # explicit to be less confusing + batch = np.array(batch) # (num_chips, channels, height, width) + + # score chips in batches + model_output = [] + model_features = [] # same spatial dims as model_output, but has 64 or 32 channels + self.model.eval() + with torch.no_grad(): + for i in range(0, len(batch), batch_size): + t_batch = batch[i:i + batch_size] + t_batch = torch.from_numpy(t_batch).to(self.device) + + scores, features = self.model.forward(t_batch, + return_features=True) # these are scores before the final softmax + softmax_scores = torch.nn.functional.softmax(scores, + dim=1).cpu().numpy() # (batch_size, num_classes, H, W) + + softmax_scores = np.transpose(softmax_scores, axes=(0, 2, 3, 1)) # (batch_size, H, W, num_classes) + # only save the center crop + softmax_scores = softmax_scores[ + :, + prediction_window_offset:prediction_window_offset + prediction_window_size, + prediction_window_offset:prediction_window_offset + prediction_window_size, + : + ] + model_output.append(softmax_scores) + + features = features.cpu().numpy() + features = np.transpose(features, axes=(0, 2, 3, 1)) # (batch_size, H, W, num_features) + features = features[ + :, + prediction_window_offset:prediction_window_offset + prediction_window_size, + prediction_window_offset:prediction_window_offset + prediction_window_size, + : + ] + model_features.append(features) + + model_output = np.concatenate(model_output, axis=0) + model_features = np.concatenate(model_features, axis=0) + + # fill in the output array; self.num_classes is the number of classes supported by the current model + output = np.zeros((height, width, self.num_classes), dtype=np.float32) + for i, (row_start, row_end, col_start, col_end) in enumerate(batch_indices): + h = row_end - row_start + w = col_end - col_start + output[row_start:row_end, col_start:col_end, :] = model_output[i, :h, :w, :] + print(f"--- Orinoquia ModelSession, output[-1, -1, :] is {output[-1, -1, :]}") + + num_features = 64 if self.config.feature_scale == 1 else 32 + output_features = np.zeros((height, width, num_features), dtype=np.float32) # float32 used during training too + for i, (row_start, row_end, col_start, col_end) in enumerate(batch_indices): + h = row_end - row_start + w = col_end - col_start + output_features[row_start:row_end, col_start:col_end, :] = model_features[i, :h, :w, :] + print(f"--- Orinoquia ModelSession, output_features[-1, -1, :] is {output_features[-1, -1, :]}") + # save the features + self.current_features = output_features + + return output + + def add_sample_point(self, row, col, class_idx): + self.corr_labels.append(class_idx) + self.corr_features.append(self.current_features[row, col, :]) + + print(f"After add_sample_point, corr_labels length is {len(self.corr_labels)}") + return { + "message": f"Training sample for class {class_idx} added", + "success": True + } + + def undo(self): + if len(self.corr_features) > 0: + self.corr_features = self.corr_features[:-1] + self.corr_labels = self.corr_labels[:-1] + return { + "message": "Undid training sample", + "success": True + } + else: + return { + "message": "Nothing to undo", + "success": False + } + + def reset(self): + self._init_model() + self.num_classes = self.config.num_classes + self.corr_features = [] + self.corr_labels = [] + return { + "message": f"Model is reset and support {self.num_classes} classes", + "success": True + } + + def retrain(self, train_steps=100, learning_rate=1e-3): + print_every = 10 + + # if any new classes have been added, update self.num_classes and re-initialize final layer + # class start from 0 + if max(self.corr_labels) >= self.num_classes: + self.num_classes = max(self.corr_labels) + 1 + self.model.change_num_classes(self.num_classes) + self.model.final.to(device=self.device) + LOGGER.debug(f"New classes have been added (total {self.num_classes}) and final layer re-initialized.") + + # all corrections since the last reset are used + batch_x = torch.from_numpy(np.array(self.corr_features)).float().to(self.device) + batch_y = torch.from_numpy(np.array(self.corr_labels)).to(self.device) + + # make the last layer `final` trainable TODO do we need to do this - default trainable? + for param in self.model.final.parameters(): # see UNet implementation in WCS project repo + param.requires_grad = True + + optimizer = optim.Adam(self.model.final.parameters(), lr=learning_rate) # only the last layer + + # during re-training, we use equal weight for all classes + criterion = nn.CrossEntropyLoss().to(device=self.device) + + self.model.train() + for step in range(train_steps): + with torch.enable_grad(): + # forward pass + batch_x_reshaped = batch_x.unsqueeze(2).unsqueeze(3) + scores = self.model.final.forward(batch_x_reshaped).squeeze(3).squeeze(2) + loss = criterion(scores, batch_y) + + # backward pass + optimizer.zero_grad() + loss.backward() # compute gradients + optimizer.step() # update parameters + + if step % print_every == 0: + preds = scores.argmax(1) + accuracy = (batch_y == preds).float().mean() + + print(f'step {step}, loss: {loss.item()}, accuracy: {accuracy.item()}') + + return { + "message": f"Fine-tuned model with {len(self.corr_features)} samples for {train_steps} steps", + "success": True + } + + def save_state_to(self, directory): + # number of classes could be different from what's in the config for the initial model + return { + "message": "Saving not yet implemented", + "success": False + } + + def load_state_from(self, directory): + return { + "message": "Saving and loading not yet implemented", + "success": False + } diff --git a/finetuning/README.md b/finetuning/README.md new file mode 100644 index 0000000..d544772 --- /dev/null +++ b/finetuning/README.md @@ -0,0 +1,45 @@ +# Finetuning the land cover model interactively + +Files in this folder are configurations and implementations of required classes for finetuning the model interactively in an instance of the [Land Cover Mapping tool](https://github.com/microsoft/landcover) (this repo will be referred to as the `landcover` repo below). + +## Setup +Because our implementation of [ModelSession](https://github.com/microsoft/landcover/blob/master/web_tool/ModelSessionAbstract.py) relies on the experiment configuration file (a `.py` file) that produced the model, this repo needs to be on the `PYTHONPATH` when running the Land Cover Mapping tool's server, in additional to the AI for Earth utilities [repo](https://github.com/microsoft/ai4eutils): +``` +export PYTHONPATH="${PYTHONPATH}:/home/boto/wcs/pycharm:/home/boto/lib/ai4eutils" +``` + +Note that directory names in this repo should not clash with ones in the `landcover` repo. + +Basemap needs to be in the `landcover` repo's root directory for the server to serve the data. We can create a symbolic link to the files stored in a blob storage container: +``` +ln -s /home/boto/wcs/mnt/wcs-orinoquia/images_sr_median/2013_2014_dem/wcs_orinoquia_sr_median_2013_2014_dem.vrt wcs_orinoquia_sr_median_2013_2014_dem.vrt +``` + +The configuration files for the dataset and model in this folder and `ModelSessionOrinoquia.py` should be copied to the `landcover` repo's `web_tool` directory. + +We also need to make the following changes: +- Modify [`worker.py`](https://github.com/microsoft/landcover/blob/master/worker.py) to add a case for the `model_type` `pytorch_landsat`. +- Modify `web_tool/DataLoader.py`, changing + ```python + resolution=(x_res, y_res) + ``` + to + ```python + resolution=(30, 30) # hardcode Landsat 8 resolution + ``` + +- In `web_tool/js/components.js`, modify these values in `addInferenceWindowSizeSlider` to: + ```python + min: 7680, + max: 23040, + ``` +- In `web_tool/js/globals.js`, set the following variables: + ```python + var INFERENCE_WINDOW_SIZE = 300; + var INFERENCE_WINDOW_SIZE = 7680; + ``` + + +## Operation + +![Using the Land Cover Mapping tool on Landsat 8 imagery](../visuals/in_the_tool.png) diff --git a/finetuning/datasets.mine.json b/finetuning/datasets.mine.json new file mode 100644 index 0000000..9943e43 --- /dev/null +++ b/finetuning/datasets.mine.json @@ -0,0 +1,38 @@ +{ + "landsat_orinoquia": { + "metadata": { + "displayName": "Orinoquia Colombia, 2013-2014, Landsat 8", + "locationName": null + }, + "dataLayer": { + "type": "CUSTOM", + "path": "data/imagery/wcs_orinoquia_sr_median_2013_2014_dem.vrt", + "padding": 0, + "resolution": 30 + }, + "basemapLayers": [ + { + "layerName": "Landsat 8 2013-2014", + "initialZoom": 8, + "url": "data/basemaps/wcs_2013_2014_basemap_exp07/{z}/{x}/{y}.png", + "initialLocation": [4.400127, -72.304724], + "args": { + "attribution": "Georeferenced Image", + "tms": true, + "maxNativeZoom": 13, + "maxZoom": 16, + "minZoom": 8, + "bounds": [[1.4752987731256113, -67.25191674463355], [7.516203982228033, -74.96450029130249]] + } + } + ], + "shapeLayers": [ + { + "shapesFn": "data/zones/Orinoquia_outline.geojson", + "zoneNameKey": "NAME_1", + "name": "Region outline" + } + ], + "validModels": ["landsat_orinoquia_coarse"] + } +} diff --git a/finetuning/models.mine.json b/finetuning/models.mine.json new file mode 100644 index 0000000..7864414 --- /dev/null +++ b/finetuning/models.mine.json @@ -0,0 +1,77 @@ +{ + "landsat_orinoquia_coarse": { + "metadata": { + "displayName": "Landsat Orinoquia Coarse-class" + }, + "model": { + "type": "pytorch_landsat", + "fineTuneLayer": -1, + "numParameters": -1, + "inputShape": [ + 256, + 256, + 6 + ], + "config_module_path": "/home/boto/wcs/pycharm/training_wcs/experiments/coarse_baseline/coarse_baseline_config_refactored.py", + "fn": "/home/boto/wcs/mnt/wcs-orinoquia/useful_checkpoints/wcs_coarse_baseline/wcs_coarse_baseline_epoch93_best.pth.tar" + }, + "classes": [ + { + "name": "Empty of data", + "color": "#000000" + }, + { + "name": "Urban and infrastructure", + "color": "#d3d3d3" + }, + { + "name": "Agriculture", + "color": "#ffc0cb" + }, + { + "name": "Arboreal and forestry crops", + "color": "#008080" + }, + { + "name": "Pasture", + "color": "#fa8072" + }, + { + "name": "Vegetation", + "color": "#daa520" + }, + { + "name": "Forest", + "color": "#8fbc8f" + }, + { + "name": "Savanna", + "color": "#ffd700" + }, + { + "name": "Sand, rocks and bare land", + "color": "#ffebcd" + }, + { + "name": "Unavailable", + "color": "#f5f5f5" + }, + { + "name": "Swamp", + "color": "#556b2f" + }, + { + "name": "Water", + "color": "#00bfff" + }, + { + "name": "Seasonal savanna", + "color": "#f0e68c" + }, + { + "name": "Seasonally flooded savanna", + "color": "#d8bfd8" + } + ] + } +} diff --git a/training_wcs/experiments/baseline/baseline_config.py b/training_wcs/experiments/baseline/baseline_config.py new file mode 100644 index 0000000..fce8ce9 --- /dev/null +++ b/training_wcs/experiments/baseline/baseline_config.py @@ -0,0 +1,200 @@ +""" +Configurations for the 20200505_mini_baseline experiment +""" + +import json +import os + +import torch +import numpy as np + +from viz_utils import VizUtils +from training_wcs.scripts.models.unet.unet import Unet # models.unet.unet import Unet + + +experiment_name = 'wcs_baseline_202005' + +eval_mode = True + +# I/O ------------------------------------------------------------------------------------------------- +if not eval_mode: + aml_data_ref = os.environ.get('AZUREML_DATAREFERENCE_wcsorinoquia', '') + assert len(aml_data_ref) > 0, 'Reading aml_data_ref from environment vars resulted in empty string.' + + data_dir = os.path.join(aml_data_ref, 'tiles', 'full_sr_median_2013_2014') + assert 'tiles' in os.listdir(data_dir) + assert 'tiles_masks' in os.listdir(data_dir) + + # a dir with experiment_name will be created in here and checkpoints are saved here + # set as './outputs' for AML to stream to this Run's folder + out_dir = '/boto_disk_0/wcs/20190518_feature_scale_1/outputs' # './outputs' + os.makedirs(out_dir, exist_ok=True) + + # TF events go here. Set it as './logs' if using AML so they can be streamed + log_dir = '/boto_disk_0/wcs/20190518_feature_scale_1/logs' # './logs' + + # train/val splits are stored in + # on AML, this needs to be relative to the source_directory level + splits_file = './constants/splits/full_sr_median_2013_2014_splits.json' # '../training_wcs/scripts/constants/splits/full_sr_median_2013_2014_splits.json' + + with open(splits_file) as f: + splits = json.load(f) + train_split = splits['train'] + val_split = splits['val'] + print(f'Train set has {len(train_split)} tiles; val set has {len(val_split)} tiles.') + + +# Training ---------------------------------------------------------------------------------------------- + +evaluate_only = False # Only evaluate the model on the val set once + +# this is the *total* epoch; if restarting from a checkpoint, be sure to add the additional number of epochs +# to fine-tune on top of the original value of this var +total_epochs = 1000 +print_every = 100 # print every how many steps; just the minibatch loss and accuracy +assert print_every >= 1, 'print_every needs to be greater than or equal 1' + +starting_checkpoint_path = None + +init_learning_rate = 1e-4 + +batch_size = 24 + +# probability a chip is kept in the sample while sampling train and val chips at the start of training_wcs +# this should be smaller if we now have more training_wcs examples +# prob_keep_chip = 0.006 +# 133 training_wcs tiles * 64 chips per tile = 8512 chips. Should keep every 177 if visualizing 48, which is 0.0056 +keep_every = 30 # a balance between not covering all training_wcs tiles vs iterating through val tiles too many times + +num_chips_to_viz = 48 + + +# Hardware and framework -------------------------------------------------------------------------------- +dtype = torch.float32 + + +# Model ------------------------------------------------------------------------------------------------- + +num_classes = 34 # empty plus the 33 WCS classes; this is the number of output nodes + +num_in_channels = 5 # 2, 3, 6, 7, NDVI + +# the smallest number of filters is 64 when feature_scale is 1, and it is 32 when feature_scale is 2 +feature_scale = 1 + +is_deconv = True # True to use transpose convolution filters to learn upsampling; otherwise upsampling is not learnt + +is_batchnorm = True + +model = Unet(feature_scale=feature_scale, + n_classes=num_classes, + in_channels=num_in_channels, + is_deconv=is_deconv, + is_batchnorm=is_batchnorm) + + +# Data --------------------------------------------------------------------------------------------------- + +common_classes = [ + 12 +] +less_common_classes = [ + 32, 33 +] + +weights = [] +for i in range(num_classes): + if i in common_classes: + weights.append(1) + elif i in less_common_classes: + weights.append(2) + else: + weights.append(10) +loss_weights = torch.FloatTensor(weights) # None if no weighting for classes +print('Weights on loss per class used:') +print(loss_weights) + +# how many subprocesses to use for data loading +# None for now - need to modify datasets.py to use +data_loader_num_workers = None + +# not available in IterableDataset data_loader_shuffle = True # True to have the data reshuffled at every epoch + +chip_size = 256 + + +# based on min and max values from the sample tile +# wcs_orinoquia_sr_median_2013_2014-0000007424-0000007424_-71.347_4.593.tif in training_wcs set +# bands 4 and 5 are combined to get the NDVI, so the normalization params for 4 and 5 are +# not used during training_wcs data generation, only for visualization (actually not yet used for viz either). +bands_normalization_params = { + # these are the min and max to clip to for the band + 'min': { + 2: 0, + 3: 0, + 4: 0, + 5: 0, + 6: 0, + 7: 0 + }, + 'max': { + 2: 700, + 3: 1500, + 4: 1500, + 5: 5000, + 6: 5000, + 7: 3000 + }, + 'gamma': { # all the same in this experiment with value 1 which means no effect + 2: 1.0, + 3: 1.0, + 4: 1.0, + 5: 1.0, + 6: 1.0, + 7: 1.0 + } +} + +viz_util = VizUtils() + +def get_chip(tile_reader, chip_window): + """ + + Returns: + A numpy array of dims (5, H, W) + """ + normal_bands = [2, 3, 6, 7] # bands to be used without calculating other indices e.g. NDVI + bands_to_stack = [] + for b in normal_bands: + # getting one band at a time because min, max and gamma may be different + band = viz_util.show_landsat8_tile( + tile_reader, + bands=[b], # pass in a list to get the batch dimension in the results + window=chip_window, + band_min=bands_normalization_params['min'][b], + band_max=bands_normalization_params['max'][b], + gamma=bands_normalization_params['gamma'][b], + return_array=True + ) + bands_to_stack.append(band) # band is 2D (h, w), already squeezed, dtype is float 32 + + ndvi = viz_util.show_landsat8_ndvi(tile_reader, window=chip_window) # 2D, dtype is float32 + bands_to_stack.append(ndvi) + + stacked = np.stack(bands_to_stack) + + if stacked.shape != (5, chip_size, chip_size): + # default pad constant value is 0 + stacked = np.pad(stacked, + [(0, 0), (0, chip_size - stacked.shape[1]), (0, chip_size - stacked.shape[2])]) + + assert stacked.shape == (5, chip_size, chip_size), f'Landsat chip has wrong shape: {stacked.shape}, should be (5, h, w)' + + # prepare the chip for display + chip_for_display = viz_util.show_landsat8_tile(tile_reader, + window=chip_window, + band_max=3000, # what looks good for RGB + gamma=0.5, + return_array=True) + return stacked, chip_for_display + diff --git a/training_wcs/experiments/coarse_baseline/coarse_baseline_config.py b/training_wcs/experiments/coarse_baseline/coarse_baseline_config.py new file mode 100644 index 0000000..ef8d8d9 --- /dev/null +++ b/training_wcs/experiments/coarse_baseline/coarse_baseline_config.py @@ -0,0 +1,352 @@ +""" +First experiment using 6 channels (2, 3, 6, 7, NDVI, elevation) with the 13 + 1 coarse categories +mapped June 29 2020. +""" + +import os +import sys + +import numpy as np +import rasterio +import torch +import torchvision.transforms as transforms +from torch.utils.data import DataLoader + +# ai4eutils needs to be on the PYTHONPATH +from geospatial.enums import ExperimentConfigMode +from geospatial.visualization.imagery_visualizer import ImageryVisualizer +from geospatial.visualization.raster_label_visualizer import RasterLabelVisualizer + +from training_wcs.scripts.models.unet.unet import Unet +from training_wcs.scripts.utils.data_transforms import ToTensor, RandomHorizontalFlip, RandomVerticalFlip +from training_wcs.scripts.utils.datasets import SingleShardChipsDataset + +experiment_name = 'wcs_coarse_baseline' + +config_mode = ExperimentConfigMode.SCORING + +# I/O ------------------------------------------------------------------------------------------------- +if config_mode in [ExperimentConfigMode.PREPROCESSING, ExperimentConfigMode.TRAINING]: + data_shard_dir = '/boto_disk_0/wcs_data/shards/full_sr_median_2013_2014_elevation' + + # a dir with experiment_name will be created in here and checkpoints are saved here + # set as './outputs' for AML to stream to this Run's folder + out_dir = f'/boto_disk_0/wcs/{experiment_name}/outputs' + os.makedirs(out_dir, exist_ok=True) + + # TF events go here. Set it as './logs' if using AML so they can be streamed + log_dir = f'/boto_disk_0/wcs/{experiment_name}/logs' # './logs' + os.makedirs(log_dir, exist_ok=True) + +# for scoring script and make_chip_shards +if config_mode in [ExperimentConfigMode.PREPROCESSING, ExperimentConfigMode.SCORING]: + prediction_window_size = 128 + + label_viz = RasterLabelVisualizer( + label_map='/home/boto/wcs/pycharm/constants/class_lists/wcs_coarse_label_map.json') + + data_dir = '/boto_disk_0/wcs_data' # which contains images_srtm + +# Training ---------------------------------------------------------------------------------------------- + +# this is the *total* epoch; if restarting from a checkpoint, be sure to add the additional number of epochs +# to fine-tune on top of the original value of this var +total_epochs = 500 +print_every = 150 # print every how many steps; just the minibatch loss and accuracy +assert print_every >= 1, 'print_every needs to be greater than or equal 1' + +starting_checkpoint_path = None + +init_learning_rate = 5e-5 + +batch_size = 28 + +# visualizing results on a sample of chips during training_wcs +num_chips_to_viz = 48 + +# Hardware and framework -------------------------------------------------------------------------------- +dtype = torch.float32 + +# Model ------------------------------------------------------------------------------------------------- + +num_classes = 14 # empty plus the 13 *coarse* WCS classes; this is the number of output nodes + +num_in_channels = 6 # 2, 3, 6, 7, NDVI, elevation + +# the smallest number of filters is 64 when feature_scale is 1, and it is 32 when feature_scale is 2 +feature_scale = 1 + +is_deconv = True # True to use transpose convolution filters to learn upsampling; otherwise upsampling is not learnt + +is_batchnorm = True + +model = Unet(feature_scale=feature_scale, + n_classes=num_classes, + in_channels=num_in_channels, + is_deconv=is_deconv, + is_batchnorm=is_batchnorm) + +# Data --------------------------------------------------------------------------------------------------- + +common_classes = [ +] +less_common_classes = [ +] + +weights = [] +for i in range(num_classes): + if i in common_classes: + weights.append(0) + elif i in less_common_classes: + weights.append(0) + else: + weights.append(1) + +loss_weights = torch.FloatTensor(weights) # None if no weighting for classes +print('Weights on loss per class used:') +print(loss_weights) + +# how many subprocesses to use for data loading +# None for now - need to modify datasets.py to use +data_loader_num_workers = None + +# not available in IterableDataset data_loader_shuffle = True # True to have the data reshuffled at every epoch + +chip_size = 256 + +# datasets and dataloaders +if config_mode == ExperimentConfigMode.PREPROCESSING: + dset_train = SingleShardChipsDataset(data_shard_dir, shard_prefix='train', channels=None, + transform=transforms.Compose([ + ToTensor(), + RandomHorizontalFlip(), # these operate on Tensors, not PIL images + RandomVerticalFlip() + ])) + loader_train = DataLoader(dset_train, + batch_size=batch_size, + num_workers=4, + shuffle=True) # currently num_workers is None + + dset_val = SingleShardChipsDataset(data_shard_dir, shard_prefix='val', channels=None, + transform=transforms.Compose([ + ToTensor(), + RandomHorizontalFlip(), # these operate on Tensors, not PIL images + RandomVerticalFlip() + ])) + loader_val = DataLoader(dset_val, + num_workers=4, + batch_size=batch_size) + +# Data shards generation configurations -------------------------------------------------------------------- + +# These configurations are copied from training_wcs/experiments/elevation/elevation_2_config.py +# They are only used with make_chip_shards.py and infer.py +# train.py only use the generated chip shards as numpy arrays +if config_mode in [ExperimentConfigMode.PREPROCESSING, ExperimentConfigMode.SCORING]: + elevation_path = os.path.join(data_dir, 'images_srtm', 'wcs_orinoquia_srtm.tif') + elevation_reader = rasterio.open(elevation_path) + +# based on min and max values from the sample tile +# wcs_orinoquia_sr_median_2013_2014-0000007424-0000007424_-71.347_4.593.tif in training_wcs set +# bands 4 and 5 are combined to get the NDVI, so the normalization params for 4 and 5 are +# not used during training_wcs data generation, only for visualization (actually not yet used for viz either). +bands_normalization_params = { + # these are the min and max to clip to for the band + 'min': { + 2: 0, + 3: 0, + 4: 0, + 5: 0, + 6: 0, + 7: 0 + }, + 'max': { + 2: 700, + 3: 1500, + 4: 1500, + 5: 5000, + 6: 5000, + 7: 3000 + }, + 'gamma': { # all the same in this experiment with value 1 which means no effect + 2: 1.0, + 3: 1.0, + 4: 1.0, + 5: 1.0, + 6: 1.0, + 7: 1.0 + } +} + +elevation_standardization_params = { + # from calculations done in GEE + 'mean': 399.78, + 'std_dev': 714.78 +} + + +def get_elevation_chip(tile_reader, chip_window): + x, y = (tile_reader.bounds.left, tile_reader.bounds.top) + + # getting the pixel array indices corresponding to points in georeferenced space + row, col = elevation_reader.index(x, y) + + # tile wcs_orinoquia_sr_median_2013_2014-0000000000-0000007424_-72.425_7.671.tif + # top left corner looks up to a negative row index. Clipping to 0 seems to be okay visually + row = max(0, row) + col = max(0, col) + + # resolution and project are the same for the elevation data and the Landsat imagery + row = row + chip_window[1] + col = col + chip_window[0] # x is col + + try: + w = rasterio.windows.Window.from_slices((row, row + chip_window[3]), (col, col + chip_window[2])) + except Exception as e: + print(str(e)) + print('chip window:', str(chip_window)) + print('original row and col: ', str(elevation_reader.index(x, y))) + print('row:', row) + print('col:', col) + print(tile_reader.bounds) + print('x:', x) + print('y:', y) + import sys + sys.exit(1) + + chip_elevation = elevation_reader.read(1, window=w) # only 1 band + + # standardize + chip_elevation = (chip_elevation - elevation_standardization_params['mean']) / elevation_standardization_params[ + 'std_dev'] + return chip_elevation + + +def _pad_chip(band, chip_window): + """ + + Args: + band: numpy array of dims (h, w) + chip_window: (col_off x, row_off y, width, height) + + Returns: + band padded to dims (width, height) of the chip_window provided + """ + width = chip_window[2] + height = chip_window[3] + # check for smaller than because we use get_chip to get the entire tile during scoring + if band.shape[0] < height or band.shape[1] < width: + # default pad constant value is 0 + try: + band = np.pad(band, + [(0, height - band.shape[0]), (0, width - band.shape[1])]) + except Exception as e: + print(f'coarse_baseline_config, _pad_chip exception: {e}') + + sys.exit(1) + return band + + +normal_bands = [2, 3, 6, 7] # bands to be used without calculating other indices e.g. NDVI + + +def get_chip(tile_reader, chip_window, chip_for_display=True): + """ + Get an area (chip) specified by the chip_window. Is not related to chip_size + Args: + tile_reader: rasterio dataset object of the imagery tile + chip_window: (col_off x, row_off y, width, height) + chip_for_display: True if also return a chip that looks good + Returns: + stacked: A numpy array of dims (6, H, W) - note that height and width are switched from chip_window + chip_for_display: If chip_for_display is True, also a 3-band array of the RGB channels scaled to + look good (R channel not included in stacked) + """ + + bands_to_stack = [] + for b in normal_bands: + # getting one band at a time because min, max and gamma may be different + band = ImageryVisualizer.show_landsat8_patch( + tile_reader, + bands=[b], # pass in a list to get the batch dimension in the results + window=chip_window, + band_min=bands_normalization_params['min'][b], + band_max=bands_normalization_params['max'][b], + gamma=bands_normalization_params['gamma'][b], + return_array=True + ) + + # deal with incomplete chips + band = _pad_chip(band, chip_window) + + bands_to_stack.append(band) # band is 2D (h, w), already squeezed, dtype is float 32 + + ndvi = ImageryVisualizer.get_landsat8_ndvi(tile_reader, window=chip_window) # 2D, dtype is float32 + ndvi = _pad_chip(ndvi, chip_window) + bands_to_stack.append(ndvi) + + elevation = get_elevation_chip(tile_reader, chip_window) # scene covers entire region, not tiled, so no gaps + elevation = _pad_chip(elevation, chip_window) + bands_to_stack.append(elevation) + + try: + stacked = np.stack(bands_to_stack) + except Exception as e: + print(f'Exception in get_chip: {e}') + for b in bands_to_stack: + print(b.shape) + print('') + + assert stacked.shape == (6, chip_window[3], chip_window[2]), \ + f'Chip has wrong shape: {stacked.shape}, should be (6, h, w)' + + if chip_for_display: + # chip for display, getting the RBG bands (default) with a different gamma and band_max that look good + chip_for_display = ImageryVisualizer.show_landsat8_patch(tile_reader, + window=chip_window, + band_max=3000, # what looks good for RGB + gamma=0.5, + return_array=True) + + return stacked, chip_for_display + else: + return stacked + + +def preprocess_tile(tile_array: np.ndarray) -> np.ndarray: + """Same functionality as get_chip(), but applies to a numpy array tile of arbitrary shape. + Currently only used with the landcover tool. + + Args: + tile_array: A numpy array of dims (height, width, channels). Expect elevation to be the eleventh channel + + Returns: + Numpy array representing of the preprocessed chip of dims (6, height, width) - note that channels is + in-front. + """ + bands_to_stack = [] + for b in normal_bands: + # getting one band at a time because min, max and gamma may be different + band = ImageryVisualizer.show_landsat8_patch( + tile_array, + bands=[b], # pass in a list to get the batch dimension in the results + band_min=bands_normalization_params['min'][b], + band_max=bands_normalization_params['max'][b], + gamma=bands_normalization_params['gamma'][b], + return_array=True + ) + bands_to_stack.append(band) # band is 2D (h, w), already squeezed, dtype is float 32 + + ndvi = ImageryVisualizer.get_landsat8_ndvi(tile_array) # 2D, dtype is float32 + bands_to_stack.append(ndvi) + + # for the interactive tool, elevation is band 11 (1-indexed) or 10 (0-indexed), and already normalized + # by elevation_standardization_params (could have done the normalization here too) + elevation = tile_array[:, :, 10] + bands_to_stack.append(elevation) + + stacked = np.stack(bands_to_stack) + + assert stacked.shape == ( + 6, tile_array.shape[0], tile_array.shape[1]), f'preprocess_tile, wrong shape: {stacked.shape}' + return stacked diff --git a/training_wcs/experiments/random_forest/rf_baseline_notebook.ipynb b/training_wcs/experiments/random_forest/rf_baseline_notebook.ipynb new file mode 100644 index 0000000..1b24243 --- /dev/null +++ b/training_wcs/experiments/random_forest/rf_baseline_notebook.ipynb @@ -0,0 +1,702 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import sys, os, time\n", + "sys.path.append(\"..\")\n", + "from pathlib import Path\n", + "import json\n", + "\n", + "import numpy as np\n", + "import rasterio\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from sklearn.ensemble import RandomForestClassifier" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from viz_utils import VizUtils" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "with open(\"../constants/class_lists/wcs_fine_coarse_label_maps.json\",\"r\") as f:\n", + " label_maps = json.loads(f.read())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "with open(\"../constants/splits/full_sr_median_2013_2014_splits.json\", \"r\") as f:\n", + " splits = json.loads(f.read())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of training tiles: 133\n", + "Number of validation tiles: 15\n" + ] + } + ], + "source": [ + "IMAGES_DIR = Path(\"/home/caleb/data1/wcs_data/tiles/\")\n", + "LABELS_DIR = Path(\"/home/caleb/data1/wcs_data/tiles_masks_coarse/\")\n", + "\n", + "\n", + "def get_image_label_fn_pairs(fns):\n", + " fn_pairs = []\n", + " for fn in fns:\n", + " parts = fn[:-4].split(\"_\")\n", + " lon, lat = parts[-2], parts[-1]\n", + "\n", + " image_fn = IMAGES_DIR / fn\n", + " label_fn = LABELS_DIR / (\"mask_%s_%s.tif\" % (lon, lat))\n", + "\n", + " if label_fn.exists(): \n", + " fn_pairs.append((image_fn, label_fn))\n", + " else:\n", + " print(\"Skipping %s because there isn't a matching label filename\" % (fn))\n", + " return fn_pairs\n", + "\n", + "train_fns = get_image_label_fn_pairs(splits[\"train\"])\n", + "val_fns = get_image_label_fn_pairs(splits[\"val\"])\n", + "\n", + "print(\"Number of training tiles: %d\" % (len(train_fns)))\n", + "print(\"Number of validation tiles: %d\" % (len(val_fns)))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 133\n", + "10 133\n", + "20 133\n", + "30 133\n", + "40 133\n", + "50 133\n", + "60 133\n", + "70 133\n", + "80 133\n", + "90 133\n", + "100 133\n", + "110 133\n", + "120 133\n", + "130 133\n", + "CPU times: user 3min 3s, sys: 4.68 s, total: 3min 8s\n", + "Wall time: 3min 8s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "class_counts = []\n", + "for i, (image_fn, label_fn) in enumerate(train_fns):\n", + " if i % 10 == 0:\n", + " print(i, len(train_fns))\n", + " with rasterio.open(image_fn, \"r\") as f:\n", + " data = np.rollaxis(f.read(), 0, 3)\n", + " with rasterio.open(label_fn, \"r\") as f:\n", + " labels = f.read().squeeze()\n", + " \n", + " vals, counts = np.unique(labels, return_counts=True) \n", + " class_counts.append((vals, counts))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((2000, 2000, 10), (2000, 2000))" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.shape, labels.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 133\n", + "10 133\n", + "20 133\n", + "30 133\n", + "40 133\n", + "50 133\n", + "60 133\n", + "70 133\n", + "80 133\n", + "90 133\n", + "100 133\n", + "110 133\n", + "120 133\n", + "130 133\n", + "CPU times: user 3min 22s, sys: 34.2 s, total: 3min 56s\n", + "Wall time: 3min 56s\n" + ] + } + ], + "source": [ + "%%time\n", + "n_samples_per_tile = 5000\n", + "\n", + "x_train_tiles = np.zeros((len(train_fns), 2000, 2000, 10), dtype=np.float64)\n", + "y_train_tiles = np.zeros((len(train_fns), 2000, 2000), dtype=np.uint8)\n", + "\n", + "x_train = np.zeros((n_samples_per_tile * len(train_fns), 10), dtype=np.float64)\n", + "y_train = np.zeros((n_samples_per_tile * len(train_fns)), dtype=np.int32)\n", + "\n", + "for i, (image_fn, label_fn) in enumerate(train_fns):\n", + " if i % 10 == 0:\n", + " print(i, len(train_fns))\n", + " with rasterio.open(image_fn, \"r\") as f:\n", + " data = np.rollaxis(f.read(), 0, 3)\n", + " with rasterio.open(label_fn, \"r\") as f:\n", + " labels = f.read().squeeze()\n", + " \n", + " x_train_tiles[i] = data\n", + " y_train_tiles[i] = labels\n", + " \n", + " data = data.reshape(-1, 10)\n", + " labels = labels.reshape(-1,)\n", + " \n", + " idxs = np.random.choice(data.shape[0], replace=False, size=n_samples_per_tile)\n", + " \n", + " x_train[(i)*n_samples_per_tile:(i+1)*n_samples_per_tile] = data[idxs]\n", + " y_train[(i)*n_samples_per_tile:(i+1)*n_samples_per_tile] = labels[idxs]" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "x_train_tiles = x_train_tiles.reshape(-1,10)\n", + "y_train_tiles = y_train_tiles.reshape(-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Class counts all:\n", + "Empty of data (0)\t20.65%\t109880338\n", + "Urban and infrastructure (1)\t0.06%\t300046\n", + "Agriculture (2)\t3.97%\t21114120\n", + "Arboreal and forestry crops (3)\t0.52%\t2787604\n", + "Pasture (4)\t5.95%\t31638817\n", + "Vegetation (5)\t1.99%\t10574669\n", + "Forest (6)\t36.33%\t193271855\n", + "Savanna (7)\t1.71%\t9119246\n", + "Sand, rocks and bare land (8)\t0.14%\t731057\n", + "Unavailable (9)\t0.25%\t1305558\n", + "Swamp (10)\t0.25%\t1312385\n", + "Water (11)\t1.05%\t5598361\n", + "Seasonal savanna (12)\t16.15%\t85926785\n", + "Seasonally flooded savanna (13)\t10.98%\t58439159\n" + ] + } + ], + "source": [ + "print(\"Class counts all:\")\n", + "vals, counts = np.unique(y_train_tiles, return_counts=True)\n", + "for val, count in zip(vals, counts):\n", + " print(\"%s (%d)\\t%0.2f%%\\t%d\" % (label_maps[\"wcs_num_to_name\"][str(val)], val, count / counts.sum() * 100, count))" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampling for class 1\n", + "Sampling for class 2\n", + "Sampling for class 3\n", + "Sampling for class 4\n", + "Sampling for class 5\n", + "Sampling for class 6\n", + "Sampling for class 7\n", + "Sampling for class 8\n", + "Sampling for class 9\n", + "Sampling for class 10\n", + "Sampling for class 11\n", + "Sampling for class 12\n", + "Sampling for class 13\n" + ] + } + ], + "source": [ + "n_samples_per_class = 40000\n", + "\n", + "x_train = []\n", + "y_train = []\n", + "\n", + "for class_idx in range(1,14):\n", + " print(\"Sampling for class %d\" % (class_idx))\n", + " idxs = np.where(y_train_tiles == class_idx)[0]\n", + " idxs = np.random.choice(idxs, size=n_samples_per_class, replace=True)\n", + " x_train.append(x_train_tiles[idxs])\n", + " y_train.append(y_train_tiles[idxs])\n", + " \n", + "x_train = np.concatenate(x_train, axis=0)\n", + "y_train = np.concatenate(y_train, axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [], + "source": [ + "n_samples_per_class = 40000\n", + "\n", + "idxs = np.random.choice(x_train_tiles.shape[0], size=n_samples_per_class * 14, replace=True)\n", + "x_train = x_train_tiles[idxs].copy()\n", + "y_train = y_train_tiles[idxs].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([ 0, 2, 4, 5, 6, 7, 8, 11, 12], dtype=uint8), array([3796, 14, 18, 145, 1283, 115, 1, 5, 1]))\n" + ] + } + ], + "source": [ + "nan_mask = np.any(np.isnan(x_train), axis=1)\n", + "x_train[nan_mask] = 0\n", + "print(np.unique(y_train[nan_mask], return_counts=True))\n", + "y_train[nan_mask] = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [], + "source": [ + "nodata_mask = y_train == 0\n", + "x_train[nodata_mask] = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Class counts training:\n", + "Empty of data (0)\t20.93%\t117194\n", + "Urban and infrastructure (1)\t0.06%\t353\n", + "Agriculture (2)\t3.96%\t22200\n", + "Arboreal and forestry crops (3)\t0.53%\t2955\n", + "Pasture (4)\t5.97%\t33406\n", + "Vegetation (5)\t1.96%\t10977\n", + "Forest (6)\t36.08%\t202033\n", + "Savanna (7)\t1.69%\t9470\n", + "Sand, rocks and bare land (8)\t0.13%\t752\n", + "Unavailable (9)\t0.24%\t1367\n", + "Swamp (10)\t0.25%\t1389\n", + "Water (11)\t1.04%\t5850\n", + "Seasonal savanna (12)\t16.16%\t90524\n", + "Seasonally flooded savanna (13)\t10.99%\t61530\n" + ] + } + ], + "source": [ + "print(\"Class counts training:\")\n", + "vals, counts = np.unique(y_train, return_counts=True)\n", + "for val, count in zip(vals, counts):\n", + " print(\"%s (%d)\\t%0.2f%%\\t%d\" % (label_maps[\"wcs_num_to_name\"][str(val)], val, count / counts.sum() * 100, count))" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1min 46s, sys: 1.03 s, total: 1min 47s\n", + "Wall time: 6.24 s\n" + ] + }, + { + "data": { + "text/plain": [ + "RandomForestClassifier(n_estimators=50, n_jobs=24)" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "model = RandomForestClassifier(n_jobs=24, n_estimators=50)\n", + "model.fit(x_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 15 1.239776611328125e-05\n", + "5 15 64.12146019935608\n", + "10 15 61.065794467926025\n", + "CPU times: user 15min 39s, sys: 12min 5s, total: 27min 45s\n", + "Wall time: 2min 56s\n" + ] + } + ], + "source": [ + "%%time\n", + "y_true_tiles = np.zeros((len(val_fns), 2000, 2000), dtype=np.uint8)\n", + "y_pred_tiles = np.zeros((len(val_fns), 2000, 2000), dtype=np.uint8)\n", + "\n", + "tic = float(time.time())\n", + "for i, (image_fn, label_fn) in enumerate(val_fns):\n", + " if i % 5 == 0:\n", + " print(i, len(val_fns), time.time()-tic)\n", + " tic = float(time.time())\n", + " \n", + " with rasterio.open(image_fn, \"r\") as f:\n", + " data = np.rollaxis(f.read(), 0, 3)\n", + " with rasterio.open(label_fn, \"r\") as f:\n", + " labels = f.read().squeeze()\n", + " \n", + " data = data.reshape(-1, 10)\n", + " nan_mask = np.any(np.isnan(data), axis=1)\n", + "\n", + " data[nan_mask] = 0\n", + " y_true = labels.reshape(-1,)\n", + " \n", + " y_pred = model.predict(data).astype(np.uint8)\n", + " \n", + " y_pred[nan_mask] = 0\n", + " \n", + " y_pred_tiles[i] = y_pred.reshape(2000,2000)\n", + " y_true_tiles[i] = y_true.reshape(2000,2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [], + "source": [ + "viz = VizUtils(\"wcs_fine_coarse_label_maps.json\")" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "viz.show_label_raster(y_true_tiles[0])[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 143, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "viz.show_label_raster(y_pred_tiles[0])[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [], + "source": [ + "y_preds = []\n", + "for i in range(y_pred_tiles.shape[0]):\n", + " y_preds.append(scipy.ndimage.median_filter(y_pred_tiles[i],size=5))\n", + "y_preds = np.array(y_preds).reshape(-1,)" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [], + "source": [ + "y_true = y_true_tiles.reshape(-1,)" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [], + "source": [ + "def get_cnf(raster1, raster2, classes):\n", + " \n", + " cnf = np.zeros((len(classes), len(classes)), dtype=int)\n", + " for i, class_a in enumerate(classes):\n", + " mask1 = raster1 == class_a\n", + " for j, class_b in enumerate(classes):\n", + " mask2 = raster2 == class_b\n", + " overlap = np.sum(mask1 & mask2)\n", + " cnf[i,j] = overlap\n", + " \n", + " return cnf" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [], + "source": [ + "num_classes = 14\n", + "cm = get_cnf(y_true, y_preds, list(range(num_classes)))" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [], + "source": [ + "classes_present_in_gt = np.unique(y_true)" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],\n", + " dtype=uint8)" + ] + }, + "execution_count": 148, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "classes_present_in_gt" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],\n", + " dtype=uint8)" + ] + }, + "execution_count": 149, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.unique(y_preds)" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [], + "source": [ + "total_obs = cm.sum()\n", + "\n", + "per_class_accuracy = {}\n", + "per_class_recall = {}\n", + "per_class_precision = {}\n", + "\n", + "for cls in range(num_classes):\n", + " if cls not in classes_present_in_gt:\n", + " continue\n", + " \n", + " true_pos = cm[cls, cls]\n", + " \n", + " true_neg = total_obs - cm[cls, :].sum() - cm[:, cls].sum() + true_pos\n", + " \n", + " false_pos = cm[:, cls].sum() - true_pos\n", + " \n", + " false_neg = cm[cls, :].sum() - true_pos\n", + " \n", + " per_class_accuracy[cls] = (true_pos + true_neg) / total_obs\n", + " \n", + " per_class_precision[cls] = true_pos / (true_pos + false_pos)\n", + " \n", + " per_class_recall[cls] = true_pos / (true_pos + false_neg)" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 Empty of data,0.6734255666666666,0.22408919132453956,0.11671147240411378\n", + "1 Urban and infrastructure,0.9985908166666667,0.017251131221719458,0.0024626895799970392\n", + "2 Agriculture,0.8962647333333333,0.2965878342357711,0.21387258012834498\n", + "3 Arboreal and forestry crops,0.9939105833333334,0.25666767007826613,0.051205443337106755\n", + "4 Pasture,0.8872791166666667,0.46718450752349333,0.4202877331944504\n", + "5 Vegetation,0.9584894166666666,0.14678786632716,0.016057741258641445\n", + "6 Forest,0.8224525666666667,0.6018360466107346,0.8350316936569855\n", + "7 Savanna,0.95212325,0.5056429237561962,0.5392844208786413\n", + "8 Sand, rocks and bare land,0.99609655,0.4939627977809203,0.13617358522897657\n", + "9 Unavailable,0.99817415,0.0,0.0\n", + "10 Swamp,0.9970988,0.1710680751173709,0.006875486473099512\n", + "11 Water,0.9826308,0.41823605798585994,0.5025137339770268\n", + "12 Seasonal savanna,0.8540314,0.36613875040062893,0.8290167707821933\n", + "13 Seasonally flooded savanna,0.8979317833333333,0.5135307183043014,0.4390524059121347\n" + ] + } + ], + "source": [ + "for cls, acc in per_class_accuracy.items():\n", + " prec = per_class_precision[cls]\n", + " recall = per_class_recall[cls]\n", + " print(f'{cls} {label_maps[\"wcs_num_to_name\"][str(cls)]},{acc},{prec},{recall}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "wcs", + "language": "python", + "name": "wcs" + }, + "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.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/training_wcs/scripts/models/unet/unet.py b/training_wcs/scripts/models/unet/unet.py new file mode 100644 index 0000000..02d03a6 --- /dev/null +++ b/training_wcs/scripts/models/unet/unet.py @@ -0,0 +1,105 @@ +import logging + +import torch.nn as nn + +from .unet_utils import * + +""" +Unet model definition. + +Code mostly taken from https://github.com/meetshah1995/pytorch-semseg/blob/master/ptsemseg/models/unet.py +""" + + +class Unet(nn.Module): + + def __init__(self, feature_scale=1, + n_classes=3, in_channels=3, + is_deconv=True, is_batchnorm=False): + """A U-Net implementation. + + Args: + feature_scale: the smallest number of filters (depth c) is 64 when feature_scale is 1, + and it is 32 when feature_scale is 2 + n_classes: number of output classes + in_channels: number of channels in input + is_deconv: + is_batchnorm: + """ + super(Unet, self).__init__() + + self._num_classes = n_classes + + assert 64 % feature_scale == 0, f'feature_scale {feature_scale} does not work with this UNet' + + filters = [64, 128, 256, 512, 1024] # this is `c` in the diagram, [c, 2c, 4c, 8c, 16c] + filters = [int(x / feature_scale) for x in filters] + logging.info('filters used are: {}'.format(filters)) + + # downsampling + self.conv1 = UnetConv2(in_channels, filters[0], is_batchnorm) + self.maxpool1 = nn.MaxPool2d(kernel_size=2) + + self.conv2 = UnetConv2(filters[0], filters[1], is_batchnorm) + self.maxpool2 = nn.MaxPool2d(kernel_size=2) + + self.conv3 = UnetConv2(filters[1], filters[2], is_batchnorm) + self.maxpool3 = nn.MaxPool2d(kernel_size=2) + + self.conv4 = UnetConv2(filters[2], filters[3], is_batchnorm) + self.maxpool4 = nn.MaxPool2d(kernel_size=2) + + self.center = UnetConv2(filters[3], filters[4], is_batchnorm) + + # upsampling + self.up_concat4 = UnetUp(filters[4], filters[3], is_deconv) + self.up_concat3 = UnetUp(filters[3], filters[2], is_deconv) + self.up_concat2 = UnetUp(filters[2], filters[1], is_deconv) + self.up_concat1 = UnetUp(filters[1], filters[0], is_deconv) + + # final conv (without any concat) + self.final = nn.Conv2d(filters[0], self._num_classes, kernel_size=1) + self._filters = filters # we need this info for re-training + + def forward(self, inputs, return_features=False): + """If return_features is True, returns tuple (final outputs, last feature map), + else returns final outputs only. + """ + conv1 = self.conv1(inputs) + maxpool1 = self.maxpool1(conv1) + + conv2 = self.conv2(maxpool1) + maxpool2 = self.maxpool2(conv2) + + conv3 = self.conv3(maxpool2) + maxpool3 = self.maxpool3(conv3) + + conv4 = self.conv4(maxpool3) + maxpool4 = self.maxpool4(conv4) + + center = self.center(maxpool4) + up4 = self.up_concat4(conv4, center) + up3 = self.up_concat3(conv3, up4) + up2 = self.up_concat2(conv2, up3) + up1 = self.up_concat1(conv1, up2) + + final = self.final(up1) + + if return_features: + return final, up1 + else: + return final + + def change_num_classes(self, new_num_classes: int): + """Re-initialize the final layer with another number of output classes if different from + existing number of classes + """ + if new_num_classes == self._num_classes: + return + + assert new_num_classes > 1, 'Number of classes need to be > 1' + self._num_classes = new_num_classes + + self.final = nn.Conv2d(self._filters[0], self._num_classes, kernel_size=1) + nn.init.kaiming_uniform_(self.final.weight) + self.final.bias.data.zero_() diff --git a/training_wcs/scripts/models/unet/unet_utils.py b/training_wcs/scripts/models/unet/unet_utils.py new file mode 100644 index 0000000..afb46a5 --- /dev/null +++ b/training_wcs/scripts/models/unet/unet_utils.py @@ -0,0 +1,74 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class UnetConv2(nn.Module): + + def __init__(self, in_channels, out_channels, is_batchnorm): + super(UnetConv2, self).__init__() + + if is_batchnorm: + self.conv1 = nn.Sequential( + # this amount of padding/stride/kernel_size preserves width/height + nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1), + nn.BatchNorm2d(out_channels), + nn.ReLU() + ) + self.conv2 = nn.Sequential( + nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1), + nn.BatchNorm2d(out_channels), + nn.ReLU() + ) + else: + self.conv1 = nn.Sequential( + nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1), + nn.ReLU() + ) + self.conv2 = nn.Sequential( + nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1), + nn.ReLU() + ) + + def forward(self, inputs): + outputs = self.conv1(inputs) + outputs = self.conv2(outputs) + return outputs + + +class UnetUp(nn.Module): + + def __init__(self, in_channels, out_channels, is_deconv): + """ + + is_deconv: use transposed conv layer to upsample - parameters are learnt; otherwise use + bilinear interpolation to upsample. + """ + super(UnetUp, self).__init__() + + self.conv = UnetConv2(in_channels, out_channels, False) + + self.is_deconv = is_deconv + if is_deconv: + self.up = nn.ConvTranspose2d(in_channels, out_channels, kernel_size=2, stride=2) + # nn.UpsamplingBilinear2d is deprecated in favor of F.interpolate() + # else: + # self.up = nn.UpsamplingBilinear2d(scale_factor=2) + + def forward(self, inputs1, inputs2): + """ + inputs1 is from the downward path, of higher resolution + inputs2 is from the 'lower' layer. It gets upsampled (spatial size increases) and its depth (channels) halves + to match the depth of inputs1, before being concatenated in the depth dimension. + """ + if self.is_deconv: + outputs2 = self.up(inputs2) + else: + # scale_factor is the multiplier for spatial size + outputs2 = F.interpolate(inputs2, scale_factor=2, mode='bilinear', align_corners=True) + + offset = outputs2.size()[2] - inputs1.size()[2] + padding = 2 * [offset // 2, offset // 2] + outputs1 = F.pad(inputs1, padding) + + return self.conv(torch.cat([outputs1, outputs2], dim=1))