app.py

"""
E3Diff: High-Resolution SAR-to-Optical Translation
HuggingFace Spaces Deployment

Features:
- Full resolution processing with seamless tiling
- Multi-step inference for maximum quality
- TIFF output support
- Professional post-processing
"""

import os
import sys
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from PIL import Image, ImageEnhance
import gradio as gr
from pathlib import Path
import tempfile
import time
from tqdm import tqdm
from huggingface_hub import hf_hub_download

# ============================================================================
# SoftPool Implementation (Pure PyTorch)
# ============================================================================

def soft_pool2d(x, kernel_size=(2, 2), stride=None, force_inplace=False):
    if stride is None:
        stride = kernel_size
    if isinstance(kernel_size, int):
        kernel_size = (kernel_size, kernel_size)
    if isinstance(stride, int):
        stride = (stride, stride)
    
    batch, channels, height, width = x.shape
    kh, kw = kernel_size
    sh, sw = stride
    out_h = (height - kh) // sh + 1
    out_w = (width - kw) // sw + 1
    
    x_unfold = F.unfold(x, kernel_size=kernel_size, stride=stride)
    x_unfold = x_unfold.view(batch, channels, kh * kw, out_h * out_w)
    x_max = x_unfold.max(dim=2, keepdim=True)[0]
    exp_x = torch.exp(x_unfold - x_max)
    softpool = (x_unfold * exp_x).sum(dim=2) / (exp_x.sum(dim=2) + 1e-8)
    return softpool.view(batch, channels, out_h, out_w)


class SoftPool2d(nn.Module):
    def __init__(self, kernel_size=(2, 2), stride=None, force_inplace=False):
        super(SoftPool2d, self).__init__()
        self.kernel_size = kernel_size if isinstance(kernel_size, tuple) else (kernel_size, kernel_size)
        self.stride = stride if stride is not None else self.kernel_size
    
    def forward(self, x):
        return soft_pool2d(x, self.kernel_size, self.stride)


# Monkey-patch SoftPool into the expected location
import sys
class SoftPoolModule:
    soft_pool2d = staticmethod(soft_pool2d)
    SoftPool2d = SoftPool2d
sys.modules['SoftPool'] = SoftPoolModule()

# ============================================================================
# Model Architecture
# ============================================================================

import math
from inspect import isfunction

def exists(x):
    return x is not None

def default(val, d):
    if exists(val):
        return val
    return d() if isfunction(d) else d


class PositionalEncoding(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.dim = dim

    def forward(self, noise_level):
        count = self.dim // 2
        step = torch.arange(count, dtype=noise_level.dtype, device=noise_level.device) / count
        encoding = noise_level.unsqueeze(1) * torch.exp(-math.log(1e4) * step.unsqueeze(0))
        encoding = torch.cat([torch.sin(encoding), torch.cos(encoding)], dim=-1)
        return encoding


class Swish(nn.Module):
    def forward(self, x):
        return x * torch.sigmoid(x)


class FeatureWiseAffine(nn.Module):
    def __init__(self, in_channels, out_channels, use_affine_level=False):
        super(FeatureWiseAffine, self).__init__()
        self.use_affine_level = use_affine_level
        self.noise_func = nn.Sequential(nn.Linear(in_channels, out_channels*(1+self.use_affine_level)))

    def forward(self, x, noise_embed):
        batch = x.shape[0]
        if self.use_affine_level:
            gamma, beta = self.noise_func(noise_embed).view(batch, -1, 1, 1).chunk(2, dim=1)
            x = (1 + gamma) * x + beta
        else:
            x = x + self.noise_func(noise_embed).view(batch, -1, 1, 1)
        return x


class Upsample(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.up = nn.Upsample(scale_factor=2, mode="nearest")
        self.conv = nn.Conv2d(dim, dim, 3, padding=1)

    def forward(self, x):
        return self.conv(self.up(x))


class Downsample(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.conv = nn.Conv2d(dim, dim, 3, 2, 1)

    def forward(self, x):
        return self.conv(x)


class Block(nn.Module):
    def __init__(self, dim, dim_out, groups=32, dropout=0, stride=1):
        super().__init__()
        self.block = nn.Sequential(
            nn.GroupNorm(groups, dim),
            Swish(),
            nn.Dropout(dropout) if dropout != 0 else nn.Identity(),
            nn.Conv2d(dim, dim_out, 3, stride=stride, padding=1)
        )

    def forward(self, x):
        return self.block(x)


class ResnetBlock(nn.Module):
    def __init__(self, dim, dim_out, noise_level_emb_dim=None, dropout=0, use_affine_level=False, norm_groups=32):
        super().__init__()
        self.noise_func = FeatureWiseAffine(noise_level_emb_dim, dim_out, use_affine_level)
        self.c_func = nn.Conv2d(dim_out, dim_out, 1)
        self.block1 = Block(dim, dim_out, groups=norm_groups)
        self.block2 = Block(dim_out, dim_out, groups=norm_groups, dropout=dropout)
        self.res_conv = nn.Conv2d(dim, dim_out, 1) if dim != dim_out else nn.Identity()

    def forward(self, x, time_emb, c):
        h = self.block1(x)
        h = self.noise_func(h, time_emb)
        h = self.block2(h)
        h = self.c_func(c) + h
        return h + self.res_conv(x)


class SelfAttention(nn.Module):
    def __init__(self, in_channel, n_head=1, norm_groups=32):
        super().__init__()
        self.n_head = n_head
        self.norm = nn.GroupNorm(norm_groups, in_channel)
        self.qkv = nn.Conv2d(in_channel, in_channel * 3, 1, bias=False)
        self.out = nn.Conv2d(in_channel, in_channel, 1)

    def forward(self, input, t=None, save_flag=None, file_num=None):
        batch, channel, height, width = input.shape
        n_head = self.n_head
        head_dim = channel // n_head
        norm = self.norm(input)
        qkv = self.qkv(norm).view(batch, n_head, head_dim * 3, height, width)
        query, key, value = qkv.chunk(3, dim=2)
        attn = torch.einsum("bnchw, bncyx -> bnhwyx", query, key).contiguous() / math.sqrt(channel)
        attn = attn.view(batch, n_head, height, width, -1)
        attn = torch.softmax(attn, -1)
        attn = attn.view(batch, n_head, height, width, height, width)
        out = torch.einsum("bnhwyx, bncyx -> bnchw", attn, value).contiguous()
        out = self.out(out.view(batch, channel, height, width))
        return out + input


class ResnetBlocWithAttn(nn.Module):
    def __init__(self, dim, dim_out, *, noise_level_emb_dim=None, norm_groups=32, dropout=0, with_attn=False, size=256):
        super().__init__()
        self.with_attn = with_attn
        self.res_block = ResnetBlock(dim, dim_out, noise_level_emb_dim, norm_groups=norm_groups, dropout=dropout)
        if with_attn:
            self.attn = SelfAttention(dim_out, norm_groups=norm_groups)

    def forward(self, x, time_emb, c, t=0, save_flag=False, file_i=0):
        x = self.res_block(x, time_emb, c)
        if self.with_attn:
            x = self.attn(x, t=t, save_flag=save_flag, file_num=file_i)
        return x


class ResBlock_normal(nn.Module):
    def __init__(self, dim, dim_out, dropout=0, norm_groups=32):
        super().__init__()
        self.block1 = Block(dim, dim_out, groups=norm_groups)
        self.block2 = Block(dim_out, dim_out, groups=norm_groups, dropout=dropout)
        self.res_conv = nn.Conv2d(dim, dim_out, 1) if dim != dim_out else nn.Identity()

    def forward(self, x):
        h = self.block1(x)
        h = self.block2(h)
        return h + self.res_conv(x)


class CPEN(nn.Module):
    def __init__(self, inchannel=1):
        super(CPEN, self).__init__()
        self.pool = SoftPool2d(kernel_size=(2,2), stride=(2,2))
        self.E1 = nn.Sequential(nn.Conv2d(inchannel, 64, kernel_size=3, padding=1), Swish())
        self.E2 = nn.Sequential(ResBlock_normal(64, 128, dropout=0, norm_groups=16), ResBlock_normal(128, 128, dropout=0, norm_groups=16))
        self.E3 = nn.Sequential(ResBlock_normal(128, 256, dropout=0, norm_groups=16), ResBlock_normal(256, 256, dropout=0, norm_groups=16))
        self.E4 = nn.Sequential(ResBlock_normal(256, 512, dropout=0, norm_groups=16), ResBlock_normal(512, 512, dropout=0, norm_groups=16))
        self.E5 = nn.Sequential(ResBlock_normal(512, 512, dropout=0, norm_groups=16), ResBlock_normal(512, 1024, dropout=0, norm_groups=16))

    def forward(self, x):
        x1 = self.E1(x)
        x2 = self.pool(x1)
        x2 = self.E2(x2)
        x3 = self.pool(x2)
        x3 = self.E3(x3)
        x4 = self.pool(x3)
        x4 = self.E4(x4)
        x5 = self.pool(x4)
        x5 = self.E5(x5)
        return x1, x2, x3, x4, x5


class UNet(nn.Module):
    def __init__(self, in_channel=6, out_channel=3, inner_channel=32, norm_groups=32,
                 channel_mults=(1, 2, 4, 8, 8), attn_res=(8), res_blocks=3, dropout=0,
                 with_noise_level_emb=True, image_size=128, condition_ch=3):
        super().__init__()
        
        if with_noise_level_emb:
            noise_level_channel = inner_channel
            self.noise_level_mlp = nn.Sequential(
                PositionalEncoding(inner_channel),
                nn.Linear(inner_channel, inner_channel * 4),
                Swish(),
                nn.Linear(inner_channel * 4, inner_channel)
            )
        else:
            noise_level_channel = None
            self.noise_level_mlp = None

        self.res_blocks = res_blocks
        num_mults = len(channel_mults)
        self.num_mults = num_mults
        pre_channel = inner_channel
        feat_channels = [pre_channel]
        now_res = image_size
        
        downs = [nn.Conv2d(in_channel, inner_channel, kernel_size=3, padding=1)]
        for ind in range(num_mults):
            is_last = (ind == num_mults - 1)
            use_attn = (now_res in attn_res)
            channel_mult = inner_channel * channel_mults[ind]
            for _ in range(0, res_blocks):
                downs.append(ResnetBlocWithAttn(pre_channel, channel_mult, noise_level_emb_dim=noise_level_channel, 
                                                norm_groups=norm_groups, dropout=dropout, with_attn=use_attn, size=now_res))
                feat_channels.append(channel_mult)
                pre_channel = channel_mult
            if not is_last:
                downs.append(Downsample(pre_channel))
                feat_channels.append(pre_channel)
                now_res = now_res // 2
        self.downs = nn.ModuleList(downs)

        self.mid = nn.ModuleList([
            ResnetBlocWithAttn(pre_channel, pre_channel, noise_level_emb_dim=noise_level_channel, 
                              norm_groups=norm_groups, dropout=dropout, with_attn=True, size=now_res),
            ResnetBlocWithAttn(pre_channel, pre_channel, noise_level_emb_dim=noise_level_channel,
                              norm_groups=norm_groups, dropout=dropout, with_attn=False, size=now_res)
        ])

        ups = []
        for ind in reversed(range(num_mults)):
            is_last = (ind < 1)
            use_attn = (now_res in attn_res)
            channel_mult = inner_channel * channel_mults[ind]
            for _ in range(0, res_blocks + 1):
                ups.append(ResnetBlocWithAttn(pre_channel + feat_channels.pop(), channel_mult, 
                                              noise_level_emb_dim=noise_level_channel, norm_groups=norm_groups,
                                              dropout=dropout, with_attn=use_attn, size=now_res))
                pre_channel = channel_mult
            if not is_last:
                ups.append(Upsample(pre_channel))
                now_res = now_res * 2
        self.ups = nn.ModuleList(ups)

        self.final_conv = Block(pre_channel, default(out_channel, in_channel), groups=norm_groups)
        self.condition = CPEN(inchannel=condition_ch)
        self.condition_ch = condition_ch

    def forward(self, x, time, img_s1=None, class_label=None, return_condition=False, t_ori=0):
        condition = x[:, :self.condition_ch, ...].clone()
        x = x[:, self.condition_ch:, ...]
        
        c1, c2, c3, c4, c5 = self.condition(condition)
        c_base = [c1, c2, c3, c4, c5]
        
        c = []
        for i in range(len(c_base)):
            for _ in range(self.res_blocks):
                c.append(c_base[i])

        t = self.noise_level_mlp(time) if exists(self.noise_level_mlp) else None

        feats = []
        i = 0
        for layer in self.downs:
            if isinstance(layer, ResnetBlocWithAttn):
                x = layer(x, t, c[i])
                i += 1
            else:
                x = layer(x)
            feats.append(x)

        for layer in self.mid:
            if isinstance(layer, ResnetBlocWithAttn):
                x = layer(x, t, c5)
            else:
                x = layer(x)

        c_base = [c5, c4, c3, c2, c1]
        c = []
        for i in range(len(c_base)):
            for _ in range(self.res_blocks + 1):
                c.append(c_base[i])
        
        i = 0
        for layer in self.ups:
            if isinstance(layer, ResnetBlocWithAttn):
                x = layer(torch.cat((x, feats.pop()), dim=1), t, c[i])
                i += 1
            else:
                x = layer(x)

        if not return_condition:
            return self.final_conv(x)
        else:
            return self.final_conv(x), [c1, c2, c3, c4, c5]


# ============================================================================
# E3Diff High-Resolution Inference
# ============================================================================

class E3DiffHighRes:
    def __init__(self, device="cuda"):
        self.device = torch.device(device if torch.cuda.is_available() else "cpu")
        self.model = None
        self.image_size = 256
        
    def load_model(self, weights_path=None):
        if weights_path is None:
            # Download from HuggingFace
            weights_path = hf_hub_download(
                repo_id="Dhenenjay/E3Diff-SAR2Optical",
                filename="I700000_E719_gen.pth"
            )
        
        # Build UNet
        self.model = UNet(
            in_channel=3,
            out_channel=3,
            norm_groups=16,
            inner_channel=64,
            channel_mults=[1, 2, 4, 8, 16],
            attn_res=[],
            res_blocks=1,
            dropout=0,
            image_size=self.image_size,
            condition_ch=3
        ).to(self.device)
        
        # Load weights
        state_dict = torch.load(weights_path, map_location=self.device, weights_only=False)
        
        # Filter only UNet weights
        unet_dict = {k.replace('denoise_fn.', ''): v for k, v in state_dict.items() 
                     if k.startswith('denoise_fn.')}
        
        self.model.load_state_dict(unet_dict, strict=False)
        self.model.eval()
        print(f"Model loaded on {self.device}")
        
    @torch.no_grad()
    def translate_tile(self, tile_tensor, num_steps=1):
        """Translate a single 256x256 tile."""
        batch_size = tile_tensor.shape[0]
        
        # Initialize noise
        noise = torch.randn(batch_size, 3, self.image_size, self.image_size, device=self.device)
        
        # DDIM sampling
        total_timesteps = 1000
        ts = torch.linspace(total_timesteps, 0, num_steps + 1).to(self.device).long()
        
        # Create beta schedule
        betas = torch.linspace(1e-6, 1e-2, total_timesteps, device=self.device)
        alphas = 1. - betas
        alphas_cumprod = torch.cumprod(alphas, dim=0)
        sqrt_alphas_cumprod_prev = torch.sqrt(torch.cat([torch.ones(1, device=self.device), alphas_cumprod]))
        
        x = noise
        for i in range(1, num_steps + 1):
            cur_t = ts[i - 1] - 1
            prev_t = ts[i] - 1
            
            noise_level = sqrt_alphas_cumprod_prev[cur_t].repeat(batch_size, 1)
            
            alpha_prod_t = alphas_cumprod[cur_t]
            alpha_prod_t_prev = alphas_cumprod[prev_t] if prev_t >= 0 else torch.tensor(1.0, device=self.device)
            beta_prod_t = 1 - alpha_prod_t
            
            # Model prediction
            model_input = torch.cat([tile_tensor, x], dim=1)
            model_output = self.model(model_input, noise_level)
            
            # DDIM update
            pred_original = (x - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5
            pred_original = pred_original.clamp(-1, 1)
            
            sigma_2 = 0.8 * (1 - alpha_prod_t_prev) / (1 - alpha_prod_t) * (1 - alpha_prod_t / alpha_prod_t_prev)
            pred_dir = (1 - alpha_prod_t_prev - sigma_2) ** 0.5 * model_output
            
            if i < num_steps:
                noise = torch.randn_like(x)
                x = alpha_prod_t_prev ** 0.5 * pred_original + pred_dir + sigma_2 ** 0.5 * noise
            else:
                x = pred_original
        
        return x
    
    def create_blend_weights(self, tile_size, overlap):
        """Create smooth blending weights for seamless tiling."""
        # Linear ramp for overlap regions
        ramp = np.linspace(0, 1, overlap)
        
        # Create 2D weight matrix
        weight = np.ones((tile_size, tile_size))
        
        # Apply ramps to edges
        weight[:overlap, :] *= ramp[:, np.newaxis]  # Top
        weight[-overlap:, :] *= ramp[::-1, np.newaxis]  # Bottom
        weight[:, :overlap] *= ramp[np.newaxis, :]  # Left
        weight[:, -overlap:] *= ramp[np.newaxis, ::-1]  # Right
        
        return weight[:, :, np.newaxis]
    
    def translate_full_resolution(self, image, num_steps=1, overlap=64, progress_callback=None):
        """
        Translate full resolution image using seamless tiling.
        """
        # Convert to numpy if PIL
        if isinstance(image, Image.Image):
            if image.mode != 'RGB':
                image = image.convert('RGB')
            img_np = np.array(image).astype(np.float32) / 255.0
        else:
            img_np = image
        
        h, w = img_np.shape[:2]
        tile_size = self.image_size
        step = tile_size - overlap
        
        # Pad image to ensure full coverage
        pad_h = (step - (h - overlap) % step) % step
        pad_w = (step - (w - overlap) % step) % step
        img_padded = np.pad(img_np, ((0, pad_h), (0, pad_w), (0, 0)), mode='reflect')
        
        h_pad, w_pad = img_padded.shape[:2]
        
        # Output arrays
        output = np.zeros((h_pad, w_pad, 3), dtype=np.float32)
        weights = np.zeros((h_pad, w_pad, 1), dtype=np.float32)
        
        # Blending weights
        blend_weight = self.create_blend_weights(tile_size, overlap)
        
        # Calculate tile positions
        y_positions = list(range(0, h_pad - tile_size + 1, step))
        x_positions = list(range(0, w_pad - tile_size + 1, step))
        total_tiles = len(y_positions) * len(x_positions)
        
        print(f"Processing {total_tiles} tiles ({len(x_positions)}x{len(y_positions)})...")
        
        tile_idx = 0
        for y in y_positions:
            for x in x_positions:
                # Extract tile
                tile = img_padded[y:y+tile_size, x:x+tile_size]
                
                # Convert to tensor [-1, 1]
                tile_tensor = torch.from_numpy(tile).permute(2, 0, 1).unsqueeze(0)
                tile_tensor = tile_tensor * 2.0 - 1.0
                tile_tensor = tile_tensor.to(self.device)
                
                # Translate
                result_tensor = self.translate_tile(tile_tensor, num_steps)
                
                # Convert back to numpy [0, 1]
                result = result_tensor.squeeze(0).permute(1, 2, 0).cpu().numpy()
                result = (result + 1.0) / 2.0
                result = np.clip(result, 0, 1)
                
                # Add to output with blending
                output[y:y+tile_size, x:x+tile_size] += result * blend_weight
                weights[y:y+tile_size, x:x+tile_size] += blend_weight
                
                tile_idx += 1
                if progress_callback:
                    progress_callback(tile_idx / total_tiles)
        
        # Normalize by weights
        output = output / (weights + 1e-8)
        
        # Crop to original size
        output = output[:h, :w]
        
        return output
    
    def enhance_output(self, image, contrast=1.1, sharpness=1.15, color=1.1):
        """Apply professional post-processing."""
        if isinstance(image, np.ndarray):
            image = Image.fromarray((image * 255).astype(np.uint8))
        
        # Contrast
        image = ImageEnhance.Contrast(image).enhance(contrast)
        # Sharpness
        image = ImageEnhance.Sharpness(image).enhance(sharpness)
        # Color saturation
        image = ImageEnhance.Color(image).enhance(color)
        
        return image


# ============================================================================
# Gradio Interface
# ============================================================================

model = None

def load_sar_image(filepath):
    """Load SAR image from various formats."""
    try:
        import rasterio
        with rasterio.open(filepath) as src:
            data = src.read(1)
            if data.dtype in [np.float32, np.float64]:
                valid = data[np.isfinite(data)]
                if len(valid) > 0:
                    p2, p98 = np.percentile(valid, [2, 98])
                    data = np.clip(data, p2, p98)
                    data = ((data - p2) / (p98 - p2 + 1e-8) * 255).astype(np.uint8)
            elif data.dtype == np.uint16:
                p2, p98 = np.percentile(data, [2, 98])
                data = np.clip(data, p2, p98)
                data = ((data - p2) / (p98 - p2 + 1e-8) * 255).astype(np.uint8)
            return Image.fromarray(data).convert('RGB')
    except:
        pass
    
    return Image.open(filepath).convert('RGB')


def translate_sar(image, num_steps, overlap, enhance, progress=gr.Progress()):
    """Main translation function."""
    global model
    
    if model is None:
        progress(0, desc="Loading model...")
        model = E3DiffHighRes()
        model.load_model()
    
    progress(0.1, desc="Processing image...")
    
    # Handle file upload
    if isinstance(image, str):
        image = load_sar_image(image)
    
    w, h = image.size
    print(f"Input size: {w}x{h}")
    
    # Progress callback
    def update_progress(p):
        progress(0.1 + 0.8 * p, desc=f"Translating... {int(p*100)}%")
    
    # Translate
    start = time.time()
    result = model.translate_full_resolution(
        image, 
        num_steps=num_steps, 
        overlap=overlap,
        progress_callback=update_progress
    )
    elapsed = time.time() - start
    
    progress(0.9, desc="Post-processing...")
    
    # Convert to PIL
    result_pil = Image.fromarray((result * 255).astype(np.uint8))
    
    # Enhance if requested
    if enhance:
        result_pil = model.enhance_output(result_pil)
    
    # Save as TIFF
    tiff_path = tempfile.mktemp(suffix='.tiff')
    result_pil.save(tiff_path, format='TIFF', compression='lzw')
    
    progress(1.0, desc="Complete!")
    
    info = f"Processed in {elapsed:.1f}s | Output: {result_pil.size[0]}x{result_pil.size[1]}"
    
    return result_pil, tiff_path, info


# Create Gradio interface
with gr.Blocks(title="E3Diff: SAR-to-Optical Translation", theme=gr.themes.Soft()) as demo:
    gr.Markdown("""
    # 🛰️ E3Diff: High-Resolution SAR-to-Optical Translation
    
    **CVPR PBVS2025 Challenge Winner** | Upload any SAR image and get a photorealistic optical translation.
    
    - Supports full resolution processing with seamless tiling
    - Multiple quality levels (1-8 inference steps)
    - Professional post-processing
    - TIFF output for commercial use
    """)
    
    with gr.Row():
        with gr.Column():
            input_image = gr.Image(label="SAR Input", type="pil")
            
            with gr.Row():
                num_steps = gr.Slider(1, 8, value=1, step=1, label="Quality Steps (1=fast, 4-8=high quality)")
                overlap = gr.Slider(16, 128, value=64, step=16, label="Tile Overlap (higher=smoother)")
            
            enhance = gr.Checkbox(value=True, label="Apply post-processing enhancement")
            
            submit_btn = gr.Button("🚀 Translate to Optical", variant="primary")
        
        with gr.Column():
            output_image = gr.Image(label="Optical Output")
            output_file = gr.File(label="Download TIFF (full resolution)")
            info_text = gr.Textbox(label="Processing Info")
    
    submit_btn.click(
        fn=translate_sar,
        inputs=[input_image, num_steps, overlap, enhance],
        outputs=[output_image, output_file, info_text]
    )
    
    gr.Markdown("""
    ---
    **Tips for best results:**
    - For aerial/satellite SAR: Use steps=1-2 for speed, steps=4-8 for quality
    - For noisy SAR: Apply speckle filtering first (Lee or PPB filter)
    - The model works best with Sentinel-1 style imagery
    
    **Citation:** Qin et al., "Efficient End-to-End Diffusion Model for One-step SAR-to-Optical Translation", IEEE GRSL 2024
    """)


if __name__ == "__main__":
    demo.launch()