diff --git a/aitlas/datasets/__init__.py b/aitlas/datasets/__init__.py index eb97371..c8ef98f 100644 --- a/aitlas/datasets/__init__.py +++ b/aitlas/datasets/__init__.py @@ -31,7 +31,7 @@ from .amazon_rainforest import AmazonRainforestDataset from .airs import AIRSDataset from .camvid import CamVidDataset -# from .spacenet6 import SpaceNet6Dataset +from .spacenet6 import SpaceNet6Dataset from .massachusetts_buildings import MassachusettsBuildingsDataset from .massachusetts_roads import MassachusettsRoadsDataset from .inria import InriaDataset diff --git a/aitlas/datasets/spacenet6.py b/aitlas/datasets/spacenet6.py index e5c034a..2534e22 100644 --- a/aitlas/datasets/spacenet6.py +++ b/aitlas/datasets/spacenet6.py @@ -12,20 +12,19 @@ from multiprocessing import Pool import cv2 -import gdal +from osgeo import gdal import numpy as np import pandas as pd import torch from shapely.wkt import loads from skimage import io, measure -from skimage.morphology import dilation, erosion, square +from skimage.morphology import square, erosion, dilation from skimage.segmentation import watershed from tqdm import tqdm -from ..base import BaseDataset -from ..datasets.schemas import SpaceNet6DatasetSchema -from ..utils import parse_img_id - +from aitlas.base import BaseDataset +from aitlas.datasets.schemas import SpaceNet6DatasetSchema +from aitlas.utils.utils import parse_img_id # Ignore the "low-contrast" warnings warnings.filterwarnings("ignore") @@ -44,9 +43,7 @@ def integer_coordinates(x): return image_mask -def process_image( - image_path, segmentation_directory, edge_width, contact_width, gt_buildings_csv -): +def process_image(image_path, segmentation_directory, edge_width, contact_width, gt_buildings_csv): """ Creates and saves the target (ground-truth) segmentation mask for the input image. @@ -65,11 +62,10 @@ def process_image( """ gt_buildings = pd.read_csv(gt_buildings_csv) image_name = os.path.basename(image_path) - values = gt_buildings[ - (gt_buildings["ImageId"] == "_".join(image_name.split("_")[-4:])[:-4]) - ][["TileBuildingId", "PolygonWKT_Pix", "Mean_Building_Height"]].values - labels = np.zeros((900, 900), dtype="uint16") - heights = np.zeros((900, 900), dtype="float") + values = gt_buildings[(gt_buildings["ImageId"] == "_".join(image_name.split("_")[-4:])[:-4])][ + ["TileBuildingId", "PolygonWKT_Pix", "Mean_Building_Height"]].values + labels = np.zeros((900, 900), dtype='uint16') + heights = np.zeros((900, 900), dtype='float') cur_lbl = 0 for i in range(values.shape[0]): poly = loads(values[i, 1]) @@ -103,31 +99,24 @@ def process_image( sz = 3 else: sz = 1 - unique = np.unique( - labels[ - max(0, y0 - sz) : min(labels.shape[0], y0 + sz + 1), - max(0, x0 - sz) : min(labels.shape[1], x0 + sz + 1), - ] - ) + unique = np.unique(labels[max(0, y0 - sz):min(labels.shape[0], y0 + sz + 1), + max(0, x0 - sz):min(labels.shape[1], x0 + sz + 1)]) if len(unique[unique > 0]) > 1: contact_msk[y0, x0] = True - msk = np.stack( - (255 * footprint_msk, 255 * border_msk, 255 * contact_msk) - ).astype("uint8") + msk = np.stack((255 * footprint_msk, 255 * border_msk, 255 * contact_msk)).astype("uint8") msk = np.rollaxis(msk, 0, 3) io.imsave(os.path.join(segmentation_directory, image_name), msk) class SpaceNet6Dataset(BaseDataset): """SpaceNet6 dataset.""" - schema = SpaceNet6DatasetSchema def __init__(self, config): BaseDataset.__init__(self, config) self.image_paths = list() self.mask_paths = list() - self.orients = pd.read_csv(config.orients, index_col=0) + self.orients = pd.read_csv(config["orients"], index_col=0) self.orients["val"] = list(range(len(self.orients.index))) def __getitem__(self, index): @@ -151,7 +140,7 @@ def __getitem__(self, index): m = np.where((image.sum(axis=2) > 0).any(0)) x_min, x_max = np.amin(m), np.amax(m) + 1 # Remove black parts - image = image[y_min:y_max, x_min:x_max] + image = image[y_min: y_max, x_min: x_max] # Apply transformations, (should be available only for training data) if self.config.transforms: # Get mask path @@ -159,26 +148,27 @@ def __getitem__(self, index): # Read mask mask = io.imread(mask_path) # Remove black parts - mask = mask[y_min:y_max, x_min:x_max] - image, mask = self.transform({"image": image, "mask": mask}) + mask = mask[y_min: y_max, x_min: x_max] + image, mask = self.transform({ + "image": image, + "mask": mask + }) # Extract direction, strip and coordinates from image direction, strip, coordinate = parse_img_id(image_path, self.orients) if direction.item(): image = np.fliplr(np.flipud(image)) if self.config.transforms: mask = np.fliplr(np.flipud(mask)) - image = ( - image - np.array([28.62501827, 36.09922463, 33.84483687, 26.21196667]) - ) / np.array([8.41487376, 8.26645475, 8.32328472, 8.63668993]) + image = (image - np.array([28.62501827, 36.09922463, 33.84483687, 26.21196667])) / np.array( + [8.41487376, 8.26645475, 8.32328472, 8.63668993]) # Transpose image image = torch.from_numpy(image.transpose((2, 0, 1)).copy()).float() # Reorder bands image = image[[0, 3, 1, 2]] if self.config.transforms: weights = np.ones_like(mask[:, :, :1], dtype=float) - region_labels, region_count = measure.label( - mask[:, :, 0], background=0, connectivity=1, return_num=True - ) + region_labels, region_count = measure.label(mask[:, :, 0], background=0, connectivity=1, + return_num=True) region_properties = measure.regionprops(region_labels) for bl in range(region_count): weights[region_labels == bl + 1] = 1024.0 / region_properties[bl].area @@ -199,7 +189,7 @@ def __getitem__(self, index): "ymin": y_min, "xmin": x_min, "b_count": region_count, - "weights": weights, + "weights": weights } def __len__(self): @@ -213,34 +203,16 @@ def load_directory(self): def load_other_folds(self, fold): """Loads all images (and masks) except the ones from this fold.""" df = pd.read_csv(self.config.folds_path) - self.image_paths = [ - os.path.join( - self.config.root_directory, "SAR-Intensity", os.path.basename(x) - ) - for x in df[ - np.logical_or( - df["fold"] > (fold % 10) + 1, df["fold"] < (fold % 10) - 1 - ) - ]["sar"].values - ] - self.mask_paths = [ - os.path.join(self.config.segmentation_directory, os.path.basename(x)) - for x in df[ - np.logical_or( - df["fold"] > (fold % 10) + 1, df["fold"] < (fold % 10) - 1 - ) - ]["segm"].values - ] + self.image_paths = [os.path.join(self.config.root_directory, "SAR-Intensity", os.path.basename(x)) for x in + df[np.logical_or(df["fold"] > (fold % 10) + 1, df["fold"] < (fold % 10) - 1)]["sar"].values] + self.mask_paths = [os.path.join(self.config.segmentation_directory, os.path.basename(x)) for x in + df[np.logical_or(df["fold"] > (fold % 10) + 1, df["fold"] < (fold % 10) - 1)]["segm"].values] def load_fold(self, fold): """Loads the images from this fold.""" df = pd.read_csv(self.config.folds_path) - self.image_paths = [ - os.path.join( - self.config.root_directory, "SAR-Intensity", os.path.basename(x) - ) - for x in df[df["fold"] == (fold % 10)]["sar"].values - ] + self.image_paths = [os.path.join(self.config.root_directory, "SAR-Intensity", os.path.basename(x)) for x in + df[df["fold"] == (fold % 10)]["sar"].values] self.mask_paths = None def labels(self): @@ -261,87 +233,53 @@ def prepare(self): os.makedirs(self.config.segmentation_directory, exist_ok=True) os.makedirs(self.config.folds_dir, exist_ok=True) # Path to the ground-truth buildings csv file - gt_buildings_csv_filepath = os.path.join( - self.config.root_directory, - "SummaryData/SN6_Train_AOI_11_Rotterdam_Buildings.csv", - ) + gt_buildings_csv_filepath = os.path.join(self.config.root_directory, + "SummaryData/SN6_Train_AOI_11_Rotterdam_Buildings.csv") # Read gt building csv file gt_buildings = pd.read_csv(gt_buildings_csv_filepath) # Walk the raw data directory with the SAR images and save the filenames in it - sar_image_paths = glob.glob( - os.path.join(self.config.root_directory, "SAR-Intensity", "*.tif") - ) + sar_image_paths = glob.glob(os.path.join(self.config.root_directory, "SAR-Intensity", "*.tif")) # Process each SAR image with Pool(self.config.num_threads) as pool: - for _ in tqdm( - pool.imap_unordered( - partial( - process_image, - segmentation_directory=self.config.segmentation_directory, - edge_width=self.config.edge_width, - contact_width=self.config.contact_width, - gt_buildings_csv=gt_buildings_csv_filepath, - ), - sar_image_paths, - ) - ): + for _ in tqdm(pool.imap_unordered( + partial(process_image, + segmentation_directory=self.config.segmentation_directory, + edge_width=self.config.edge_width, + contact_width=self.config.contact_width, + gt_buildings_csv=gt_buildings_csv_filepath), + sar_image_paths)): pass - orientations = pd.read_csv( - filepath_or_buffer=self.config.orients, - sep=" ", - index_col=0, - names=["strip", "direction"], - header=None, - ) - df_fold = pd.DataFrame( - columns=["ImageId", "sar", "segm", "rotation", "x", "y", "fold"] - ) + orientations = pd.read_csv(filepath_or_buffer=self.config.orients, sep=' ', index_col=0, + names=["strip", "direction"], header=None) + df_fold = pd.DataFrame(columns=["ImageId", "sar", "segm", "rotation", "x", "y", "fold"]) l_edge = 591640 r_edge = 596160 orientations["sum_y"] = 0.0 orientations["ctr_y"] = 0.0 for sar_path in tqdm(sar_image_paths): - image_id = "_".join( - os.path.splitext(os.path.basename(sar_path))[0].split("_")[-4:] - ) + image_id = "_".join(os.path.splitext(os.path.basename(sar_path))[0].split("_")[-4:]) strip_name = "_".join(image_id.split("_")[-4:-2]) rotation = orientations.loc[strip_name]["direction"].squeeze() tr = gdal.Open(sar_path).GetGeoTransform() orientations.loc[strip_name, "sum_y"] += tr[3] orientations.loc[strip_name, "ctr_y"] += 1 - fold_no = min( - self.config.num_folds - 1, - max( - 0, - math.floor( - (tr[0] - l_edge) / (r_edge - l_edge) * self.config.num_folds - ), - ), - ) - segmentation_path = os.path.join( - self.config.segmentation_directory, os.path.basename(sar_path) - ) - df_fold = df_fold.append( - { - "ImageId": image_id, - "sar": sar_path, - "segm": segmentation_path, - "rotation": rotation, - "x": tr[0], - "y": tr[3], - "fold": fold_no, - }, - ignore_index=True, - ) + fold_no = min(self.config.num_folds - 1, + max(0, math.floor((tr[0] - l_edge) / (r_edge - l_edge) * self.config.num_folds))) + segmentation_path = os.path.join(self.config.segmentation_directory, os.path.basename(sar_path)) + df_fold = df_fold.append({ + "ImageId": image_id, + "sar": sar_path, + "segm": segmentation_path, + "rotation": rotation, + "x": tr[0], + "y": tr[3], + "fold": fold_no + }, ignore_index=True) df_fold.to_csv(os.path.join(self.config.folds_dir, "folds.csv"), index=False) for i in range(self.config.num_folds): img_ids = df_fold[df_fold["fold"] == i]["ImageId"].values gt_buildings[gt_buildings.ImageId.isin(img_ids)].to_csv( - os.path.join(self.config.folds_dir, "gt_fold{}.csv").format(i), - index=False, - ) + os.path.join(self.config.folds_dir, "gt_fold{}.csv").format(i), index=False) orientations["mean_y"] = orientations["sum_y"] / orientations["ctr_y"] - orientations["coord_y"] = ( - (orientations["mean_y"] - 5746153.106161971) / 11000 - ) + 0.2 + orientations["coord_y"] = (((orientations["mean_y"] - 5746153.106161971) / 11000) + 0.2) orientations.to_csv(self.config.orients_output, index=True) diff --git a/aitlas/models/__init__.py b/aitlas/models/__init__.py index db9da7d..c8430a3 100644 --- a/aitlas/models/__init__.py +++ b/aitlas/models/__init__.py @@ -18,5 +18,5 @@ EfficientNetB0, EfficientNetB0MultiLabel, EfficientNetB4, EfficientNetB4MultiLabel, EfficientNetB7, EfficientNetB7MultiLabel ) -# from .unet_efficientnet import UNetEfficientNet +from .unet_efficientnet import UNetEfficientNet from .vgg import VGG16, VGG19, VGG16MultiLabel, VGG19MultiLabel diff --git a/aitlas/models/unet_efficientnet.py b/aitlas/models/unet_efficientnet.py index 206154e..fba2f2e 100644 --- a/aitlas/models/unet_efficientnet.py +++ b/aitlas/models/unet_efficientnet.py @@ -3,6 +3,22 @@ ----- Based on the implementation at: https://github.com/SpaceNetChallenge/SpaceNet_SAR_Buildings_Solutions/blob/master/1-zbigniewwojna/main.py#L178 + + Using this model requires installing some packages that are specific to this model / use case, which are not + registered as requirements for aitlas. + These are: + + rasterio - https://rasterio.readthedocs.io/en/latest/installation.html + geopandas - https://geopandas.org/en/stable/getting_started/install.html + shapely - https://pypi.org/project/Shapely/ + geffnet - https://pypi.org/project/geffnet/ + gdal - https://gdal.org/index.html + + gdal is a bit tricky to install, you can follow the tutorial at: + https://medium.com/@egiron/how-to-install-gdal-and-qgis-on-macos-catalina-ca690dca4f91 + to install it on Mac OS, or: + https://mothergeo-py.readthedocs.io/en/latest/development/how-to/gdal-ubuntu-pkg.html + on Linux OS. """ import copy import glob @@ -10,87 +26,493 @@ import shutil from functools import partial from math import ceil -from multiprocessing import Pool, Queue +from multiprocessing import Pool import cv2 -import gdal +import geopandas as gpd import numpy as np import pandas as pd +import shapely.wkt import torch import torch.nn as nn import torch.nn.functional as F from geffnet.conv2d_layers import select_conv2d -from geffnet.efficientnet_builder import ( - BN_EPS_TF_DEFAULT, - EfficientNetBuilder, - decode_arch_def, - initialize_weight_default, - initialize_weight_goog, - resolve_bn_args, - round_channels, -) +from geffnet.efficientnet_builder import round_channels, initialize_weight_goog, initialize_weight_default, \ + EfficientNetBuilder, decode_arch_def, BN_EPS_TF_DEFAULT, resolve_bn_args +from osgeo import gdal from rasterio import features from shapely.geometry import shape from shapely.wkt import dumps from skimage import io, measure from skimage.segmentation import watershed -from solaris.eval.base import Evaluator from torch.hub import load_state_dict_from_url from tqdm import tqdm +from tqdm.auto import tqdm + +from aitlas.base import BaseSegmentationClassifier +from aitlas.datasets import SpaceNet6Dataset +from aitlas.models.schemas import UNetEfficientNetModelSchema + + +class Evaluator: + """ + Taken from: https://solaris.readthedocs.io/en/latest/api/eval.html + Object to test IoU for predictions and ground truth polygons. + + Attributes + ---------- + ground_truth_fname : str + The filename for the ground truth CSV or JSON. + ground_truth_GDF : :class:`geopandas.GeoDataFrame` + A :class:`geopandas.GeoDataFrame` containing the ground truth vector + labels. + ground_truth_GDF_Edit : :class:`geopandas.GeoDataFrame` + A copy of ``ground_truth_GDF`` which will be manipulated during + processing. + proposal_GDF : :class:`geopandas.GeoDataFrame` + The proposal :class:`geopandas.GeoDataFrame`, added using + ``load_proposal()``. + + Arguments + --------- + ground_truth_vector_file : str + Path to .geojson file for ground truth. + + """ + + def __init__(self, ground_truth_vector_file): + # Load Ground Truth : Ground Truth should be in geojson or shape file + try: + if ground_truth_vector_file.lower().endswith('json'): + self.load_truth(ground_truth_vector_file) + elif ground_truth_vector_file.lower().endswith('csv'): + self.load_truth(ground_truth_vector_file, truthCSV=True) + self.ground_truth_fname = ground_truth_vector_file + except AttributeError: # handles passing gdf instead of path to file + self.ground_truth_GDF = ground_truth_vector_file + self.ground_truth_fname = 'GeoDataFrame variable' + self.ground_truth_sindex = self.ground_truth_GDF.sindex # get sindex + # create deep copy of ground truth file for calculations + self.ground_truth_GDF_Edit = self.ground_truth_GDF.copy(deep=True) + self.proposal_GDF = gpd.GeoDataFrame([]) # initialize proposal GDF + + def calculate_iou(pred_poly, test_data_GDF): + """Get the best intersection over union for a predicted polygon. + + Arguments + --------- + pred_poly : :py:class:`shapely.Polygon` + Prediction polygon to test. + test_data_GDF : :py:class:`geopandas.GeoDataFrame` + GeoDataFrame of ground truth polygons to test ``pred_poly`` against. + + Returns + ------- + iou_GDF : :py:class:`geopandas.GeoDataFrame` + A subset of ``test_data_GDF`` that overlaps ``pred_poly`` with an added + column ``iou_score`` which indicates the intersection over union value. + + """ + + # Fix bowties and self-intersections + if not pred_poly.is_valid: + pred_poly = pred_poly.buffer(0.0) + + precise_matches = test_data_GDF[test_data_GDF.intersects(pred_poly)] + + iou_row_list = [] + for _, row in precise_matches.iterrows(): + # Load ground truth polygon and check exact iou + test_poly = row.geometry + # Ignore invalid polygons for now + if pred_poly.is_valid and test_poly.is_valid: + intersection = pred_poly.intersection(test_poly).area + union = pred_poly.union(test_poly).area + # Calculate iou + iou_score = intersection / float(union) + else: + iou_score = 0 + row['iou_score'] = iou_score + iou_row_list.append(row) + + iou_GDF = gpd.GeoDataFrame(iou_row_list) + return iou_GDF + + def eval_iou_spacenet_csv(self, miniou=0.5, iou_field_prefix="iou_score", imageIDField="ImageId", debug=False, + min_area=0): + """Evaluate IoU between the ground truth and proposals in CSVs. + + Arguments + --------- + miniou : float , optional + Minimum intersection over union score to qualify as a successful + object detection event. Defaults to ``0.5``. + iou_field_prefix : str , optional + The name of the IoU score column in ``self.proposal_GDF``. Defaults + to ``"iou_score"`` . + imageIDField : str , optional + The name of the column corresponding to the image IDs in the + ground truth data. Defaults to ``"ImageId"``. + debug : bool , optional + Argument for verbose execution during debugging. Defaults to + ``False`` (silent execution). + min_area : float or int , optional + Minimum area of a ground truth polygon to be considered during + evaluation. Often set to ``20`` in SpaceNet competitions. Defaults + to ``0`` (consider all ground truth polygons). + + Returns + ------- + scoring_dict_list : list + list of score output dicts for each image in the ground + truth and evaluated image datasets. The dicts contain + the following keys: :: + + ('imageID', 'iou_field', 'TruePos', 'FalsePos', 'FalseNeg', + 'Precision', 'Recall', 'F1Score') + + """ + # Get List of all ImageID in both ground truth and proposals + imageIDList = [] + imageIDList.extend(list(self.ground_truth_GDF[imageIDField].unique())) + if not self.proposal_GDF.empty: + imageIDList.extend(list(self.proposal_GDF[imageIDField].unique())) + imageIDList = list(set(imageIDList)) + iou_field = iou_field_prefix + scoring_dict_list = [] + self.ground_truth_GDF[iou_field] = 0. + iou_index = self.ground_truth_GDF.columns.get_loc(iou_field) + id_cols = 2 + ground_truth_ids = self.ground_truth_GDF.iloc[:, :id_cols] + + for imageID in tqdm(imageIDList): + self.ground_truth_GDF_Edit = self.ground_truth_GDF[ + self.ground_truth_GDF[imageIDField] == imageID].copy(deep=True) + self.ground_truth_GDF_Edit = self.ground_truth_GDF_Edit[self.ground_truth_GDF_Edit.area >= min_area] + proposal_GDF_copy = self.proposal_GDF[self.proposal_GDF[imageIDField] == imageID].copy(deep=True) + proposal_GDF_copy = proposal_GDF_copy[proposal_GDF_copy.area > min_area] + if debug: + print(iou_field) + for _, pred_row in proposal_GDF_copy.iterrows(): + if debug: + print(pred_row.name) + if pred_row.geometry.area > 0: + pred_poly = pred_row.geometry + iou_GDF = self.calculate_iou(pred_poly, self.ground_truth_GDF_Edit) + # Get max iou + if not iou_GDF.empty: + max_index = iou_GDF['iou_score'].idxmax(axis=0, skipna=True) + max_iou_row = iou_GDF.loc[max_index] + # Update entry in full ground truth table + previous_iou = self.ground_truth_GDF.iloc[max_index, iou_index] + new_iou = max_iou_row[iou_field] + if new_iou > previous_iou: + self.ground_truth_GDF.iloc[max_index, iou_index] = new_iou + if max_iou_row['iou_score'] > miniou: + self.proposal_GDF.loc[pred_row.name, iou_field] = max_iou_row['iou_score'] + self.ground_truth_GDF_Edit = self.ground_truth_GDF_Edit.drop(max_iou_row.name, axis=0) + else: + self.proposal_GDF.loc[pred_row.name, iou_field] = 0 + else: + self.proposal_GDF.loc[pred_row.name, iou_field] = 0 + else: + self.proposal_GDF.loc[pred_row.name, iou_field] = 0 + if debug: + print(self.proposal_GDF.loc[pred_row.name]) + + if self.proposal_GDF.empty: + TruePos = 0 + FalsePos = 0 + else: + proposal_GDF_copy = self.proposal_GDF[self.proposal_GDF[imageIDField] == imageID].copy(deep=True) + proposal_GDF_copy = proposal_GDF_copy[proposal_GDF_copy.area > min_area] + if not proposal_GDF_copy.empty: + if iou_field in proposal_GDF_copy.columns: + TruePos = proposal_GDF_copy[proposal_GDF_copy[iou_field] >= miniou].shape[0] + FalsePos = proposal_GDF_copy[proposal_GDF_copy[iou_field] < miniou].shape[0] + else: + print("iou field {} missing".format(iou_field)) + TruePos = 0 + FalsePos = 0 + else: + print("Empty Proposal Id") + TruePos = 0 + FalsePos = 0 + + # false negatives is the number of objects remaining in ground + # truth after pulling out matched objects + FalseNeg = self.ground_truth_GDF_Edit[self.ground_truth_GDF_Edit.area > 0].shape[0] + if float(TruePos + FalsePos) > 0: + Precision = TruePos / float(TruePos + FalsePos) + else: + Precision = 0 + if float(TruePos + FalseNeg) > 0: + Recall = TruePos / float(TruePos + FalseNeg) + else: + Recall = 0 + if Recall * Precision > 0: + F1Score = 2 * Precision * Recall / (Precision + Recall) + else: + F1Score = 0 + + score_calc = {'imageID': imageID, + 'iou_field': iou_field, + 'TruePos': TruePos, + 'FalsePos': FalsePos, + 'FalseNeg': FalseNeg, + 'Precision': Precision, + 'Recall': Recall, + 'F1Score': F1Score + } + scoring_dict_list.append(score_calc) + + return scoring_dict_list + + def eval_iou(self, miniou=0.5, iou_field_prefix='iou_score', ground_truth_class_field='', + calculate_class_scores=True, class_list=['all']): + """Evaluate IoU between the ground truth and proposals. + + Arguments + --------- + miniou : float, optional + Minimum intersection over union score to qualify as a successful + object detection event. Defaults to ``0.5``. + iou_field_prefix : str, optional + The name of the IoU score column in ``self.proposal_GDF``. Defaults + to ``"iou_score"``. + ground_truth_class_field : str, optional + The column in ``self.ground_truth_GDF`` that indicates the class of + each polygon. Required if using ``calculate_class_scores``. + calculate_class_scores : bool, optional + Should class-by-class scores be calculated? Defaults to ``True``. + class_list : list, optional + List of classes to be scored. Defaults to ``['all']`` (score all + classes). + + Returns + ------- + scoring_dict_list : list + list of score output dicts for each image in the ground + truth and evaluated image datasets. The dicts contain + the following keys: :: + + ('class_id', 'iou_field', 'TruePos', 'FalsePos', 'FalseNeg', + 'Precision', 'Recall', 'F1Score') + + """ + + scoring_dict_list = [] + + if calculate_class_scores: + if not ground_truth_class_field: + raise ValueError('Must provide ground_truth_class_field if using calculate_class_scores.') + if class_list == ['all']: + class_list = list(self.ground_truth_GDF[ground_truth_class_field].unique()) + if not self.proposal_GDF.empty: + class_list.extend(list(self.proposal_GDF['__max_conf_class'].unique())) + class_list = list(set(class_list)) + + for class_id in class_list: + iou_field = "{}_{}".format(iou_field_prefix, class_id) + if class_id is not 'all': # this is probably unnecessary now + self.ground_truth_GDF_Edit = self.ground_truth_GDF[ + self.ground_truth_GDF[ground_truth_class_field] == class_id].copy(deep=True) + else: + self.ground_truth_GDF_Edit = self.ground_truth_GDF.copy(deep=True) + + for _, pred_row in tqdm(self.proposal_GDF.iterrows()): + if pred_row['__max_conf_class'] == class_id or class_id == 'all': + pred_poly = pred_row.geometry + iou_GDF = self.calculate_iou(pred_poly, self.ground_truth_GDF_Edit) + # Get max iou + if not iou_GDF.empty: + max_iou_row = iou_GDF.loc[iou_GDF['iou_score'].idxmax(axis=0, skipna=True)] + if max_iou_row['iou_score'] > miniou: + self.proposal_GDF.loc[pred_row.name, iou_field] = max_iou_row['iou_score'] + self.ground_truth_GDF_Edit = self.ground_truth_GDF_Edit.drop(max_iou_row.name, axis=0) + else: + self.proposal_GDF.loc[pred_row.name, iou_field] = 0 + else: + self.proposal_GDF.loc[pred_row.name, iou_field] = 0 + + if self.proposal_GDF.empty: + TruePos = 0 + FalsePos = 0 + else: + try: + TruePos = self.proposal_GDF[self.proposal_GDF[iou_field] >= miniou].shape[0] + FalsePos = self.proposal_GDF[self.proposal_GDF[iou_field] < miniou].shape[0] + except KeyError: # handle missing iou_field + print("iou field {} missing") + TruePos = 0 + FalsePos = 0 + + # number of remaining rows in ground_truth_gdf_edit after removing + # matches is number of false negatives + FalseNeg = self.ground_truth_GDF_Edit.shape[0] + if float(TruePos + FalsePos) > 0: + Precision = TruePos / float(TruePos + FalsePos) + else: + Precision = 0 + if float(TruePos + FalseNeg) > 0: + Recall = TruePos / float(TruePos + FalseNeg) + else: + Recall = 0 + if Recall * Precision > 0: + F1Score = 2 * Precision * Recall / (Precision + Recall) + else: + F1Score = 0 + + score_calc = {'class_id': class_id, + 'iou_field': iou_field, + 'TruePos': TruePos, + 'FalsePos': FalsePos, + 'FalseNeg': FalseNeg, + 'Precision': Precision, + 'Recall': Recall, + 'F1Score': F1Score + } + scoring_dict_list.append(score_calc) + + return scoring_dict_list + + def load_proposal(self, proposal_vector_file, conf_field_list=['conf'], proposalCSV=False, + pred_row_geo_value='PolygonWKT_Pix', conf_field_mapping=None): + """Load in a proposal geojson or CSV. + + Arguments + --------- + proposal_vector_file : str + Path to the file containing proposal vector objects. This can be + a .geojson or a .csv. + conf_field_list : list, optional + List of columns corresponding to confidence value(s) in the + proposal vector file. Defaults to ``['conf']``. + proposalCSV : bool, optional + Is the proposal file a CSV? Defaults to no (``False``), in which + case it's assumed to be a .geojson. + pred_row_geo_value : str, optional + The name of the geometry-containing column in the proposal vector + file. Defaults to ``'PolygonWKT_Pix'``. Note: this method assumes + the geometry is in WKT format. + conf_field_mapping : dict, optional + ``'__max_conf_class'`` column value:class ID mapping dict for + multiclass use. Only required in multiclass cases. + + Returns + ------- + ``0`` upon successful completion. + + Notes + ----- + Loads in a .geojson or .csv-formatted file of proposal polygons for + comparison to the ground truth and stores it as part of the + ``Evaluator`` instance. This method assumes the geometry contained in + the proposal file is in WKT format. + + """ + + # Load Proposal if proposal_vector_file is a path to a file + if os.path.isfile(proposal_vector_file): + # if it's a CSV format, first read into a pd df and then convert + # to gpd gdf by loading in geometries using shapely + if proposalCSV: + pred_data = pd.read_csv(proposal_vector_file) + self.proposal_GDF = gpd.GeoDataFrame( + pred_data, geometry=[ + shapely.wkt.loads(pred_row[pred_row_geo_value]) + for idx, pred_row in pred_data.iterrows() + ] + ) + else: # if it's a .geojson + try: + self.proposal_GDF = gpd.read_file(proposal_vector_file).dropna() + except (): + self.proposal_GDF = gpd.GeoDataFrame(geometry=[]) + + if conf_field_list: + self.proposal_GDF['__total_conf'] = self.proposal_GDF[conf_field_list].max(axis=1) + self.proposal_GDF['__max_conf_class'] = self.proposal_GDF[conf_field_list].idxmax(axis=1) + else: + # set arbitrary (meaningless) values otherwise + self.proposal_GDF['__total_conf'] = 1.0 + self.proposal_GDF['__max_conf_class'] = 1 + + if conf_field_mapping is not None: + self.proposal_GDF['__max_conf_class'] = [ + conf_field_mapping[item] for item in + self.proposal_GDF['__max_conf_class'].values] + self.proposal_GDF = self.proposal_GDF.sort_values(by='__total_conf', ascending=False) + else: + self.proposal_GDF = gpd.GeoDataFrame(geometry=[]) + + def load_truth(self, ground_truth_vector_file, truthCSV=False, truth_geo_value='PolygonWKT_Pix'): + """Load in the ground truth geometry data. + + Arguments + --------- + ground_truth_vector_file : str + Path to the ground truth vector file. Must be either .geojson or + .csv format. + truthCSV : bool, optional + Is the ground truth a CSV? Defaults to ``False``, in which case + it's assumed to be a .geojson. + truth_geo_value : str, optional + Column of the ground truth vector file that corresponds to + geometry. + + Returns + ------- + Nothing. + + Notes + ----- + Loads the ground truth vector data into the ``Evaluator`` instance. -from ..base import BaseSegmentationClassifier -from ..datasets import SpaceNet6Dataset -from ..models.schemas import UNetEfficientNetModelSchema + """ + if truthCSV: + truth_data = pd.read_csv(ground_truth_vector_file) + self.ground_truth_GDF = gpd.GeoDataFrame( + truth_data, geometry=[ + shapely.wkt.loads(truth_row[truth_geo_value]) + for idx, truth_row in truth_data.iterrows()]) + else: + try: + self.ground_truth_GDF = gpd.read_file(ground_truth_vector_file) + except (): # empty geojson + self.ground_truth_GDF = gpd.GeoDataFrame({'sindex': [], + 'condition': [], + 'geometry': []}) + # force calculation of spatialindex + self.ground_truth_sindex = self.ground_truth_GDF.sindex + # create deep copy of ground truth file for calculations + self.ground_truth_GDF_Edit = self.ground_truth_GDF.copy(deep=True) def post_process(prediction_directory, prediction_csv): np.seterr(over="ignore") - source_files = sorted(glob.glob(os.path.join(prediction_directory, "*"))) + source_files = sorted(glob.glob(os.path.join(prediction_directory, '*'))) with Pool() as pool: - proposals = [ - p - for p in tqdm( - pool.imap_unordered(partial(post_process_single), source_files), - total=len(source_files), - ) - ] + proposals = [p for p in tqdm(pool.imap_unordered(partial(post_process_single), source_files), + total=len(source_files))] if len(proposals) > 0: pd.concat(proposals).to_csv(prediction_csv, index=False) -def post_process_single( - sourcefile, - watershed_line=True, - conn=2, - polygon_buffer=0.5, - tolerance=0.5, - seed_msk_th=0.75, - area_th_for_seed=110, - prediction_threshold=0.5, - area_th=80, - contact_weight=1.0, - edge_weight=0.0, - seed_contact_weight=1.0, - seed_edge_weight=1.0, -): +def post_process_single(sourcefile, watershed_line=True, conn=2, polygon_buffer=0.5, tolerance=0.5, + seed_msk_th=0.75, area_th_for_seed=110, prediction_threshold=0.5, area_th=80, + contact_weight=1.0, edge_weight=0.0, seed_contact_weight=1.0, seed_edge_weight=1.0): mask = gdal.Open(sourcefile).ReadAsArray() mask = 1.0 / (1 + np.exp(-mask)) mask[0] = mask[0] * (1 - contact_weight * mask[2]) * (1 - edge_weight * mask[1]) - seed_msk = ( - mask[0] * (1 - seed_contact_weight * mask[2]) * (1 - seed_edge_weight * mask[1]) - ) + seed_msk = mask[0] * (1 - seed_contact_weight * mask[2]) * (1 - seed_edge_weight * mask[1]) seed_msk = measure.label((seed_msk > seed_msk_th), connectivity=conn, background=0) props = measure.regionprops(seed_msk) for i in range(len(props)): if props[i].area < area_th_for_seed: seed_msk[seed_msk == i + 1] = 0 seed_msk = measure.label(seed_msk, connectivity=conn, background=0) - mask = watershed( - -mask[0], - seed_msk, - mask=(mask[0] > prediction_threshold), - watershed_line=watershed_line, - ) + mask = watershed(-mask[0], seed_msk, mask=(mask[0] > prediction_threshold), watershed_line=watershed_line) mask = measure.label(mask, connectivity=conn, background=0).astype("uint8") polygon_generator = features.shapes(mask, mask) polygons = [] @@ -99,17 +521,13 @@ def post_process_single( if p.area >= area_th: p = dumps(p.simplify(tolerance=tolerance), rounding_precision=0) polygons.append(p) - tile_name = "_".join( - os.path.splitext(os.path.basename(sourcefile))[0].split("_")[-4:] - ) - csv_addition = pd.DataFrame( - { - "ImageId": tile_name, - "BuildingId": range(len(polygons)), - "PolygonWKT_Pix": polygons, - "Confidence": 1, - } - ) + tile_name = "_".join(os.path.splitext(os.path.basename(sourcefile))[0].split("_")[-4:]) + csv_addition = pd.DataFrame({ + "ImageId": tile_name, + "BuildingId": range(len(polygons)), + "PolygonWKT_Pix": polygons, + "Confidence": 1 + }) return csv_addition @@ -145,10 +563,10 @@ def forward(self, outputs, targets, weights=1.0): targets = targets.view(-1)[non_ignored].float() outputs = outputs.contiguous().view(-1)[non_ignored] weights = weights.contiguous().view(-1)[non_ignored] - outputs = torch.clamp(outputs, self.eps, 1.0 - self.eps) - targets = torch.clamp(targets, self.eps, 1.0 - self.eps) + outputs = torch.clamp(outputs, self.eps, 1. - self.eps) + targets = torch.clamp(targets, self.eps, 1. - self.eps) pt = (1 - targets) * (1 - outputs) + targets * outputs - return ((-((1.0 - pt) ** self.gamma) * torch.log(pt)) * weights).mean() + return ((-(1. - pt) ** self.gamma * torch.log(pt)) * weights).mean() class DiceLoss(nn.Module): @@ -172,56 +590,26 @@ def forward(self, outputs, targets): class GenEfficientNet(nn.Module): - def __init__( - self, - block_args, - num_classes=1000, - in_channels=3, - num_features=1280, - stem_size=32, - fix_stem=False, - channel_multiplier=1.0, - channel_divisor=8, - channel_min=None, - pad_type="", - act_layer=nn.ReLU, - drop_connect_rate=0.0, - se_kwargs=None, - norm_layer=nn.BatchNorm2d, - norm_kwargs=None, - weight_init="goog", - ): + def __init__(self, block_args, num_classes=1000, in_channels=3, num_features=1280, stem_size=32, fix_stem=False, + channel_multiplier=1.0, channel_divisor=8, channel_min=None, + pad_type='', act_layer=nn.ReLU, drop_connect_rate=0., se_kwargs=None, norm_layer=nn.BatchNorm2d, + norm_kwargs=None, weight_init='goog'): super(GenEfficientNet, self).__init__() - stem_size = round_channels( - stem_size, channel_multiplier, channel_divisor, channel_min - ) - self.conv_stem = select_conv2d( - in_channels, stem_size, 3, stride=2, padding=pad_type - ) + stem_size = round_channels(stem_size, channel_multiplier, channel_divisor, channel_min) + self.conv_stem = select_conv2d(in_channels, stem_size, 3, stride=2, padding=pad_type) self.bn1 = norm_layer(stem_size, **norm_kwargs) self.act1 = act_layer(inplace=True) - builder = EfficientNetBuilder( - channel_multiplier, - channel_divisor, - channel_min, - pad_type, - act_layer, - se_kwargs, - norm_layer, - norm_kwargs, - drop_connect_rate, - ) + builder = EfficientNetBuilder(channel_multiplier, channel_divisor, channel_min, pad_type, act_layer, se_kwargs, + norm_layer, norm_kwargs, drop_connect_rate) self.blocks = nn.Sequential(*builder(stem_size, block_args)) - self.conv_head = select_conv2d( - builder.in_chs, num_features, 1, padding=pad_type - ) + self.conv_head = select_conv2d(builder.in_chs, num_features, 1, padding=pad_type) self.bn2 = norm_layer(num_features, **norm_kwargs) self.act2 = act_layer(inplace=True) self.global_pool = nn.AdaptiveAvgPool2d(1) self.classifier = nn.Linear(num_features, num_classes) for module in self.modules(): - if weight_init == "goog": + if weight_init == 'goog': initialize_weight_goog(module) else: initialize_weight_default(module) @@ -243,30 +631,30 @@ def __init__(self, config): enc_ch = list() depth_multiplier, channel_multiplier = 1, 1 url = "" - if self.config.net == "b4": + if self.config.net == 'b4': channel_multiplier = 1.4 depth_multiplier = 1.8 - url = "https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b4_ns-d6313a46.pth" + url = 'https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b4_ns-d6313a46.pth' enc_ch = [24, 32, 56, 160, 1792] - if self.config.net == "b5": + if self.config.net == 'b5': channel_multiplier = 1.6 depth_multiplier = 2.2 - url = "https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b5_ns-6f26d0cf.pth" + url = 'https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b5_ns-6f26d0cf.pth' enc_ch = [24, 40, 64, 176, 2048] - if self.config.net == "b6": + if self.config.net == 'b6': channel_multiplier = 1.8 depth_multiplier = 2.6 - url = "https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b6_ns-51548356.pth" + url = 'https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b6_ns-51548356.pth' enc_ch = [32, 40, 72, 200, 2304] - if self.config.net == "b7": + if self.config.net == 'b7': channel_multiplier = 2.0 depth_multiplier = 3.1 - url = "https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b7_ns-1dbc32de.pth" + url = 'https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b7_ns-1dbc32de.pth' enc_ch = [32, 48, 80, 224, 2560] - if self.config.net == "l2": + if self.config.net == 'l2': channel_multiplier = 4.3 depth_multiplier = 5.3 - url = "https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_l2_ns-df73bb44.pth" + url = 'https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_l2_ns-df73bb44.pth' enc_ch = [72, 104, 176, 480, 5504] if self.config.stride == 16: dec_ch[4] = enc_ch[4] @@ -274,9 +662,7 @@ def __init__(self, config): dec_ch[3] = enc_ch[4] def mod(cin, cout, k=3): - return nn.Sequential( - nn.Conv2d(cin, cout, k, padding=k // 2), nn.ReLU(inplace=True) - ) + return nn.Sequential(nn.Conv2d(cin, cout, k, padding=k // 2), nn.ReLU(inplace=True)) self.model.bot0extra = mod(206, enc_ch[4]) self.model.bot1extra = mod(206, dec_ch[4]) @@ -301,37 +687,30 @@ def mod(cin, cout, k=3): self.model.final = nn.Conv2d(dec_ch[0], 6, 1) self._initialize_weights() arch_def = [ - ["ds_r1_k3_s1_e1_c16_se0.25"], - ["ir_r2_k3_s2_e6_c24_se0.25"], - ["ir_r2_k5_s2_e6_c40_se0.25"], - ["ir_r3_k3_s2_e6_c80_se0.25"], - ["ir_r3_k5_s1_e6_c112_se0.25"], - ["ir_r4_k5_s2_e6_c192_se0.25"], - ["ir_r1_k3_s1_e6_c320_se0.25"], + ['ds_r1_k3_s1_e1_c16_se0.25'], + ['ir_r2_k3_s2_e6_c24_se0.25'], + ['ir_r2_k5_s2_e6_c40_se0.25'], + ['ir_r3_k3_s2_e6_c80_se0.25'], + ['ir_r3_k5_s1_e6_c112_se0.25'], + ['ir_r4_k5_s2_e6_c192_se0.25'], + ['ir_r1_k3_s1_e6_c320_se0.25'] ] - enc = GenEfficientNet( - in_channels=3, - block_args=decode_arch_def(arch_def, depth_multiplier), - num_features=round_channels(1280, channel_multiplier, 8, None), - stem_size=32, - channel_multiplier=channel_multiplier, - norm_kwargs=resolve_bn_args({"bn_eps": BN_EPS_TF_DEFAULT}), - pad_type="same", - ) + enc = GenEfficientNet(in_channels=3, block_args=decode_arch_def(arch_def, depth_multiplier), + num_features=round_channels(1280, channel_multiplier, 8, None), stem_size=32, + channel_multiplier=channel_multiplier, + norm_kwargs=resolve_bn_args({'bn_eps': BN_EPS_TF_DEFAULT}), pad_type='same') state_dict = load_state_dict_from_url(url) enc.load_state_dict(state_dict, strict=True) stem_size = round_channels(32, channel_multiplier, 8, None) - conv_stem = select_conv2d(4, stem_size, 3, stride=2, padding="same") + conv_stem = select_conv2d(4, stem_size, 3, stride=2, padding='same') _w = enc.conv_stem.state_dict() - _w["weight"] = torch.cat([_w["weight"], _w["weight"][:, 1:2]], 1) + _w['weight'] = torch.cat([_w['weight'], _w['weight'][:, 1:2]], 1) conv_stem.load_state_dict(_w) self.model.enc0 = nn.Sequential(conv_stem, enc.bn1, enc.act1, enc.blocks[0]) self.model.enc1 = nn.Sequential(enc.blocks[1]) self.model.enc2 = nn.Sequential(enc.blocks[2]) self.model.enc3 = nn.Sequential(enc.blocks[3], enc.blocks[4]) - self.model.enc4 = nn.Sequential( - enc.blocks[5], enc.blocks[6], enc.conv_head, enc.bn2, enc.act2 - ) + self.model.enc4 = nn.Sequential(enc.blocks[5], enc.blocks[6], enc.conv_head, enc.bn2, enc.act2) def forward(self, x, strip, direction, coord): enc0 = self.model.enc0(x) @@ -373,9 +752,7 @@ def load_optimizer(self): return torch.optim.AdamW(self.model.parameters(), lr=2e-4, weight_decay=1e-2) def load_lr_scheduler(self): - return torch.optim.lr_scheduler.MultiStepLR( - self.load_optimizer(), milestones=[80, 100, 120], gamma=0.5 - ) + return torch.optim.lr_scheduler.MultiStepLR(self.load_optimizer(), milestones=[80, 100, 120], gamma=0.5) def train_and_evaluate_model( self, @@ -428,32 +805,23 @@ def train_and_evaluate_model( output = self.forward(images, strip, direction, coord) if isinstance(output, tuple): output = output[0] - l0 = focal_loss(output[:, 0], target[:, 0], weights[:, 0]) + dice_loss( - output[:, 0], target[:, 0] - ) - l1 = edge_weight * ( - focal_loss(output[:, 1], target[:, 1], weights[:, 1]) - + dice_loss(output[:, 1], target[:, 1]) - ) - l2 = contact_weight * ( - focal_loss(output[:, 2], target[:, 2], weights[:, 2]) - + dice_loss(output[:, 2], target[:, 2]) - ) + l0 = focal_loss(output[:, 0], target[:, 0], weights[:, 0]) + dice_loss(output[:, 0], target[:, 0]) + l1 = edge_weight * (focal_loss(output[:, 1], target[:, 1], weights[:, 1]) + dice_loss(output[:, 1], + target[:, 1])) + l2 = contact_weight * (focal_loss(output[:, 2], target[:, 2], weights[:, 2]) + dice_loss(output[:, 2], + target[:, 2])) loss = l0 + l1 + l2 optimizer.zero_grad() loss.backward() torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.2) optimizer.step() iterator.set_description( - "epoch: {}; lr {:.5f}; loss {:.4f}".format( - epoch, scheduler.get_lr()[-1], loss - ) - ) + "epoch: {}; lr {:.5f}; loss {:.4f}".format(epoch, scheduler.get_lr()[-1], loss)) scheduler.step() - torch.save( - {"epoch": epoch, "state_dict": self.model.state_dict()}, - os.path.join(model_directory, "last_model"), - ) + os.makedirs(model_directory, exist_ok=True) + torch.save({"epoch": epoch, + "state_dict": self.model.state_dict()}, + os.path.join(model_directory, "last_model")) if epoch >= val_dataset.config.start_val_epoch: shutil.rmtree(pred_folder, ignore_errors=True) os.makedirs(pred_folder, exist_ok=True) @@ -468,71 +836,38 @@ def train_and_evaluate_model( _, _, h, w = images.shape scales = [0.8, 1.0, 1.5] flips = [lambda x: x, lambda x: torch.flip(x, (3,))] - rots = [ - (lambda x: torch.rot90(x, i, (2, 3))) for i in range(0, 1) - ] - rots2 = [ - (lambda x: torch.rot90(x, 4 - i, (2, 3))) - for i in range(0, 1) - ] - oos = torch.zeros( - (images.shape[0], 6, images.shape[2], images.shape[3]) - ).to(self.device) + rots = [(lambda x: torch.rot90(x, i, (2, 3))) for i in range(0, 1)] + rots2 = [(lambda x: torch.rot90(x, 4 - i, (2, 3))) for i in range(0, 1)] + oos = torch.zeros((images.shape[0], 6, images.shape[2], images.shape[3])).to(self.device) for sc in scales: - im = F.interpolate( - images, - size=(ceil(h * sc / 32) * 32, ceil(w * sc / 32) * 32), - mode="bilinear", - align_corners=True, - ) + im = F.interpolate(images, size=(ceil(h * sc / 32) * 32, ceil(w * sc / 32) * 32), + mode="bilinear", align_corners=True) for fl in flips: for i, rot in enumerate(rots): - o = self.forward( - rot(fl(im)), strip, direction, coord - ) + o = self.forward(rot(fl(im)), strip, direction, coord) if isinstance(o, tuple): o = o[0] - oos += F.interpolate( - fl(rots2[i](o)), - size=(h, w), - mode="bilinear", - align_corners=True, - ) + oos += F.interpolate(fl(rots2[i](o)), size=(h, w), mode="bilinear", + align_corners=True) o = oos / (len(scales) * len(flips) * len(rots)) o = np.moveaxis(o.cpu().data.numpy(), 1, 3) for i in range(len(o)): img = o[i][:, :, :3] if direction[i].item(): img = np.fliplr(np.flipud(img)) - img = cv2.copyMakeBorder( - img, - ymin, - 900 - h - ymin, - xmin, - 900 - w - xmin, - cv2.BORDER_CONSTANT, - 0.0, - ) - io.imsave( - os.path.join( - pred_folder, - os.path.split(sample["image_path"][i])[1], - ), - img, - ) - to_save = { - k: copy.deepcopy(v.cpu()) - for k, v in self.model.state_dict().items() - } + img = cv2.copyMakeBorder(img, ymin, 900 - h - ymin, xmin, 900 - w - xmin, + cv2.BORDER_CONSTANT, 0.0) + io.imsave(os.path.join(pred_folder, os.path.split(sample["image_path"][i])[1]), img) + to_save = {k: copy.deepcopy(v.cpu()) for k, v in self.model.state_dict().items()} pred_csv = val_dataset.config.pred_csv.format(fold) gt_csv = val_dataset.config.gt_csv.format(fold) post_process(pred_folder, pred_csv) val_f1 = evaluation(pred_csv, gt_csv) if best_f1_score < val_f1: - torch.save( - {"epoch": epoch, "state_dict": to_save, "best_score": val_f1}, - os.path.join(model_directory, "best_model"), - ) + torch.save({"epoch": epoch, + "state_dict": to_save, + "best_score": val_f1}, + os.path.join(model_directory, "best_model")) best_f1_score = max(best_f1_score, val_f1) def evaluate(self, dataset: SpaceNet6Dataset = None, model_path: str = None): @@ -562,48 +897,25 @@ def evaluate(self, dataset: SpaceNet6Dataset = None, model_path: str = None): flips = [lambda x: x, lambda x: torch.flip(x, (3,))] rots = [(lambda x: torch.rot90(x, i, (2, 3))) for i in range(0, 1)] rots2 = [(lambda x: torch.rot90(x, 4 - i, (2, 3))) for i in range(0, 1)] - oos = torch.zeros( - (images.shape[0], 6, images.shape[2], images.shape[3]) - ).to(self.device) + oos = torch.zeros((images.shape[0], 6, images.shape[2], images.shape[3])).to(self.device) for sc in scales: - im = F.interpolate( - images, - size=(ceil(h * sc / 32) * 32, ceil(w * sc / 32) * 32), - mode="bilinear", - align_corners=True, - ) + im = F.interpolate(images, size=(ceil(h * sc / 32) * 32, ceil(w * sc / 32) * 32), + mode="bilinear", + align_corners=True) for fl in flips: for i, rot in enumerate(rots): o = self.forward(rot(fl(im)), strip, direction, coord) if isinstance(o, tuple): o = o[0] - oos += F.interpolate( - fl(rots2[i](o)), - size=(h, w), - mode="bilinear", - align_corners=True, - ) + oos += F.interpolate(fl(rots2[i](o)), size=(h, w), mode="bilinear", align_corners=True) o = oos / (len(scales) * len(flips) * len(rots)) o = np.moveaxis(o.cpu().data.numpy(), 1, 3) for i in range(len(o)): img = o[i][:, :, :3] if direction[i].item(): img = np.fliplr(np.flipud(img)) - img = cv2.copyMakeBorder( - img, - ymin, - 900 - h - ymin, - xmin, - 900 - w - xmin, - cv2.BORDER_CONSTANT, - 0.0, - ) - io.imsave( - os.path.join( - pred_folder, os.path.split(sample["image_path"][i])[1] - ), - img, - ) + img = cv2.copyMakeBorder(img, ymin, 900 - h - ymin, xmin, 900 - w - xmin, cv2.BORDER_CONSTANT, 0.0) + io.imsave(os.path.join(pred_folder, os.path.split(sample["image_path"][i])[1]), img) ################################################################################################ # # Merge everything # shutil.rmtree(dataset.config.merged_pred_dir, ignore_errors=True) @@ -627,24 +939,16 @@ def load_model(self, file_path, optimizer=None): missing_keys = [] unexpected_keys = [] - metadata = getattr(loaded["state_dict"], "_metadata", None) + metadata = getattr(loaded["state_dict"], '_metadata', None) state_dict = loaded["state_dict"].copy() if metadata is not None: state_dict._metadata = metadata - def load(module, prefix=""): + def load(module, prefix=''): local_metadata = {} if metadata is None else metadata.get(prefix[:-1], {}) - module._load_from_state_dict( - state_dict, - prefix, - local_metadata, - True, - missing_keys, - unexpected_keys, - [], - ) + module._load_from_state_dict(state_dict, prefix, local_metadata, True, missing_keys, unexpected_keys, []) for name, child in module._modules.items(): if child is not None: - load(child, prefix + name + ".") + load(child, prefix + name + '.') load(self.model) diff --git a/examples/multi_attenttion_cnn_rnn_classification.ipynb b/examples/multi_attenttion_cnn_rnn_classification.ipynb new file mode 100644 index 0000000..2daddca --- /dev/null +++ b/examples/multi_attenttion_cnn_rnn_classification.ipynb @@ -0,0 +1,340 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multi label classification of UC Merced data set with multi-attention CNN-RNN model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "is_executing": true, + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# import modules\n", + "from aitlas.models import CNNRNN\n", + "from aitlas.datasets import UcMercedMultiLabelDataset\n", + "from aitlas.visualizations import display_image_labels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instantiate a model object. Using the default, recommended settings should provide quite good performance. The first time this cell is run, Python will download a pretrained Resnet152 network (> 200 MB)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "pycharm": { + "is_executing": true, + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/spopov/Downloads/aitlas/venv/lib/python3.9/site-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ], + "source": [ + "model = CNNRNN({\n", + " \"num_classes\": 17 # there are 17 different classes in the example data set\n", + "})\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Prepare the model (this loads the criterion, optimizer and the learning rate scheduler)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "pycharm": { + "is_executing": true + } + }, + "outputs": [], + "source": [ + "model.prepare()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Declare data sets. In this example, the data set has already been split into two directories: train and test." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "pycharm": { + "is_executing": true, + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# training set\n", + "train_set = UcMercedMultiLabelDataset({\n", + " \"batch_size\": 16,\n", + " \"shuffle\": True,\n", + " \"num_workers\": 4,\n", + " \"data_dir\": \"/Users/spopov/Downloads/UC_merced_multilabel/train\",\n", + " \"csv_file\": \"/Users/spopov/Downloads/UC_merced_multilabel/train/multilabels.txt\",\n", + " \"transforms\": [\"aitlas.transforms.ResizeCenterCropFlipHVToTensor\"]\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwIAAAJuCAYAAAAD/bUtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABGhElEQVR4nO3deZwkdX3/8dcbFuRmuVS8WC4FQbkWgwcG0HggKgYUAx4guiJGJcYDr4iJ5CchxguBrIoQIQZBFPBCBTlEQZZzQUQUUBQElvuQ+/P7o2q0GXpmZ3Znpneo1/PxmMd0V32r6lPd1T397u+3alJVSJIkSeqWpQZdgCRJkqSpZxCQJEmSOsggIEmSJHWQQUCSJEnqIIOAJEmS1EEGAUmSJKmDDAKSRpTk9CTXLGxaV+oY5Hb71LF9knOS3Jmkkuw56Jo08ZLs2T6/2w26ln7G+3pIcmSSGjbtgHYfZy1iDZP2GPWrdxHWsUQ/h+o2g4DUSrJd+2b9vkHX8liUZPP2D/6sQdeyMEn2W5I/WCdZDTgBWBH4Z+CNwJlTsN1Z7WvkyFHaXDPSB8Mks9sPVlcl+XOSu5NcmuSzSTYaw/aHPjBWkl1HaPOanjYHjHHXNIHaD777DbqOx4ol+b3T53r6MwhIGq+XAM9YhOU2Bz4OzJrCbS6q/YA9R5g31bX0szUwE/h4Vc2tqqOr6qoB1zSqJB8HfgHsCJwEvIcmxPwE2A24NMnKY1zdvcBeI8x7Sztfg7MnzWuon7cBy09ZJY8Nm7Po752TbU9Gfq41DcwYdAGSppequn8qtpNkaeBxVXXPVG1zLJaQWp7Y/r5lIlfa+5hP8HrfAhxA86H/NVV1+7D5H6D5oJMxrvJbwOuSrF1V1/es54nAy4BvALtPQOmPkGTlqrpzotfbJVX1APDAoOuQ1LBHQBpFz1CIA5K8LslF7ZCG3yTZq23ztCTHJ7mlHa999PBvNpNslOTQJJe1be5Jcn6St46w3Wcn+WE7dOLmJEclWXOkYRlJdkvy0551nzvS0IkRtrdaki8lWdBu8/QkW43Qtt94/U2SHJfkj0nuS/KnJD9J8op2/gHAV9vmP+kZunFkO39oDO2Lk3wsyW9pvtV93Ujb7Nn2eklOTHJ7kjuSfCvJesPajDhGd/i62/HA6wB/21PnX8Yvj1RLkhcm+VFbx5+TXJBk75G2l+RJSb6e5Nb2OTslydP77eOw5a8Bjmrv/uWx7Jm/ZpIvJrk2yf3t7y8mWWOEx6TvYz5RkiwLHAjcBew2PAQAVNWfq2r/qrpjjKs9GngYeNOw6W8Cqp0/Uj1jeq0MHZ9JXtS2vws4uWf+Fu0xf0N7zF/bPp/rD1vPi9vX8m1J7k1ySZJ9RqjtbUl+1a7vN2mGXIw1HPUeW7Pa18Ft7fF1ZJKVkiyV5MNJrm5ruSDJ84etY8yvlRFquAb4W2CdYa+f7dr5Yxpz374+Pp3mPffWtt5fJvlgmsDaz4w079W/ax/DS5K8foT1z24fowVt2yuSfCTJYn1BOtbncKz7l4W/d66c5JPtcbygZ7ufSrLCsG0ulWbY4yXt8X9Hu99fSbLMeB+fhT3Xmh7sEZDGZidgH+BQmm9h9waOSHI/8O/AacCHaYZsDA1N6P2Qvx3wQuA7wNU0Y7tfC3wpyVpV9f+GGibZEDiLJqh/HvgjzXCKH/QrLMkngY+08z9G8wHpNcBxSf6xqr442o61fwBOaWv/GnAOTVf0j4GbF/bApPmAeVp793Dgd8CawGzgb4Dv0oxnXxuYQ/N4Xd62/+2w1f0nsAzwJeAO4IqFbH5F4HTgXOBDwIbAvsA2Sbaoqj8trP4+3gh8BlhA8wF2yE0jLZDklTTfUv8J+DRwJ/B64MtJ1quqj/Sp+0yax/rDwLo0Q2VOTLJpVT00Sn37AS/n0Y8lSVYFfgZsABwBXABsAbwD2CHJc/p8oz3ex3y8nk/Tg/G1qhrxMRynG2mOq72Ag3qm70XzGuu7nUV4rcwGdqF5bI7qWc9OwDeBu4EvA7+h2ceXApvSHtdJ5tC8Js6hOZbuBv4OOCzJ+lX1/p517kdz3F1Mc0ysALyv3dfxWJHm9XgGsD9/fU9ajub1/DfAF2ie8/cBJydZZwJ7OvYD/h/Ne8A/9Uy/vG/rkT0b+Hua19Vvaep9GfApYD3g7X2WOYhm/w9t7+8FfD3JclV15FCjNF9QnEDzvH2a5j39ucC/0rz3vXactQ6tdz/G/hyOdf8W9t75ZJq/Nd8E/hd4kObD+QdoXvsv7dnmR9p9PJnmuHyI5r3nVcDjaHtqxvH47MfEPNcapKryxx9/qqD5sF7A+3qmzWqn3Q2s0zN9LZoP+w8D7x22nhOA+4GVeqat2Gd7S9F8iL0dWKZn+jfabT5/WPtj2+lH9kzbsp32733W/22aD3YrL2S/57Tr+MSw6fu1068ZNv303mk0f0QKeN1CtrNn2267UeZdAazQZ/7pI9RRwGeHTX9NO/3wMW6737qvAU4fYT+G7//SNOHnNuBJPdOXBc6m+WO7YZ+6PzBsve9vp790DMdq3/2h+bBZwL7Dpr+znf5vY33MR9jurOHHYJ821wx7fN7VLvPesWxjIds/oF3XbOCV7e3ntfOe197fqZ1fwAGL+lpp2xbw4mFtV6AJGjcCT+6zrqXa32vTvEf8b582n2uPi/Xa+zNp3mN+2ftcAE+h6Unpe+yOcGwW8P5h00+gea+axyPfa4Zeu29fjNfKmKb1zDsSqBGe11k905YH0mf5r7WP3dp9av4dsGrP9FXbabcAy7fTlqMJ7GcCM4at+5+G73u/ekfYr3E9h4u4f/2ek2V7n9Oe6f/WLvOcnmkXAL9cyH6M9/EZ8bn2Z3r8ODRIGptvV9Xvhu5U883mFTR/XId/i3gWzbc7s3ra3z10O8ly7bfoqwM/BFYBNmrnLU3z7f8vqursYev9dJ+69qB5Yz4qzZCQv/zQnJC5Ms03OaPZmeYPz/D1H0bz4WhhhoZ6vDzJKmNoP5rDavzj0z/Ve6eqvkXz3Oy8mLWM1VbA04Ajquq6njruB/6DJvC9etgyD9P09vQa6lXZcDFqeQ3Nh9S5w6b/dzv9NX2WWZTHfDyGjomxDvsZq+/TfGAZOml4L+D6dno/i/Jaubiqfjxs2ktpvgH9dFX9cfhGqurh9uauNN+yfqXP9k6mOS5e3LZ9CU3A+GLvc1FVfwCOGfVReLSHaL7x73UWzfCUw6sZo987HRbvmJsU1QwXK2iGlyVZvX3sTqF57Gb3Weyw6hl61t4+HFiN5oseaHpknkAz3GbmsOfle22blyxCyeN6Dhdx/x6lqu4fek6TzEgzzHNNmh5daHqAhtwOPDnJC0ZZ5WQ9PlpCOTRIGpt+V2S5Fbi+qu7rMx3gL2Oyk6xE863X64Cn9lnXau3vtWi6tvsNz+g3bWOaP/C/Gqlwmjf10axHsx+P+KBWVfcluaqntr6q6owk/0PzrdUeSc6j+SN0bFX9ciHbHu7X42x/W/Uf/nM5sHOSFXtD2CRZt/19WZ95Q9PWGzb9uqoafmWboWFYa7Do1gXmVdWDvROr6sEkv6b5Vny48T7mY1E9t4eOq7FeEWhsG2j26WvA25N8mObKQ4dV1UNJ32H1i/Ja6ffYDH1ovnAhJW7c/h4eJPptb+j46FfbeF9D1/c5tobek67unVhVt7aP1eIcc5OiHYu+P815Hxvw6HH2/d6X+g1JGXr8hh7joefliFE2v7D3zH7G9Rwu4v71lWRfmqGrm/Docz971/Nhmt6vs5JcR/Nt/neB4+uvF0GYrMdHSyiDgDQ2I43ZHm0sd+8b+//SDFmYS9PlenO77I403a2L2jsXmg9dLx+lln4fUCdUVb05ycFtHdvSXBbyI0n2q6pDxrGqyfpmukaZN4j3wbEeN1NhPI/5n9vfK4zSZkUeOUb/0vb3FuMpaoyOoBlSdQxN0Bjtw8uivFYW53gceh7fRNNT0c9kXPJ1tGNrpHm9x9yS8lr5L5phZcfSDHm7kWYM+5Y05wIsznsmNMfNRSO0uW6E6RNpQvYvyXtpenN/SNPLeB3N0NQn0wxr+st6qurnaU5mfymwffuzO/DRJC+oqltYch4fTRGDgDTJksykCQFfq6p9hs178bDmN9GMM+13nfp+066kOcHs91W1qCdoXQW8JMkqvb0CSR5H8y3XrSMu2aOqLqX50Hdwu8/nAp9K8sW2C3y0DxiLamaSJ/bpFdgYuLGnN2DoMpur91nHujz6cobjqXXow9wmfeY9c1ibyXYV8IwkM3p7BdpvH58+AXUsoBnvvHG/mUnWohk284ueyWfTDOHZOckaVbXQE9DHqqp+leTnNMMZflZVo53oPBGvFfhrL8HmNB++RtsewII+w4uGG3peNgJOHTbvmUyt8b5W+pmI1/obgTOr6hFX/UmywSjLbAycOGza8Nfg0PNy9xiel/EY73M4nv0b7fF8I815OS/vGZZGkpf1a1xVd9GcWPzNtt2+NMNb9wYOZvyPz2S8r2sKeY6ANPmGvoV7xDe9SdbmkVcWopqrxXwfeE6GXdaP5lv24b7W/v739LmkXpKxdOGeSHPC6/D1v4O/ju8eUTu29RHvJVV1G80whBVoTj6D5gMk9P+AsTj2H1bPa2hC07d7Jg99eHvxsLb/ADypzzrvYux1XgD8HtgrzXXsh9a9DH89AXj4h5PJ8m2a4WXDL0v7tnb6txZn5e3xeTKwaZJ+44Tf21PH0DL301ytZGXg2PT5p2HteTP/vojnmOwPfILmqlGjmYjXCjQf/hcA/9y+hoevZ+h1/g3gPuATSR71D7SSrNqGbYAf0fS2vDM9l3xM8hQm4f8hLMR4Xyv93AWs1vNYLIqHePR75oo88uo0w72jvXLWUPtVaYbM3EZzFSVoxuDfCOyf5FGv8STL9ztGx2C8z+F49m+0986HaN5j/rKunmFHj9CO8x/ugmHrHu/jMxHPtQbIHgFpklXVnUl+CLwhyZ+B82iuU/92mg/Lw8fnfpSm6/YHSQ4B/gC8guaDHPR8A1NV56W5zvQBwEVJjqPptl2b5iTWHWmuKjGar9JcOehfkqwL/JxmGMdraS5Rt7D3iTcB/5TkWzSXm3uA5vJ1LwW+UVVDw0nOozlJ9iNJVqPp+bi6qs5dyPpHswD4+yRPohnvOnT50BtoHhMAquqKJD+mGU8emi7vzWlOnv0Nzcndvc4B9k7ybzTjjh8GTu53vkE7Jv0faT5kn5dkLs3lQ3cDtqG5Ss2Vw5ebJP9B87x9McmWNOPYt6D5tu+Kdv7i2p9mSMF3kxzVbmN54EU037ifQTMk4S+q6ogkT6X5p2G/SfK/NOOml6L5Fve1wONpLkU4LlV1Js1wu4W1m4jXClV1T5r/D3E8zX9DHrp86Fo0x/x/ASdW1R+SvIPm8qKXt+cz/K5t9yyak9mfSXPFlVuTfIzmUq4/a8+5WYHmQ+yVTM6wqpH2b7yvlX7OoekFPSTJz2g+rJ5WVeO5FOrxbQ3H0pxn8QSay6CO1qO0ADg3yVfb+3vRnMj/1qETeKvq7iRvogmrVyQ5ot2vmTTf5v89zb6ePo5aWYTncDz7N9p75/E0r5vvJzmB5sub3enfc3N5knNoemuHjv05NEOJ/q/dj/E+PhPxXGuQBn3ZIn/8WVJ+GP3yoQf0aX86fS6bRp9LvdEMl/gyzZvvvcB8mm9pH9W2bb85zR+He2i66v+Hplu+gEP7bPMVNN/k3ELzLeS1ND0L+4xx31cHvkLzR+judt9m99vH4dPaWo+i+WNxN83JoRfT9DA8btiyb6b5AHg/PZehHOlxGO2xHppGM3zpxHa7d7a3N+izjicCx7Xt7mofn41HWPfjabrOb6H5A/yXSxuO8rz/Lc23gne0z/GFwN7jOG5GPNbGcoz1zFuL5jrqf6D5MPAHmq7/Nce6jjFs/0nAITRB8b72eb+QJiQ8bpTlZrfHytXtY3QPzWvhv+i5xOooyx/Q1jx7Ie0edfnQ8b5Weo/PEbbxHJoPSwva9fye5lyF9Ya1ez5NSLyR5ri/juY/LP8zsNywtm+nCWz30bye9qP5MDum52mUY2u04+VR+8n4Xiv9pq1A835yA3/9xnq7dt6RjO3yoSvQDFX5XXusXNkeXy9q2+7ZZ/9eTNM79Pv2MZwP7D7CY7UpzT+e+2P7vNxA8z84Pgas3tPuUfUu5DkY03M4nv1r24/03rk0TW/Yb9pt/o4m8G/Moy+huz9NaL6Rvx77xwFbLsbjM+Jz7c/0+En7REpawqX5T7/zgA9V1acW1l6SJGk0niMgLYGGjyluu+g/0N790dRXJEmSHms8R0BaMl2U5DSaru0Vaf6L6rY01+Y/f6CVSZKkxwSHBklLoCT/QfPh/6k0gf1qmvHHB9Uj/zOoJEnSIjEISJIkSR3kOQKSJElSBxkEJEmSpA4yCEiSJEkdZBCQJEmSOsggIEmSJHWQQUCSJEnqIIOAJEmS1EEGAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkdZBCQJEmSOsggIEmSJHWQQUCSJEnqoBmDLqCr1lxzzZo1a9agy5AkSdJj2Pnnn7+gqtbqN88gMCCzZs1i3rx5gy5DkiRJj2FJfjfSPIcGSZIkSR1kj8CAPHjTLdx02NGDLmOxrfWONwy6BEmSJC0CewQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBBQJIkSeogg4AkSZLUQQYBSZIkqYMMApIkSVIHGQQkSZKkDnrMBYEk30syc5zLHJlk10kqSZIkSVrizBh0AROtqnYcPi1JgFTVwwMoSZIkSVriTOsegSTfTnJ+ksuSzGmnXZNkzSSzklyR5H+AS4GnJrkryWfa9qcmWavPOv8lyXlJLk0ytw0RJDk9yUFJfpHk10m2bacvneTgdplLkrx9Kh8DSZIkaVFM6yAAvKWqtgJmA+9Ossaw+RsCh1bVJlX1O2BFYF5VbQKcAXy8zzoPqaqtq2pTYHlgp555M6rqOcB+PcvuDdxeVVsDWwNvS7Juv2KTzEkyL8m8m++6Y5F2WJIkSZoI0z0IvDvJxcA5wFNpPvj3+l1VndNz/2Hg2Pb20cAL+qxz+yTnJpkP7ABs0jPvhPb3+cCs9vZLgDcluQg4F1ijTx0AVNXcqppdVbPXWGmVMeyeJEmSNDmm7TkCSbYDXgw8t6ruSXI6sNywZncvZDU1bJ3LAYcCs6vq2iQHDFvnfe3vh/jrYxfgXVV1yjh3QZIkSRqY6dwjsCpwaxsCNgK2GcMySwFDVwfaHfjpsPlDH/oXJFmpp+1oTgHekWQZgCRPT7LiGJaTJEmSBmba9ggAPwD2SXI5cAXN8KCFuRt4TpKPAjcCu/XOrKrbknyJ5uTiPwHnjWGdX6YZJnRBe2LxTcDOY9wHSZIkaSBSVQtv9RiR5K6qWmnQdQBsvs569aP9/3XQZSy2td7xhkGXIEmSpBEkOb+qZvebN52HBkmSJElaRJ0KAktKb4AkSZI0aJ0KApIkSZIaBgFJkiSpgwwCkiRJUgcZBCRJkqQOMghIkiRJHTSd/6HYtDZjrdW9Br8kSZIGxh4BSZIkqYMMApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yKsGDcgDN/2R6w/9yKDLkKTHpLX3PXDQJUjSEs8eAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkdZBCQJEmSOsggIEmSJHWQQUCSJEnqIIOAJEmS1EEGAUmSJKmDpmUQSDIryaWDrqNXki8neWZ7+5okaw66JkmSJGkkMwZdwFRLMqOqHpzo9VbVWyd6nZIkSdJkmZY9Aq0ZSY5JcnmS45OskORfkpyX5NIkc5MEIMnpST6bZB7wniRbJTkjyflJTkmy9vCVJ1kxyXeTXNyub7d2+ouSXJhkfpIjkjyuZxuzp/QRkCRJkhbRdA4CzwAOraqNgTuAfYFDqmrrqtoUWB7Yqaf9slU1G/g88AVg16raCjgCOLDP+l8GXFdVm7Xr+0GS5YAjgd2q6lk0PSrvGGvBSeYkmZdk3s133TPe/ZUkSZImzHQOAtdW1dnt7aOBFwDbJzk3yXxgB2CTnvbHtr+fAWwK/CjJRcBHgaf0Wf984O+SHJRk26q6vV326qr6ddvmKOCFYy24quZW1eyqmr3GSiuMdTFJkiRpwk3ncwSqz/1DgdlVdW2SA4Dleubf3f4OcFlVPbd34SRPBU5u7x5eVYcn2RLYEfhkklOBEyd4HyRJkqSBmM49Ak9LMvRhfnfgp+3tBUlWAnYdYbkrgLWGlk2yTJJNquraqtq8/Tk8yZOAe6rqaOBgYMt22VlJNmjX9UbgjEnYN0mSJGlSTecegSuAdyY5AvglcBiwGnAp8CfgvH4LVdX9SXYFPp9kVZrH4LPAZcOaPgs4OMnDwAPAO6rq3iR7AcclmdFu4/AJ3zNJkiRpkqVq+AgbTYXN1lm7fvDBtwy6DEl6TFp7337XgJCk7klyfnvBnEeZzkODJEmSJC0ig4AkSZLUQQYBSZIkqYMMApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6aDr/Q7FpbZm1nux1riVJkjQw9ghIkiRJHWQQkCRJkjrIICBJkiR1kEFAkiRJ6iCDgCRJktRBXjVoQO656TdcePgrB12GJE17W+xz8qBLkKRpyR4BSZIkqYMMApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBBQJIkSeogg4AkSZLUQQYBSZIkqYOmTRBIMivJpeNo/6ok+7e3D0jyvtHWmWR2ks9PXMWSJEnSkmvGoAuYLFV1EnDSONrPA+ZNXkWSJEnSkmPa9Ai0ZiQ5JsnlSY5PskKSa5KsCX/5Vv/09vaeSQ4ZvoIkWyW5OMnFwDt7pm+X5Dvt7QOSHJHk9CRXJXl3T7uPJbkiyU+TfH2opyHJu5P8MsklSf5vch8GSZIkafFMtyDwDODQqtoYuAPYdxHW8VXgXVW12ULabQS8FHgO8PEkyyTZGtgF2Ax4OTC7p/3+wBZV9Wxgn34rTDInybwk82696/5FKF2SJEmaGNMtCFxbVWe3t48GXjCehZPMBGZW1ZntpK+N0vy7VXVfVS0AbgSeADwfOLGq7q2qO4GTe9pfAhyT5A3Ag/1WWFVzq2p2Vc1ebaVlx1O6JEmSNKGmWxCoPvcf5K/7sdwEbuu+ntsPsfDzKV4BfBHYEjgvyWP2/AtJkiRNf9MtCDwtyXPb27sDPwWuAbZqp+0y2sJVdRtwW5KhnoQ9xrn9s4FXJlkuyUrATgBJlgKeWlU/AT4IrAqsNM51S5IkSVNmugWBK4B3JrkcWA04DPgE8Lkk82i+uV+YvYAvJrkIyHg2XlXn0VyJ6BLg+8B84HZgaeDoJPOBC4HPt6FDkiRJWiKlavhoG40myUpVdVeSFYAzgTlVdcF41/PMdWbWMR/aduILlKSO2WKfkxfeSJI6Ksn5VTW73zzHsY/f3CTPpDkf4ahFCQGSJEnSoBkExqmqdh90DZIkSdLimm7nCEiSJEmaAAYBSZIkqYMMApIkSVIHGQQkSZKkDjIISJIkSR3kVYMGZIW1NvDa15IkSRoYewQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBBQJIkSeogrxo0ILcvuJLvfWXHQZchSdJC7bj39wZdgqRJYI+AJEmS1EEGAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkdZBCQJEmSOsggIEmSJHWQQUCSJEnqIIOAJEmS1EEGAUmSJKmDDAKLKcmMQdcgSZIkjZcfYnskeRPwPqCAS4BvAB8FlgVuBvaoqhuSHACsD6wH/D7JJ4Gvtu2WAnapqiunfg8kSZKksTEItJJsQvOh/3lVtSDJ6jSBYJuqqiRvBT4A/HO7yDOBF1TVn5N8AfhcVR2TZFlg6RG2MQeYA7DW6stN8h5JkiRJIzMI/NUOwHFVtQCgqm5J8izg2CRr03zbf3VP+5Oq6s/t7Z8DH0nyFOCEkXoDqmouMBdgw1mr1iTthyRJkrRQniMwui8Ah1TVs4C3A71f4989dKOq/hd4FfBn4HtJdpjSKiVJkqRxMgj81WnAa5OsAdAODVoV+GM7/80jLZhkPeCqqvo8cCLw7EmuVZIkSVosDg1qVdVlSQ4EzkjyEHAhcABwXJJbaYLCuiMs/jrgjUkeAP4E/PsUlCxJkiQtMoNAj6o6Cjhq2OQT+7Q7YNj9TwGfmrzKJEmSpInl0CBJkiSpgwwCkiRJUgcZBCRJkqQOMghIkiRJHWQQkCRJkjrIICBJkiR1kEFAkiRJ6iD/j8CArLrmhuy49/cGXYYkSZI6yh4BSZIkqYMMApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yKsGDciCm3/NEUe9ZNBlTKq3vPmHgy5BkiRJI7BHQJIkSeogg4AkSZLUQQYBSZIkqYMMApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBBQJIkSeqgaRkEkhyZZNdB19FPkj2THDLoOiRJkqTRTMsgMNWSzBjtviRJkjTdTIsgkORNSS5JcnGSr7WTX5jkZ0muGuodSLJSklOTXJBkfpJXt9NnJflVkmOSXJ7k+CQrtPP+Jcl5SS5NMjdJ2umnJ/lsknnAe/rcf2WSc5NcmOTHSZ4wgIdGkiRJWiRLfBBIsgnwUWCHqtoMeE87a23gBcBOwKfaafcCr6mqLYHtgU8PfbAHngEcWlUbA3cA+7bTD6mqratqU2D5dn1Dlq2q2VX16T73fwpsU1VbAP8HfGAM+zInybwk8+6684HxPhSSJEnShFnigwCwA3BcVS0AqKpb2unfrqqHq+qXwNC38QH+PcklwI+BJ/fMu7aqzm5vH00TIgC2b7/Zn99ua5OebR87rJbe+08BTmmXe/+w5fqqqrltkJi90srLLKy5JEmSNGmmQxAYyX09t4e+9d8DWAvYqqo2B24Almvn1bDlK8lywKHArlX1LOBLPe0B7h62TO/9L9D0JjwLePuw5SRJkqQl2nQIAqcBr02yBkCS1UdpuypwY1U9kGR7YJ2eeU9L8tz29u40Q3uGPrwvSLISMJ4rEa0K/LG9/eZxLCdJkiQN3BJ/9ZuquizJgcAZSR4CLhyl+THAye1wnXnAr3rmXQG8M8kRwC+Bw6rqniRfAi4F/gScN47SDgCOS3IrTVhZdxzLSpIkSQOVquEjZh57kswCvtOeELxEmLXuKvUvB2wz6DIm1Vve/MNBlyBJktRpSc6vqtn95k2HoUGSJEmSJtgSPzRoIlTVNcAS0xsgSZIkDZo9ApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdVAnrhq0JFpzjad7nX1JkiQNjD0CkiRJUgcZBCRJkqQOMghIkiRJHWQQkCRJkjrIICBJkiR1kFcNGpDrb72STx770kGXMaE+utspgy5BkiRJY2SPgCRJktRBBgFJkiSpgwwCkiRJUgcZBCRJkqQOMghIkiRJHWQQkCRJkjrIICBJkiR1kEFAkiRJ6iCDgCRJktRBBoEJkmRmkn0HXYckSZI0FgaBCZBkBjATMAhIkiRpWuhsEEjypiSXJLk4ydeSzEpyWjvt1CRPa9sdmWTXnuXuan9vl+SsJCcBvwQ+Bayf5KIkBw9kpyRJkqQxmjHoAgYhySbAR4HnVdWCJKsDRwFHVdVRSd4CfB7YeSGr2hLYtKquTjKrvb35KNudA8wBWHXN5RZ7PyRJkqRF1dUegR2A46pqAUBV3QI8F/jfdv7XgBeMYT2/qKqrx7rRqppbVbOravaKqyw73polSZKkCdPVIDAeD9I+TkmWAno/wd89kIokSZKkxdTVIHAa8NokawC0Q4N+Bry+nb8HcFZ7+xpgq/b2q4BlRljnncDKk1GsJEmSNNE6eY5AVV2W5EDgjCQPARcC7wK+muT9wE3AXm3zLwEnJrkY+AEj9AJU1c1Jzk5yKfD9qnr/pO+IJEmStIg6GQQAquoomhOEe+3Qp90NwDY9kz7YTj8dOH1Y290ntEhJkiRpknR1aJAkSZLUaQYBSZIkqYMMApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdVBn/4/AoK292oZ8dLdTBl2GJEmSOsoeAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkdZBCQJEmSOsirBg3IlbddxctP/IdBl7HIvv/qrw+6BEmSJC0GewQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBBQJIkSeogg4AkSZLUQQYBSZIkqYMMApIkSVIHGQQkSZKkDjIIDJPkgCTvG+cy2yX5zmTVJEmSJE00g4AkSZLUQQYBIMlHkvw6yU+BZ7TTNk9yTpJLknwryWrt9A2S/DjJxUkuSLL+sHVtneTC4dMlSZKkJUnng0CSrYDXA5sDOwJbt7P+B/hgVT0bmA98vJ1+DPDFqtoMeB5wfc+6ngccDry6qn7bZ1tzksxLMu/+O+6bpD2SJEmSFq7zQQDYFvhWVd1TVXcAJwErAjOr6oy2zVHAC5OsDDy5qr4FUFX3VtU9bZuNgbnAK6vq9/02VFVzq2p2Vc1edpXHTeY+SZIkSaMyCEyc64F7gS0GXYgkSZK0MAYBOBPYOcny7Tf+rwTuBm5Nsm3b5o3AGVV1J/CHJDsDJHlckhXaNrcBrwD+X5Ltpq58SZIkafw6HwSq6gLgWOBi4PvAee2sNwMHJ7mE5vyBf22nvxF4dzv9Z8ATe9Z1A7AT8MUkfzMlOyBJkiQtghmDLmBJUFUHAgf2mbVNn7ZXAjsMm3wVcHo7//fAJhNcoiRJkjShOt8jIEmSJHWRQUCSJEnqIIOAJEmS1EEGAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkd5P8RGJANZ67H91/99UGXIUmSpI6yR0CSJEnqIIOAJEmS1EEGAUmSJKmDDAKSJElSBxkEJEmSpA7yqkEDcuVtf2LHbx006DIm1fde88FBlyBJkqQR2CMgSZIkdZBBQJIkSeogg4AkSZLUQQYBSZIkqYMMApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBBoJXk3UkuT3Jrkv0X0nbPJIeMMO+uyalQkiRJmjgzBl3AEmRf4MVV9YdBFyJJkiRNNnsEgCSHA+sB30/yT0Pf9idZK8k3k5zX/jy/z7LrJvl5kvlJPjnVtUuSJEmLwiAAVNU+wHXA9sCtPbM+B3ymqrYGdgG+3GfxzwGHVdWzgOtH206SOUnmJZl3/x13T0zxkiRJ0iJwaNDoXgw8M8nQ/VWSrDSszfNpQgLA14CDRlpZVc0F5gKsusFTamJLlSRJksbOIDC6pYBtqure3ok9wWCIH+olSZI0rTg0aHQ/BN41dCfJ5n3anA28vr29xxTUJEmSJC02g8Do3g3MTnJJkl8C+/Rp8x7gnUnmA0+e0uokSZKkReTQoFZVzWpvHtn+UFULgN36tO1tczXw3J7ZH520IiVJkqQJYo+AJEmS1EEGAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkdZBCQJEmSOsggIEmSJHWQ/0dgQDac+US+95oPDroMSZIkdZQ9ApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBXDRqQ39y6gJ2++ZVBlyFJUid9Z5e9B12CNHD2CEiSJEkdZBCQJEmSOmjUoUFJ7gRq6G77u9rbVVWrTGJtkiRJkibJqEGgqlaeqkIkSZIkTZ0xDw1K8oIke7W310yy7uSVJUmSJGkyjSkIJPk48EHgQ+2kZYGjJ6soSZIkSZNrrD0CrwFeBdwNUFXXAQ4bkiRJkqapsQaB+6uqaE8cTrLi5JUkSZIkabKNNQh8I8l/AzOTvA34MfClyStLkiRJ0mQa038Wrqr/TPJ3wB3A04F/qaofTWplkiRJkibNmIJAaz6wPM3woPmTU86SIcmMqnpw0HVIkiRJk2WsVw16K/AL4O+BXYFzkrxlMgubTEk+luSKJD9N8vUk70tyepLPJpkHvCfJK5Ocm+TCJD9O8oR22b9NclH7c2GSlZOsneTMdtqlSbYd8C5KkiRJoxprj8D7gS2q6maAJGsAPwOOmKzCJkuSrYFdgM2AZYALgPPb2ctW1ey23WrANlVVbRD6APDPwPuAd1bV2UlWAu4F5gCnVNWBSZYGVhhh23Patiy/5uqTtYuSJEnSQo01CNwM3Nlz/8522nT0fODEqroXuDfJyT3zju25/RTg2CRr0/zfhKvb6WcD/5XkGOCEqvpDkvOAI5IsA3y7qi7qt+GqmgvMBZi5/qyayJ2SJEmSxmPUoUFJ3pvkvcBvgHOTHND+c7FzgF9PRYFT7O6e218ADqmqZwFvB5YDqKpPAW+lOV/i7CQbVdWZwAuBPwJHJnnT1JYtSZIkjc/CzhFYuf35LfBt2v8jAJzIX78hn27OBl6ZZLl2aM9OI7RbleaDPcCbhyYmWb+q5lfVQcB5wEZJ1gFuqKovAV8Gtpy88iVJkqTFN+rQoKr6xFQVMlWq6rwkJwGXADfQXAHp9j5NDwCOS3IrcBqwbjt9vyTbAw8DlwHfB14PvD/JA8BdgD0CkiRJWqKN6RyBJGvRnCy7Ce0QGYCq2mGS6pps/1lVByRZATgTOL/9Nv8vqupEmp4Phk1/V5/1HdX+SJIkSdPCWP+z8DHAr2i+Ff8EcA3NsJjpam6Si2iuGPTNqrpgwPVIkiRJU2qsVw1ao6q+kuQ9VXUGcEZ7pZxpqap2H3QNkiRJ0iCNNQg80P6+PskrgOsAL4QvSZIkTVNjDQKfTLIqzT/U+gKwCrDfZBUlSZIkaXKNKQhU1Xfam7cD2wMk2W+SapIkSZI0ycZ6snA/752wKiRJkiRNqcUJApmwKiRJkiRNqbGeI9BPLbyJRrLBamvynV32HnQZkiRJ6qhRg0CSO+n/gT/A8pNSkSRJkqRJN2oQqKqVp6oQSZIkSVNncc4RkCRJkjRNGQQkSZKkDjIISJIkSR20OFcN0mL4za238srjvznoMibEybvuMugSJEmSNE72CEiSJEkdZBCQJEmSOsggIEmSJHWQQUCSJEnqIIOAJEmS1EEGAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkdtEQGgSQHJHlfn+lPSnJ8e3u7JN8Z53pPTzJ7ouqUJEmSpqsZgy5gPKrqOmDXQdchSZIkTXeT1iOQZFaSXyU5MsmvkxyT5MVJzk5yZZLnJFk9ybeTXJLknCTP7lnFZkl+3rZ9W886L+2zrRWTHJHkF0kuTPLqUUp7bdvu10m2bZdfLslXk8xvl9++nb5nW9+PklyT5B+TvLdtc06S1dt26yf5QZLzk5yVZKOJeyQlSZKkiTfZPQIbAK8F3gKcB+wOvAB4FfBh4FrgwqraOckOwP8Am7fLPhvYBlgRuDDJd0fZzkeA06rqLUlmAr9I8uOqurtP2xlV9ZwkOwIfB14MvBOoqnpW+yH+h0me3rbfFNgCWA74DfDBqtoiyWeANwGfBeYC+1TVlUn+BjgU2GH4hpPMAeYALL/mmqPsjiRJkjS5JjsIXF1V8wGSXAacWlWVZD4wC1gH2AWgqk5LskaSVdplT6yqPwN/TvIT4DnARSNs5yXAq3rOK1gOeBpweZ+2J7S/z29rgCacfKGt41dJfgcMBYGfVNWdwJ1JbgdObqfPB56dZCXgecBxSYa28bh+RVbVXJrQwMz1168R9kWSJEmadJMdBO7ruf1wz/2H220/MMqywz8oj/bBOcAuVXXFIyYmX6X5Nv+6qtpxWE0PMbb9X9g+LAXcVlWbj2FdkiRJ0hJh0FcNOgvYA5qrAAELquqOdt6r27H7awDb0QwtGskpwLvSfiWfZAuAqtqrqjbvCQFjqePpNL0JV4y6RKut9+okr22XT5LNxrKsJEmSNCiDDgIHAFsluQT4FPDmnnmXAD8BzgH+rb1i0Ej+DVgGuKQdgvRv46zjUGCpdsjSscCeVXXfQpbptQewd5KLgcuA0U5WliRJkgYuVQ5VH4SZ669f2x70H4MuY0KcvOsugy5BkiRJfSQ5v6r6/h+tQfcISJIkSRoAg4AkSZLUQQYBSZIkqYMMApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6aMagC+iqDVZbzevvS5IkaWDsEZAkSZI6yCAgSZIkdZBBQJIkSeogg4AkSZLUQQYBSZIkqYO8atCA/PbWO3nNN38y6DIkSZI0ib61y/aDLmFE9ghIkiRJHWQQkCRJkjrIICBJkiR1kEFAkiRJ6iCDgCRJktRBBgFJkiSpgwwCkiRJUgcZBCRJkqQOMghIkiRJHWQQmEBJdk7yzEHXIUmSJC2MQWBi7QwYBCRJkrTEWyKDQJJZSX6V5Jgklyc5PskKSf4lyXlJLk0yN42Nkvxi2LLz29tbJTkjyflJTkmydjv99CSfSTKvXf/WSU5IcmWST/as6w1JfpHkoiT/nWTpdvpdSQ5McnGSc5I8IcnzgFcBB7ft15/aR02SJEkauyUyCLSeARxaVRsDdwD7AodU1dZVtSmwPLBTVf0KWDbJuu1yuwHHJlkG+AKwa1VtBRwBHNiz/vurajZwOHAi8E5gU2DPJGsk2bhd1/OranPgIWCPdtkVgXOqajPgTOBtVfUz4CTg/VW1eVX9dvgOJZnTho95991x+8Q8SpIkSdIimDHoAkZxbVWd3d4+Gng3cHWSDwArAKsDlwEnA9+g+dD+qfb3bjRBYlPgR0kAlgau71n/Se3v+cBlVXU9QJKrgKcCLwC2As5rl18euLFd5n7gO+3t84G/G8sOVdVcYC7Aaus/o8ayjCRJkjQZluQgMPyDcgGHArOr6tokBwDLtfOOBY5LcgJQVXVlkmfRfMB/7gjrv6/9/XDP7aH7M4AAR1XVh/os+0BVDdX3EEv24yhJkiQ9ypI8NOhpSYY+xO8O/LS9vSDJSsCuQw3bYTgPAR+jCQUAVwBrDa0jyTJJNhnH9k8Fdk3y+Hb51ZOss5Bl7gRWHsc2JEmSpIFYkoPAFcA7k1wOrAYcBnwJuBQ4BThvWPtjgTfQDBOiqu6nCQsHJbkYuAh43lg3XlW/BD4K/DDJJcCPgLUXstj/Ae9PcqEnC0uSJGlJlr+OcFlyJJkFfKc9KfgxabX1n1Hb/cfhgy5DkiRJk+hbu2w/0O0nOb+9QM6jLMk9ApIkSZImyRJ5kmtVXUNzxR9JkiRJk8AeAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkdZBCQJEmSOmiJvGpQF6y/2soDv66sJEmSusseAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkdZBCQJEmSOsirBg3IVbfey27f/PWgy9A0dewuTx90CZIkaZqzR0CSJEnqIIOAJEmS1EEGAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkdZBCQJEmSOsggIEmSJHWQQUCSJEnqIIPABEtyepLZg65DkiRJGo1BQJIkSeqgGYMuYJCSrAh8A3gKsDTwb8AzgFcCywM/A95eVZXkdOBcYHtgJrB3VZ2VZHngq8BmwK/a5SRJkqQlWtd7BF4GXFdVm1XVpsAPgEOqauv2/vLATj3tZ1TVc4D9gI+3094B3FNVG7fTthppY0nmJJmXZN59d9w6CbsjSZIkjU3Xg8B84O+SHJRk26q6Hdg+yblJ5gM7AJv0tD+h/X0+MKu9/ULgaICqugS4ZKSNVdXcqppdVbMft8pqE7wrkiRJ0th1emhQVf06yZbAjsAnk5wKvBOYXVXXJjkAWK5nkfva3w/R8cdOkiRJ01unewSSPIlmWM/RwMHAlu2sBUlWAnYdw2rOBHZv17cp8OzJqFWSJEmaSF3/VvtZwMFJHgYeoBnvvzNwKfAn4LwxrOMw4KtJLgcupxk2JEmSJC3ROh0EquoU4JRhk+cBH+3Tdrue2wtozxGoqj8Dr5+0IiVJkqRJ0OmhQZIkSVJXGQQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBBQJIkSeogg4AkSZLUQZ3+PwKDtN5qy3HsLk8fdBmSJEnqKHsEJEmSpA4yCEiSJEkdZBCQJEmSOsggIEmSJHWQQUCSJEnqIK8aNCA33fYgc0+4cdBlLJY5f//4QZcgSZKkRWSPgCRJktRBBgFJkiSpgwwCkiRJUgcZBCRJkqQOMghIkiRJHWQQkCRJkjrIICBJkiR1kEFAkiRJ6iCDgCRJktRBBgFJkiSpgwwCkiRJUgcZBEaQZMUk301ycZJLk+yWZKskZyQ5P8kpSdZu274tyXlt228mWWHQ9UuSJEmjMQiM7GXAdVW1WVVtCvwA+AKwa1VtBRwBHNi2PaGqtq6qzYDLgb37rTDJnCTzksy76/abp2AXJEmSpP5mDLqAJdh84NNJDgK+A9wKbAr8KAnA0sD1bdtNk3wSmAmsBJzSb4VVNReYC7DOBpvXZBYvSZIkjcYgMIKq+nWSLYEdgU8CpwGXVdVz+zQ/Eti5qi5Osiew3VTVKUmSJC0KhwaNIMmTgHuq6mjgYOBvgLWSPLedv0ySTdrmKwPXJ1kG2GMgBUuSJEnjYI/AyJ4FHJzkYeAB4B3Ag8Dnk6xK89h9FrgM+BhwLnBT+3vlQRQsSZIkjZVBYARVdQr9x/q/sE/bw4DDJr0oSZIkaYI4NEiSJEnqIIOAJEmS1EEGAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkdZBCQJEmSOsj/IzAga82cwZy/f/ygy5AkSVJH2SMgSZIkdZBBQJIkSeogg4AkSZLUQQYBSZIkqYMMApIkSVIHedWgAbnzlgc57ZibBl3GYtlhj7UGXYIkSZIWkT0CkiRJUgcZBCRJkqQOMghIkiRJHWQQkCRJkjrIICBJkiR1kEFAkiRJ6iCDgCRJktRBBgFJkiSpgwwCkiRJUgcZBBYiyTVJ1uwz/VVJ9h9ETZIkSdLimjHoAqarqjoJOGnQdUiSJEmLwh6BHklWTPLdJBcnuTTJbu2sdyW5IMn8JBu1bfdMckh7+8gkhyeZl+TXSXYa2E5IkiRJY2AQeKSXAddV1WZVtSnwg3b6gqraEjgMeN8Iy84CngO8Ajg8yXLDGySZ04aFebfdcfPEVy9JkiSNkUHgkeYDf5fkoCTbVtXt7fQT2t/n03zg7+cbVfVwVV0JXAVsNLxBVc2tqtlVNXvmKmtMdO2SJEnSmHmOQI+q+nWSLYEdgU8mObWddV/7+yFGfsxqIfclSZKkJYY9Aj2SPAm4p6qOBg4GthzH4q9NslSS9YH1gCsmo0ZJkiRpItgj8EjPAg5O8jDwAPAO4PgxLvt74BfAKsA+VXXv5JQoSZIkLT6DQI+qOgU4ZdjkWT3z5wHbtbePBI7saffjqtpnUguUJEmSJohDgyRJkqQOskdgAlTVnoOuQZIkSRoPewQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBBQJIkSeogrxo0ICuvPoMd9lhr0GVIkiSpo+wRkCRJkjrIICBJkiR1kEFAkiRJ6iCDgCRJktRBBgFJkiSpg7xq0IDcd+MDXHnIDYMuY7Fs+I9PGHQJkiRJWkT2CEiSJEkdZBCQJEmSOsggIEmSJHWQQUCSJEnqIIOAJEmS1EEGAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkd1LkgkGRmkn0XY/nTk8yeyJokSZKkqda5IADMBBY5CEiSJEmPBV0MAp8C1k9yUZLPJDk1yQVJ5id5NUCSWUkuT/KlJJcl+WGS5XtXkmSpJEcm+WSSpdvbl7br+aeB7JkkSZI0RjMGXcAA7A9sWlWbJ5kBrFBVdyRZEzgnyUltuw2Bf6iqtyX5BrALcHQ7bwZwDHBpVR2YZCvgyVW1KTTDj/ptOMkcYA7Ak1Z7yiTtniRJkrRwXewR6BXg35NcAvwYeDLwhHbe1VV1UXv7fGBWz3L/TRsC2vtXAesl+UKSlwF39NtYVc2tqtlVNXv1lVaf2D2RJEmSxqHrQWAPYC1gq6raHLgBWK6dd19Pu4d4ZO/Jz4DtkywHUFW3ApsBpwP7AF+e1KolSZKkxdTFIHAnsHJ7e1Xgxqp6IMn2wDpjXMdXgO8B30gyox1WtFRVfRP4KLDlRBctSZIkTaTOnSNQVTcnOTvJpcB5wEZJ5gPzgF+NYz3/lWRV4Gs0JyB/NclQsPrQRNctSZIkTaTOBQGAqtp9DM027Wn/nz23t+u5/fGe9vYCSJIkadro4tAgSZIkqfMMApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBBQJIkSeqgTv4fgSXB4x6/DBv+4xMGXYYkSZI6yh4BSZIkqYMMApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yKsGDcgDN/yZP/3XZYMuQ5IkjdET37vJoEuQJpQ9ApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBBQJIkSeogg4AkSZLUQQYBSZIkqYMMApIkSVIHdTYIJJmZZN9B1yFJkiQNQmeDADATeFQQSDJj6kuRJEmSplaXg8CngPWTXJTkvCRnJTkJ+GWSpZMc3E6/JMnbhxZK8v6e6Z9op62Y5LtJLk5yaZLdBrVTkiRJ0lh0+dvv/YFNq2rzJNsB323vX51kDnB7VW2d5HHA2Ul+CGzY/jwHCHBSkhcCawHXVdUrAJKs2m+D7XrnADx5tbUndeckSZKk0XS5R2C4X1TV1e3tlwBvSnIRcC6wBk0AeEn7cyFwAbBRO30+8HdJDkqybVXd3m8DVTW3qmZX1ew1VlxtcvdGkiRJGkWXewSGu7vndoB3VdUpvQ2SvBT4f1X138MXTrIlsCPwySSnVtW/Tmq1kiRJ0mLoco/AncDKI8w7BXhHkmUAkjw9yYrt9LckWamd/uQkj0/yJOCeqjoaOBjYcvLLlyRJkhZdZ3sEqurmJGcnuRT4M3BDz+wvA7OAC5IEuAnYuap+mGRj4OfNZO4C3gBsAByc5GHgAeAdU7cnkiRJ0vh1NggAVNXuI0x/GPhw+zN83ueAzw2b/Fua3gJJkiRpWujy0CBJkiSpswwCkiRJUgcZBCRJkqQOMghIkiRJHWQQkCRJkjrIICBJkiR1kEFAkiRJ6qBO/x+BQVrmCcvzxPduMugyJEmS1FH2CEiSJEkdZBCQJEmSOsggIEmSJHWQQUCSJEnqIIOAJEmS1EFeNWhAHrzxTm78wqmDLqOTHv+uFw26BEmSpIGzR0CSJEnqIIOAJEmS1EEGAUmSJKmDDAKSJElSBxkEJEmSpA4yCEiSJEkdZBCQJEmSOsggIEmSJHWQQUCSJEnqIIPAGCTZL8kKg65DkiRJmigGgbHZDxhXEEiy9OSUIkmSJC2+TgWBJO9P8u729meSnNbe3iHJMUkOSzIvyWVJPtHOezfwJOAnSX7STntJkp8nuSDJcUlWaqdfk+SgJBcArx3ITkqSJElj0KkgAJwFbNveng2slGSZdtqZwEeqajbwbOBvkzy7qj4PXAdsX1XbJ1kT+Cjw4qraEpgHvLdnGzdX1ZZV9X/DN55kThs05t18122TtY+SJEnSQnUtCJwPbJVkFeA+4Oc0gWBbmpDwuvbb/AuBTYBn9lnHNu30s5NcBLwZWKdn/rEjbbyq5lbV7KqavcZKMxd/byRJkqRFNGPQBUylqnogydXAnsDPgEuA7YENgD8D7wO2rqpbkxwJLNdnNQF+VFX/MMJm7p7ouiVJkqSJ1rUeAWi++X8fzVCgs4B9aHoAVqH5EH97kicAL+9Z5k5g5fb2OcDzk2wAkGTFJE+fotolSZKkCdHVILA28POqugG4Fzirqi6mCQS/Av4XOLtnmbnAD5L8pKpuoulR+HqSS2iGF200hfVLkiRJi61TQ4MAqupUYJme+0/vub3nCMt8AfhCz/3TgK37tJs1gaVKkiRJk6aLPQKSJElS5xkEJEmSpA4yCEiSJEkdZBCQJEmSOsggIEmSJHWQQUCSJEnqIIOAJEmS1EGd+z8CS4oZj1+Zx7/rRYMuQ5IkSR1lj4AkSZLUQQYBSZIkqYNSVYOuoZOS3AlcMeg6NFBrAgsGXYQGymNAHgMCjwNN7jGwTlWt1W+G5wgMzhVVNXvQRWhwkszzGOg2jwF5DAg8DjS4Y8ChQZIkSVIHGQQkSZKkDjIIDM7cQReggfMYkMeAPAYEHgca0DHgycKSJElSB9kjIEmSJHWQQUCSJEnqIIPAFEvysiRXJPlNkv0HXY8mR5KnJvlJkl8muSzJe9rpqyf5UZIr29+rtdOT5PPtcXFJki0HuweaKEmWTnJhku+099dNcm77XB+bZNl2+uPa+79p588aaOGaMElmJjk+ya+SXJ7kub4XdEuSf2r/Flya5OtJlvO94LEtyRFJbkxyac+0cb/uk7y5bX9lkjdPdJ0GgSmUZGngi8DLgWcC/5DkmYOtSpPkQeCfq+qZwDbAO9vnen/g1KraEDi1vQ/NMbFh+zMHOGzqS9YkeQ9wec/9g4DPVNUGwK3A3u30vYFb2+mfadvpseFzwA+qaiNgM5rjwfeCjkjyZODdwOyq2hRYGng9vhc81h0JvGzYtHG97pOsDnwc+BvgOcDHh8LDRDEITK3nAL+pqquq6n7g/4BXD7gmTYKqur6qLmhv30nzh//JNM/3UW2zo4Cd29uvBv6nGucAM5OsPbVVa6IleQrwCuDL7f0AOwDHt02GHwNDx8bxwIva9prGkqwKvBD4CkBV3V9Vt+F7QdfMAJZPMgNYAbge3wse06rqTOCWYZPH+7p/KfCjqrqlqm4FfsSjw8ViMQhMrScD1/bc/0M7TY9hbbfuFsC5wBOq6vp21p+AJ7S3PTYemz4LfAB4uL2/BnBbVT3Y3u99nv9yDLTzb2/ba3pbF7gJ+Go7ROzLSVbE94LOqKo/Av8J/J4mANwOnI/vBV003tf9pL8fGASkSZRkJeCbwH5VdUfvvGqu3ev1ex+jkuwE3FhV5w+6Fg3UDGBL4LCq2gK4m78OBwB8L3isa4dyvJomFD4JWJEJ/lZX08+S8ro3CEytPwJP7bn/lHaaHoOSLEMTAo6pqhPayTcMdfO3v29sp3tsPPY8H3hVkmtohgHuQDNWfGY7PAAe+Tz/5Rho568K3DyVBWtS/AH4Q1Wd294/niYY+F7QHS8Grq6qm6rqAeAEmvcH3wu6Z7yv+0l/PzAITK3zgA3bKwUsS3Oy0EkDrkmToB3P+RXg8qr6r55ZJwFDZ/2/GTixZ/qb2isHbAPc3tN9qGmoqj5UVU+pqlk0r/XTqmoP4CfArm2z4cfA0LGxa9t+4N8WafFU1Z+Aa5M8o530IuCX+F7QJb8HtkmyQvu3YegY8L2ge8b7uj8FeEmS1dqepZe00yaM/1l4iiXZkWbc8NLAEVV14GAr0mRI8gLgLGA+fx0f/mGa8wS+ATwN+B3wuqq6pf3jcAhNd/E9wF5VNW/KC9ekSLId8L6q2inJejQ9BKsDFwJvqKr7kiwHfI3mfJJbgNdX1VUDKlkTKMnmNCeMLwtcBexF80Wc7wUdkeQTwG40V5S7EHgrzVhv3wseo5J8HdgOWBO4gebqP99mnK/7JG+h+fwAcGBVfXVC6zQISJIkSd3j0CBJkiSpgwwCkiRJUgcZBCRJkqQOMghIkiRJHWQQkCRJkjrIICBJmnJJnpjk/5L8Nsn5Sb6X5OkTuP7tkjxvotYnSY9FBgFJ0pRqr5n9LeD0qlq/qrYCPgQ8YQI3sx1gEJCkURgEJElTbXvggao6fGhCVV0M/DTJwUkuTTI/yW7wl2/3vzPUNskhSfZsb1+T5BNJLmiX2SjJLGAf4J+SXJRk26ncOUmaLmYMugBJUudsCpzfZ/rfA5sDm9H8N87zkpw5hvUtqKotk+xL8x+c35rkcOCuqvrPiSpakh5r7BGQJC0pXgB8vaoeqqobgDOArcew3Ant7/OBWZNUmyQ95hgEJElT7TJgq3G0f5BH/r1abtj8+9rfD2FPtySNmUFAkjTVTgMel2TO0IQkzwZuA3ZLsnSStYAXAr8Afgc8M8njkswEXjSGbdwJrDzRhUvSY4nfnEiSplRVVZLXAJ9N8kHgXuAaYD9gJeBioIAPVNWfAJJ8A7gUuBq4cAybORk4PsmrgXdV1VkTvR+SNN2lqgZdgyRJkqQp5tAgSZIkqYMMApIkSVIHGQQkSZKkDjIISJIkSR1kEJAkSZI6yCAgSZIkdZBBQJIkSeqg/w/BSsuTcuZ1cwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "train_set.data_distribution_barchart();" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "pycharm": { + "is_executing": true, + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/spopov/Downloads/aitlas/venv/lib/python3.9/site-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ], + "source": [ + "# validation set\n", + "val_set = UcMercedMultiLabelDataset({\n", + " \"batch_size\": 16,\n", + " \"shuffle\": True,\n", + " \"num_workers\": 4,\n", + " \"data_dir\": \"/Users/spopov/Downloads/UC_merced_multilabel/test\",\n", + " \"csv_file\": \"/Users/spopov/Downloads/UC_merced_multilabel/test/multilabels.txt\",\n", + " \"transforms\": [\"aitlas.transforms.ResizeCenterCropFlipHVToTensor\"]\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "val_set.data_distribution_barchart();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We call `model.train_and_evaluate_model(...)` for only one epoch, to demonstrate usage. Increasing that number should result in better performance." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "pycharm": { + "is_executing": true, + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/spopov/Downloads/aitlas/venv/lib/python3.9/site-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n", + "2021-11-25 22:53:08,445 INFO Starting training.\n", + "training: 99%|█████████▉| 99/100 [10:06<00:07, 7.19s/it]2021-11-25 23:03:25,499 INFO [1, 100], loss: 9.10973\n", + "training: 100%|██████████| 100/100 [10:37<00:00, 6.37s/it]\n", + "2021-11-25 23:03:45,526 INFO epoch: 1, time: 637, loss: 0.56936\n", + "testing on train set: 100%|██████████| 100/100 [10:18<00:00, 6.19s/it]\n", + "2021-11-25 23:14:04,617 INFO F1_score Micro:0.6867792077553067, F1_score Macro:0.4574388813563156, F1_score Weighted:0.6473861631428166, F1_score per Class:[0. 0.40428062 0.64146341 0.75434531 0.42477876 0.\n", + " 0.7107438 0.18556701 0.74416244 0. 0.88981869 0.57709251\n", + " 0.46464646 0.67241379 0. 0.70588235 0.60126582]\n", + "testing on validation set: 100%|██████████| 32/32 [03:22<00:00, 6.32s/it]\n", + "2021-11-25 23:17:26,988 INFO F1_score Micro:0.689419795221843, F1_score Macro:0.46620157969240017, F1_score Weighted:0.6542708262082148, F1_score per Class:[0. 0.38062284 0.64202335 0.78623188 0.54054054 0.\n", + " 0.7804878 0.23529412 0.74025974 0. 0.89512555 0.54929577\n", + " 0.38709677 0.68421053 0. 0.69266771 0.61157025]\n", + "2021-11-25 23:17:27,440 INFO finished training. training time: 1459\n" + ] + } + ], + "source": [ + "model.train_and_evaluate_model(\n", + " train_dataset=train_set,\n", + " val_dataset=val_set,\n", + " epochs=1,\n", + " model_directory=\"./\",\n", + " run_id=\"1\",\n", + " metrics=[\"f1_score\"]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run inference, then plot and save the results to disk." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "pycharm": { + "is_executing": true + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "running prediction: 100%|██████████| 32/32 [03:17<00:00, 6.17s/it]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "y_true, y_pred, y_prob = model.predict(dataset=val_set,)\n", + "NUM_IMAGES = 3\n", + "DISPLAYED = 0\n", + "# save and plot predictions for a sub-set of images (saves memory for the notebook)\n", + "for i, image_path in enumerate(val_set.data):\n", + " if DISPLAYED < NUM_IMAGES:\n", + " display_image_labels(\n", + " image_path[0],\n", + " y_true[i],\n", + " y_pred[i],\n", + " y_prob[i],\n", + " val_set.labels,\n", + " f\"/Users/spopov/{i}_plot.png\",\n", + " )\n", + " DISPLAYED += 1\n", + " else:\n", + " break" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} \ No newline at end of file diff --git a/examples/spacenet6.ipynb b/examples/spacenet6.ipynb new file mode 100644 index 0000000..9c8ab8d --- /dev/null +++ b/examples/spacenet6.ipynb @@ -0,0 +1,324 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "collapsed": true, + "pycharm": { + "is_executing": true + } + }, + "source": [ + "# Challenge: Spacenet6 - Multi-Sensor All-Weather Mapping" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook demonstrates the usage of the winning [solution](https://github.com/SpaceNetChallenge/SpaceNet_SAR_Buildings_Solutions/tree/master/1-zbigniewwojna) of the [Spacenet6 challenge](https://spacenet.ai/sn6-challenge/). \n", + "\n", + "The goal there was to automatically extract building footprints with computer vision and artificial intelligence (AI) algorithms using a combination of SAR and electro-optical imagery datasets. \n", + "\n", + "For that purpose the organisers have collected over 120 sq km of both high resolution synthetic aperture radar (SAR) data and electro optical (EO) imagery with ~48,000 building footprint labels of Rotterdam, The Netherlands.\n", + "\n", + "The winning solution of the challenge was implemented in `aitlas`. This notebook will demonstrate how to use it." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from aitlas.datasets import SpaceNet6Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a first step we need to download and prepare the data set. The instructions for downloading are available at the main [page](https://spacenet.ai/sn6-challenge/) of the challenge. Basically, you just need an AWS account with an access key and secret access key in your local configuration file. The data set is quite large (40 GB) and it takes a while to download. Once you do that, initialize a `SpaceNet6Dataset` object and call the `prepare` method to create training folds:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/spopov/Downloads/aitlas/venv/lib/python3.9/site-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ], + "source": [ + "### Parameters\n", + "\n", + "# base directory after unzipping the downloaded files from S3\n", + "ROOT_DIRECTORY = \"/Users/spopov/train/AOI_11_Rotterdam\"\n", + "\n", + "# directory for storing the ground-truth segmentation masks\n", + "SEGMENTATION_DIRECTORY = \"/Users/spopov/results/segmentation_masks\"\n", + "\n", + "# directory for storing information about the training / validation folds\n", + "FOLDS_DIR = \"/Users/spopov/results/folds\"\n", + "\n", + "# orientation file indicating the directions from which each SAR image is captured (0 North, 1 South).\n", + "ORIENTS = \"/Users/spopov/train/AOI_11_Rotterdam/SummaryData/SAR_orientations.txt\"\n", + "\n", + "# CSV of building footprint locations in pixel coordinates\n", + "ORIENTS_OUTPUT = \"/Users/spopov/train/AOI_11_Rotterdam/SummaryData/SAR_orientations.csv\"\n", + "\n", + "# directory for storing the predicted masks\n", + "PRED_FOLDER = \"/Users/spopov/results/pred{}\"\n", + "\n", + "# path to the CSV file containing the fold splits\n", + "FOLDS_PATH = \"/Users/spopov/results/folds/folds.csv\"\n", + "\n", + "# path to the CSV containing the predicted buildings\n", + "PRED_CSV = \"/Users/spopov/results/folds/pred_csv{}.csv\"\n", + "\n", + "# path to the CSV containing the ground-truth buildings\n", + "GT_CSV = \"/Users/spopov/results/folds/gt_fold{}.csv\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "raw_data_set = SpaceNet6Dataset({\n", + " \"root_directory\": ROOT_DIRECTORY,\n", + " \"segmentation_directory\": SEGMENTATION_DIRECTORY,\n", + " \"folds_dir\": FOLDS_DIR,\n", + " \"num_threads\": 12,\n", + " \"edge_width\": 3,\n", + " \"contact_width\": 9,\n", + " \"orients\": ORIENTS,\n", + " \"orients_output\": ORIENTS_OUTPUT\n", + "})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `prepare` method on the dataset object creates the segmentation masks and the training / validation folds. After this step we can actually ignore the `raw_data_set` object and create new `SpaceNet6DataSet` objects for training and validation." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "pycharm": { + "is_executing": true + } + }, + "outputs": [], + "source": [ + "# raw_data_set.prepare()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "pycharm": { + "is_executing": true + } + }, + "outputs": [], + "source": [ + "from aitlas.models import UNetEfficientNet" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In `aitlas` we have implemented the winning base model of the challenge. More information can be found in this [paper](https://proceedings.mlr.press/v97/tan19a/tan19a.pdf), in Table 2 under **Efficient Net B5**. Using this model requires installation of few packages that are not specified as requirements for `aitlas`, since they are unique to this use case. Refer to the source code of `aitlas.models.unet_efficientnet.py` for information." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "pycharm": { + "is_executing": true + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/spopov/Downloads/aitlas/venv/lib/python3.9/site-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ], + "source": [ + "model = UNetEfficientNet({\n", + " \"net\": \"b5\",\n", + " \"stride\": 32,\n", + " \"use_cuda\": True\n", + "})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Creating training and validation sets." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "training_data_set = SpaceNet6Dataset({\n", + " \"batch_size\": 4,\n", + " \"shuffle\": True,\n", + " \"num_workers\": 8,\n", + " \"transforms\": [\n", + " \"aitlas.transforms.SpaceNet6Transforms\"\n", + " ],\n", + " \"orients\": ORIENTS_OUTPUT,\n", + " \"pred_folder\": PRED_FOLDER,\n", + " \"folds_path\": FOLDS_PATH,\n", + " \"root_directory\": ROOT_DIRECTORY,\n", + " \"segmentation_directory\": SEGMENTATION_DIRECTORY,\n", + " \"edge_weight\": 0.25,\n", + " \"contact_weight\": 0.1\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "validation_data_set = SpaceNet6Dataset({\n", + " \"batch_size\": 1,\n", + " \"shuffle\": False,\n", + " \"num_workers\": 1,\n", + " \"orients\": ORIENTS_OUTPUT,\n", + " \"folds_path\": FOLDS_PATH,\n", + " \"root_directory\": ROOT_DIRECTORY,\n", + " \"start_val_epoch\": 0,\n", + " \"pred_csv\": PRED_CSV,\n", + " \"gt_csv\": GT_CSV\n", + "})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, we just call `train_and_evaluate_model`. This will train the model for the specified number of epochs, and after the `start_val_epoch` will evaluate its performance in terms of F1 score, where precision and recall would be calculated on a pixel level (precision is the number of pixels that are predicted and are actually buildings out of all predicted as buildings, and recall is the number of pixels that are predicted as buildings out of all pixels that are buildings). The predicted images will be stored in the `PRED_FOLDER` directory, and a CSV file of all buildings will be outputed at `PRED_CSV` in a format required by the SpaceNet6 challenge." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "16a21405c1e346b28685e18ad6b4ff25", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/694 [00:26