Upload 4 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+single/example_data.safetensor filter=lfs diff=lfs merge=lfs -text
+single/model.safetensor filter=lfs diff=lfs merge=lfs -text

single/example_data.safetensor

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

single/load.py

@@ -0,0 +1,114 @@
+import pathlib
+import safetensors.torch
+import segmentation_models_pytorch as smp
+import matplotlib.pyplot as plt
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class SegformerBranch(nn.Module):
+    def __init__(self, in_channels=4, classes=4):
+        super(SegformerBranch, self).__init__()
+        self.segformer = smp.Segformer(
+            encoder_name="mobilenet_v2",
+            encoder_weights=None,
+            in_channels=in_channels,
+            classes=classes,
+        )
+    
+    def forward(self, x):
+        return self.segformer(x)
+    
+
+class PixelWiseNet(nn.Module):
+    def __init__(self, in_channels=4, out_channels=4, base_channels=32):
+        super(PixelWiseNet, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels, base_channels, kernel_size=1, bias=False)
+        self.bn1   = nn.BatchNorm2d(base_channels)
+        self.conv2 = nn.Conv2d(base_channels, base_channels, kernel_size=1, bias=False)
+        self.bn2   = nn.BatchNorm2d(base_channels)
+        self.conv3 = nn.Conv2d(base_channels, out_channels, kernel_size=1, bias=False)
+    
+    def forward(self, x):
+        x = F.relu(self.bn1(self.conv1(x)))
+        x = F.relu(self.bn2(self.conv2(x)))
+        x = self.conv3(x)
+        return x
+
+class CombinedNet(nn.Module):
+    def __init__(self, in_channels=4, classes=4, base_channels=32, benchmark=False):
+        super(CombinedNet, self).__init__()
+        self.seg_branch = SegformerBranch(in_channels=in_channels, classes=classes)
+        self.pixel_branch = PixelWiseNet(in_channels=in_channels, out_channels=classes, base_channels=base_channels)
+        self.fusion_conv = nn.Conv2d(classes, classes, kernel_size=1, bias=False)
+        self.benchmark = benchmark
+    
+    def forward(self, x):
+        seg_out = self.seg_branch(x)
+        pixel_out = self.pixel_branch(x)
+        fused = seg_out + pixel_out
+        out = self.fusion_conv(fused)
+        if self.benchmark:
+            out = torch.sigmoid(out)
+        return out
+    
+
+
+# MLSTAC API -----------------------------------------------------------------------
+def example_data(path: pathlib.Path, *args, **kwargs):
+    data_f = path / "example_data.safetensor"    
+    sample = safetensors.torch.load_file(data_f)
+    return  sample["image"]
+
+def trainable_model(path, device: str = "cpu", *args, **kwargs):
+    trainable_f = path / "model.safetensor"
+
+    # Load model parameters
+    cloud_model_weights = safetensors.torch.load_file(trainable_f)
+    cloud_model = CombinedNet(classes=1)
+    cloud_model.load_state_dict(cloud_model_weights)
+    cloud_model = cloud_model.eval()    
+
+    return cloud_model
+
+
+def compiled_model(path, device: str = "cpu", *args, **kwargs):
+    trainable_f = path / "model.safetensor"
+
+    # Load model parameters
+    cloud_model_weights = safetensors.torch.load_file(trainable_f)
+    cloud_model = CombinedNet(classes=1, benchmark=True)
+    cloud_model.load_state_dict(cloud_model_weights)
+    cloud_model = cloud_model.eval()
+
+    # Move model to device
+    cloud_model = cloud_model.to(device)
+
+    # Desativate gradients
+    for param in cloud_model.parameters():
+        param.requires_grad = False
+
+    return cloud_model
+
+def display_results(path: pathlib.Path, device: str = "cpu", *args, **kwargs):
+    # Load model
+    model = compiled_model(path, device, benchmark=True)
+
+    # Load data
+    probav = example_data(path)
+
+    # Run model
+    cloudprobs = model(probav.float().unsqueeze(0).to(device)).squeeze(0).cpu()
+
+    #Display results
+    fig, ax = plt.subplots(1, 2, figsize=(8, 4))
+    ax[0].imshow(probav[[2, 1, 0]].cpu().detach().numpy().transpose(1, 2, 0))
+    ax[0].set_title("Input")
+    ax[1].imshow(cloudprobs[0].cpu().detach().numpy(), cmap="gray")
+    ax[1].set_title("Output")    
+    for a in ax:
+        a.axis("off")
+    fig.tight_layout()    
+    return fig

single/mlm.json

@@ -0,0 +1,154 @@
+{
+    "type": "Feature",
+    "stac_version": "1.1.0",
+    "stac_extensions": [
+        "https://stac-extensions.github.io/mlm/v1.4.0/schema.json"
+    ],
+    "id": "SegFormerPlusMLP",
+    "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 two branch model for cloud detection in PROBA and SPOTVGT images. The first branch is a SegFormer model for semantic segmentation, and the second branch is a MLP model. The model is trained on PROBA-V and SPOTVGT images.",
+        "dependencies": [
+            "torch",
+            "safetensors.torch",
+            "semantic-segmentation-models-pytorch"
+        ],
+        "mlm:framework": "pytorch",
+        "mlm:framework_version": "2.1.2+cu121",
+        "file:size": 40455416,
+        "mlm:memory_size": 1,
+        "mlm:accelerator": "cuda",
+        "mlm:accelerator_constrained": false,
+        "mlm:accelerator_summary": "Unknown",
+        "mlm:name": "SegFormerPlusMLP",
+        "mlm:architecture": "SegFormer and MLP",
+        "mlm:tasks": [
+            "cloud detection"
+        ],
+        "mlm:input": [
+            {
+                "name": "ProbaVGT and SPOTVGT images",
+                "bands": [
+                    "Blue[B0]",
+                    "Red[B1]",
+                    "Near-Infrared[B3]",
+                    "SWIR[MIR]"
+                ],
+                "input": {
+                    "shape": [
+                        -1,
+                        4,
+                        128,
+                        128
+                    ],
+                    "dim_order": [
+                        "batch",
+                        "channel",
+                        "height",
+                        "width"
+                    ],
+                    "data_type": "float32"
+                },
+                "pre_processing_function": null
+            }
+        ],
+        "mlm:output": [
+            {
+                "name": "cloud mask",
+                "tasks": [
+                    "cloud detection"
+                ],
+                "result": {
+                    "shape": [
+                        -1,
+                        1,
+                        128,
+                        128
+                    ],
+                    "dim_order": [
+                        "batch",
+                        "channel",
+                        "height",
+                        "width"
+                    ],
+                    "data_type": "uint8"
+                },
+                "classification:classes": [],
+                "post_processing_function": null
+            }
+        ],
+        "mlm:total_parameters": 12894526,
+        "mlm:pretrained": true,
+        "datetime": null
+    },
+    "links": [],
+    "assets": {
+        "model": {
+            "href": "https://huggingface.co/tacofoundation/PROBAandSPOT/resolve/main/single/model.safetensor",
+            "type": "application/octet-stream; application=safetensor",
+            "title": "Pytorch model weights checkpoint",
+            "description": "The weights of the model in safetensor format.",
+            "mlm:artifact_type": "safetensor.torch.save_file",
+            "roles": [
+                "mlm:model",
+                "mlm:weights",
+                "data"
+            ]
+        },
+        "source_code": {
+            "href": "https://huggingface.co/tacofoundation/PROBAandSPOT/resolve/main/single/load.py",
+            "type": "text/x-python",
+            "title": "Model load script",
+            "description": "Python script to load the model.",
+            "roles": [
+                "mlm:source_code",
+                "code"
+            ]
+        },
+        "example_data": {
+            "href": "https://huggingface.co/tacofoundation/PROBAandSPOT/resolve/main/single/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": "SegFormerPlusMLP"
+}

single/model.safetensor

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