Upload 7 files

.gitattributes

@@ -90,3 +90,8 @@ SR_S2_BestModel/auxiliar_refsrx2.safetensor filter=lfs diff=lfs merge=lfs -text
 SR_S2_BestModel/auxiliar_sr.safetensor filter=lfs diff=lfs merge=lfs -text
 SR_S2_BestModel/example_data.safetensor filter=lfs diff=lfs merge=lfs -text
 SR_S2_BestModel/model.safetensor filter=lfs diff=lfs merge=lfs -text
+SR_S2_FastModel/auxiliar_refsrx2.jit filter=lfs diff=lfs merge=lfs -text
+SR_S2_FastModel/auxiliar_sr.jit filter=lfs diff=lfs merge=lfs -text
+SR_S2_FastModel/example_data.safetensor filter=lfs diff=lfs merge=lfs -text
+SR_S2_FastModel/model.jit filter=lfs diff=lfs merge=lfs -text
+SR_S2_FastModel/model.safetensor filter=lfs diff=lfs merge=lfs -text

SR_S2_FastModel/auxiliar_refsrx2.jit

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a700df91e9eba64d0039f4ccd476c47bbf81e6a3e9749c13236aa0ef2eaec62
+size 2532385

SR_S2_FastModel/auxiliar_sr.jit

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d357606c29caffbee3316afd2badf2a2b2c289dd23a050d9d346201faf5c7a01
+size 2561891

SR_S2_FastModel/example_data.safetensor

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7709dd46aabc069c2005f39ce830cb5659306a9c11221307557c56f6ed6cf65
+size 13631584

SR_S2_FastModel/load.py

@@ -0,0 +1,624 @@
+# I stole the code from here: https://github.com/hongyuanyu/SPAN
+# The author of the code deserves all the  credit. I just make
+# basic modifications to make it work with my codebase.
+
+
+from collections import OrderedDict
+from typing import List, Optional, Union
+
+import safetensors.numpy
+import torch
+import torch.nn.functional as F
+from torch import nn
+import safetensors.torch
+import pathlib
+
+
+def _make_pair(value: int) -> tuple:
+    """
+    Converts a single integer into a tuple of the same integer repeated twice.
+
+    Args:
+        value (int): Integer value to be converted.
+
+    Returns:
+        tuple: Tuple containing the integer repeated twice.
+    """
+    if isinstance(value, int):
+        value = (value,) * 2
+    return value
+
+
+def conv_layer(
+    in_channels: int, out_channels: int, kernel_size: int, bias: bool = True
+) -> nn.Conv2d:
+    """
+    Creates a 2D convolutional layer with adaptive padding.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        kernel_size (int): Size of the convolution kernel.
+        bias (bool, optional): Whether to include a bias term. Defaults to True.
+
+    Returns:
+        nn.Conv2d: 2D convolutional layer with calculated padding.
+    """
+    kernel_size = _make_pair(kernel_size)
+    padding = (int((kernel_size[0] - 1) / 2), int((kernel_size[1] - 1) / 2))
+    return nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding, bias=bias)
+
+
+def activation(
+    act_type: str, inplace: bool = True, neg_slope: float = 0.05, n_prelu: int = 1
+) -> nn.Module:
+    """
+    Returns an activation layer based on the specified type.
+
+    Args:
+        act_type (str): Type of activation ('relu', 'lrelu', 'prelu').
+        inplace (bool, optional): If True, performs the operation in-place. Defaults to True.
+        neg_slope (float, optional): Negative slope for 'lrelu' and 'prelu'. Defaults to 0.05.
+        n_prelu (int, optional): Number of parameters for 'prelu'. Defaults to 1.
+
+    Returns:
+        nn.Module: Activation layer.
+    """
+    act_type = act_type.lower()
+    if act_type == "relu":
+        layer = nn.ReLU(inplace)
+    elif act_type == "lrelu":
+        layer = nn.LeakyReLU(neg_slope, inplace)
+    elif act_type == "prelu":
+        layer = nn.PReLU(num_parameters=n_prelu, init=neg_slope)
+    else:
+        raise NotImplementedError(
+            "activation layer [{:s}] is not found".format(act_type)
+        )
+    return layer
+
+
+def sequential(*args) -> nn.Sequential:
+    """
+    Constructs a sequential container for the provided modules.
+
+    Args:
+        args: Modules in order of execution.
+
+    Returns:
+        nn.Sequential: A Sequential container.
+    """
+    if len(args) == 1:
+        if isinstance(args[0], OrderedDict):
+            raise NotImplementedError("sequential does not support OrderedDict input.")
+        return args[0]
+    modules = []
+    for module in args:
+        if isinstance(module, nn.Sequential):
+            for submodule in module.children():
+                modules.append(submodule)
+        elif isinstance(module, nn.Module):
+            modules.append(module)
+    return nn.Sequential(*modules)
+
+
+def pixelshuffle_block(
+    in_channels: int, out_channels: int, upscale_factor: int = 2, kernel_size: int = 3
+) -> nn.Sequential:
+    """
+    Creates an upsampling block using pixel shuffle.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        upscale_factor (int, optional): Factor by which to upscale. Defaults to 2.
+        kernel_size (int, optional): Size of the convolution kernel. Defaults to 3.
+
+    Returns:
+        nn.Sequential: Sequential block for upsampling.
+    """
+    conv = conv_layer(in_channels, out_channels * (upscale_factor**2), kernel_size)
+    pixel_shuffle = nn.PixelShuffle(upscale_factor)
+    return sequential(conv, pixel_shuffle)
+
+
+class Conv3XC(nn.Module):
+    def __init__(
+        self,
+        c_in: int,
+        c_out: int,
+        gain1: int = 1,
+        s: int = 1,
+        bias: bool = True,
+        relu: bool = False,
+        train_mode: bool = True,
+    ):
+        """
+        Custom 3-stage convolutional block with optional ReLU activation and train/evaluation mode support.
+
+        Args:
+            c_in (int): Number of input channels.
+            c_out (int): Number of output channels.
+            gain1 (int, optional): Gain multiplier for intermediate layers. Defaults to 1.
+            s (int, optional): Stride value for the convolutions. Defaults to 1.
+            bias (bool, optional): Whether to include a bias term in the convolutions. Defaults to True.
+            relu (bool, optional): If True, apply a LeakyReLU activation after the convolution. Defaults to False.
+            train_mode (bool, optional): If True, use training mode with learnable parameters. Defaults to True.
+        """
+        super(Conv3XC, self).__init__()
+        self.train_mode = train_mode
+        self.weight_concat = None
+        self.bias_concat = None
+        self.update_params_flag = False
+        self.stride = s
+        self.has_relu = relu
+        gain = gain1
+
+        self.sk = nn.Conv2d(
+            in_channels=c_in,
+            out_channels=c_out,
+            kernel_size=1,
+            padding=0,
+            stride=s,
+            bias=bias,
+        )
+        self.conv = nn.Sequential(
+            nn.Conv2d(
+                in_channels=c_in,
+                out_channels=c_in * gain,
+                kernel_size=1,
+                padding=0,
+                bias=bias,
+            ),
+            nn.Conv2d(
+                in_channels=c_in * gain,
+                out_channels=c_out * gain,
+                kernel_size=3,
+                stride=s,
+                padding=0,
+                bias=bias,
+            ),
+            nn.Conv2d(
+                in_channels=c_out * gain,
+                out_channels=c_out,
+                kernel_size=1,
+                padding=0,
+                bias=bias,
+            ),
+        )
+
+        self.eval_conv = nn.Conv2d(
+            in_channels=c_in,
+            out_channels=c_out,
+            kernel_size=3,
+            padding=1,
+            stride=s,
+            bias=bias,
+        )
+        self.eval_conv.weight.requires_grad = False
+        self.eval_conv.bias.requires_grad = False
+        if not self.train_mode:
+            self.update_params()
+
+    def update_params(self):
+        """
+        Updates the parameters for evaluation mode by combining weights from the convolution layers.
+        """
+        w1 = self.conv[0].weight.data.clone().detach()
+        b1 = self.conv[0].bias.data.clone().detach()
+        w2 = self.conv[1].weight.data.clone().detach()
+        b2 = self.conv[1].bias.data.clone().detach()
+        w3 = self.conv[2].weight.data.clone().detach()
+        b3 = self.conv[2].bias.data.clone().detach()
+
+        w = (
+            F.conv2d(w1.flip(2, 3).permute(1, 0, 2, 3), w2, padding=2, stride=1)
+            .flip(2, 3)
+            .permute(1, 0, 2, 3)
+        )
+        b = (w2 * b1.reshape(1, -1, 1, 1)).sum((1, 2, 3)) + b2
+
+        self.weight_concat = (
+            F.conv2d(w.flip(2, 3).permute(1, 0, 2, 3), w3, padding=0, stride=1)
+            .flip(2, 3)
+            .permute(1, 0, 2, 3)
+        )
+        self.bias_concat = (w3 * b.reshape(1, -1, 1, 1)).sum((1, 2, 3)) + b3
+
+        sk_w = self.sk.weight.data.clone().detach()
+        sk_b = self.sk.bias.data.clone().detach()
+        target_kernel_size = 3
+
+        H_pixels_to_pad = (target_kernel_size - 1) // 2
+        W_pixels_to_pad = (target_kernel_size - 1) // 2
+        sk_w = F.pad(
+            sk_w, [H_pixels_to_pad, H_pixels_to_pad, W_pixels_to_pad, W_pixels_to_pad]
+        )
+
+        self.weight_concat = self.weight_concat + sk_w
+        self.bias_concat = self.bias_concat + sk_b
+
+        self.eval_conv.weight.data = self.weight_concat
+        self.eval_conv.bias.data = self.bias_concat
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Forward pass of the convolution block.
+
+        Args:
+            x (torch.Tensor): Input tensor.
+
+        Returns:
+            torch.Tensor: Output tensor after convolution and optional activation.
+        """
+        if self.train_mode:
+            pad = 1
+            x_pad = F.pad(x, (pad, pad, pad, pad), "constant", 0)
+            out = self.conv(x_pad) + self.sk(x)
+        else:
+            self.update_params()
+            out = self.eval_conv(x)
+
+        if self.has_relu:
+            out = F.leaky_relu(out, negative_slope=0.05)
+        return out
+
+
+class SPAB(nn.Module):
+    def __init__(
+        self,
+        in_channels: int,
+        mid_channels: Optional[int] = None,
+        out_channels: Optional[int] = None,
+        train_mode: bool = True,
+        bias: bool = False,
+    ):
+        """
+        Self-parameterized attention block (SPAB) with multiple convolution layers.
+
+        Args:
+            in_channels (int): Number of input channels.
+            mid_channels (Optional[int], optional): Number of middle channels. Defaults to in_channels.
+            out_channels (Optional[int], optional): Number of output channels. Defaults to in_channels.
+            train_mode (bool, optional): Indicates if the block is in training mode. Defaults to True.
+            bias (bool, optional): Include bias in convolutions. Defaults to False.
+        """
+        super(SPAB, self).__init__()
+        if mid_channels is None:
+            mid_channels = in_channels
+        if out_channels is None:
+            out_channels = in_channels
+
+        self.in_channels = in_channels
+        self.c1_r = Conv3XC(
+            in_channels, mid_channels, gain1=2, s=1, train_mode=train_mode
+        )
+        self.c2_r = Conv3XC(
+            mid_channels, mid_channels, gain1=2, s=1, train_mode=train_mode
+        )
+        self.c3_r = Conv3XC(
+            mid_channels, out_channels, gain1=2, s=1, train_mode=train_mode
+        )
+        self.act1 = torch.nn.SiLU(inplace=True)
+        self.act2 = activation("lrelu", neg_slope=0.1, inplace=True)
+
+    def forward(self, x: torch.Tensor) -> tuple:
+        """
+        Forward pass of the SPAB block.
+
+        Args:
+            x (torch.Tensor): Input tensor.
+
+        Returns:
+            tuple: (Output tensor, intermediate tensor, attention map).
+        """
+        out1 = self.c1_r(x)
+        out1_act = self.act1(out1)
+
+        out2 = self.c2_r(out1_act)
+        out2_act = self.act1(out2)
+
+        out3 = self.c3_r(out2_act)
+
+        sim_att = torch.sigmoid(out3) - 0.5
+        out = (out3 + x) * sim_att
+
+        return out, out1, sim_att
+
+
+class CNNSR(nn.Module):
+    """
+    Swift Parameter-free Attention Network (SPAN) for efficient super-resolution
+    with deeper layers and channel attention.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        feature_channels: int = 48,
+        upscale: int = 4,
+        bias: bool = True,
+        train_mode: bool = True,
+        num_blocks: int = 10,
+        **kwargs,
+    ):
+        """
+        Initializes the CNNSR model.
+
+        Args:
+            in_channels (int): Number of input channels.
+            out_channels (int): Number of output channels.
+            feature_channels (int, optional): Number of feature channels. Defaults to 48.
+            upscale (int, optional): Upscaling factor. Defaults to 4.
+            bias (bool, optional): Whether to include a bias term. Defaults to True.
+            train_mode (bool, optional): If True, the model is in training mode. Defaults to True.
+            num_blocks (int, optional): Number of attention blocks in the network. Defaults to 10.
+        """
+        super(CNNSR, self).__init__()
+
+        # Initial Convolution
+        self.conv_1 = Conv3XC(
+            in_channels, feature_channels, gain1=2, s=1, train_mode=train_mode
+        )
+
+        # Deeper Blocks
+        self.blocks = nn.ModuleList(
+            [
+                SPAB(feature_channels, bias=bias, train_mode=train_mode)
+                for _ in range(num_blocks)
+            ]
+        )
+
+        # Convolution after attention blocks
+        self.conv_cat = conv_layer(
+            feature_channels * 4, feature_channels, kernel_size=1, bias=True
+        )
+        self.conv_2 = Conv3XC(
+            feature_channels, feature_channels, gain1=2, s=1, train_mode=train_mode
+        )
+
+        # Upsampling
+        self.upsampler = pixelshuffle_block(
+            feature_channels, out_channels, upscale_factor=upscale
+        )
+
+    def forward(
+        self, x: torch.Tensor, save_attentions: Optional[List[int]] = None
+    ) -> Union[torch.Tensor, tuple]:
+        """
+        Forward pass of the CNNSR model.
+
+        Args:
+            x (torch.Tensor): Input tensor.
+            save_attentions (Optional[List[int]], optional): List of block indices from which to save attention maps.
+
+        Returns:
+            torch.Tensor: Super-resolved output.
+            tuple: If save_attentions is specified, returns (output tensor, attention maps).
+        """
+        # Initial Convolution
+        out_feature = self.conv_1(x)
+
+        # Pass through all blocks, accumulating attention outputs
+        attentions = []
+        for index, block in enumerate(self.blocks):
+            out, out2, att = block(out_feature)
+
+            # Save the first residual block output
+            if index == 0:
+                out_b1 = out
+
+            # Save the last residual block output
+            if index == len(self.blocks) - 1:
+                out_blast = out2
+
+            # Save attention if needed
+            if save_attentions is not None and index in save_attentions:
+                attentions.append(att)
+
+        # Final Convolution and concatenation
+        out_bn = self.conv_2(out)
+        out = self.conv_cat(torch.cat([out_feature, out_bn, out_b1, out_blast], 1))
+
+        # Upsample
+        output = self.upsampler(out)
+
+        if save_attentions is not None:
+            return output, attentions
+        return output
+    
+
+def butterworth_filter(shape: tuple[int, int], cutoff: int, order: int) -> torch.Tensor:
+    """
+    Creates a Butterworth low-pass filter.
+
+    Args:
+        shape: (rows, cols) of the filter.
+        cutoff: Cutoff frequency.
+        order: Order of the Butterworth filter.
+
+    Returns:
+        torch.Tensor: Normalized Butterworth filter.
+    """
+    rows, cols = shape
+    crow, ccol = rows // 2, cols // 2
+    filter = torch.zeros((rows, cols), dtype=torch.float32)
+    for u in range(rows):
+        for v in range(cols):
+            distance = ((u - crow) ** 2 + (v - ccol) ** 2) ** 0.5
+            filter[u, v] = 1 / (1 + (distance / cutoff) ** (2 * order))
+    filter /= filter.sum()
+    return filter
+
+
+class CNNHardConstraint(nn.Module):
+    """
+    Applies a convolutional hard constraint using predefined filters for low-pass and high-pass filtering.
+
+    Args:
+        filter_method: The type of filter to apply ('ideal', 'butterworth', 'gaussian', 'sigmoid').
+        filter_hyperparameters: Dictionary containing hyperparameters specific to the chosen filter method.
+        scale_factor: Scaling factor used to determine kernel size and cutoff frequency.
+        in_channels: Number of input channels.
+        out_channels: List of channels to be processed (default is [0, 1, 2, 3, 4, 5]).
+    """
+
+    def __init__(
+        self,
+        scale_factor: int,
+        in_channels: int,
+        out_channels: list = [0, 1, 2, 3, 4, 5],
+    ):
+        super().__init__()
+
+        self.in_channels = in_channels
+
+        # Estimate the kernel according to the scale
+        kernel_size = scale_factor * 3 + 1
+        cutoff = scale_factor * 2
+
+        # Define the convolution layer with multiple input and output channels
+        self.conv = nn.Conv2d(
+            in_channels=in_channels,
+            out_channels=len(out_channels),
+            kernel_size=kernel_size,
+            padding=kernel_size // 2,
+            bias=False,
+            groups=in_channels,
+        )
+
+        # Remove the gradient for the filter weights
+        self.conv.weight.requires_grad = False
+
+        # Initialize the filter kernel based on the filter method
+        # hyperparameters["order"] = 6
+        weight_data = butterworth_filter((kernel_size, kernel_size), cutoff, 6)
+
+        # Apply the same filter to all input channels
+        self.conv.weight.data = (
+            weight_data.unsqueeze(0).unsqueeze(0).repeat(in_channels, 1, 1, 1)
+        )
+        self.out_channels = out_channels
+
+    def forward(self, lr: torch.Tensor, sr: torch.Tensor) -> torch.Tensor:
+        """
+        Applies the filter constraint on the super-resolution image.
+
+        Args:
+            lr: Low-resolution input tensor.
+            sr: Super-resolution output tensor.
+
+        Returns:
+            torch.Tensor: The resulting hybrid image after applying the constraint.
+        """
+        # Upsample the LR image to the size of SR
+        lr = lr[:, self.out_channels]
+
+        # Upsample the LR image to the size of SR
+        lr_up = F.interpolate(lr, size=sr.shape[-2:], mode="bicubic", antialias=True)
+
+        # Apply the convolutional filter to both LR and SR images
+        lr_filtered = self.conv(lr_up)
+        sr_filtered = self.conv(sr)
+
+        # Combine low-pass and high-pass components
+        hybrid_image = lr_filtered + (sr - sr_filtered)
+
+        return hybrid_image
+    
+
+class HardConstraintModel(torch.nn.Module):
+    def __init__(self, sr_model_rgbn, sr_model_rswir):
+        super().__init__()
+        params = {
+            "in_channels": 10,
+            "out_channels": 6,
+            "feature_channels": 24,
+            "upscale": 1,
+            "bias": True,
+            "train_mode": True,
+            "num_blocks": 6,
+        }        
+        self.sr_model = CNNSR(**params)
+        self.hard_constraint = CNNHardConstraint(2, 6, [0, 1, 2, 3, 4, 5])
+        
+        # Load the model and freeze the parameters
+        self.sr_model_rgbn = torch.jit.load(sr_model_rgbn)
+        self.sr_model_rgbn.eval()
+        for param in self.sr_model_rgbn.parameters():
+            param.requires_grad = False
+        
+        self.sr_model_rswir = torch.jit.load(sr_model_rswir)
+        self.sr_model_rswir.eval()
+        for param in self.sr_model_rswir.parameters():
+            param.requires_grad = False
+                
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # Band Selection
+        bands_20m = [3, 4, 5, 7, 8, 9]
+        bands_10m = [2, 1, 0, 6] # WARNING: The SR model needs RGBNIR bands? why? because i'm stupid
+
+        # Run Referece SR in the RSWIR bands (from 20m to 10m)
+        allbands10m = self.sr_model_rswir(x)
+
+        # Convert the SWIR bands to 2.5m
+        rsiwr_10m = allbands10m[:, bands_20m]        
+        rsiwr_2dot5m_billinear = torch.nn.functional.interpolate(
+            rsiwr_10m, scale_factor=4, mode="bilinear", antialias=True
+        )        
+
+        # Run SR in the RGBN bands (from 10m to 2.5m)
+        rgbn_2dot5m = self.sr_model_rgbn(x[:, bands_10m])
+        
+        # Reorder the bands from RGBNIR to BGRNIR
+        rgbn_2dot5m = rgbn_2dot5m[:, [2, 1, 0, 3]]
+        
+        # Run the fusion x4 model in the SWIR bands (10m to 2.5m)
+        input_data = torch.cat([rsiwr_2dot5m_billinear, rgbn_2dot5m], dim=1)                
+        rsiwr_2dot5m_sr = self.hard_constraint(rsiwr_2dot5m_billinear, self.sr_model(input_data))
+
+        # Order the channels back
+        results = torch.stack(
+            [
+                rgbn_2dot5m[:, 0],
+                rgbn_2dot5m[:, 1],
+                rgbn_2dot5m[:, 2],
+                rsiwr_2dot5m_sr[:, 0],
+                rsiwr_2dot5m_sr[:, 1],
+                rsiwr_2dot5m_sr[:, 2],
+                rgbn_2dot5m[:, 3],
+                rsiwr_2dot5m_sr[:, 3],
+                rsiwr_2dot5m_sr[:, 4],
+                rsiwr_2dot5m_sr[:, 5],
+            ],
+            dim=1,
+        )
+
+        return results
+
+
+# MLSTAC API -----------------------------------------------------------------------
+def example_data(path: pathlib.Path, *args, **kwargs):
+    data_file = path / "example_data.safetensor"
+    # Select only 10 meters and 20 meters bands
+    # B2, B3, B4, B5, B6, B7, B8, B8A, B11, B12
+    bands = [1, 2, 3, 4, 5, 6, 7, 8, 11, 12]
+    return safetensors.torch.load_file(data_file)["example_data"][bands, 128:384, 128:384][None]
+
+def trainable_model(path, *args, **kwargs):
+    # from 10m to 2.5m (RGBN)
+    sr_model_rgbn = path / "auxiliar_sr.jit"
+
+    # from 20m to 10m (RSWIR)
+    sr_model_rswir = path / "auxiliar_refsrx2.jit"
+
+    # Load model parameters from 10m to 2.5m (RSWIR)
+    weights = safetensors.torch.load_file(path / "model.safetensor")
+
+    # Load model 
+    srmodel = HardConstraintModel(sr_model_rgbn=sr_model_rgbn, sr_model_rswir=sr_model_rswir)
+    srmodel.sr_model.load_state_dict(weights)
+    
+    return srmodel

SR_S2_FastModel/mlm.json

@@ -0,0 +1,202 @@
+{
+    "type": "Feature",
+    "stac_version": "1.1.0",
+    "stac_extensions": [
+        "https://stac-extensions.github.io/mlm/v1.4.0/schema.json"
+    ],
+    "id": "SPAN model",
+    "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+            [
+                [
+                    -180.0,
+                    -90.0
+                ],
+                [
+                    -180.0,
+                    90.0
+                ],
+                [
+                    180.0,
+                    90.0
+                ],
+                [
+                    180.0,
+                    -90.0
+                ],
+                [
+                    -180.0,
+                    -90.0
+                ]
+            ]
+        ]
+    },
+    "bbox": [
+        -180,
+        -90,
+        180,
+        90
+    ],
+    "properties": {
+        "start_datetime": "1900-01-01T00:00:00Z",
+        "end_datetime": "9999-01-01T00:00:00Z",
+        "description": "A Swift Parameter-free Attention Network (SPAN). The model was trained using the CloudSEN12+ dataset.",
+        "forward_backward_pass": {
+            "32": 24.593536,
+            "64": 96.375936,
+            "128": 381.5968,
+            "256": 1518.662784,
+            "512": 6059.291776
+        },
+        "dependencies": [
+            "torch",
+            "safetensors.torch"
+        ],
+        "mlm:framework": "pytorch",
+        "mlm:framework_version": "2.1.2+cu121",
+        "file:size": 1861672,
+        "mlm:memory_size": 1,
+        "mlm:accelerator": "cuda",
+        "mlm:accelerator_constrained": false,
+        "mlm:accelerator_summary": "Unknown",
+        "mlm:name": "CNN_Light_F4",
+        "mlm:architecture": "SPAN",
+        "mlm:tasks": [
+            "super-resolution"
+        ],
+        "mlm:input": [
+            {
+                "name": "Sentinel-2 10m converted 2.5m and 20m bands converted to 10m",
+                "bands": [
+                    "B02",
+                    "B03",
+                    "B04",
+                    "B05",
+                    "B06",
+                    "B07",
+                    "B08",
+                    "B8A",
+                    "B11",
+                    "B12"
+                ],
+                "input": {
+                    "shape": [
+                        -1,
+                        10,
+                        128,
+                        128
+                    ],
+                    "dim_order": [
+                        "batch",
+                        "channel",
+                        "height",
+                        "width"
+                    ],
+                    "data_type": "float16"
+                },
+                "pre_processing_function": null
+            }
+        ],
+        "mlm:output": [
+            {
+                "name": "super-resolution",
+                "tasks": [
+                    "super-resolution"
+                ],
+                "result": {
+                    "shape": [
+                        -1,
+                        10,
+                        512,
+                        512
+                    ],
+                    "dim_order": [
+                        "batch",
+                        "channel",
+                        "height",
+                        "width"
+                    ],
+                    "data_type": "float16"
+                },
+                "classification:classes": [],
+                "post_processing_function": null
+            }
+        ],
+        "mlm:total_parameters": 465418,
+        "mlm:pretrained": true,
+        "datetime": null
+    },
+    "links": [],
+    "assets": {
+        "auxiliar_sr": {
+            "href": "https://huggingface.co/tacofoundation/mlstac/resolve/main/CNN_Light_F4/auxiliar_sr.jit",
+            "type": "application/octet-stream; application=safetensor",
+            "title": "Torchscript model",
+            "description": "A Swift Parameter-free Attention Network (SPAN). The model was trained using the CloudSEN12+ dataset.The model can convert RGBN bands from 10m to 2.5m resolution.",
+            "mlm:artifact_type": "torch.jit.save",
+            "roles": [
+                "mlm:model",
+                "mlm:weights",
+                "data"
+            ]
+        },
+        "auxiliar_refsrx2": {
+            "href": "https://huggingface.co/tacofoundation/mlstac/resolve/main/CNN_Light_F4/auxiliar_refsrx2.jit",
+            "type": "application/octet-stream; application=safetensor",
+            "title": "Torchscript model",
+            "description": "A Swift Parameter-free Attention Network (SPAN). The model was trained using the CloudSEN12+ dataset.The model can convert RSWIR bands from 20m to 10m resolution.",
+            "mlm:artifact_type": "torch.jit.save",
+            "roles": [
+                "mlm:model",
+                "mlm:weights",
+                "data"
+            ]
+        },
+        "trainable": {
+            "href": "https://huggingface.co/tacofoundation/mlstac/resolve/main/CNN_Light_F4/model.safetensor",
+            "type": "application/octet-stream; application=safetensor",
+            "title": "Pytorch weights checkpoint",
+            "description": "A Swift Parameter-free Attention Network (SPAN). The model was trained using the CloudSEN12+ dataset.",
+            "mlm:artifact_type": "safetensor.torch.save_file",
+            "roles": [
+                "mlm:model",
+                "mlm:weights",
+                "data"
+            ]
+        },
+        "compile": {
+            "href": "https://huggingface.co/tacofoundation/mlstac/resolve/main/CNN_Light_F4/model.jit",
+            "type": "application/octet-stream; application=pytorch",
+            "title": "Torchscript model",
+            "description": "A Swift Parameter-free Attention Network (SPAN). The model was trained using the CloudSEN12+ dataset.",
+            "mlm:artifact_type": "torch.jit.save",
+            "roles": [
+                "mlm:model",
+                "mlm:weights",
+                "data"
+            ]
+        },
+        "source_code": {
+            "href": "https://huggingface.co/tacofoundation/mlstac/resolve/main/CNN_Light_F4/load.py",
+            "type": "text/x-python",
+            "title": "Model load script",
+            "description": "Source code to run the model.",
+            "roles": [
+                "mlm:source_code",
+                "code"
+            ]
+        },
+        "example_data": {
+            "href": "https://huggingface.co/tacofoundation/mlstac/resolve/main/CNN_Light_F4/example_data.safetensor",
+            "type": "application/octet-stream; application=safetensors",
+            "title": "Example Sentinel-2 image",
+            "description": "Example Sentinel-2 image for model inference.",
+            "roles": [
+                "mlm:example_data",
+                "data"
+            ]
+        }
+    },
+    "collection": "ml-model"
+}

SR_S2_FastModel/model.jit

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3305cb8a07b1e2fdd4e05c25f4a2de883ba71f56f408510699e598c10cd86568
+size 7604602

SR_S2_FastModel/model.safetensor

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f45c99af1d08408cb622ba02d1aeadaab2ca964f08991feeb4fd7ffd5197f59d
+size 2285088