Upload 14 files

.gitattributes

@@ -33,3 +33,9 @@ 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
+first.tif filter=lfs diff=lfs merge=lfs -text
+second.tif filter=lfs diff=lfs merge=lfs -text
+streamlit-testing.webm filter=lfs diff=lfs merge=lfs -text
+temp/1ab7b057-9543-4240-92a1-f85bba853af6.jpg filter=lfs diff=lfs merge=lfs -text
+temp/771eca76-489a-41c7-bcfb-28b841e78dd7.jpg filter=lfs diff=lfs merge=lfs -text
+third.tif filter=lfs diff=lfs merge=lfs -text

Korea_data.zip

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

Prithvi.py

@@ -0,0 +1,319 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+# --------------------------------------------------------
+# References:
+# timm: https://github.com/rwightman/pytorch-image-models/tree/master/timm
+# DeiT: https://github.com/facebookresearch/deit
+# --------------------------------------------------------
+
+from functools import partial
+
+import torch
+import torch.nn as nn
+
+from timm.models.vision_transformer import Block
+from timm.models.layers import to_2tuple
+
+import numpy as np
+
+from einops import rearrange
+
+def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
+    """
+    embed_dim: output dimension for each position
+    pos: a list of positions to be encoded: size (M,)
+    out: (M, D)
+    """
+    assert embed_dim % 2 == 0
+    omega = np.arange(embed_dim // 2, dtype=np.float32)
+    omega /= embed_dim / 2.
+    omega = 1. / 10000**omega  # (D/2,)
+
+    pos = pos.reshape(-1)  # (M,)
+    out = np.einsum('m,d->md', pos, omega)  # (M, D/2), outer product
+
+    emb_sin = np.sin(out) # (M, D/2)
+    emb_cos = np.cos(out) # (M, D/2)
+
+    emb = np.concatenate([emb_sin, emb_cos], axis=1)  # (M, D)
+    return emb
+
+def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
+    assert embed_dim % 2 == 0
+
+    # use half of dimensions to encode grid_h
+    emb_h = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[0])  # (H*W, D/2)
+    emb_w = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[1])  # (H*W, D/2)
+
+    emb = np.concatenate([emb_h, emb_w], axis=1) # (H*W, D)
+    return emb
+
+def get_3d_sincos_pos_embed(embed_dim, grid_size, cls_token=False):
+    """
+    grid_size: 3d tuple of grid size: t, h, w
+    return:
+    pos_embed: L, D
+    """
+
+    assert embed_dim % 16 == 0
+
+    t_size, h_size, w_size = grid_size
+
+    w_embed_dim = embed_dim // 16 * 6
+    h_embed_dim = embed_dim // 16 * 6
+    t_embed_dim = embed_dim // 16 * 4
+
+    w_pos_embed = get_1d_sincos_pos_embed_from_grid(w_embed_dim, np.arange(w_size))
+    h_pos_embed = get_1d_sincos_pos_embed_from_grid(h_embed_dim, np.arange(h_size))
+    t_pos_embed = get_1d_sincos_pos_embed_from_grid(t_embed_dim, np.arange(t_size))
+
+    w_pos_embed = np.tile(w_pos_embed, (t_size * h_size, 1))
+    h_pos_embed = np.tile(np.repeat(h_pos_embed, w_size, axis=0), (t_size, 1))
+    t_pos_embed = np.repeat(t_pos_embed, h_size * w_size, axis=0)
+
+    pos_embed = np.concatenate((w_pos_embed, h_pos_embed, t_pos_embed), axis=1)
+
+    if cls_token:
+        pos_embed = np.concatenate([np.zeros([1, embed_dim]), pos_embed], axis=0)
+    return pos_embed
+
+
+class PatchEmbed(nn.Module):
+    """ Frames of 2D Images to Patch Embedding
+    The 3D version of timm.models.vision_transformer.PatchEmbed
+    """
+    def __init__(
+            self,
+            img_size=224,
+            patch_size=16,
+            num_frames=3,
+            tubelet_size=1,
+            in_chans=3,
+            embed_dim=768,
+            norm_layer=None,
+            flatten=True,
+            bias=True,
+    ):
+        super().__init__()
+        img_size = to_2tuple(img_size)
+        patch_size = to_2tuple(patch_size)
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.num_frames = num_frames
+        self.tubelet_size = tubelet_size
+        self.grid_size = (num_frames // tubelet_size, img_size[0] // patch_size[0], img_size[1] // patch_size[1])
+        self.num_patches = self.grid_size[0] * self.grid_size[1] * self.grid_size[2]
+        self.flatten = flatten
+
+        self.proj = nn.Conv3d(in_chans, embed_dim,
+                              kernel_size=(tubelet_size, patch_size[0], patch_size[1]),
+                              stride=(tubelet_size, patch_size[0], patch_size[1]), bias=bias)
+        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
+
+    def forward(self, x):
+        B, C, T, H, W = x.shape
+        x = self.proj(x)
+        if self.flatten:
+            x = x.flatten(2).transpose(1, 2)  # B,C,T,H,W -> B,C,L -> B,L,C
+        x = self.norm(x)
+        return x
+
+
+class MaskedAutoencoderViT(nn.Module):
+    """ Masked Autoencoder with VisionTransformer backbone
+    """
+    def __init__(self, img_size=224, patch_size=16,
+                 num_frames=3, tubelet_size=1,
+                 in_chans=3, embed_dim=1024, depth=24, num_heads=16,
+                 decoder_embed_dim=512, decoder_depth=8, decoder_num_heads=16,
+                 mlp_ratio=4., norm_layer=nn.LayerNorm, norm_pix_loss=False):
+        super().__init__()
+
+        # --------------------------------------------------------------------------
+        # MAE encoder specifics
+        self.patch_embed = PatchEmbed(img_size, patch_size,num_frames, tubelet_size, in_chans, embed_dim)
+        num_patches = self.patch_embed.num_patches
+
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim), requires_grad=False)  # fixed sin-cos embedding
+
+        self.blocks = nn.ModuleList([
+            Block(embed_dim, num_heads, mlp_ratio, qkv_bias=True, norm_layer=norm_layer)
+            for i in range(depth)])
+        self.norm = norm_layer(embed_dim)
+        # --------------------------------------------------------------------------
+
+        # --------------------------------------------------------------------------
+        # MAE decoder specifics
+        self.decoder_embed = nn.Linear(embed_dim, decoder_embed_dim, bias=True)
+
+        self.mask_token = nn.Parameter(torch.zeros(1, 1, decoder_embed_dim))
+
+        self.decoder_pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, decoder_embed_dim), requires_grad=False)  # fixed sin-cos embedding
+
+        self.decoder_blocks = nn.ModuleList([
+            Block(decoder_embed_dim, decoder_num_heads, mlp_ratio, qkv_bias=True, norm_layer=norm_layer)
+            for i in range(decoder_depth)])
+
+        self.decoder_norm = norm_layer(decoder_embed_dim)
+        self.decoder_pred = nn.Linear(decoder_embed_dim, tubelet_size * patch_size * patch_size * in_chans, bias=True) # decoder to patch
+        # --------------------------------------------------------------------------
+
+        self.norm_pix_loss = norm_pix_loss
+
+        self.initialize_weights()
+
+    def initialize_weights(self):
+        # initialization
+        # initialize (and freeze) pos_embed by sin-cos embedding
+        pos_embed = get_3d_sincos_pos_embed(self.pos_embed.shape[-1], self.patch_embed.grid_size, cls_token=True)
+        self.pos_embed.data.copy_(torch.from_numpy(pos_embed).float().unsqueeze(0))
+
+        decoder_pos_embed = get_3d_sincos_pos_embed(self.decoder_pos_embed.shape[-1], self.patch_embed.grid_size, cls_token=True)
+        self.decoder_pos_embed.data.copy_(torch.from_numpy(decoder_pos_embed).float().unsqueeze(0))
+
+        # initialize patch_embed like nn.Linear (instead of nn.Conv2d)
+        w = self.patch_embed.proj.weight.data
+        torch.nn.init.xavier_uniform_(w.view([w.shape[0], -1]))
+
+        # timm's trunc_normal_(std=.02) is effectively normal_(std=0.02) as cutoff is too big (2.)
+        torch.nn.init.normal_(self.cls_token, std=.02)
+        torch.nn.init.normal_(self.mask_token, std=.02)
+
+        # initialize nn.Linear and nn.LayerNorm
+        self.apply(self._init_weights)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            # we use xavier_uniform following official JAX ViT:
+            torch.nn.init.xavier_uniform_(m.weight)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.LayerNorm):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    def patchify(self, imgs):
+        """
+        imgs: B, C, T, H, W
+        x: B, L, D
+        """
+        p = self.patch_embed.patch_size[0]
+        tub = self.patch_embed.tubelet_size
+        x = rearrange(imgs, 'b c (t tub) (h p) (w q) -> b (t h w) (tub p q c)', tub=tub, p=p, q=p)
+
+        return x
+
+    def unpatchify(self, x):
+        """
+        x: B, L, D
+        imgs: B, C, T, H, W
+        """
+        p = self.patch_embed.patch_size[0]
+        num_p = self.patch_embed.img_size[0] // p
+        tub = self.patch_embed.tubelet_size
+        imgs = rearrange(x, 'b (t h w) (tub p q c) -> b c (t tub) (h p) (w q)', h=num_p, w=num_p, tub=tub, p=p, q=p)
+        return imgs
+
+    def random_masking(self, x, mask_ratio):
+        """
+        Perform per-sample random masking by per-sample shuffling.
+        Per-sample shuffling is done by argsort random noise.
+        x: [N, L, D], sequence
+        """
+        N, L, D = x.shape  # batch, length, dim
+        len_keep = int(L * (1 - mask_ratio))
+
+        noise = torch.rand(N, L, device=x.device)  # noise in [0, 1]
+
+        # sort noise for each sample
+        ids_shuffle = torch.argsort(noise, dim=1)  # ascend: small is keep, large is remove
+        ids_restore = torch.argsort(ids_shuffle, dim=1)
+
+        # keep the first subset
+        ids_keep = ids_shuffle[:, :len_keep]
+        x_masked = torch.gather(x, dim=1, index=ids_keep.unsqueeze(-1).repeat(1, 1, D))
+
+        # generate the binary mask: 0 is keep, 1 is remove
+        mask = torch.ones([N, L], device=x.device)
+        mask[:, :len_keep] = 0
+        # unshuffle to get the binary mask
+        mask = torch.gather(mask, dim=1, index=ids_restore)
+
+        return x_masked, mask, ids_restore
+
+    def forward_encoder(self, x, mask_ratio):
+        # embed patches
+        x = self.patch_embed(x)
+
+        # add pos embed w/o cls token
+        x = x + self.pos_embed[:, 1:, :]
+
+        # masking: length -> length * mask_ratio
+        x, mask, ids_restore = self.random_masking(x, mask_ratio)
+
+        # append cls token
+        cls_token = self.cls_token + self.pos_embed[:, :1, :]
+        cls_tokens = cls_token.expand(x.shape[0], -1, -1)
+        x = torch.cat((cls_tokens, x), dim=1)
+
+        # apply Transformer blocks
+        for blk in self.blocks:
+            x = blk(x)
+        x = self.norm(x)
+
+        return x, mask, ids_restore
+
+    def forward_decoder(self, x, ids_restore):
+        # embed tokens
+        x = self.decoder_embed(x)
+
+        # append mask tokens to sequence
+        mask_tokens = self.mask_token.repeat(x.shape[0], ids_restore.shape[1] + 1 - x.shape[1], 1)
+        x_ = torch.cat([x[:, 1:, :], mask_tokens], dim=1)  # no cls token
+        x_ = torch.gather(x_, dim=1, index=ids_restore.unsqueeze(-1).repeat(1, 1, x.shape[2]))  # unshuffle
+        x = torch.cat([x[:, :1, :], x_], dim=1)  # append cls token
+
+        # add pos embed
+        x = x + self.decoder_pos_embed
+
+        # apply Transformer blocks
+        for blk in self.decoder_blocks:
+            x = blk(x)
+        x = self.decoder_norm(x)
+
+        # predictor projection
+        x = self.decoder_pred(x)
+
+        # remove cls token
+        x = x[:, 1:, :]
+
+        return x
+
+    def forward_loss(self, imgs, pred, mask):
+        """
+        imgs: B, C, T, H, W
+        target: B, L, D
+        pred: B, L, D
+        mask: B, L. 0 is keep, 1 is remove,
+        """
+        target = self.patchify(imgs)
+        if self.norm_pix_loss:
+            mean = target.mean(dim=-1, keepdim=True)
+            var = target.var(dim=-1, keepdim=True)
+            target = (target - mean) / (var + 1.e-6)**.5
+
+        loss = (pred - target) ** 2
+        loss = loss.mean(dim=-1)  # [N, L], mean loss per patch
+
+        loss = (loss * mask).sum() / mask.sum()  # mean loss on removed patches
+        return loss
+
+    def forward(self, imgs, mask_ratio=0.75):
+        latent, mask, ids_restore = self.forward_encoder(imgs, mask_ratio)
+        pred = self.forward_decoder(latent, ids_restore)
+        loss = self.forward_loss(imgs, pred, mask)
+        return loss, pred, mask

Prithvi_100M.pt

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

Prithvi_100M_config.yaml

@@ -0,0 +1,19 @@
+num_frames: 3
+img_size: 224
+bands: [B02, B03, B04, B05, B06, B07]
+random_cropping: true
+data_loader_num_workers: 1
+depth: 12
+decoder_depth: 8
+patch_size: 16
+embed_dim: 768
+decoder_embed_dim: 512
+num_heads: 12
+decoder_num_heads: 16
+mask_ratio: 0.75
+tubelet_size: 1
+data_mean: [775.2290211032589, 1080.992780391705, 1228.5855250417867, 2497.2022620507532,
+  2204.2139147975554, 1610.8324823273745]
+data_std: [1281.526139861424, 1270.0297974547493, 1399.4802505642526, 1368.3446143747644,
+  1291.6764008585435, 1154.505683480695]
+batch_size: 16

Prithvi_run_inference.py

@@ -0,0 +1,399 @@
+import argparse
+import functools
+import os
+from typing import List
+
+import numpy as np
+import rasterio
+import torch
+import yaml
+from einops import rearrange
+
+from Prithvi import MaskedAutoencoderViT
+
+NO_DATA = -9999
+NO_DATA_FLOAT = 0.0001
+PERCENTILES = (0.1, 99.9)
+
+
+def process_channel_group(orig_img, new_img, channels, data_mean, data_std):
+    """ Process *orig_img* and *new_img* for RGB visualization. Each band is rescaled back to the
+        original range using *data_mean* and *data_std* and then lowest and highest percentiles are
+        removed to enhance contrast. Data is rescaled to (0, 1) range and stacked channels_first.
+
+    Args:
+        orig_img: torch.Tensor representing original image (reference) with shape = (bands, H, W).
+        new_img: torch.Tensor representing image with shape = (bands, H, W).
+        channels: list of indices representing RGB channels.
+        data_mean: list of mean values for each band.
+        data_std: list of std values for each band.
+
+    Returns:
+        torch.Tensor with shape (num_channels, height, width) for original image
+        torch.Tensor with shape (num_channels, height, width) for the other image
+    """
+
+    stack_c = [], []
+
+    for c in channels:
+        orig_ch = orig_img[c, ...]
+        valid_mask = torch.ones_like(orig_ch, dtype=torch.bool)
+        valid_mask[orig_ch == NO_DATA_FLOAT] = False
+
+        # Back to original data range
+        orig_ch = (orig_ch * data_std[c]) + data_mean[c]
+        new_ch = (new_img[c, ...] * data_std[c]) + data_mean[c]
+
+        # Rescale (enhancing contrast)
+        min_value, max_value = np.percentile(orig_ch[valid_mask], PERCENTILES)
+
+        orig_ch = torch.clamp((orig_ch - min_value) / (max_value - min_value), 0, 1)
+        new_ch = torch.clamp((new_ch - min_value) / (max_value - min_value), 0, 1)
+
+        # No data as zeros
+        orig_ch[~valid_mask] = 0
+        new_ch[~valid_mask] = 0
+
+        stack_c[0].append(orig_ch)
+        stack_c[1].append(new_ch)
+
+    # Channels first
+    stack_orig = torch.stack(stack_c[0], dim=0)
+    stack_rec = torch.stack(stack_c[1], dim=0)
+
+    return stack_orig, stack_rec
+
+
+def read_geotiff(file_path: str):
+    """ Read all bands from *file_path* and return image + meta info.
+
+    Args:
+        file_path: path to image file.
+
+    Returns:
+        np.ndarray with shape (bands, height, width)
+        meta info dict
+    """
+
+    with rasterio.open(file_path) as src:
+        img = src.read()
+        meta = src.meta
+
+    return img, meta
+
+
+def save_geotiff(image, output_path: str, meta: dict):
+    """ Save multi-band image in Geotiff file.
+
+    Args:
+        image: np.ndarray with shape (bands, height, width)
+        output_path: path where to save the image
+        meta: dict with meta info.
+    """
+
+    with rasterio.open(output_path, "w", **meta) as dest:
+        for i in range(image.shape[0]):
+            dest.write(image[i, :, :], i + 1)
+
+    return
+
+
+def _convert_np_uint8(float_image: torch.Tensor):
+
+    image = float_image.numpy() * 255.0
+    image = image.astype(dtype=np.uint8)
+
+    return image
+
+
+def load_example(file_paths: List[str], mean: List[float], std: List[float]):
+    """ Build an input example by loading images in *file_paths*.
+
+    Args:
+        file_paths: list of file paths .
+        mean: list containing mean values for each band in the images in *file_paths*.
+        std: list containing std values for each band in the images in *file_paths*.
+
+    Returns:
+        np.array containing created example
+        list of meta info for each image in *file_paths*
+    """
+
+    imgs = []
+    metas = []
+
+    for file in file_paths:
+        img, meta = read_geotiff(file)
+
+        # Rescaling (don't normalize on nodata)
+        img = np.moveaxis(img, 0, -1)   # channels last for rescaling
+        img = np.where(img == NO_DATA, NO_DATA_FLOAT, (img - mean) / std)
+
+        imgs.append(img)
+        metas.append(meta)
+
+    imgs = np.stack(imgs, axis=0)    # num_frames, H, W, C
+    imgs = np.moveaxis(imgs, -1, 0).astype('float32')  # C, num_frames, H, W
+    imgs = np.expand_dims(imgs, axis=0)  # add batch dim
+
+    return imgs, metas
+
+
+def run_model(model: torch.nn.Module, input_data: torch.Tensor, mask_ratio: float, device: torch.device):
+    """ Run *model* with *input_data* and create images from output tokens (mask, reconstructed + visible).
+
+    Args:
+        model: MAE model to run.
+        input_data: torch.Tensor with shape (B, C, T, H, W).
+        mask_ratio: mask ratio to use.
+        device: device where model should run.
+
+    Returns:
+        3 torch.Tensor with shape (B, C, T, H, W).
+    """
+
+    with torch.no_grad():
+        x = input_data.to(device)
+
+        _, pred, mask = model(x, mask_ratio)
+
+    # Create mask and prediction images (un-patchify)
+    mask_img = model.unpatchify(mask.unsqueeze(-1).repeat(1, 1, pred.shape[-1])).detach().cpu()
+    pred_img = model.unpatchify(pred).detach().cpu()
+
+    # Mix visible and predicted patches
+    rec_img = input_data.clone()
+    rec_img[mask_img == 1] = pred_img[mask_img == 1]  # binary mask: 0 is keep, 1 is remove
+
+    # Switch zeros/ones in mask images so masked patches appear darker in plots (better visualization)
+    mask_img = (~(mask_img.to(torch.bool))).to(torch.float)
+
+    return rec_img, mask_img
+
+
+def save_rgb_imgs(input_img, rec_img, mask_img, channels, mean, std, output_dir, meta_data):
+    """ Wrapper function to save Geotiff images (original, reconstructed, masked) per timestamp.
+
+    Args:
+        input_img: input torch.Tensor with shape (C, T, H, W).
+        rec_img: reconstructed torch.Tensor with shape (C, T, H, W).
+        mask_img: mask torch.Tensor with shape (C, T, H, W).
+        channels: list of indices representing RGB channels.
+        mean: list of mean values for each band.
+        std: list of std values for each band.
+        output_dir: directory where to save outputs.
+        meta_data: list of dicts with geotiff meta info.
+    """
+
+    for t in range(input_img.shape[1]):
+        rgb_orig, rgb_pred = process_channel_group(orig_img=input_img[:, t, :, :],
+                                                   new_img=rec_img[:, t, :, :],
+                                                   channels=channels, data_mean=mean,
+                                                   data_std=std)
+
+        rgb_mask = mask_img[channels, t, :, :] * rgb_orig
+
+        # Saving images
+
+        save_geotiff(image=_convert_np_uint8(rgb_orig),
+                     output_path=os.path.join(output_dir, f"original_rgb_t{t}.tiff"),
+                     meta=meta_data[t])
+
+        save_geotiff(image=_convert_np_uint8(rgb_pred),
+                     output_path=os.path.join(output_dir, f"predicted_rgb_t{t}.tiff"),
+                     meta=meta_data[t])
+
+        save_geotiff(image=_convert_np_uint8(rgb_mask),
+                     output_path=os.path.join(output_dir, f"masked_rgb_t{t}.tiff"),
+                     meta=meta_data[t])
+
+
+def save_imgs(rec_img, mask_img, mean, std, output_dir, meta_data):
+    """ Wrapper function to save Geotiff images (reconstructed, mask) per timestamp.
+
+    Args:
+        rec_img: reconstructed torch.Tensor with shape (C, T, H, W).
+        mask_img: mask torch.Tensor with shape (C, T, H, W).
+        mean: list of mean values for each band.
+        std: list of std values for each band.
+        output_dir: directory where to save outputs.
+        meta_data: list of dicts with geotiff meta info.
+    """
+
+    mean = torch.tensor(np.asarray(mean)[:, None, None])  # C H W
+    std = torch.tensor(np.asarray(std)[:, None, None])
+
+    for t in range(rec_img.shape[1]):
+
+        # Back to original data range
+        rec_img_t = ((rec_img[:, t, :, :] * std) + mean).to(torch.int16)
+
+        mask_img_t = mask_img[:, t, :, :].to(torch.int16)
+
+        # Saving images
+
+        save_geotiff(image=rec_img_t,
+                     output_path=os.path.join(output_dir, f"predicted_t{t}.tiff"),
+                     meta=meta_data[t])
+
+        save_geotiff(image=mask_img_t,
+                     output_path=os.path.join(output_dir, f"mask_t{t}.tiff"),
+                     meta=meta_data[t])
+
+
+def main(data_files: List[str], yaml_file_path: str, checkpoint: str, output_dir: str,
+         mask_ratio: float, rgb_outputs: bool):
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Get parameters --------
+
+    with open(yaml_file_path, 'r') as f:
+        params = yaml.safe_load(f)
+
+    # data related
+    num_frames = len(data_files)
+    img_size = params['img_size']
+    bands = params['bands']
+    mean = params['data_mean']
+    std = params['data_std']
+
+    # model related
+    depth = params['depth']
+    patch_size = params['patch_size']
+    embed_dim = params['embed_dim']
+    num_heads = params['num_heads']
+    tubelet_size = params['tubelet_size']
+    decoder_embed_dim = params['decoder_embed_dim']
+    decoder_num_heads = params['decoder_num_heads']
+    decoder_depth = params['decoder_depth']
+
+    batch_size = params['batch_size']
+
+    mask_ratio = params['mask_ratio'] if mask_ratio is None else mask_ratio
+
+    print(f"\nTreating {len(data_files)} files as {len(data_files)} time steps from the same location\n")
+    if len(data_files) != 3:
+        print("The original model was trained for 3 time steps (expecting 3 files). \nResults with different numbers of timesteps may vary")
+
+    if torch.cuda.is_available():
+        device = torch.device('cuda')
+    else:
+        device = torch.device('cpu')
+
+    print(f"Using {device} device.\n")
+
+    # Loading data ---------------------------------------------------------------------------------
+
+    input_data, meta_data = load_example(file_paths=data_files, mean=mean, std=std)
+
+    # Create model and load checkpoint -------------------------------------------------------------
+
+    model = MaskedAutoencoderViT(
+            img_size=img_size,
+            patch_size=patch_size,
+            num_frames=num_frames,
+            tubelet_size=tubelet_size,
+            in_chans=len(bands),
+            embed_dim=embed_dim,
+            depth=depth,
+            num_heads=num_heads,
+            decoder_embed_dim=decoder_embed_dim,
+            decoder_depth=decoder_depth,
+            decoder_num_heads=decoder_num_heads,
+            mlp_ratio=4.,
+            norm_layer=functools.partial(torch.nn.LayerNorm, eps=1e-6),
+            norm_pix_loss=False)
+
+    total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"\n--> Model has {total_params:,} parameters.\n")
+
+    model.to(device)
+
+    state_dict = torch.load(checkpoint, map_location=device)
+    # discard fixed pos_embedding weight
+    del state_dict['pos_embed']
+    del state_dict['decoder_pos_embed']
+    model.load_state_dict(state_dict, strict=False)
+    print(f"Loaded checkpoint from {checkpoint}")
+
+    # Running model --------------------------------------------------------------------------------
+
+    model.eval()
+    channels = [bands.index(b) for b in ['B04', 'B03', 'B02']]  # BGR -> RGB
+
+    # Reflect pad if not divisible by img_size
+    original_h, original_w = input_data.shape[-2:]
+    pad_h = img_size - (original_h % img_size)
+    pad_w = img_size - (original_w % img_size)
+    input_data = np.pad(input_data, ((0, 0), (0, 0), (0, 0), (0, pad_h), (0, pad_w)), mode='reflect')
+
+    # Build sliding window
+    batch = torch.tensor(input_data, device='cpu')
+    windows = batch.unfold(3, img_size, img_size).unfold(4, img_size, img_size)
+    h1, w1 = windows.shape[3:5]
+    windows = rearrange(windows, 'b c t h1 w1 h w -> (b h1 w1) c t h w', h=img_size, w=img_size)
+
+    # Split into batches if number of windows > batch_size
+    num_batches = windows.shape[0] // batch_size if windows.shape[0] > batch_size else 1
+    windows = torch.tensor_split(windows, num_batches, dim=0)
+
+    # Run model
+    rec_imgs = []
+    mask_imgs = []
+    for x in windows:
+        rec_img, mask_img = run_model(model, x, mask_ratio, device)
+        rec_imgs.append(rec_img)
+        mask_imgs.append(mask_img)
+
+    rec_imgs = torch.concat(rec_imgs, dim=0)
+    mask_imgs = torch.concat(mask_imgs, dim=0)
+
+    # Build images from patches
+    rec_imgs = rearrange(rec_imgs, '(b h1 w1) c t h w -> b c t (h1 h) (w1 w)',
+                         h=img_size, w=img_size, b=1, c=len(bands), t=num_frames, h1=h1, w1=w1)
+    mask_imgs = rearrange(mask_imgs, '(b h1 w1) c t h w -> b c t (h1 h) (w1 w)',
+                          h=img_size, w=img_size, b=1, c=len(bands), t=num_frames, h1=h1, w1=w1)
+
+    # Cut padded images back to original size
+    rec_imgs_full = rec_imgs[..., :original_h, :original_w]
+    mask_imgs_full = mask_imgs[..., :original_h, :original_w]
+    batch_full = batch[..., :original_h, :original_w]
+
+    # Build output images
+    if rgb_outputs:
+        for d in meta_data:
+            d.update(count=3, dtype='uint8', compress='lzw', nodata=0)
+
+        save_rgb_imgs(batch_full[0, ...], rec_imgs_full[0, ...], mask_imgs_full[0, ...],
+                      channels, mean, std, output_dir, meta_data)
+    else:
+        for d in meta_data:
+            d.update(compress='lzw', nodata=0)
+
+        save_imgs(rec_imgs_full[0, ...], mask_imgs_full[0, ...], mean, std, output_dir, meta_data)
+
+    print("Done!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser('MAE run inference', add_help=False)
+
+    parser.add_argument('--data_files', required=True, type=str, nargs='+',
+                        help='Path to the data files. Assumes multi-band files.')
+    parser.add_argument('--yaml_file_path', type=str, required=True,
+                        help='Path to yaml file containing model training parameters.')
+    parser.add_argument('--checkpoint', required=True, type=str,
+                        help='Path to a checkpoint file to load from.')
+    parser.add_argument('--output_dir', required=True, type=str,
+                        help='Path to the directory where to save outputs.')
+    parser.add_argument('--mask_ratio', default=None, type=float,
+                        help='Masking ratio (percentage of removed patches). '
+                             'If None (default) use same value used for pretraining.')
+    parser.add_argument('--rgb_outputs', action='store_true',
+                        help='If present, output files will only contain RGB channels. '
+                             'Otherwise, all bands will be saved.')
+    args = parser.parse_args()
+
+    main(**vars(args))
+

README.md

@@ -0,0 +1,41 @@
+---
+license: apache-2.0
+tags:
+- Pytorch
+- Geospatial
+- Temporal ViT
+- Vit
+---
+
+
+### Code
+The model follows the [original repo](https://huggingface.co/ibm-nasa-geospatial/Prithvi-100M)
+I made simple modification by using original repo source code to visualize.
+
+### Data
+Area: South Korea Jeollanam-do
+Sourced the image from this [link](https://search.earthdata.nasa.gov/search/granules?p=C2021957657-LPCLOUD&pg[0][v]=f&pg[0][qt]=2009-01-01T00%3A00%3A00.000Z%2C&pg[0][dnf]=DAY&pg[0][gsk]=-start_date&q=HLSL30&sb[0]=126.57129%2C34.87923%2C126.97998%2C35.09012&tl=1696429462!3!!&lat=33.70166015625&long=125.0771484375&zoom=7)
+Google map location [link](https://www.google.co.kr/maps/place/34%C2%B052'45.2%22N+126%C2%B034'16.6%22E/data=!4m4!3m3!8m2!3d34.87923!4d126.57129?hl=ko&entry=ttu)
+
+### Usecase
+Here's a sample video:
+
+![Sample Video](streamlit-testing.webm)
+
+
+
+### Citation
+
+Please cite original repository.
+If this model helped your research, please cite `Prithvi-100M` in your publications. Here is an example BibTeX entry:
+
+```
+@misc{Prithvi-100M,
+    author          = {Jakubik, Johannes and Chu, Linsong and Fraccaro, Paolo and Gomes, Carlos and Nyirjesy, Gabby and Bangalore, Ranjini and Lambhate, Devyani and Das, Kamal and Oliveira Borges, Dario and Kimura, Daiki and Simumba, Naomi and Szwarcman, Daniela and Muszynski, Michal and Weldemariam, Kommy and Zadrozny, Bianca and Ganti, Raghu and Costa, Carlos and Edwards, Blair & Watson, Campbell and Mukkavilli, Karthik and Schmude, Johannes & Hamann, Hendrik and Robert, Parkin and Roy, Sujit and Phillips, Christopher and Ankur, Kumar and Ramasubramanian, Muthukumaran and Gurung, Iksha and Leong, Wei Ji and Avery, Ryan and Ramachandran, Rahul and Maskey, Manil and Olofossen, Pontus and Fancher, Elizabeth and Lee, Tsengdar and Murphy, Kevin and Duffy, Dan and Little, Mike and Alemohammad, Hamed and Cecil, Michael and Li, Steve and Khallaghi, Sam and Godwin, Denys and Ahmadi, Maryam and Kordi, Fatemeh and Saux, Bertrand and Pastick, Neal and Doucette, Peter and Fleckenstein, Rylie and Luanga, Dalton and Corvin, Alex and Granger, Erwan},
+    doi             = {10.57967/hf/0952},
+    month           = aug,
+    title           = {{Prithvi-100M}},
+    repository-code = {https://github.com/NASA-IMPACT/hls-foundation-os},
+    year            = {2023}
+}
+```

app.py

@@ -0,0 +1,483 @@
+from huggingface_hub import hf_hub_download
+import os
+import functools
+from typing import List
+import numpy as np
+import torch
+import yaml
+from einops import rearrange
+from Prithvi import MaskedAutoencoderViT
+from functools import partial
+
+import rasterio
+from rasterio.merge import merge
+from rasterio import Affine
+from rasterio.warp import calculate_default_transform, reproject, Resampling
+
+import streamlit as st
+from streamlit_image_comparison import image_comparison
+
+NO_DATA = -9999
+NO_DATA_FLOAT = 0.0001
+PERCENTILES = (0.1, 99.9)
+
+TOKEN = "JONATHAN_TOKEN"
+yaml_file_path=hf_hub_download(repo_id="ibm-nasa-geospatial/Prithvi-100M", filename="Prithvi_100M_config.yaml", token=TOKEN)
+checkpoint=hf_hub_download(repo_id="ibm-nasa-geospatial/Prithvi-100M", filename='Prithvi_100M.pt', token=TOKEN)
+model_def=hf_hub_download(repo_id="ibm-nasa-geospatial/Prithvi-100M", filename='Prithvi.py', token=TOKEN)
+
+
+
+def process_channel_group(orig_img, new_img, channels, data_mean, data_std):
+    """ Process *orig_img* and *new_img* for RGB visualization. Each band is rescaled back to the
+        original range using *data_mean* and *data_std* and then lowest and highest percentiles are
+        removed to enhance contrast. Data is rescaled to (0, 1) range and stacked channels_first.
+    Args:
+        orig_img: torch.Tensor representing original image (reference) with shape = (bands, H, W).
+        new_img: torch.Tensor representing image with shape = (bands, H, W).
+        channels: list of indices representing RGB channels.
+        data_mean: list of mean values for each band.
+        data_std: list of std values for each band.
+    Returns:
+        torch.Tensor with shape (num_channels, height, width) for original image
+        torch.Tensor with shape (num_channels, height, width) for the other image
+    """
+
+    stack_c = [], []
+
+    for c in channels:
+        orig_ch = orig_img[c, ...]
+        valid_mask = torch.ones_like(orig_ch, dtype=torch.bool)
+        valid_mask[orig_ch == NO_DATA_FLOAT] = False
+
+        # Back to original data range
+        orig_ch = (orig_ch * data_std[c]) + data_mean[c]
+        new_ch = (new_img[c, ...] * data_std[c]) + data_mean[c]
+
+        # Rescale (enhancing contrast)
+        min_value, max_value = np.percentile(orig_ch[valid_mask], PERCENTILES)
+
+        orig_ch = torch.clamp((orig_ch - min_value) / (max_value - min_value), 0, 1)
+        new_ch = torch.clamp((new_ch - min_value) / (max_value - min_value), 0, 1)
+
+        # No data as zeros
+        orig_ch[~valid_mask] = 0
+        new_ch[~valid_mask] = 0
+
+        stack_c[0].append(orig_ch)
+        stack_c[1].append(new_ch)
+
+    # Channels first
+    stack_orig = torch.stack(stack_c[0], dim=0)
+    stack_rec = torch.stack(stack_c[1], dim=0)
+
+    return stack_orig, stack_rec
+
+
+def read_geotiff(file_path: str):
+    """ Read all bands from *file_path* and returns image + meta info.
+    Args:
+        file_path: path to image file.
+    Returns:
+        np.ndarray with shape (bands, height, width)
+        meta info dict
+    """
+
+    with rasterio.open(file_path) as src:
+        img = src.read()
+        meta = src.meta
+
+    return img, meta
+
+
+def save_geotiff(image, output_path: str, meta: dict):
+    """ Save multi-band image in Geotiff file.
+    Args:
+        image: np.ndarray with shape (bands, height, width)
+        output_path: path where to save the image
+        meta: dict with meta info.
+    """
+
+    with rasterio.open(output_path, "w", **meta) as dest:
+        for i in range(image.shape[0]):
+            dest.write(image[i, :, :], i + 1)
+
+    return
+
+
+def _convert_np_uint8(float_image: torch.Tensor):
+
+    image = float_image.numpy() * 255.0
+    image = image.astype(dtype=np.uint8)
+    image = image.transpose((1, 2, 0))
+
+    return image
+
+
+def load_example(file_paths: List[str], mean: List[float], std: List[float]):
+    """ Build an input example by loading images in *file_paths*.
+    Args:
+        file_paths: list of file paths .
+        mean: list containing mean values for each band in the images in *file_paths*.
+        std: list containing std values for each band in the images in *file_paths*.
+    Returns:
+        np.array containing created example
+        list of meta info for each image in *file_paths*
+    """
+
+    imgs = []
+    metas = []
+
+    for file in file_paths:
+        img, meta = read_geotiff(file)
+        img = img[:6]*10000 if img[:6].mean() <= 2 else img[:6]
+
+        # Rescaling (don't normalize on nodata)
+        img = np.moveaxis(img, 0, -1)   # channels last for rescaling
+        img = np.where(img == NO_DATA, NO_DATA_FLOAT, (img - mean) / std)
+
+        imgs.append(img)
+        metas.append(meta)
+
+    imgs = np.stack(imgs, axis=0)    # num_frames, H, W, C
+    imgs = np.moveaxis(imgs, -1, 0).astype('float32')  # C, num_frames, H, W
+    imgs = np.expand_dims(imgs, axis=0)  # add batch dim
+
+    return imgs, metas
+
+
+def run_model(model: torch.nn.Module, input_data: torch.Tensor, mask_ratio: float, device: torch.device):
+    """ Run *model* with *input_data* and create images from output tokens (mask, reconstructed + visible).
+    Args:
+        model: MAE model to run.
+        input_data: torch.Tensor with shape (B, C, T, H, W).
+        mask_ratio: mask ratio to use.
+        device: device where model should run.
+    Returns:
+        3 torch.Tensor with shape (B, C, T, H, W).
+    """
+
+    with torch.no_grad():
+        x = input_data.to(device)
+
+        _, pred, mask = model(x, mask_ratio)
+
+    # Create mask and prediction images (un-patchify)
+    mask_img = model.unpatchify(mask.unsqueeze(-1).repeat(1, 1, pred.shape[-1])).detach().cpu()
+    pred_img = model.unpatchify(pred).detach().cpu()
+
+    # Mix visible and predicted patches
+    rec_img = input_data.clone()
+    rec_img[mask_img == 1] = pred_img[mask_img == 1]  # binary mask: 0 is keep, 1 is remove
+
+    # Switch zeros/ones in mask images so masked patches appear darker in plots (better visualization)
+    mask_img = (~(mask_img.to(torch.bool))).to(torch.float)
+
+    return rec_img, mask_img
+
+
+def save_rgb_imgs(input_img, rec_img, mask_img, channels, mean, std, output_dir, meta_data):
+    """ Wrapper function to save Geotiff images (original, reconstructed, masked) per timestamp.
+    Args:
+        input_img: input torch.Tensor with shape (C, T, H, W).
+        rec_img: reconstructed torch.Tensor with shape (C, T, H, W).
+        mask_img: mask torch.Tensor with shape (C, T, H, W).
+        channels: list of indices representing RGB channels.
+        mean: list of mean values for each band.
+        std: list of std values for each band.
+        output_dir: directory where to save outputs.
+        meta_data: list of dicts with geotiff meta info.
+    """
+
+    for t in range(input_img.shape[1]):
+        rgb_orig, rgb_pred = process_channel_group(orig_img=input_img[:, t, :, :],
+                                                   new_img=rec_img[:, t, :, :],
+                                                   channels=channels, data_mean=mean,
+                                                   data_std=std)
+
+        rgb_mask = mask_img[channels, t, :, :] * rgb_orig
+
+        # Saving images
+
+        save_geotiff(image=_convert_np_uint8(rgb_orig),
+                     output_path=os.path.join(output_dir, f"original_rgb_t{t}.tiff"),
+                     meta=meta_data[t])
+
+        save_geotiff(image=_convert_np_uint8(rgb_pred),
+                     output_path=os.path.join(output_dir, f"predicted_rgb_t{t}.tiff"),
+                     meta=meta_data[t])
+
+        save_geotiff(image=_convert_np_uint8(rgb_mask),
+                     output_path=os.path.join(output_dir, f"masked_rgb_t{t}.tiff"),
+                     meta=meta_data[t])
+
+
+def extract_rgb_imgs(input_img, rec_img, mask_img, channels, mean, std):
+    """ Wrapper function to save Geotiff images (original, reconstructed, masked) per timestamp.
+    Args:
+        input_img: input torch.Tensor with shape (C, T, H, W).
+        rec_img: reconstructed torch.Tensor with shape (C, T, H, W).
+        mask_img: mask torch.Tensor with shape (C, T, H, W).
+        channels: list of indices representing RGB channels.
+        mean: list of mean values for each band.
+        std: list of std values for each band.
+        output_dir: directory where to save outputs.
+        meta_data: list of dicts with geotiff meta info.
+    """
+    rgb_orig_list = []
+    rgb_mask_list = []
+    rgb_pred_list = []
+    
+    for t in range(input_img.shape[1]):
+        rgb_orig, rgb_pred = process_channel_group(orig_img=input_img[:, t, :, :],
+                                                   new_img=rec_img[:, t, :, :],
+                                                   channels=channels, data_mean=mean,
+                                                   data_std=std)
+
+        rgb_mask = mask_img[channels, t, :, :] * rgb_orig
+
+        # extract images
+        rgb_orig_list.append(_convert_np_uint8(rgb_orig))
+        rgb_mask_list.append(_convert_np_uint8(rgb_mask))
+        rgb_pred_list.append(_convert_np_uint8(rgb_pred))
+        
+    outputs = rgb_orig_list + rgb_mask_list + rgb_pred_list
+
+    return outputs
+
+
+def predict_on_images(data_files: list, mask_ratio: float, yaml_file_path: str, checkpoint: str):
+
+    
+    try:
+        data_files = [x.name for x in data_files]
+        print('Path extracted from example')
+    except:
+        print('Files submitted through UI')
+
+    # Get parameters --------
+    print('This is the printout', data_files)
+
+    with open(yaml_file_path, 'r') as f:
+        params = yaml.safe_load(f)
+
+    # data related
+    num_frames = params['num_frames']
+    img_size = params['img_size']
+    bands = params['bands']
+    mean = params['data_mean']
+    std = params['data_std']
+
+    # model related
+    depth = params['depth']
+    patch_size = params['patch_size']
+    embed_dim = params['embed_dim']
+    num_heads = params['num_heads']
+    tubelet_size = params['tubelet_size']
+    decoder_embed_dim = params['decoder_embed_dim']
+    decoder_num_heads = params['decoder_num_heads']
+    decoder_depth = params['decoder_depth']
+
+    batch_size = params['batch_size']
+
+    mask_ratio = params['mask_ratio'] if mask_ratio is None else mask_ratio
+
+    # We must have *num_frames* files to build one example!
+    assert len(data_files) == num_frames, "File list must be equal to expected number of frames."
+
+    if torch.cuda.is_available():
+        device = torch.device('cuda')
+    else:
+        device = torch.device('cpu')
+
+    print(f"Using {device} device.\n")
+
+    # Loading data ---------------------------------------------------------------------------------
+
+    input_data, meta_data = load_example(file_paths=data_files, mean=mean, std=std)
+
+    # Create model and load checkpoint -------------------------------------------------------------
+
+    model = MaskedAutoencoderViT(
+            img_size=img_size,
+            patch_size=patch_size,
+            num_frames=num_frames,
+            tubelet_size=tubelet_size,
+            in_chans=len(bands),
+            embed_dim=embed_dim,
+            depth=depth,
+            num_heads=num_heads,
+            decoder_embed_dim=decoder_embed_dim,
+            decoder_depth=decoder_depth,
+            decoder_num_heads=decoder_num_heads,
+            mlp_ratio=4.,
+            norm_layer=functools.partial(torch.nn.LayerNorm, eps=1e-6),
+            norm_pix_loss=False)
+
+    total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"\n--> Model has {total_params:,} parameters.\n")
+
+    model.to(device)
+
+    state_dict = torch.load(checkpoint, map_location=device)
+    model.load_state_dict(state_dict)
+    print(f"Loaded checkpoint from {checkpoint}")
+
+    # Running model --------------------------------------------------------------------------------
+
+    model.eval()
+    channels = [bands.index(b) for b in ['B04', 'B03', 'B02']]  # BGR -> RGB
+    
+    # Reflect pad if not divisible by img_size
+    original_h, original_w = input_data.shape[-2:]
+    pad_h = img_size - (original_h % img_size)
+    pad_w = img_size - (original_w % img_size)
+    input_data = np.pad(input_data, ((0, 0), (0, 0), (0, 0), (0, pad_h), (0, pad_w)), mode='reflect')
+
+    # Build sliding window
+    batch = torch.tensor(input_data, device='cpu')
+    windows = batch.unfold(3, img_size, img_size).unfold(4, img_size, img_size)
+    h1, w1 = windows.shape[3:5]
+    windows = rearrange(windows, 'b c t h1 w1 h w -> (b h1 w1) c t h w', h=img_size, w=img_size)
+
+    # Split into batches if number of windows > batch_size
+    num_batches = windows.shape[0] // batch_size if windows.shape[0] > batch_size else 1
+    windows = torch.tensor_split(windows, num_batches, dim=0)
+
+    # Run model
+    rec_imgs = []
+    mask_imgs = []
+    for x in windows:
+        rec_img, mask_img = run_model(model, x, mask_ratio, device)
+        rec_imgs.append(rec_img)
+        mask_imgs.append(mask_img)
+
+    rec_imgs = torch.concat(rec_imgs, dim=0)
+    mask_imgs = torch.concat(mask_imgs, dim=0)
+
+    # Build images from patches
+    rec_imgs = rearrange(rec_imgs, '(b h1 w1) c t h w -> b c t (h1 h) (w1 w)',
+                         h=img_size, w=img_size, b=1, c=len(bands), t=num_frames, h1=h1, w1=w1)
+    mask_imgs = rearrange(mask_imgs, '(b h1 w1) c t h w -> b c t (h1 h) (w1 w)',
+                          h=img_size, w=img_size, b=1, c=len(bands), t=num_frames, h1=h1, w1=w1)
+
+    # Cut padded images back to original size
+    rec_imgs_full = rec_imgs[..., :original_h, :original_w]
+    mask_imgs_full = mask_imgs[..., :original_h, :original_w]
+    batch_full = batch[..., :original_h, :original_w]
+
+    # Build RGB images
+    for d in meta_data:
+        d.update(count=3, dtype='uint8', compress='lzw', nodata=0)
+
+    # save_rgb_imgs(batch[0, ...], rec_imgs_full[0, ...], mask_imgs_full[0, ...],
+    #               channels, mean, std, output_dir, meta_data)
+
+    outputs = extract_rgb_imgs(batch_full[0, ...], rec_imgs_full[0, ...], mask_imgs_full[0, ...],
+                  channels, mean, std)
+
+
+    print("Done!")
+
+    return outputs
+
+# partial function prep
+func = partial(predict_on_images, yaml_file_path=yaml_file_path,checkpoint=checkpoint,mask_ratio=0.75)
+
+
+
+
+## South Korea rural area HSL landset merger (from B02 channel to B07 channel)
+
+def raw_NASA_tif_file_merger(PSD_NAME,tif_files):
+    src_files_to_mosaic = []
+    for tif_file in tif_files:
+        src = rasterio.open(tif_file)
+        src_files_to_mosaic.append(src)
+    mosaic, out_trans = merge(src_files_to_mosaic)
+    out_meta = src.meta.copy()
+    out_meta.update({"driver": "GTiff",
+                     "height": mosaic.shape[1],
+                     "width": mosaic.shape[2],
+                     "transform": out_trans})
+    
+    
+    with rasterio.open(PSD_NAME, "w", **out_meta) as dest:
+        dest.write(mosaic)
+
+# raw_NASA_tif_file_merger("third.tif","./1/*.tif")
+
+
+
+# streamlit area
+def main_loop():
+    st.title("HuggingFace Inference Demo")
+    st.subheader("Be sure to set the parameter")
+
+    [out1_orig_t1,out2_orig_t2,out3_orig_t3,out4_masked_t1,out5_masked_t2,out6_masked_t3,out7_pred_t1,out8_pred_t2,out9_pred_t3]=func(["first.tif","second.tif","third.tif"])
+
+
+    st.markdown("### first original image and masked image comparison")
+    image_comparison(
+        img1=out1_orig_t1,
+        img2=out4_masked_t1,
+        label1="original-1",
+        label2="masked-1",
+        width=1024,
+        )
+
+
+    st.markdown("### second original image and masked image comparison")
+    image_comparison(
+        img1=out2_orig_t2,
+        img2=out5_masked_t2,
+        label1="original-2",
+        label2="masked-2",
+        width=1024,
+        )
+
+
+    st.markdown("### thrid original image and masked image comparison")
+    image_comparison(
+        img1=out3_orig_t3,
+        img2=out6_masked_t3,
+        label1="original-1",
+        label2="masked-1",
+        width=1024,
+        )
+
+
+
+    st.markdown("### first original image and encoded image comparison")
+    image_comparison(
+        img1=out1_orig_t1,
+        img2=out7_pred_t1,
+        label1="original-1",
+        label2="masked-1",
+        width=1024,
+        )
+
+
+    st.markdown("### second original image and encoded image comparison")
+    image_comparison(
+        img1=out2_orig_t2,
+        img2=out8_pred_t2,
+        label1="original-2",
+        label2="masked-2",
+        width=1024,
+        )
+
+
+    st.markdown("### thrid original image and encoded image comparison")
+    image_comparison(
+        img1=out3_orig_t3,
+        img2=out9_pred_t3,
+        label1="original-1",
+        label2="masked-1",
+        width=1024,
+        )
+
+if __name__ == '__main__':
+    main_loop()
+
+

requirements.txt

@@ -0,0 +1,5 @@
+torch
+torchvision
+timm
+einops
+rasterio

streamlit-testing.webm

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