eoml 0.9.0__py3-none-any.whl

eoml/torch/resnet.py

@@ -0,0 +1,437 @@
+"""ResNet architecture implementations for PyTorch.
+
+This module provides ResNet (Residual Network) implementations adapted from
+https://colab.research.google.com/github/seyrankhademi/ResNet_CIFAR10/blob/master/CIFAR10_ResNet.ipynb
+
+Includes ResNet variants (ResNet-20, ResNet-32, ResNet-56) and a year-aware variant
+that incorporates temporal information as an additional input feature.
+"""
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from eoml.torch.cnn.torch_utils import conv_out_sizes
+from torch import nn
+from torch.nn import init
+
+
+# taken from https://colab.research.google.com/github/seyrankhademi/ResNet_CIFAR10/blob/master/CIFAR10_ResNet.ipynb#scrollTo=V9Y2hYRwB-qg
+
+# We define all the classes and function regarding the ResNet architecture in this code cell
+#__all__ = ['resnet20']
+#'ResNet','resnet32', 'resnet44', 'resnet56', 'resnet110', 'resnet1202'
+
+
+def _weights_init(m):
+    """Initialize CNN weights using Kaiming normal initialization.
+
+    Applies to Linear and Conv2d layers.
+
+    Args:
+        m: PyTorch module/layer to initialize.
+    """
+    classname = m.__class__.__name__
+    if isinstance(m, nn.Linear) or isinstance(m, nn.Conv2d):
+        init.kaiming_normal_(m.weight)
+
+
+class LambdaLayer(nn.Module):
+    """Lambda layer for identity mapping between ResNet blocks with different feature map sizes.
+
+    Used for handling dimension changes in skip connections when feature map sizes differ.
+
+    Attributes:
+        lambd: Lambda function to apply to input.
+    """
+
+    def __init__(self, lambd):
+        """Initialize LambdaLayer.
+
+        Args:
+            lambd: Lambda function for transforming input.
+        """
+        super().__init__()
+        self.lambd = lambd
+
+    def forward(self, x):
+        """Forward pass applying the lambda function.
+
+        Args:
+            x (torch.Tensor): Input tensor.
+
+        Returns:
+            torch.Tensor: Transformed tensor.
+        """
+        return self.lambd(x)
+
+
+# A basic block as shown in Fig.3 (right) in the paper consists of two convolutional blocks, each followed by a Bach-Norm layer.
+# Every basic block is shortcuted in ResNet architecture to construct f(x)+x module.
+# Expansion for option 'A' in the paper is equal to identity with extra zero entries padded
+# for increasing dimensions between layers with different feature map size. This option introduces no extra parameter.
+class BasicBlock(nn.Module):
+    """Basic residual block for ResNet architecture.
+
+    Consists of two convolutional layers with batch normalization and a shortcut connection.
+    Implements the f(x) + x residual mapping.
+
+    Attributes:
+        expansion (int): Expansion factor for output channels (always 1 for BasicBlock).
+        conv1 (nn.Conv2d): First convolutional layer.
+        bn1 (nn.BatchNorm2d): Batch normalization after first conv.
+        conv2 (nn.Conv2d): Second convolutional layer.
+        bn2 (nn.BatchNorm2d): Batch normalization after second conv.
+        shortcut (nn.Sequential): Shortcut connection for identity mapping.
+    """
+    # the output of a block keep the same size
+    expansion = 1
+
+    def __init__(self, in_planes, planes, stride=1, option='A'):
+        """Initialize BasicBlock.
+
+        Args:
+            in_planes (int): Number of input channels.
+            planes (int): Number of output channels.
+            stride (int, optional): Stride for first convolution. Defaults to 1.
+            option (str, optional): Shortcut option - 'A' for padding (CIFAR10) or 'B' for
+                projection. Defaults to 'A'.
+        """
+        super().__init__()
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != planes:
+            if option == 'A':
+                """
+                For CIFAR10 experiment, ResNet paper uses option A.
+                """
+                ## we colapase the side by the strid of 2
+                ##then then we take the output size (2 time input(B) in initial conf) =>initial +padding = B+(2B/4)*2=2B/
+                self.shortcut = LambdaLayer(lambda x:
+                                            F.pad(x[:, :, ::2, ::2], (0, 0, 0, 0, planes // 4, planes // 4), "constant",
+                                                  0))
+            elif option == 'B':
+                self.shortcut = nn.Sequential(
+                    nn.Conv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False),
+                    nn.BatchNorm2d(self.expansion * planes)
+                )
+
+    def forward(self, x):
+        """Forward pass through the basic block.
+
+        Args:
+            x (torch.Tensor): Input tensor.
+
+        Returns:
+            torch.Tensor: Output tensor after residual connection and activation.
+        """
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+
+# Stack of 3 times 2*n (n is the number of basic blocks) layers are used for making the ResNet model,
+# where each 2n layers have feature maps of size {16,32,64}, respectively.
+# The subsampling is performed by convolutions with a stride of 2.
+class ResNet(nn.Module):
+    """ResNet architecture for image classification.
+
+    Implements ResNet with 3 stages of residual blocks. The number of blocks in each stage
+    determines the depth (e.g., ResNet-20, ResNet-32, ResNet-56).
+
+    Attributes:
+        in_planes (int): Current number of input planes, updated as layers are built.
+        conv1 (nn.Conv2d): Initial convolutional layer.
+        bn1 (nn.BatchNorm2d): Batch normalization after initial conv.
+        layer1 (nn.Sequential): First stage of residual blocks.
+        layer2 (nn.Sequential): Second stage of residual blocks.
+        layer3 (nn.Sequential): Third stage of residual blocks.
+        linear (nn.Linear): Final fully connected layer for classification.
+    """
+    # TODO check size before dense and size
+   #(in_size, n_bands, n_out, BasicBlock, [3, 3, 3])
+    def __init__(self, size, in_band, n_out, block, num_blocks):
+        """Initialize ResNet model.
+
+        Args:
+            size (int): Input image size (not currently used in implementation).
+            in_band (int): Number of input channels/bands.
+            n_out (int): Number of output classes.
+            block: Block class to use (typically BasicBlock).
+            num_blocks (list): List of integers specifying number of blocks in each stage.
+        """
+
+        super().__init__()
+        # in plane is updated as we _make_layer (multiplied by block expansion)
+        #self.in_planes = 16
+        self.in_planes = 2*32
+        # go from in band to in_planes == input of first block
+        self.conv1 = nn.Conv2d(in_band, self.in_planes, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(self.in_planes)
+        # 3 layer of n block of 2 conv N layer = 3*n*2=6n +1 input conv +1 output dense=6n+2 layer
+        self.layer1 = self._make_layer(block, self.in_planes, num_blocks[0], stride=1)
+        self.layer2 = self._make_layer(block, 2*64, num_blocks[1], stride=2)
+        self.layer3 = self._make_layer(block, 2*128, num_blocks[2], stride=2)
+        self.linear = nn.Linear(2*128, n_out)
+        self.apply(_weights_init)
+
+
+    def _make_layer(self, block, planes, num_blocks, stride):
+        """Create a stage of residual blocks.
+
+        Args:
+            block: Block class to instantiate.
+            planes (int): Number of output channels for blocks in this stage.
+            num_blocks (int): Number of blocks in this stage.
+            stride (int): Stride for first block (subsequent blocks use stride=1).
+
+        Returns:
+            nn.Sequential: Sequential container of residual blocks.
+        """
+        strides = [stride] + [1] * (num_blocks - 1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.in_planes, planes, stride))
+            self.in_planes = planes * block.expansion  # new in plane = plane * expansion factor(1 in this case)
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        """Forward pass through ResNet.
+
+        Args:
+            x (torch.Tensor): Input tensor of shape (batch_size, in_band, height, width).
+
+        Returns:
+            torch.Tensor: Output logits of shape (batch_size, n_out).
+        """
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.layer1(out)
+        out = self.layer2(out)
+        out = self.layer3(out)
+        # todo check this one collapse 1X1Xnband fixme
+        # colaps to nband
+        out = F.avg_pool2d(out, (out.size(2), out.size(3)))
+        ## colapse to batch time all element size
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
+
+
+def resnet20(in_size, n_bands, n_out):
+    """Create ResNet-20 model (20 layers: 6*3 + 2).
+
+    Args:
+        in_size (int): Input image size.
+        n_bands (int): Number of input channels.
+        n_out (int): Number of output classes.
+
+    Returns:
+        ResNet: ResNet-20 model.
+    """
+    return ResNet(in_size, n_bands, n_out, BasicBlock, [3, 3, 3])
+
+
+def resnet32(in_size, n_bands, n_out):
+    """Create ResNet-32 model (32 layers: 6*5 + 2).
+
+    Args:
+        in_size (int): Input image size.
+        n_bands (int): Number of input channels.
+        n_out (int): Number of output classes.
+
+    Returns:
+        ResNet: ResNet-32 model.
+    """
+    return ResNet(in_size, n_bands, n_out, BasicBlock, [5, 5, 5])
+
+def resnet44():
+    """Create ResNet-44 model (44 layers: 6*7 + 2).
+
+    Note: This function has incomplete signature and may not work correctly.
+
+    Returns:
+        ResNet: ResNet-44 model.
+    """
+    return ResNet(BasicBlock, BasicBlock, [7, 7, 7])
+
+
+def resnet56(in_size, n_bands, n_out):
+    """Create ResNet-56 model (56 layers: 6*9 + 2).
+
+    Args:
+        in_size (int): Input image size.
+        n_bands (int): Number of input channels.
+        n_out (int): Number of output classes.
+
+    Returns:
+        ResNet: ResNet-56 model.
+    """
+    return ResNet(in_size, n_bands, n_out, BasicBlock, [9, 9, 9])
+
+
+#def resnet110():
+#    return ResNet(BasicBlock, [18, 18, 18])
+
+
+#def resnet1202():
+#    return ResNet(BasicBlock, [200, 200, 200])
+
+
+#def test(net):
+#    total_params = 0
+#
+#    for x in filter(lambda p: p.requires_grad, net.parameters()):
+#        total_params += np.prod(x.data.numpy().shape)
+#    print("Total number of params", total_params)
+#    print("Total layers", len(list(filter(lambda p: p.requires_grad and len(p.data.size()) > 1, net.parameters()))))
+
+
+#if __name__ == "__main__":
+#    for net_name in __all__:
+#        if net_name.startswith('resnet'):
+#            print(net_name)
+#            test(globals()[net_name]())
+#            print()
+
+
+class ResNetYear(nn.Module):
+    """ResNet architecture with year as additional input feature.
+
+    Similar to ResNet but accepts a year value as additional input, which is concatenated
+    with the conv features before the final linear layer. Useful for temporal classification tasks.
+
+    Attributes:
+        in_planes (int): Current number of input planes, updated as layers are built.
+        conv1 (nn.Conv2d): Initial convolutional layer.
+        bn1 (nn.BatchNorm2d): Batch normalization after initial conv.
+        layer1 (nn.Sequential): First stage of residual blocks.
+        layer2 (nn.Sequential): Second stage of residual blocks.
+        layer3 (nn.Sequential): Third stage of residual blocks.
+        linear (nn.Linear): Final fully connected layer (takes 2*128+1 inputs for year feature).
+    """
+    # TODO check size before dense and size
+   #(in_size, n_bands, n_out, BasicBlock, [3, 3, 3])
+    def __init__(self, size, in_band, n_out, block, num_blocks):
+        """Initialize ResNetYear model.
+
+        Args:
+            size (int): Input image size (not currently used in implementation).
+            in_band (int): Number of input channels/bands.
+            n_out (int): Number of output classes.
+            block: Block class to use (typically BasicBlock).
+            num_blocks (list): List of integers specifying number of blocks in each stage.
+        """
+
+        super().__init__()
+        # in plane is updated as we _make_layer (multiplied by block expansion)
+        #self.in_planes = 16
+        self.in_planes = 2*32
+        # go from in band to in_planes == input of first block
+        self.conv1 = nn.Conv2d(in_band, self.in_planes, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(self.in_planes)
+        # 3 layer of n block of 2 conv N layer = 3*n*2=6n +1 input conv +1 output dense=6n+2 layer
+        self.layer1 = self._make_layer(block, self.in_planes, num_blocks[0], stride=1)
+        self.layer2 = self._make_layer(block, 2*64, num_blocks[1], stride=2)
+        self.layer3 = self._make_layer(block, 2*128, num_blocks[2], stride=2)
+        self.linear = nn.Linear(2*128+1, n_out)
+        self.apply(_weights_init)
+
+
+    def _make_layer(self, block, planes, num_blocks, stride):
+        """Create a stage of residual blocks.
+
+        Args:
+            block: Block class to instantiate.
+            planes (int): Number of output channels for blocks in this stage.
+            num_blocks (int): Number of blocks in this stage.
+            stride (int): Stride for first block (subsequent blocks use stride=1).
+
+        Returns:
+            nn.Sequential: Sequential container of residual blocks.
+        """
+        strides = [stride] + [1] * (num_blocks - 1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.in_planes, planes, stride))
+            self.in_planes = planes * block.expansion  # new in plane = plane * expansion factor(1 in this case)
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x, year):
+        """Forward pass through ResNetYear with year input.
+
+        Args:
+            x (torch.Tensor): Input tensor of shape (batch_size, in_band, height, width).
+            year (torch.Tensor): Year tensor of shape (batch_size, 1) representing temporal information.
+
+        Returns:
+            torch.Tensor: Output logits of shape (batch_size, n_out).
+        """
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.layer1(out)
+        out = self.layer2(out)
+        out = self.layer3(out)
+        # todo check this one collapse 1X1Xnband fixme
+        # colaps to nband
+        out = F.avg_pool2d(out, (out.size(2), out.size(3)))
+        ## colapse to batch time all element size
+        out = out.view(out.size(0), -1)
+        out = torch.cat((out, year), dim=1)
+        out = self.linear(out)
+        return out
+
+def resnet_year_20(in_size, n_bands, n_out):
+    """Create ResNetYear-20 model with year input.
+
+    Args:
+        in_size (int): Input image size.
+        n_bands (int): Number of input channels.
+        n_out (int): Number of output classes.
+
+    Returns:
+        ResNetYear: ResNetYear-20 model.
+    """
+    return ResNetYear(in_size, n_bands, n_out, BasicBlock, [3, 3, 3])
+
+
+def resnet_year_32(in_size, n_bands, n_out):
+    """Create ResNetYear-32 model with year input.
+
+    Args:
+        in_size (int): Input image size.
+        n_bands (int): Number of input channels.
+        n_out (int): Number of output classes.
+
+    Returns:
+        ResNetYear: ResNetYear-32 model.
+    """
+    return ResNetYear(in_size, n_bands, n_out, BasicBlock, [5, 5, 5])
+
+def resnet_year_44():
+    """Create ResNetYear-44 model with year input.
+
+    Note: This function has incomplete signature and may not work correctly.
+
+    Returns:
+        ResNetYear: ResNetYear-44 model.
+    """
+    return ResNetYear(BasicBlock, [7, 7, 7])
+
+
+def resnet_year_56(in_size, n_bands, n_out):
+    """Create ResNetYear-56 model with year input.
+
+    Args:
+        in_size (int): Input image size.
+        n_bands (int): Number of input channels.
+        n_out (int): Number of output classes.
+
+    Returns:
+        ResNetYear: ResNetYear-56 model.
+    """
+    return ResNetYear(in_size, n_bands, n_out, BasicBlock, [9, 9, 9])

eoml/torch/sample_statistic.py

@@ -0,0 +1,260 @@
+"""Classification statistics and evaluation utilities for PyTorch models.
+
+This module provides classes for computing classification metrics and exporting
+misclassified samples to geospatial formats for analysis.
+"""
+
+import logging
+import math
+import os
+from collections import OrderedDict
+from typing import Optional, Literal, List
+
+import fiona
+import numpy as np
+import torch
+from fiona.crs import from_epsg
+from shapely.geometry import mapping
+from torch.utils.data import DataLoader
+from torchmetrics import F1Score, Accuracy, Recall, Precision
+from torchmetrics.classification import MulticlassConfusionMatrix
+from tqdm import tqdm
+
+logger = logging.getLogger(__name__)
+
+
+class ClassificationStats:
+    """Compute and display classification metrics for multi-class problems.
+
+    Calculates F1, accuracy, precision, recall, and confusion matrix using torchmetrics.
+    Supports multiple averaging modes (micro, macro, weighted, none).
+
+    Attributes:
+        f1_type (List): List of averaging modes for F1 score.
+        accuracy_type (List): List of averaging modes for accuracy.
+        precision_type (List): List of averaging modes for precision.
+        recall_type (List): List of averaging modes for recall.
+        f1_f (dict): Dictionary of F1Score metric objects.
+        confusion_f (MulticlassConfusionMatrix): Confusion matrix metric.
+        accuracy_f (dict): Dictionary of Accuracy metric objects.
+        recall_f (dict): Dictionary of Recall metric objects.
+        precision_f (dict): Dictionary of Precision metric objects.
+        computed (bool): Flag indicating if metrics have been computed.
+        num_class (int): Number of classes.
+        category_name (list, optional): Names of categories for display.
+    """
+
+
+
+    def __init__(self, num_class, device, category_name=None):
+        """Initialize ClassificationStats.
+
+        Args:
+            num_class (int): Number of classes in the classification problem.
+            device (str): Device to run computations on ('cpu' or 'cuda').
+            category_name (list, optional): List of category names for display. Defaults to None.
+        """
+        #, "micro", "macro", "weighted"
+        self.f1_type : List[Optional[Literal["micro", "macro", "weighted", "none"]]]= ["none", "micro"]
+        self.accuracy_type: List[Optional[Literal["micro", "macro", "weighted", "none"]]] = ["micro"]
+        self.precision_type: List[Optional[Literal["micro", "macro", "weighted", "none"]]] = ["none"]
+        self.recall_type: List[Optional[Literal["micro", "macro", "weighted", "none"]]] = ["none"]
+
+        self.f1_f = {t: F1Score(task="multiclass", average=t, num_classes=num_class).to(device) for t in self.f1_type}
+        self.confusion_f = MulticlassConfusionMatrix(num_classes=num_class).to(device)
+
+        self.accuracy_f = {t: Accuracy(task="multiclass", average=t, num_classes=num_class).to(device) for t in self.accuracy_type}
+        self.recall_f = {t: Recall(task="multiclass", average=t, num_classes=num_class) .to(device)for t in self.recall_type}
+        self.precision_f = {t: Precision(task="multiclass", average=t, num_classes=num_class).to(device) for t in self.precision_type}
+
+        self.computed = False
+
+        self.num_class = num_class
+
+        self.category_name = category_name
+
+    def compute(self, model, dataloader: DataLoader, device="cpu"):
+        """Compute classification metrics on a dataset.
+
+        Runs model inference on dataloader and accumulates metrics. Resets all metrics
+        before computation.
+
+        Args:
+            model (torch.nn.Module): Model to evaluate.
+            dataloader (DataLoader): DataLoader providing (inputs, labels, meta) batches.
+            device (str, optional): Device to run on. Defaults to "cpu".
+        """
+        model = model.to(device)
+        model.eval()
+
+        [self.f1_f[t].reset() for t in self.f1_type]
+        self.confusion_f.reset()
+        [self.accuracy_f[t].reset() for t in self.accuracy_type]
+        [self.precision_f[t].reset() for t in self.precision_type]
+        [self.recall_f[t].reset() for t in self.recall_type]
+
+        with torch.inference_mode():
+            with tqdm(total=len(dataloader), desc="Batch") as pbar:
+                for i, data in enumerate(dataloader):
+                    # Every data instance is an input + label pair
+                    inputs, labels, meta = data
+
+                    if device is not None:
+                        if isinstance(inputs, (list, tuple)):
+                            inputs = tuple(map(lambda x: x.to(device), inputs))  # trace need tuple for input
+                        else:
+                            inputs = inputs.to(device)
+
+                        labels = labels.to(device, non_blocking=True)
+
+                    output = model(*inputs)
+
+                    [self.f1_f[t](output, labels) for t in self.f1_type]
+                    self.confusion_f(output, labels)
+                    [self.accuracy_f[t](output, labels) for t in self.accuracy_type]
+                    [self.precision_f[t](output, labels) for t in self.precision_type]
+                    [self.recall_f[t](output, labels).detach() for t in self.recall_type]
+
+
+        self.computed = True
+
+    def display(self):
+        """Display computed metrics to console.
+
+        Prints category names (if provided), F1 scores, accuracy, precision, recall,
+        and confusion matrix.
+        """
+        if self.category_name is not None:
+            for i, name in enumerate(self.category_name):
+                logger.info(f'{i}: {name}')
+
+        for t, val in self.f1_f.items():
+            logger.info(f'f1 {t}: {val.compute().detach().cpu().numpy()}')
+
+        for t, val in self.accuracy_f.items():
+            logger.info(f'accuracy {t}: {val.compute().detach().cpu().numpy()}')
+
+        for t, val in self.precision_f.items():
+            logger.info(f'precision {t}: {val.compute().detach().cpu().numpy()}')
+
+        for t, val in self.recall_f.items():
+            logger.info(f'recall {t}: {val.compute().detach().cpu().numpy()}')
+
+        logger.info(f'Confusion matrix:\n{self.confusion_f.compute()}')
+
+    def to_file(self, path):
+        """Write computed metrics to a file.
+
+        Args:
+            path (str): Output file path.
+        """
+        with open(path, 'w') as f:
+
+            if self.category_name is not None:
+                for i, name in enumerate(self.category_name):
+                    f.write(f'{i}: {name}\n')
+
+            for t, val in self.f1_f.items():
+                f.write(f'f1 {t}: {val.compute().detach().cpu().numpy()}\n')
+
+            for t, val in self.accuracy_f.items():
+                f.write(f'accuracy {t}: {val.compute().detach().cpu().numpy()}\n')
+
+            for t, val in self.precision_f.items():
+                f.write(f'precision {t}: {val.compute().detach().cpu().numpy()}\n')
+
+            for t, val in self.recall_f.items():
+                f.write(f'recall {t}: {val.compute().detach().cpu().numpy()}\n')
+
+            confusion = self.confusion_f.compute().detach().cpu().numpy()
+            n_digit = math.ceil(math.log10(confusion.max())) + 1
+            np.savetxt(f, confusion, fmt=f'%{n_digit}.0d', delimiter=' ', newline=os.linesep)
+
+
+
+
+class BadlyClassifyToGPKG:
+    """Export misclassified samples to GeoPackage format for spatial analysis.
+
+    Identifies samples where model predictions don't match reference labels and exports
+    them as point geometries with prediction and reference label attributes.
+
+    Attributes:
+        results (list): List of misclassified sample records with geometry and properties.
+    """
+
+    def __init__(self):
+        """Initialize BadlyClassifyToGPKG with empty results list."""
+        self.results = []
+
+    def compute(self, model, dataloader: DataLoader, device="cpu"):
+        """Identify misclassified samples from model predictions.
+
+        Runs inference on dataloader and stores records for samples where prediction
+        differs from reference label.
+
+        Args:
+            model (torch.nn.Module): Model to evaluate.
+            dataloader (DataLoader): DataLoader providing (inputs, labels, meta) batches.
+                Meta must contain geometry information.
+            device (str, optional): Device to run on. Defaults to "cpu".
+        """
+
+        self.results = []
+
+        model = model.to(device)
+        model.eval()
+
+        with torch.inference_mode():
+            with tqdm(total=len(dataloader), desc="Batch") as pbar:
+                for i, data in enumerate(dataloader):
+                    # Every data instance is an input + label pair
+                    inputs, labels, meta = data
+
+                    if device is not None:
+                        if isinstance(inputs, (list, tuple)):
+                            inputs = tuple(map(lambda x: x.to(device), inputs))  # trace need tuple for input
+                        else:
+                            inputs = inputs.to(device)
+
+                        labels = labels.to(device, non_blocking=True)
+
+                    output = model(*inputs)
+
+                    output = torch.argmax(output, dim=1)
+                    output = output.detach().cpu().numpy()
+                    labels = labels.detach().cpu().numpy()
+
+                    for o,l, m in zip(output, labels, meta):
+                        if o != l:
+                            rec ={'geometry': mapping(m.geometry),
+                                  'properties': OrderedDict([
+                                    ('Ref_label', int(l)),
+                                    ('Pred_label', int(o)),
+                                ])
+                            }
+                            self.results.append(rec)
+
+
+    def to_file(self, path, crs="4326"):
+        """Write misclassified samples to GeoPackage file.
+
+        Args:
+            path (str): Output GeoPackage file path.
+            crs (str, optional): EPSG code for coordinate reference system. Defaults to "4326".
+        """
+        #('Class', 'float:16')
+
+        schema= {'geometry': 'Point',
+                 'properties': OrderedDict([('Ref_label', 'int'),
+                                           ('Pred_label', 'int')])
+                 }
+        crs = from_epsg(crs)
+
+        with fiona.open(path, 'w',
+                        driver='GPKG',
+                        schema=schema,
+                        crs=crs) as src:
+
+            for record in self.results:
+                src.write(record)