Update README.md

README.md

@@ -76,127 +76,13 @@ For each tile, we provide the original slide id (`slide_id`), tile id (`tile_id`
 
 # How to extract features
 
-The following code snippet allows you to extract features with your feature extractor.
-91 folders will be created, each named by the `slide_id` and containing a `features.npy` file.
-This feature file is a numpy array of shape (16278, 3+d) where d is the output dimension of your model and 3 corresponds to `(deepzoom_level, x_coordinate, y_coordinate)`.
-
 > [!IMPORTANT]
-> Tile coordinates are in the same order for each slide inside the dataset. No additional sorting is required to compare feature matrices between different slides (first element of each matrix corresponds to the same tile location).  
+> 🎉 Check [plismbench](https://github.com/owkin/plism-benchmark) to perform the feature extraction of PLISM dataset and get run our robustness benchmark 🎉 
 >
+> 
 
 2h30 and roughly 10 Gb storage are necessary to extract all features with a ViT-B model, 16 CPUs and 1 Nvidia T4 (16Go).
 
-> [!IMPORTANT]
-> 🎉 We plan to release a dedicated Github repository to properly extract features and compute metrics as done in (Filiot et al., 2025). 
->
-> 
-
-```python
-
-# Generic libraries
-from __future__ import annotations
-from pathlib import Path
-from PIL import Image
-from loguru import logger
-from tqdm import tqdm
-
-# Tensor-related libraries
-import numpy as np
-import torch
-from torch.utils.data import DataLoader
-import datasets
-
-# You first need to login with your HF token
-#from huggingface_hub import login
-#login()
-
-# Set your PIL.Image transform and embedding model
-#transform = # torchvision.transforms.transforms transforming PIL Image into Tensor
-#model = # torch.nn.Module outputing a tensor of features of shape (batch_size, features_dimension)
-
-# You can tweak the batch size depending on your hardware or model
-batch_size = 32
-num_slides = 91
-num_tiles = 16278
-device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-# Set your export directory
-export_dir = Path("/path/to/your/export/directory/")
-
-
-def collate(batch: list[dict[str, str | Image]]) -> tuple[list[str], list[str], torch.Tensor]:
-    """Return slide ids, tile ids and transformed images."""
-    slide_ids =[b["slide_id"] for b in batch]
-    tile_ids = [b["tile_id"] for b in batch]
-    imgs = torch.stack([transform(b["png"]) for b in batch], axis=0)
-    return (slide_ids, tile_ids, imgs)
-
-
-def process_imgs(imgs: torch.Tensor, tile_ids: list[str]) -> torch.Tensor:
-    """Perform inference on input (already transformed) images."""
-    with torch.inference_mode():
-        batch_features = model(imgs.to(device)).squeeze() # (N_tiles, d) numpy array
-        batch_tiles_coordinates = np.array([tile_id.split("_")[1:] for tile_id in tile_ids]).astype(int) # (N_tiles, 3) numpy array
-    batch_stack = np.concatenate([batch_tiles_coordinates, batch_features], axis=1)
-    return batch_stack
-
-def save_features(slide_features: list[np.ndarray], slide_id: str):
-    """Save features to disk."""
-    slide_features_export_dir = Path(export_dir / slide_id)
-    slide_features_export_path = slides_features_export_dir / "features.npy"
-    slide_features_export_dir.mkdir(exist_ok=True, parents=True)
-    output_slide_features = np.concatenate(slide_features, axis=0).astype(np.float32)
-    slide_num_tiles = output_slide_features.shape[0]
-    assert slide_num_tiles == num_tiles, f"Output features for slide {slide_id} contains {slide_num_tiles} < {num_tiles}."
-    np.save(slides_features_export_path, output_slide_features)
-    logger.success(f"Successfully saved features for slide: {slide_id}")
-
-# Create the dataset and dataloader without actually loading the files to disk (`streaming=True`)
-# The dataset is sorted by slide_id, meaning that the first 16278 indexes belong to the same first slide,
-# then 16278:32556 to the second slide, etc.
-dataset = datasets.load_dataset("owkin/plism-dataset-tiles", split="train", streaming=True)
-dataloader = DataLoader(
-    dataset, batch_size=batch_size, collate_fn=collate, num_workers=0, pin_memory=True, shuffle=False
-)
-
-# Iterate over the full dataset and store features each time 16278 input images have been processed
-   
-slide_features = []
-current_num_tiles = 0
-
-for (slide_ids, tile_ids, imgs) in tqdm(
-    dataloader,
-    total=ceil(num_slides * num_tiles / batch_size),
-    desc="Extracting features"
-):
-    reference_slide_id = slide_ids[0]
-
-    # If we're on the same slide, we just add the batch features to the running list
-    if all(slide_id == reference_slide_id for slide_id in slide_ids):
-        batch_stack = process_imgs(imgs, tile_ids)
-        slide_features.append(batch_stack)
-        # For the very last slide, the last batch may be of size < `batch_size`
-        current_num_tiles += batch_stack.shape[0]
-        # If the current batch contains exactly the last `batch_size` tile features for the slide,
-        # export the slide features and reset `slide_features` and `current_num_tiles`
-        if current_num_tiles == num_tiles:
-            save_features(slide_features, slide_id=reference_slide_id)
-            slide_features = []
-            current_num_tiles = 0
-    # The current batch contains tiles from slide N (`reference_slide_id`) and slide N+1
-    else:
-        # We retrieve the maximum index at which all tiles in the batch comes from slide N
-        mask = (np.array(slide_ids) != reference_slide_id)
-        idx = mask.argmax()
-        # And only process the later, then export the slides features
-        batch_stack = process_imgs(imgs[:idx], tile_ids[:idx]
-        slide_features.append(batch_stack)
-        save_features(slide_features, slide_id=reference_slide_id)
-        # We initialize `slide_features` and `current_num_tiles` with respectively
-        # the tile features from slide N+1
-        slide_features = [process_imgs(imgs[idx:], tile_ids[idx:])]
-        current_num_tiles = batch_size - idx
-```
 
 # License