Marida Marine Debris Archive

Sto provando ad utilizzare Marida, un archivio di immagini supervisionate di Sentinel 2, raccolte in area non mediterranea con 15 categorie

Le immagini del dataset si possono scaricare da questo link (1.13 Gb) e l'articolo di riferimento e' https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0262247

Il dataset e' costituito da patches (immagini geotiff con risoluzione spaziale di 10 m, dimensioni di 2560x2560 m, 256x256 pixels ed 11 bande). In questo senso si deve considerare che le bande a 20 e 60 m sono state ricampionate

Le immagini sono classificate tramite poligoni shapefile in un separatore folder

 

Su Github e' presente il codice PyTorch per addestrare due reti neurali (https://paperswithcode.com/paper/resattunet-detecting-marine-debris-using-an) ma si possono addestrare i modelli gia' addestrati da qui per Unet e Resnet

Per fare inferenza si puo' usare lo script sottostante

Esempio di inferenza classificata

 

import torch

import torch.nn as nn

import torchvision.models as models

import sys

class ResNet50Encoder(nn.Module):

    def __init__(self, input_bands=11, output_classes=11):

        super(ResNet50Encoder, self).__init__()

        resnet = models.resnet50(pretrained=False)

        self.encoder = nn.Sequential(

            nn.Conv2d(input_bands, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False),

            resnet.bn1,

            resnet.relu,

            resnet.maxpool,

            resnet.layer1,

            resnet.layer2,

            resnet.layer3,

            resnet.layer4,

            resnet.avgpool

        )

        self.fc = nn.Linear(2048, output_classes)

    def forward(self, x):

        x = self.encoder(x)

        x = x.view(x.size(0), -1)

        logits = self.fc(x)

        return logits

# Instantiate and load weights

model = ResNet50Encoder(input_bands=11, output_classes=11)

model.load_state_dict(torch.load("model_resnet.pth", map_location="cpu"))

model.eval()

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

model.to(device)

import rasterio

import numpy as np

with rasterio.open("test4.tif") as src:

    image = src.read().astype(np.float32)  # (11, 256, 256)

# Normalize

image = (image - image.min()) / (image.max() - image.min())

import torch

image_tensor = torch.from_numpy(image).unsqueeze(0)  # (1, 11, 256, 256)

image_tensor = image_tensor.to(device)

with torch.no_grad():

    output = model(image_tensor)

# If it's a classifier:

predicted_class = torch.argmax(output, dim=1)

print("Predicted class:", predicted_class.item())

#classificazione a livello di pixel

output = model(image_tensor)  # [1, num_classes, 256, 256]

mask = torch.argmax(output, dim=1).squeeze(0)  # shape: [256, 256]

import torch

from torchvision.utils import save_image

from PIL import Image

import numpy as np

# Example: your predicted mask (dtype: torch.Tensor, shape: [H, W])

mask = torch.randint(0, 10, (256, 256), dtype=torch.uint8)  # demo mask

# Option 1: using PIL directly (recommended for class masks)

mask_np = mask.numpy().astype(np.uint8)

img = Image.fromarray(mask_np, mode="L")  # 'L' = grayscale (8-bit)

img.save("predicted_mask.png")

palette = [

    0, 0, 0,         # class 0 - black

    255, 0, 0,       # class 1 - red

    0, 255, 0,       # class 2 - green

    0, 0, 255,       # class 3 - blue

    255, 255, 0,     # class 4 - yellow

    255, 0, 255,     # class 5 - magenta

    0, 255, 255,     # class 6 - cyan

    128, 128, 128,   # class 7 - gray

    255, 128, 0,     # class 8 - orange

    128, 0, 255,     # class 9 - violet

    0, 128, 255,     # class 10 - sky blue

]

# Apply the palette

color_mask = Image.fromarray(mask_np, mode="P")

color_mask.putpalette(palette)

color_mask.save("colored_mask.png")

##########################################################################################

# Define the segmentation model

class ResNetSegmentationFromClassifier(nn.Module):

    def __init__(self, encoder_model):

        super().__init__()

        # Extract the encoder part (everything except avgpool and fc)

        resnet = models.resnet50(pretrained=False)

       

        # First re-use the custom first conv layer from the encoder model

        first_conv = encoder_model.encoder[0]

       

        # Build encoder using resnet blocks

        self.encoder = nn.Sequential(

            first_conv,

            resnet.bn1,

            resnet.relu,

            resnet.maxpool,

            resnet.layer1,

            resnet.layer2,

            resnet.layer3,

            resnet.layer4

        )

       

        # Load weights from the encoder model

        # Copy weights for the shared layers

        encoder_state_dict = encoder_model.state_dict()

        for name, param in self.encoder.named_parameters():

            if name in encoder_state_dict:

                param.data.copy_(encoder_state_dict[name])

       

        # Decoder to upsample to 256x256

        self.decoder = nn.Sequential(

            nn.ConvTranspose2d(2048, 512, 2, stride=2),  # 8x8 -> 16x16

            nn.ReLU(),

            nn.ConvTranspose2d(512, 256, 2, stride=2),   # 16x16 -> 32x32

            nn.ReLU(),

            nn.ConvTranspose2d(256, 128, 2, stride=2),   # 32x32 -> 64x64

            nn.ReLU(),

            nn.ConvTranspose2d(128, 64, 2, stride=2),    # 64x64 -> 128x128

            nn.ReLU(),

            nn.ConvTranspose2d(64, 11, 2, stride=2)      # 128x128 -> 256x256

        )

   

    def forward(self, x):

        x = self.encoder(x)        # [B, 2048, 8, 8]

        x = self.decoder(x)        # [B, 11, 256, 256]

        return x

# Load the classification model

model = ResNet50Encoder(input_bands=11, output_classes=11)

model.load_state_dict(torch.load("model_resnet.pth", map_location="cpu"))

model.eval()

# Create the segmentation model

segmentation_model = ResNetSegmentationFromClassifier(model)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

segmentation_model.to(device)

segmentation_model.eval()

# Load and preprocess the image

with rasterio.open("test4.tif") as src:

    image = src.read().astype(np.float32)  # (11, 256, 256)

# Normalize

image = (image - image.min()) / (image.max() - image.min())

image_tensor = torch.from_numpy(image).unsqueeze(0)  # (1, 11, 256, 256)

image_tensor = image_tensor.to(device)

# Perform pixel-based classification

with torch.no_grad():

    output = segmentation_model(image_tensor)  # [1, 11, 256, 256]

# Create class mask by taking argmax at each pixel

mask = torch.argmax(output, dim=1).squeeze(0)  # shape: [256, 256]

mask_np = mask.cpu().numpy().astype(np.uint8)

# Define color palette (11 classes)

palette = [

    0, 0, 0,         # class 0 - black

    255, 0, 0,       # class 1 - red

    0, 255, 0,       # class 2 - green

    0, 0, 255,       # class 3 - blue

    255, 255, 0,     # class 4 - yellow

    255, 0, 255,     # class 5 - magenta

    0, 255, 255,     # class 6 - cyan

    128, 128, 128,   # class 7 - gray

    255, 128, 0,     # class 8 - orange

    128, 0, 255,     # class 9 - violet

    0, 128, 255,     # class 10 - sky blue

]

# Save grayscale mask

img = Image.fromarray(mask_np, mode="L")

img.save("predicted_mask.png")

# Save colored mask

color_mask = Image.fromarray(mask_np, mode="P")

color_mask.putpalette(palette)

color_mask.save("colored_mask.png")

# Print class distribution

unique, counts = np.unique(mask_np, return_counts=True)

class_distribution = dict(zip(unique, counts))

print("Pixel class distribution:", class_distribution)