Upload 41 files

README.md

@@ -0,0 +1,70 @@
+
+<div align="center">
+ 
+#  CSSM
+**Efficient Remote Sensing Change Detection with Change State Space Models**
+
+[**E.Ghazaei**](https://scholar.google.com/citations?user=R-ghC00AAAAJ&hl=en), [**E.Aptoula**](https://sites.google.com/view/erchan-aptoula/) 
+
+ Faculty of Engineering and Natural Sciences (VPALab), Sabanci University, Istanbul, Turkiye
+
+[[Paper Link](https://arxiv.org/abs/2504.11080)] 
+</div>
+
+
+
+## 🛎️Updates
+* **` Notice🐍🐍`**: CSSM has been accepted by [IEEE GRSL](https://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=8859)! We'd appreciate it if you could give this repo a ⭐️**star**⭐️ and stay tuned!!
+* **` Nov 05th, 2025`**: The CSSM model and training code uploaded. You are welcome to use them!!
+
+
+
+
+---
+
+
+## 🚀 Overview
+
+
+* [**CSSM**]() serves as an efficient and state-of-the-art (SOTA) benchmark for binary change detection.
+
+
+
+<p align="center">
+  
+<img width="1395" height="579" alt="Screenshot from 2025-11-03 16-28-31" src="https://github.com/user-attachments/assets/dccfdfc5-98b4-443d-b170-07e5e3ec551d" />
+</p>
+
+
+---
+
+
+## Datasets
+We used [LEVIR-CD+](https://www.kaggle.com/datasets/mdrifaturrahman33/levir-cd-change-detection), [SYSU-CD](https://github.com/liumency/SYSU-CD), and [WHU-CD](http://gpcv.whu.edu.cn/data/building_dataset.html) as the main datasets, while [CDD](http://gpcv.whu.edu.cn/data/building_dataset.html) and [OSCD](https://www.kaggle.com/datasets/soumikrakshit/onera-satellite-change-detection-dataset) were included in the ablation study to demonstrate the robustness of our model under different conditions.
+
+
+**Qualitative Analysis:**
+
+
+
+
+
+<p align="center">
+<img width="1379" height="357" alt="Screenshot from 2025-11-03 16-38-52" src="https://github.com/user-attachments/assets/c63690af-fd07-40af-b991-2b5b33ff53af" />
+</p>
+
+---
+# Results
+
+![Screenshot from 2025-04-13 14-51-16](https://github.com/user-attachments/assets/36f7487a-c08b-4205-9c05-e9b909ef0c89)
+
+
+
+# Complexity
+
+<div align="center">
+
+![Screenshot from 2025-04-13 14-56-37](https://github.com/user-attachments/assets/b4b50828-fdd0-4b31-a4c2-e802ec43b404)
+
+</div>
+

data_maker/data_provider.py

@@ -0,0 +1,178 @@
+import torch
+import torchvision
+import numpy as np 
+from PIL import Image 
+import os
+from torchvision import transforms
+import pandas as pd
+
+
+from torch.utils.data import Dataset
+
+
+
+tfms_normal = transforms.Compose([
+    transforms.CenterCrop(size=(256,256)), 
+    transforms.ToTensor()
+    # transforms.Normalize(mean=[0.46,0.44,0.39], std= [0.19,0.18,0.19])
+])
+
+tfms_target = transforms.CenterCrop(size = (256,256))
+    
+
+class Data_provider_SYSU(Dataset):
+
+
+    def __init__(self, path):
+        self.data_path = path 
+        self.pre_path = os.path.join(path, "time1")
+        self.post_path = os.path.join(path, "time2")
+        self.target_path = os.path.join(path, "label")
+
+    def __len__(self):
+        return len(os.listdir(self.post_path))
+    
+    def __getitem__(self, idx):
+
+        post_list = os.listdir(self.pre_path)
+        pre_list = os.listdir(self.post_path)
+        target_list = os.listdir(self.target_path)
+
+        post_list.sort()
+        pre_list.sort()
+        target_list.sort()
+
+        pre_image_path = os.path.join(self.pre_path, pre_list[idx])
+        post_image_path = os.path.join(self.post_path, post_list[idx])
+        target_path =  os.path.join(self.target_path, target_list[idx])
+
+        pre_image = Image.open(pre_image_path)
+        post_image = Image.open(post_image_path)
+        target_image = Image.open(target_path) 
+
+        pre_image = tfms_normal(pre_image)
+        post_image = tfms_normal(post_image)
+
+
+        target_image = torch.tensor(np.array(tfms_target(target_image))/255).long()
+
+
+
+        return pre_image, post_image, target_image
+    
+
+class Data_provider_levir(Dataset):
+
+
+    def __init__(self, path):
+        self.data_path = path 
+        self.pre_path = os.path.join(path, "A")
+        self.post_path = os.path.join(path, "B")
+        self.target_path = os.path.join(path, "label")
+
+    def __len__(self):
+        return len(os.listdir(self.post_path))
+    
+    def __getitem__(self, idx):
+
+        pre_list = os.listdir(self.pre_path)
+        post_list = os.listdir(self.post_path)
+        target_list = os.listdir(self.target_path)
+
+        post_list.sort()
+        pre_list.sort()
+        target_list.sort()
+
+        pre_image_path = os.path.join(self.pre_path, pre_list[idx])
+        post_image_path = os.path.join(self.post_path, post_list[idx])
+        target_path =  os.path.join(self.target_path, target_list[idx])
+        # print(pre_image_path)
+        # print(post_image_path)
+        # print(target_path)
+
+        pre_image = Image.open(pre_image_path)
+        post_image = Image.open(post_image_path)
+        target_image = Image.open(target_path) 
+
+        pre_image = tfms_normal(pre_image)
+        post_image = tfms_normal(post_image)
+
+
+        target_image = torch.tensor(np.array(target_image)/ 255).long()
+
+
+
+        return pre_image, post_image, target_image
+    
+    
+
+
+
+
+class Data_provider_WHU(Dataset):
+
+
+    def __init__(self, path, file):
+        self.data_path = path 
+        self.pre_path = os.path.join(path, "A")
+        self.post_path = os.path.join(path, "B")
+        self.target_path = os.path.join(path, "label")
+        self.data_names = np.array(pd.read_csv(file, names=["tt"]))
+
+
+    def __len__(self):
+        return len(self.data_names)
+    
+    def __getitem__(self, idx):
+
+        name = self.data_names[idx].item()
+
+        # post_list = os.listdir(self.post_path)
+        # pre_list = os.listdir(self.pre_path)
+        # target_list = os.listdir(self.target_path)
+
+
+        # post_list.sort()
+        # pre_list.sort()
+        # target_list.sort()
+
+
+
+        pre_image_path = os.path.join(self.pre_path,name )
+        post_image_path = os.path.join(self.post_path,name )
+        target_path =  os.path.join(self.target_path, name)
+
+
+
+ 
+
+        pre_image = Image.open(pre_image_path)
+        post_image = Image.open(post_image_path)
+        target_image = Image.open(target_path) 
+
+
+        pre_image = tfms_normal(pre_image)
+        post_image = tfms_normal(post_image)
+
+        target_image = torch.tensor(np.array(tfms_target(target_image)) / 255).long()
+  
+
+
+
+        return pre_image, post_image, target_image
+
+
+
+
+
+
+
+
+
+
+
+    
+
+
+
+

main.py

@@ -0,0 +1,247 @@
+
+
+import sys
+import os
+import argparse
+from data_maker.data_provider import Data_provider_levir, Data_provider_SYSU, Data_provider_WHU
+import matplotlib.pyplot as plt
+from torch.utils.data import random_split
+from torch.utils.data import DataLoader
+import random
+import numpy as np
+from method.Model import MambaCSSMUnet
+import copy
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn.modules.padding import ReplicationPad2d
+from utils.metrics.ev import Evaluator
+from utils.loss.L import lovasz_softmax
+import time
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Change Detection Training Script')
+    
+    # Dataset arguments
+    parser.add_argument('--dataset', type=str, required=True, 
+                        choices=['levir', 'sysu', 'whu'],
+                        help='Dataset to use: levir, sysu, or whu')
+    parser.add_argument('--train_path', type=str, required=True,
+                        help='Path to training data (for WHU: main data directory)')
+    parser.add_argument('--test_path', type=str, default=None,
+                        help='Path to test data (not used for WHU dataset)')
+    parser.add_argument('--val_path', type=str, default=None,
+                        help='Path to validation data (not used for WHU dataset)')
+    
+    # WHU-CD specific arguments
+    parser.add_argument('--train_txt', type=str, default=None,
+                        help='Text file for WHU-CD training data (required for WHU dataset)')
+    parser.add_argument('--test_txt', type=str, default=None,
+                        help='Text file for WHU-CD test data (required for WHU dataset)')
+    parser.add_argument('--val_txt', type=str, default=None,
+                        help='Text file for WHU-CD validation data (required for WHU dataset)')
+    
+    # Training hyperparameters
+    parser.add_argument('--batch_size', type=int, default=64,
+                        help='Batch size for training (default: 64)')
+    parser.add_argument('--epochs', type=int, default=50,
+                        help='Number of training epochs (default: 50)')
+    parser.add_argument('--lr', type=float, default=1e-3,
+                        help='Learning rate (default: 0.001)')
+    parser.add_argument('--step_size', type=int, default=10,
+                        help='Step size for learning rate scheduler (default: 10)')
+    
+    # Model saving
+    parser.add_argument('--save_dir', type=str, default='./checkpoints',
+                        help='Directory to save model checkpoints (default: ./checkpoints)')
+    parser.add_argument('--model_name', type=str, default='best_model.pth',
+                        help='Name for saved model file (default: best_model.pth)')
+    
+    # Other settings
+    parser.add_argument('--seed', type=int, default=42,
+                        help='Random seed (default: 42)')
+    parser.add_argument('--num_workers', type=int, default=4,
+                        help='Number of data loading workers (default: 4)')
+    
+    return parser.parse_args()
+
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def get_data_provider(dataset_name):
+    """Return the appropriate data provider class based on dataset name"""
+    providers = {
+        'levir': Data_provider_levir,
+        'sysu': Data_provider_SYSU,
+        'whu': Data_provider_WHU
+    }
+    return providers[dataset_name]
+
+
+def seed_worker(worker_id):
+    worker_seed = 42
+    np.random.seed(worker_seed)
+    random.seed(worker_seed)
+
+
+def train(model, data, loss_ce, opt, device, train_list):
+    model.train()
+    size = len(data.dataset)
+
+    for b, (pre, post, target) in enumerate(data):
+        pre, post, target = pre.to(device), post.to(device), target.to(device)
+
+        y_pred = model(pre, post)
+
+        loss = loss_ce(y_pred, target) + lovasz_softmax(F.softmax(y_pred, dim=1), target, ignore=255)    
+
+        opt.zero_grad()
+        loss.backward()
+        opt.step()
+
+        train_list.append(loss.item())
+
+        print(f"loss:{loss.item():.4f} [{b * len(pre)} | {size}]")
+
+
+def test(model, data, loss_ce, device, evaluator, val_list):
+    model.eval()
+    size = len(data.dataset)
+    num_batch = len(data)
+    test_loss = 0
+
+    evaluator.reset()
+
+    with torch.no_grad():
+        for pre, post, target in data:
+            pre, post, target = pre.to(device), post.to(device), target.to(device)
+
+            y_pred = model(pre, post) 
+            test_loss += loss_ce(y_pred, target).item()
+            output_clf = y_pred.data.cpu().numpy()
+            output_clf = np.argmax(output_clf, axis=1)
+            labels_clf = target.cpu().numpy()
+
+            evaluator.add_batch(labels_clf, output_clf)
+
+        test_loss /= num_batch
+        val_list.append(test_loss)
+        print(f"Validation Loss: {test_loss:.4f}")
+        print(f"IoU: {evaluator.Intersection_over_Union()}")
+        print(f"Confusion Matrix:\n{evaluator.confusion_matrix}")
+        return np.array(evaluator.Intersection_over_Union()).mean()
+
+
+def main():
+    args = parse_args()
+    
+    # Validate dataset requirements
+    if args.dataset == 'whu':
+        if not all([args.train_txt, args.test_txt, args.val_txt]):
+            print("Error: WHU dataset requires --train_txt, --test_txt, and --val_txt arguments")
+            sys.exit(1)
+    else:
+        if not all([args.test_path, args.val_path]):
+            print(f"Error: {args.dataset.upper()} dataset requires --train_path, --test_path, and --val_path arguments")
+            sys.exit(1)
+    
+    # Set seed
+    set_seed(args.seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    
+    # Setup device
+    if torch.cuda.is_available():
+        device = torch.device("cuda")
+        print("Using CUDA")
+    else:
+        device = torch.device("cpu")
+        print("Using CPU")
+    
+    # Create save directory
+    os.makedirs(args.save_dir, exist_ok=True)
+    
+    # Load dataset
+    print(f"\nLoading {args.dataset.upper()} dataset...")
+    DataProvider = get_data_provider(args.dataset)
+    
+    if args.dataset == 'whu':
+        # WHU uses single data path with different text files
+        train_ds = DataProvider(args.train_path, args.train_txt)
+        test_ds = DataProvider(args.train_path, args.test_txt)
+        val_ds = DataProvider(args.train_path, args.val_txt)
+    else:
+        # LEVIR and SYSU use separate paths
+        train_ds = DataProvider(args.train_path)
+        test_ds = DataProvider(args.test_path)
+        val_ds = DataProvider(args.val_path)
+    
+    # Create data loaders
+    train_dl = DataLoader(dataset=train_ds, batch_size=args.batch_size, 
+                         shuffle=True, num_workers=args.num_workers, 
+                         worker_init_fn=seed_worker)
+    val_dl = DataLoader(dataset=val_ds, batch_size=args.batch_size, 
+                       shuffle=False, num_workers=1, 
+                       worker_init_fn=seed_worker)
+    test_dl = DataLoader(dataset=test_ds, batch_size=args.batch_size, 
+                        shuffle=False, num_workers=1, 
+                        worker_init_fn=seed_worker)
+    
+    # Initialize model
+    print("\nInitializing model...")
+    model = MambaCSSMUnet().to(device)
+    
+    # Define loss and optimizer
+    loss_ce = nn.CrossEntropyLoss()
+    opt = torch.optim.Adam(params=model.parameters(), lr=args.lr)
+    scheduler = torch.optim.lr_scheduler.StepLR(optimizer=opt, step_size=args.step_size)
+    
+    # Training setup
+    train_list = []
+    val_list = []
+    evaluator = Evaluator(num_class=2)
+    best_val_iou = 0.0
+    best_model_weight = None
+    
+    # Training loop
+    print(f"\nStarting training for {args.epochs} epochs...")
+    print("="*60)
+    
+    for e in range(args.epochs):
+        print(f"\nEpoch: {e+1}/{args.epochs}")
+        t1 = time.time()
+        
+        train(model, train_dl, loss_ce, opt, device, train_list)
+        
+        val_iou = test(model, val_dl, loss_ce, device, evaluator, val_list)
+        
+        if val_iou > best_val_iou:
+            print(f"✓ Best model updated! IoU improved from {best_val_iou:.4f} to {val_iou:.4f}")
+            best_val_iou = val_iou
+            best_model_weight = copy.deepcopy(model.state_dict())
+            
+            # Save best model
+            save_path = os.path.join(args.save_dir, args.model_name)
+            torch.save(best_model_weight, save_path)
+            print(f"Model saved to {save_path}")
+        
+        scheduler.step()
+        print(f"Learning Rate: {scheduler.get_last_lr()}")
+        
+        t2 = time.time()
+        print(f"Epoch Time: {t2 - t1:.2f} seconds")
+        print("-"*60)
+    
+    print("\n" + "="*60)
+    print(f"Training completed! Best IoU: {best_val_iou:.4f}")
+    print("="*60)
+
+
+if __name__ == "__main__":
+    main()

method/CSSM.ipynb

@@ -0,0 +1,210 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from Mamba import Mamba\n",
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = torch.rand(size = (1,5,16))\n",
+    "\n",
+    "num_layers = 5\n",
+    "d_model = 16\n",
+    "d_state = 16\n",
+    "d_conv = 4\n",
+    "\n",
+    "mamba = Mamba(num_layers=num_layers,d_model=d_model, d_conv=d_conv, d_state=d_state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([1, 5, 32, 16])\n",
+      "torch.Size([1, 5, 32, 16])\n",
+      "torch.Size([1, 5, 32, 16])\n",
+      "torch.Size([1, 5, 32, 16])\n",
+      "torch.Size([1, 5, 32, 16])\n"
+     ]
+    }
+   ],
+   "source": [
+    "y1,y2 = mamba(x,x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([1, 5, 16])"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y2.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "include_paths() got an unexpected keyword argument 'cuda'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[7], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mxlstm\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m      2\u001b[0m     xLSTMBlockStack,\n\u001b[1;32m      3\u001b[0m     xLSTMBlockStackConfig,\n\u001b[1;32m      4\u001b[0m     mLSTMBlockConfig,\n\u001b[1;32m      5\u001b[0m     mLSTMLayerConfig,\n\u001b[1;32m      6\u001b[0m     sLSTMBlockConfig,\n\u001b[1;32m      7\u001b[0m     sLSTMLayerConfig,\n\u001b[1;32m      8\u001b[0m     FeedForwardConfig,\n\u001b[1;32m      9\u001b[0m )\n\u001b[1;32m     11\u001b[0m cfg \u001b[38;5;241m=\u001b[39m xLSTMBlockStackConfig(\n\u001b[1;32m     12\u001b[0m     mlstm_block\u001b[38;5;241m=\u001b[39mmLSTMBlockConfig(\n\u001b[1;32m     13\u001b[0m         mlstm\u001b[38;5;241m=\u001b[39mmLSTMLayerConfig(\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     30\u001b[0m \n\u001b[1;32m     31\u001b[0m )\n\u001b[1;32m     33\u001b[0m xlstm_stack \u001b[38;5;241m=\u001b[39m xLSTMBlockStack(cfg)\n",
+      "File \u001b[0;32m~/anaconda3/envs/CDDD/lib/python3.13/site-packages/xlstm/__init__.py:3\u001b[0m\n\u001b[1;32m      1\u001b[0m __version__ \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m2.0.2\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mblocks\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmlstm\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mblock\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m mLSTMBlock, mLSTMBlockConfig\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mblocks\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmlstm\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mlayer\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m mLSTMLayer, mLSTMLayerConfig\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mblocks\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mslstm\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mblock\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m sLSTMBlock, sLSTMBlockConfig\n",
+      "File \u001b[0;32m~/anaconda3/envs/CDDD/lib/python3.13/site-packages/xlstm/blocks/mlstm/block.py:5\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# Copyright (c) NXAI GmbH and its affiliates 2024\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;66;03m# Maximilian Beck\u001b[39;00m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mdataclasses\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m dataclass, field\n\u001b[0;32m----> 5\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mxlstm_block\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m xLSTMBlock, xLSTMBlockConfig\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mlayer\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m mLSTMLayerConfig\n\u001b[1;32m      9\u001b[0m \u001b[38;5;129m@dataclass\u001b[39m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;28;01mclass\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mmLSTMBlockConfig\u001b[39;00m:\n",
+      "File \u001b[0;32m~/anaconda3/envs/CDDD/lib/python3.13/site-packages/xlstm/blocks/xlstm_block.py:12\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcomponents\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mln\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m LayerNorm\n\u001b[1;32m     11\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmlstm\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mlayer\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m mLSTMLayer, mLSTMLayerConfig\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mslstm\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mlayer\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m sLSTMLayer, sLSTMLayerConfig\n\u001b[1;32m     16\u001b[0m \u001b[38;5;129m@dataclass\u001b[39m\n\u001b[1;32m     17\u001b[0m \u001b[38;5;28;01mclass\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mxLSTMBlockConfig\u001b[39;00m:\n\u001b[1;32m     18\u001b[0m     mlstm: Optional[mLSTMLayerConfig] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "File \u001b[0;32m~/anaconda3/envs/CDDD/lib/python3.13/site-packages/xlstm/blocks/slstm/layer.py:15\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcomponents\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01minit\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m small_init_init_\n\u001b[1;32m     14\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mtorch\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m nn\n\u001b[0;32m---> 15\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcell\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m sLSTMCell, sLSTMCellConfig\n\u001b[1;32m     18\u001b[0m \u001b[38;5;129m@dataclass\u001b[39m\n\u001b[1;32m     19\u001b[0m \u001b[38;5;28;01mclass\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01msLSTMLayerConfig\u001b[39;00m(sLSTMCellConfig):\n\u001b[1;32m     20\u001b[0m     embedding_dim: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m\n",
+      "File \u001b[0;32m~/anaconda3/envs/CDDD/lib/python3.13/site-packages/xlstm/blocks/slstm/cell.py:12\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mtorch\u001b[39;00m\n\u001b[1;32m     11\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mtorch\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mautograd\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mfunction\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m once_differentiable\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01msrc\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcuda_init\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m load\n\u001b[1;32m     13\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01msrc\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mvanilla\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m     14\u001b[0m     slstm_forward,\n\u001b[1;32m     15\u001b[0m     slstm_forward_step,\n\u001b[1;32m     16\u001b[0m     slstm_pointwise_function_registry,\n\u001b[1;32m     17\u001b[0m )\n\u001b[1;32m     18\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcomponents\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mutil\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m conditional_decorator, round_to_multiple, ParameterProxy\n",
+      "File \u001b[0;32m~/anaconda3/envs/CDDD/lib/python3.13/site-packages/xlstm/blocks/slstm/src/cuda_init.py:30\u001b[0m\n\u001b[1;32m     27\u001b[0m curdir \u001b[38;5;241m=\u001b[39m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mdirname(\u001b[38;5;18m__file__\u001b[39m)\n\u001b[1;32m     29\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mcuda\u001b[38;5;241m.\u001b[39mis_available():\n\u001b[0;32m---> 30\u001b[0m     os\u001b[38;5;241m.\u001b[39menviron[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCUDA_LIB\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39msplit(\u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mutils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcpp_extension\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minclude_paths\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcuda\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])[\u001b[38;5;241m0\u001b[39m], \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlib\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mload\u001b[39m(\u001b[38;5;241m*\u001b[39m, name, sources, extra_cflags\u001b[38;5;241m=\u001b[39m(), extra_cuda_cflags\u001b[38;5;241m=\u001b[39m(), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m     34\u001b[0m     suffix \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
+      "\u001b[0;31mTypeError\u001b[0m: include_paths() got an unexpected keyword argument 'cuda'"
+     ]
+    }
+   ],
+   "source": [
+    "from xlstm import (\n",
+    "    xLSTMBlockStack,\n",
+    "    xLSTMBlockStackConfig,\n",
+    "    mLSTMBlockConfig,\n",
+    "    mLSTMLayerConfig,\n",
+    "    sLSTMBlockConfig,\n",
+    "    sLSTMLayerConfig,\n",
+    "    FeedForwardConfig,\n",
+    ")\n",
+    "\n",
+    "cfg = xLSTMBlockStackConfig(\n",
+    "    mlstm_block=mLSTMBlockConfig(\n",
+    "        mlstm=mLSTMLayerConfig(\n",
+    "            conv1d_kernel_size=4, qkv_proj_blocksize=4, num_heads=4\n",
+    "        )\n",
+    "    ),\n",
+    "    slstm_block=sLSTMBlockConfig(\n",
+    "        slstm=sLSTMLayerConfig(\n",
+    "            # backend=,\n",
+    "            num_heads=4,\n",
+    "            conv1d_kernel_size=4,\n",
+    "            bias_init=\"powerlaw_blockdependent\",\n",
+    "        ),\n",
+    "        feedforward=FeedForwardConfig(proj_factor=1.3, act_fn=\"gelu\"),\n",
+    "    ),\n",
+    "    context_length=256,\n",
+    "    num_blocks=7,\n",
+    "    embedding_dim=128,\n",
+    "    slstm_at=[1],\n",
+    "\n",
+    ")\n",
+    "\n",
+    "xlstm_stack = xLSTMBlockStack(cfg)\n",
+    "\n",
+    "x = torch.randn(4, 256, 128).to(torch.device(\"cuda\"))\n",
+    "xlstm_stack = xlstm_stack.to(torch.device(\"cuda\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os \n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "t = os.path.join(\"/media/elman/backup/DG_CD/WHU-CD-256/list/train.txt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "f = np.array((pd.read_csv(t,names=[\"ttt\"])))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'whucd_00267.png'"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f[1].item()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "CDDD",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

method/MambaCSSM.py

@@ -0,0 +1,382 @@
+
+import math
+import json
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from dataclasses import dataclass
+from einops import rearrange, repeat, einsum
+from typing import Union
+
+
+
+
+@dataclass
+class ModelArgs:
+    d_model: int
+    n_layer: int
+    vocab_size: int
+    d_state: int = 16
+    expand: int = 2
+    dt_rank: Union[int, str] = 'auto'
+    d_conv: int = 4 
+    pad_vocab_size_multiple: int = 8
+    conv_bias: bool = True
+    bias: bool = False
+    
+    def __post_init__(self):
+        self.d_inner = int(self.expand * self.d_model)
+        
+        if self.dt_rank == 'auto':
+            self.dt_rank = math.ceil(self.d_model / 16)
+            
+        if self.vocab_size % self.pad_vocab_size_multiple != 0:
+            self.vocab_size += (self.pad_vocab_size_multiple
+                                - self.vocab_size % self.pad_vocab_size_multiple)
+
+
+
+
+
+
+class MambaBlock_CD(nn.Module):
+    def __init__(self, d_model,d_conv, d_state, bias = True, conv_bias = True):
+        """A single Mamba block, as described in Figure 3 in Section 3.4 in the Mamba paper [1]."""
+        super().__init__()
+        # self.args = args
+
+
+        self.norm = RMSNorm(d_model=d_model)
+
+
+        self.d_inner = 2 * d_model
+        self.dt_rank = math.ceil(d_model / 16)
+
+        self.in_proj = nn.Linear(d_model, self.d_inner * 2, bias=bias)
+
+        self.mlp_1 = nn.Linear(self.d_inner, d_model)
+        self.mlp_2 = nn.Linear(self.d_inner, d_model)
+
+        self.conv1d = nn.Conv1d(
+            in_channels=self.d_inner,
+            out_channels=self.d_inner,
+            bias=conv_bias,
+            kernel_size=d_conv,
+            groups=self.d_inner,
+            padding=d_conv - 1,
+        )
+
+        # x_proj takes in `x` and outputs the input-specific Δ, B, C
+        self.x_proj = nn.Linear(self.d_inner, self.dt_rank + d_state * 2, bias=False)
+        
+        # dt_proj projects Δ from dt_rank to d_in
+        self.dt_proj = nn.Linear(self.dt_rank, self.d_inner, bias=True)
+
+        A = repeat(torch.arange(1, d_state + 1), 'n -> d n', d=self.d_inner)
+        self.A_log = nn.Parameter(torch.log(A))
+        self.D = nn.Parameter(torch.ones(self.d_inner))
+        self.D_p = nn.Parameter(torch.ones(self.d_inner))
+        self.out_proj = nn.Linear(self.d_inner, d_model, bias=bias)
+        
+
+    def forward(self, t1,t2):
+
+        ee1 = t1 
+        ee2 = t2
+        
+        (b, l, d) = t1.shape
+        t1 = self.norm(t1)
+        
+        t1_and_res = self.in_proj(t1)  # shape (b, l, 2 * d_in)
+        (t1, res1) = t1_and_res.split(split_size=[self.d_inner, self.d_inner], dim=-1)
+
+        t1 = rearrange(t1, 'b l d_in -> b d_in l')
+        t1 = self.conv1d(t1)[:, :, :l]
+        t1 = rearrange(t1, 'b d_in l -> b l d_in')
+        
+        t1 = F.silu(t1)
+
+
+        (b, l, d) = t2.shape
+        t2 = self.norm(t2)
+        
+        t2_and_res = self.in_proj(t2)  # shape (b, l, 2 * d_in)
+        (t2, res2) = t2_and_res.split(split_size=[self.d_inner, self.d_inner], dim=-1)
+
+        t2 = rearrange(t2, 'b l d_in -> b d_in l')
+        t2 = self.conv1d(t2)[:, :, :l]
+        t2 = rearrange(t2, 'b d_in l -> b l d_in')
+        
+        t2 = F.silu(t2)
+
+        y1,y2 = self.cssm(t1,t2)
+        
+        y1 = y1 * F.silu(res1)
+        y2 = y2 * F.silu(res2)
+        
+        output1 = self.out_proj(y1)
+        output2 = self.out_proj(y2)
+
+
+
+        return output1 + ee1, output2 + ee2
+
+    
+    def cssm(self, t1, t2):
+
+        (d_in, n) = self.A_log.shape
+
+        
+        A = -torch.exp(self.A_log.float())  # shape (d_in, n)
+        D = self.D.float()
+
+        t1_dbl = self.x_proj(t1)  # (b, l, dt_rank + 2*n)
+        
+        (delta, B, C) = t1_dbl.split(split_size=[self.dt_rank, n, n], dim=-1)  # delta: (b, l, dt_rank). B, C: (b, l, n)
+        delta = F.softplus(self.dt_proj(delta))  # (b, l, d_in)
+
+
+        A_prim = -torch.exp(self.A_log.float())  # shape (d_in, n)
+        D_prim = self.D_p.float()
+
+        t2_dbl = self.x_proj(t2)  # (b, l, dt_rank + 2*n)
+        
+        (delta, B_prim, C_prim) = t2_dbl.split(split_size=[self.dt_rank, n, n], dim=-1)  # delta: (b, l, dt_rank). B, C: (b, l, n)
+        delta = F.softplus(self.dt_proj(delta))  # (b, l, d_in)
+        
+        y = self.selective_scan(t1,t2, delta, A, B, C, D, A_prim, B_prim, C_prim, D_prim)  # This is similar to run_SSM(A, B, C, u) in The Annotated S4 [2]
+        
+        return y
+
+    
+    def selective_scan(self, t1,t2, delta, A, B, C, D, A_prim, B_prim, C_prim, D_prim):
+
+        (b, l, d_in) = t1.shape
+        n = A.shape[1]
+
+        deltaA = torch.exp(einsum(delta, A, 'b l d_in, d_in n -> b l d_in n'))
+        deltaB_u = einsum(delta, B, t1, 'b l d_in, b l n, b l d_in -> b l d_in n')
+        deltaB_u_prim = einsum(delta, B_prim, t2, 'b l d_in, b l n, b l d_in -> b l d_in n')
+
+        x = torch.zeros((b, d_in, n), device=deltaA.device)
+        ys = []    
+        for i in range(l):
+            x = deltaA[:, i] * x + torch.abs(deltaB_u[:, i] - deltaB_u_prim[:,i])
+            y1 = einsum(x, C[:, i, :], 'b d_in n, b n -> b d_in')
+            ys.append(y1)
+        y1 = torch.stack(ys, dim=1)  # shape (b, l, d_in)
+        
+        y1 = y1 + t1 * D
+
+
+        (b, l, d_in) = t2.shape
+        n = A_prim.shape[1]
+
+        deltaA_prim = torch.exp(einsum(delta, A_prim, 'b l d_in, d_in n -> b l d_in n'))
+        # deltaB_u = einsum(delta, B, u, 'b l d_in, b l n, b l d_in -> b l d_in n')
+
+        x = torch.zeros((b, d_in, n), device=deltaA.device)
+        ys = []    
+        for i in range(l):
+            x = deltaA_prim[:, i] * x + torch.abs(deltaB_u[:, i] - deltaB_u_prim[:,i])
+            y2 = einsum(x, C_prim[:, i, :], 'b d_in n, b n -> b d_in')
+            ys.append(y2)
+        y2 = torch.stack(ys, dim=1)  # shape (b, l, d_in)
+        
+        y2 = y2 + t2 * D_prim
+    
+        return y1 ,y2
+    
+
+
+
+
+class MambaCSSM(nn.Module):
+
+    def __init__(self, num_layers, d_model,d_conv, d_state, bias = True, conv_bias = True ):
+        super().__init__()
+
+        self.layers =  nn.ModuleList([MambaBlock_CD(d_model,d_conv, d_state, bias = True, conv_bias = True) for _ in range(num_layers)])
+
+
+    def forward(self, t1,t2):
+
+        for layer in self.layers:
+            t1,t2 = layer(t1,t2)
+
+        return t1,t2 
+
+            
+
+
+
+
+
+class MambaBlock(nn.Module):
+    def __init__(self, d_model,d_conv, d_state, bias = True, conv_bias = True):
+        """A single Mamba block, as described in Figure 3 in Section 3.4 in the Mamba paper [1]."""
+        super().__init__()
+        # self.args = args
+
+
+        self.d_inner = 2 * d_model
+        self.dt_rank = math.ceil(d_model / 16)
+
+        self.in_proj = nn.Linear(d_model, self.d_inner * 2, bias=bias)
+
+        self.conv1d = nn.Conv1d(
+            in_channels=self.d_inner,
+            out_channels=self.d_inner,
+            bias=conv_bias,
+            kernel_size=d_conv,
+            groups=self.d_inner,
+            padding=d_conv - 1,
+        )
+
+        # x_proj takes in `x` and outputs the input-specific Δ, B, C
+        self.x_proj = nn.Linear(self.d_inner, self.dt_rank + d_state * 2, bias=False)
+        
+        # dt_proj projects Δ from dt_rank to d_in
+        self.dt_proj = nn.Linear(self.dt_rank, self.d_inner, bias=True)
+
+        A = repeat(torch.arange(1, d_state + 1), 'n -> d n', d=self.d_inner)
+        self.A_log = nn.Parameter(torch.log(A))
+        self.D = nn.Parameter(torch.ones(self.d_inner))
+        self.out_proj = nn.Linear(self.d_inner, d_model, bias=bias)
+        
+
+    def forward(self, x):
+        """Mamba block forward. This looks the same as Figure 3 in Section 3.4 in the Mamba paper [1].
+    
+        Args:
+            x: shape (b, l, d)    (See Glossary at top for definitions of b, l, d_in, n...)
+    
+        Returns:
+            output: shape (b, l, d)
+        
+        Official Implementation:
+            class Mamba, https://github.com/state-spaces/mamba/blob/main/mamba_ssm/modules/mamba_simple.py#L119
+            mamba_inner_ref(), https://github.com/state-spaces/mamba/blob/main/mamba_ssm/ops/selective_scan_interface.py#L311
+            
+        """
+        (b, l, d) = x.shape
+        
+        x_and_res = self.in_proj(x)  # shape (b, l, 2 * d_in)
+        (x, res) = x_and_res.split(split_size=[self.d_inner, self.d_inner], dim=-1)
+
+        x = rearrange(x, 'b l d_in -> b d_in l')
+        x = self.conv1d(x)[:, :, :l]
+        x = rearrange(x, 'b d_in l -> b l d_in')
+        
+        x = F.silu(x)
+
+        y = self.ssm(x)
+        
+        y = y * F.silu(res)
+        
+        output = self.out_proj(y)
+
+        return output
+
+    
+    def ssm(self, x):
+        """Runs the SSM. See:
+            - Algorithm 2 in Section 3.2 in the Mamba paper [1]
+            - run_SSM(A, B, C, u) in The Annotated S4 [2]
+
+        Args:
+            x: shape (b, l, d_in)    (See Glossary at top for definitions of b, l, d_in, n...)
+    
+        Returns:
+            output: shape (b, l, d_in)
+
+        Official Implementation:
+            mamba_inner_ref(), https://github.com/state-spaces/mamba/blob/main/mamba_ssm/ops/selective_scan_interface.py#L311
+            
+        """
+        (d_in, n) = self.A_log.shape
+
+        # Compute ∆ A B C D, the state space parameters.
+        #     A, D are input independent (see Mamba paper [1] Section 3.5.2 "Interpretation of A" for why A isn't selective)
+        #     ∆, B, C are input-dependent (this is a key difference between Mamba and the linear time invariant S4,
+        #                                  and is why Mamba is called **selective** state spaces)
+        
+        A = -torch.exp(self.A_log.float())  # shape (d_in, n)
+        D = self.D.float()
+
+        x_dbl = self.x_proj(x)  # (b, l, dt_rank + 2*n)
+        
+        (delta, B, C) = x_dbl.split(split_size=[self.dt_rank, n, n], dim=-1)  # delta: (b, l, dt_rank). B, C: (b, l, n)
+        delta = F.softplus(self.dt_proj(delta))  # (b, l, d_in)
+        
+        y = self.selective_scan(x, delta, A, B, C, D)  # This is similar to run_SSM(A, B, C, u) in The Annotated S4 [2]
+        
+        return y
+
+    
+    def selective_scan(self, u, delta, A, B, C, D):
+        """Does selective scan algorithm. See:
+            - Section 2 State Space Models in the Mamba paper [1]
+            - Algorithm 2 in Section 3.2 in the Mamba paper [1]
+            - run_SSM(A, B, C, u) in The Annotated S4 [2]
+
+        This is the classic discrete state space formula:
+            x(t + 1) = Ax(t) + Bu(t)
+            y(t)     = Cx(t) + Du(t)
+        except B and C (and the step size delta, which is used for discretization) are dependent on the input x(t).
+    
+        Args:
+            u: shape (b, l, d_in)    (See Glossary at top for definitions of b, l, d_in, n...)
+            delta: shape (b, l, d_in)
+            A: shape (d_in, n)
+            B: shape (b, l, n)
+            C: shape (b, l, n)
+            D: shape (d_in,)
+    
+        Returns:
+            output: shape (b, l, d_in)
+    
+        Official Implementation:
+            selective_scan_ref(), https://github.com/state-spaces/mamba/blob/main/mamba_ssm/ops/selective_scan_interface.py#L86
+            Note: I refactored some parts out of `selective_scan_ref` out, so the functionality doesn't match exactly.
+            
+        """
+        (b, l, d_in) = u.shape
+        n = A.shape[1]
+        
+        # Discretize continuous parameters (A, B)
+        # - A is discretized using zero-order hold (ZOH) discretization (see Section 2 Equation 4 in the Mamba paper [1])
+        # - B is discretized using a simplified Euler discretization instead of ZOH. From a discussion with authors:
+        #   "A is the more important term and the performance doesn't change much with the simplification on B"
+        deltaA = torch.exp(einsum(delta, A, 'b l d_in, d_in n -> b l d_in n'))
+        deltaB_u = einsum(delta, B, u, 'b l d_in, b l n, b l d_in -> b l d_in n')
+        
+        # Perform selective scan (see scan_SSM() in The Annotated S4 [2])
+        # Note that the below is sequential, while the official implementation does a much faster parallel scan that
+        # is additionally hardware-aware (like FlashAttention).
+        x = torch.zeros((b, d_in, n), device=deltaA.device)
+        ys = []    
+        for i in range(l):
+            x = deltaA[:, i] * x + deltaB_u[:, i]
+            y = einsum(x, C[:, i, :], 'b d_in n, b n -> b d_in')
+            ys.append(y)
+        y = torch.stack(ys, dim=1)  # shape (b, l, d_in)
+        
+        y = y + u * D
+    
+        return y
+
+
+class RMSNorm(nn.Module):
+    def __init__(self,
+                 d_model: int,
+                 eps: float = 1e-5):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(d_model))
+
+
+    def forward(self, x):
+        output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) * self.weight
+
+        return output

method/Model.py

@@ -0,0 +1,173 @@
+from torch import nn 
+import torch 
+from method.MambaCSSM import MambaCSSM
+
+class MambaCSSMUnet(nn.Module):
+
+    def __init__(self, output_classes = 2):
+        super(MambaCSSMUnet, self).__init__()
+
+        #### Encoder Conv
+        self.conv_block_1 = nn.Sequential(
+            nn.Conv2d(6, 16, 3, 1, padding=1),
+            nn.BatchNorm2d(16),
+            nn.ReLU(),
+            nn.Conv2d(16, 16, 3, 1, padding=1),
+            nn.BatchNorm2d(16),
+            nn.ReLU()
+        )
+
+        self.mp_block_1 = nn.MaxPool2d(2, 2, return_indices=True)
+
+        self.conv_block_2 = nn.Sequential(
+            nn.Conv2d(16, 32, 3, 1, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(),
+            nn.Conv2d(32, 32, 3, 1, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU()
+        )
+
+        self.mp_block_2 = nn.MaxPool2d(2, 2, return_indices=True)
+
+        self.conv_block_3 = nn.Sequential(
+            nn.Conv2d(32, 64, 3, 1, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.Conv2d(64, 64, 3, 1, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU()
+        )
+
+        self.mp_block_3 = nn.MaxPool2d(2, 2, return_indices=True)
+
+        self.conv_block_4 = nn.Sequential(
+            nn.Conv2d(64, 128, 3, 1, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.Conv2d(128, 128, 3, 1, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU()
+        )
+
+        self.mp_block_4 = nn.MaxPool2d(2, 2, return_indices=True)
+
+        #### Mamba
+
+
+        self.mamba = MambaCSSM(num_layers=4, d_model=256,d_conv=4, d_state=16)
+
+        
+        #### Decoder Deconv
+        self.mpu_block_4 = nn.MaxUnpool2d(2, 2)
+        self.conv_4 = nn.Sequential(
+            nn.Conv2d(256, 128, 3, 1, padding=1),
+            nn.ReLU()
+        )
+        self.deconv_4_block = nn.Sequential(
+            nn.ConvTranspose2d(128, 64, 3, 1, padding=1),
+            nn.ReLU(),
+            nn.ConvTranspose2d(64, 64, 3, 1, padding=1),
+            nn.ReLU()
+        )
+
+        self.mpu_block_3 = nn.MaxUnpool2d(2, 2)
+
+        self.conv_3 = nn.Sequential(
+            nn.Conv2d(128, 64, 3, 1, padding=1),
+            nn.ReLU()
+        )
+
+        self.deconv_3_block = nn.Sequential(
+            nn.ConvTranspose2d(64, 32, 3, 1, padding=1),
+            nn.ReLU(),
+            nn.ConvTranspose2d(32, 32, 3, 1, padding=1),
+            nn.ReLU()
+        )
+
+        self.mpu_block_2 = nn.MaxUnpool2d(2, 2)
+
+        self.conv_2 = nn.Sequential(
+            nn.Conv2d(64, 32, 3, 1, padding=1),
+            nn.ReLU()
+        )
+
+        self.deconv_2_block = nn.Sequential(
+            nn.ConvTranspose2d(32, 16, 3, 1, padding=1),
+            nn.ReLU(),
+            nn.ConvTranspose2d(16, 16, 3, 1, padding=1),
+            nn.ReLU()
+        )
+
+        self.mpu_block_1 = nn.MaxUnpool2d(2, 2)
+
+        self.conv_1 = nn.Sequential(
+            nn.Conv2d(32, 16, 3, 1, padding=1),
+            nn.ReLU()
+        )
+
+        self.deconv_1_block = nn.Sequential(
+            nn.ConvTranspose2d(16, 8, 3, 1, padding=1),
+            nn.ReLU(),
+            nn.ConvTranspose2d(8, 6, 3, 1, padding=1),
+            nn.ReLU()
+        )
+
+        self.conv_final = nn.Conv2d(6, output_classes, 1, 1)
+
+
+    def forward(self, t1,t2):
+
+        t = torch.cat([t1,t2], dim = 1)
+
+        x1 = self.conv_block_1(t)
+        f1, i1 = self.mp_block_1(x1)
+        x2 = self.conv_block_2(f1)
+        f2, i2 = self.mp_block_2(x2)
+        x3 = self.conv_block_3(f2)
+        f3, i3 = self.mp_block_3(x3)
+        x4 = self.conv_block_4(f3)
+        f4, i4 = self.mp_block_4(x4)
+
+
+
+        b,c,h,w = f4.shape
+        f4_t1 = f4[:,:c//2, :,:]
+        f4_t2 = f4[:,c//2:, :,:]
+
+
+
+        # print(f4_t1.shape)
+        f4_t1 = f4_t1.view((-1, 64, 16*16))  # Adjusted for input size 256x256
+        f4_t2 = f4_t2.view((-1, 64, 16*16))  # Adjusted for input size 256x256
+        f5_t1,f5_t2 = self.mamba(f4_t1, f4_t2)
+        f5_t1 = f5_t1.view((-1, 64, 16, 16))  # Adjust the shape for further operations
+        f5_t2 = f5_t2.view((-1, 64, 16, 16))  # Adjust the shape for further operations
+
+        f5 = torch.cat([f5_t1, f5_t2], dim = 1)
+
+
+        f6 = self.mpu_block_4(f5, i4)
+        f7 = self.conv_4(torch.cat((x4, f6), dim=1))
+        f8 = self.deconv_4_block(f7)
+
+        f9 = self.mpu_block_3(f8, i3, output_size=x3.size())
+        f10 = self.conv_3(torch.cat((f9, x3), dim=1))
+        f11 = self.deconv_3_block(f10)
+
+        f12 = self.mpu_block_2(f11, i2)
+        f13 = self.conv_2(torch.cat((f12, x2), dim=1))
+
+        f14 = self.deconv_2_block(f13)
+
+        f15 = self.mpu_block_1(f14, i1)
+        f16 = self.conv_1(torch.cat((f15, x1), dim=1))
+        f17 = self.deconv_1_block(f16)
+        f18 = self.conv_final(f17)
+
+
+
+
+
+
+        return f18

pre_trained_weights/LEVIR+/levir_cd_+_cssm.pth

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

pre_trained_weights/LEVIR+/levir_layer_1.pth

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

pre_trained_weights/LEVIR+/levir_layer_2.pth

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

pre_trained_weights/LEVIR+/levir_layer_3.pth

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

pre_trained_weights/LEVIR+/levir_layer_4.pth

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

pre_trained_weights/LEVIR+/levir_layer_6.pth

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

pre_trained_weights/SYSU-CD/sysu.pth

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

pre_trained_weights/SYSU-CD/sysu_1.pth

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

pre_trained_weights/SYSU-CD/sysu_layer_1.pth

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

pre_trained_weights/SYSU-CD/sysu_layer_2.pth

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

pre_trained_weights/SYSU-CD/sysu_layer_3.pth

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

pre_trained_weights/SYSU-CD/sysu_layer_4.pth

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

pre_trained_weights/SYSU-CD/sysu_layer_5.pth

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

pre_trained_weights/SYSU-CD/sysu_layer_6.pth

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

pre_trained_weights/WHU-CD/whu.pth

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

pre_trained_weights/WHU-CD/whu_1.pth

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

pre_trained_weights/WHU-CD/whu_layer_1.pth

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

pre_trained_weights/WHU-CD/whu_layer_2.pth

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

pre_trained_weights/WHU-CD/whu_layer_3.pth

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

pre_trained_weights/WHU-CD/whu_layer_4.pth

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

pre_trained_weights/WHU-CD/whu_layer_5.pth

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

pre_trained_weights/WHU-CD/whu_layer_6.pth

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

utils/loss/L.py

@@ -0,0 +1,245 @@
+from __future__ import print_function, division
+
+import torch
+from torch.autograd import Variable
+import torch.nn.functional as F
+import numpy as np
+try:
+    from itertools import  ifilterfalse
+except ImportError: # py3k
+    from itertools import  filterfalse as ifilterfalse
+
+
+def lovasz_grad(gt_sorted):
+    """
+    Computes gradient of the Lovasz extension w.r.t sorted errors
+    See Alg. 1 in paper
+    """
+    p = len(gt_sorted)
+    gts = gt_sorted.sum()
+    intersection = gts - gt_sorted.float().cumsum(0)
+    union = gts + (1 - gt_sorted).float().cumsum(0)
+    jaccard = 1. - intersection / union
+    if p > 1: # cover 1-pixel case
+        jaccard[1:p] = jaccard[1:p] - jaccard[0:-1]
+    return jaccard
+
+
+def iou_binary(preds, labels, EMPTY=1., ignore=None, per_image=True):
+    """
+    IoU for foreground class
+    binary: 1 foreground, 0 background
+    """
+    if not per_image:
+        preds, labels = (preds,), (labels,)
+    ious = []
+    for pred, label in zip(preds, labels):
+        intersection = ((label == 1) & (pred == 1)).sum()
+        union = ((label == 1) | ((pred == 1) & (label != ignore))).sum()
+        if not union:
+            iou = EMPTY
+        else:
+            iou = float(intersection) / float(union)
+        ious.append(iou)
+    iou = mean(ious)    # mean accross images if per_image
+    return 100 * iou
+
+
+def iou(preds, labels, C, EMPTY=1., ignore=None, per_image=False):
+    """
+    Array of IoU for each (non ignored) class
+    """
+    if not per_image:
+        preds, labels = (preds,), (labels,)
+    ious = []
+    for pred, label in zip(preds, labels):
+        iou = []    
+        for i in range(C):
+            if i != ignore: # The ignored label is sometimes among predicted classes (ENet - CityScapes)
+                intersection = ((label == i) & (pred == i)).sum()
+                union = ((label == i) | ((pred == i) & (label != ignore))).sum()
+                if not union:
+                    iou.append(EMPTY)
+                else:
+                    iou.append(float(intersection) / float(union))
+        ious.append(iou)
+    ious = [mean(iou) for iou in zip(*ious)] # mean accross images if per_image
+    return 100 * np.array(ious)
+
+
+# --------------------------- BINARY LOSSES ---------------------------
+
+
+def lovasz_hinge(logits, labels, per_image=True, ignore=None):
+    """
+    Binary Lovasz hinge loss
+      logits: [B, H, W] Variable, logits at each pixel (between -\infty and +\infty)
+      labels: [B, H, W] Tensor, binary ground truth masks (0 or 1)
+      per_image: compute the loss per image instead of per batch
+      ignore: void class id
+    """
+    if per_image:
+        loss = mean(lovasz_hinge_flat(*flatten_binary_scores(log.unsqueeze(0), lab.unsqueeze(0), ignore))
+                          for log, lab in zip(logits, labels))
+    else:
+        loss = lovasz_hinge_flat(*flatten_binary_scores(logits, labels, ignore))
+    return loss
+
+
+def lovasz_hinge_flat(logits, labels):
+    """
+    Binary Lovasz hinge loss
+      logits: [P] Variable, logits at each prediction (between -\infty and +\infty)
+      labels: [P] Tensor, binary ground truth labels (0 or 1)
+      ignore: label to ignore
+    """
+    if len(labels) == 0:
+        # only void pixels, the gradients should be 0
+        return logits.sum() * 0.
+    signs = 2. * labels.float() - 1.
+    errors = (1. - logits * Variable(signs))
+    errors_sorted, perm = torch.sort(errors, dim=0, descending=True)
+    perm = perm.data
+    gt_sorted = labels[perm]
+    grad = lovasz_grad(gt_sorted)
+    loss = torch.dot(F.relu(errors_sorted), Variable(grad))
+    return loss
+
+
+def flatten_binary_scores(scores, labels, ignore=None):
+    """
+    Flattens predictions in the batch (binary case)
+    Remove labels equal to 'ignore'
+    """
+    scores = scores.view(-1)
+    labels = labels.view(-1)
+    if ignore is None:
+        return scores, labels
+    valid = (labels != ignore)
+    vscores = scores[valid]
+    vlabels = labels[valid]
+    return vscores, vlabels
+
+
+class StableBCELoss(torch.nn.modules.Module):
+    def __init__(self):
+         super(StableBCELoss, self).__init__()
+    def forward(self, input, target):
+         neg_abs = - input.abs()
+         loss = input.clamp(min=0) - input * target + (1 + neg_abs.exp()).log()
+         return loss.mean()
+
+
+def binary_xloss(logits, labels, ignore=None):
+    """
+    Binary Cross entropy loss
+      logits: [B, H, W] Variable, logits at each pixel (between -\infty and +\infty)
+      labels: [B, H, W] Tensor, binary ground truth masks (0 or 1)
+      ignore: void class id
+    """
+    logits, labels = flatten_binary_scores(logits, labels, ignore)
+    loss = StableBCELoss()(logits, Variable(labels.float()))
+    return loss
+
+
+# --------------------------- MULTICLASS LOSSES ---------------------------
+
+
+def lovasz_softmax(probas, labels, classes='present', per_image=False, ignore=None):
+    """
+    Multi-class Lovasz-Softmax loss
+      probas: [B, C, H, W] Variable, class probabilities at each prediction (between 0 and 1).
+              Interpreted as binary (sigmoid) output with outputs of size [B, H, W].
+      labels: [B, H, W] Tensor, ground truth labels (between 0 and C - 1)
+      classes: 'all' for all, 'present' for classes present in labels, or a list of classes to average.
+      per_image: compute the loss per image instead of per batch
+      ignore: void class labels
+    """
+    if per_image:
+        loss = mean(lovasz_softmax_flat(*flatten_probas(prob.unsqueeze(0), lab.unsqueeze(0), ignore), classes=classes)
+                          for prob, lab in zip(probas, labels))
+    else:
+        loss = lovasz_softmax_flat(*flatten_probas(probas, labels, ignore), classes=classes)
+    return loss
+
+
+def lovasz_softmax_flat(probas, labels, classes='present'):
+    """
+    Multi-class Lovasz-Softmax loss
+      probas: [P, C] Variable, class probabilities at each prediction (between 0 and 1)
+      labels: [P] Tensor, ground truth labels (between 0 and C - 1)
+      classes: 'all' for all, 'present' for classes present in labels, or a list of classes to average.
+    """
+    if probas.numel() == 0:
+        # only void pixels, the gradients should be 0
+        return probas * 0.
+    C = probas.size(1)
+    losses = []
+    class_to_sum = list(range(C)) if classes in ['all', 'present'] else classes
+    for c in class_to_sum:
+        fg = (labels == c).float() # foreground for class c
+        if (classes is 'present' and fg.sum() == 0):
+            continue
+        if C == 1:
+            if len(classes) > 1:
+                raise ValueError('Sigmoid output possible only with 1 class')
+            class_pred = probas[:, 0]
+        else:
+            class_pred = probas[:, c]
+        errors = (Variable(fg) - class_pred).abs()
+        errors_sorted, perm = torch.sort(errors, 0, descending=True)
+        perm = perm.data
+        fg_sorted = fg[perm]
+        losses.append(torch.dot(errors_sorted, Variable(lovasz_grad(fg_sorted))))
+    return mean(losses)
+
+
+def flatten_probas(probas, labels, ignore=None):
+    """
+    Flattens predictions in the batch
+    """
+    if probas.dim() == 3:
+        # assumes output of a sigmoid layer
+        B, H, W = probas.size()
+        probas = probas.view(B, 1, H, W)
+    B, C, H, W = probas.size()
+    probas = probas.permute(0, 2, 3, 1).contiguous().view(-1, C)  # B * H * W, C = P, C
+    labels = labels.view(-1)
+    if ignore is None:
+        return probas, labels
+    valid = (labels != ignore)
+    vprobas = probas[valid.nonzero().squeeze()]
+    vlabels = labels[valid]
+    return vprobas, vlabels
+
+def xloss(logits, labels, ignore=None):
+    """
+    Cross entropy loss
+    """
+    return F.cross_entropy(logits, Variable(labels), ignore_index=255)
+
+
+# --------------------------- HELPER FUNCTIONS ---------------------------
+def isnan(x):
+    return x != x
+    
+    
+def mean(l, ignore_nan=False, empty=0):
+    """
+    nanmean compatible with generators.
+    """
+    l = iter(l)
+    if ignore_nan:
+        l = ifilterfalse(isnan, l)
+    try:
+        n = 1
+        acc = next(l)
+    except StopIteration:
+        if empty == 'raise':
+            raise ValueError('Empty mean')
+        return empty
+    for n, v in enumerate(l, 2):
+        acc += v
+    if n == 1:
+        return acc
+    return acc / n

utils/metrics/ev.py

@@ -0,0 +1,103 @@
+import numpy as np
+
+
+class Evaluator(object):
+    def __init__(self, num_class):
+        self.num_class = num_class
+        self.confusion_matrix = np.zeros((self.num_class,) * 2, dtype=np.longlong)
+        self._epsilon = 1e-7
+
+    def Pixel_Accuracy(self):
+        Acc = np.diag(self.confusion_matrix).sum() / self.confusion_matrix.sum()
+        return Acc
+
+    def Pixel_Accuracy_Class(self):
+        Acc = np.diag(self.confusion_matrix) / (self.confusion_matrix.sum(axis=1) + self._epsilon)
+        mAcc = np.nanmean(Acc)
+        return mAcc, Acc
+
+    def Pixel_Precision_Rate(self):
+        assert self.confusion_matrix.shape[0] == 2
+        Pre = self.confusion_matrix[1, 1] / (self.confusion_matrix[0, 1] + self.confusion_matrix[1, 1] + self._epsilon)
+        return Pre
+
+    def Pixel_Recall_Rate(self):
+        assert self.confusion_matrix.shape[0] == 2
+        Rec = self.confusion_matrix[1, 1] / (self.confusion_matrix[1, 0] + self.confusion_matrix[1, 1] + self._epsilon)
+        return Rec
+
+    def Pixel_F1_score(self):
+        assert self.confusion_matrix.shape[0] == 2
+        Rec = self.Pixel_Recall_Rate()
+        Pre = self.Pixel_Precision_Rate()
+        F1 = 2 * Rec * Pre / (Rec + Pre)
+        return F1
+
+
+    def calculate_per_class_metrics(self):
+        # Adjustments to exclude class 0 in calculations
+        TPs = np.diag(self.confusion_matrix)[1:]  # Start from index 1 to exclude class 0
+        FNs = np.sum(self.confusion_matrix, axis=1)[1:] - TPs
+        FPs = np.sum(self.confusion_matrix, axis=0)[1:] - TPs
+        return TPs, FNs, FPs
+    
+    def Damage_F1_socore(self):
+        TPs, FNs, FPs = self.calculate_per_class_metrics()
+        precisions = TPs / (TPs + FPs + 1e-7)
+        recalls = TPs / (TPs + FNs + 1e-7)
+        f1_scores = 2 * (precisions * recalls) / (precisions + recalls + 1e-7)
+        return f1_scores
+    
+    def Mean_Intersection_over_Union(self):
+        MIoU = np.nanmean(self.Intersection_over_Union())
+        return MIoU
+
+    def Intersection_over_Union(self):
+        IoU = np.diag(self.confusion_matrix) / (
+                np.sum(self.confusion_matrix, axis=1) + np.sum(self.confusion_matrix, axis=0) -
+                np.diag(self.confusion_matrix) + 1e-7)
+        return IoU
+
+    def Kappa_coefficient(self):
+        # Number of observations (total number of classifications)
+        # num_total = np.array(0, dtype=np.long)
+        # row_sums = np.array([0, 0], dtype=np.long)
+        # col_sums = np.array([0, 0], dtype=np.long)
+        # total += np.sum(self.confusion_matrix)
+        # # Observed agreement (i.e., sum of diagonal elements)
+        # observed_agreement = np.sum(np.diag(self.confusion_matrix))
+        # # Compute expected agreement
+        # row_sums += np.sum(self.confusion_matrix, axis=0)
+        # col_sums += np.sum(self.confusion_matrix, axis=1)
+        # expected_agreement = np.sum((row_sums * col_sums) / total)
+        num_total = np.sum(self.confusion_matrix)
+        observed_accuracy = np.trace(self.confusion_matrix) / num_total
+        expected_accuracy = np.sum(
+            np.sum(self.confusion_matrix, axis=0) / num_total * np.sum(self.confusion_matrix, axis=1) / num_total)
+
+        # Calculate Cohen's kappa
+        kappa = (observed_accuracy - expected_accuracy) / (1 - expected_accuracy)
+        return kappa
+
+    def Frequency_Weighted_Intersection_over_Union(self):
+        freq = np.sum(self.confusion_matrix, axis=1) / np.sum(self.confusion_matrix)
+        iu = np.diag(self.confusion_matrix) / (
+                np.sum(self.confusion_matrix, axis=1) + np.sum(self.confusion_matrix, axis=0) -
+                np.diag(self.confusion_matrix))
+
+        FWIoU = (freq[freq > 0] * iu[freq > 0]).sum()
+        return FWIoU
+
+    def _generate_matrix(self, gt_image, pre_image):
+        mask = (gt_image >= 0) & (gt_image < self.num_class)
+        label = self.num_class * gt_image[mask].astype('int64') + pre_image[mask]
+        count = np.bincount(label, minlength=self.num_class ** 2)
+        confusion_matrix = count.reshape(self.num_class, self.num_class)
+        return confusion_matrix
+
+    def add_batch(self, gt_image, pre_image):
+        assert gt_image.shape == pre_image.shape
+        self.confusion_matrix += self._generate_matrix(gt_image, pre_image)
+
+    def reset(self):
+        self.confusion_matrix = np.zeros((self.num_class,) * 2)