fusion-bench 0.2.27__tar.gz → 0.2.28__tar.gz

{fusion_bench-0.2.27 → fusion_bench-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fusion-bench
-Version: 0.2.27
+Version: 0.2.28
 Summary: A Comprehensive Benchmark of Deep Model Fusion
 Author-email: Anke Tang <tang.anke@foxmail.com>
 Project-URL: Repository, https://github.com/tanganke/fusion_bench

{fusion_bench-0.2.27 → fusion_bench-0.2.28}/fusion_bench/__init__.py

@@ -41,6 +41,8 @@ _import_structure = {
         "CausalLMBackbonePool",
         "CausalLMPool",
         "CLIPVisionModelPool",
+        "ConvNextForImageClassificationPool",
+        "Dinov2ForImageClassificationPool",
         "GPT2ForSequenceClassificationPool",
         "HuggingFaceGPT2ClassificationPool",
         "NYUv2ModelPool",
@@ -107,6 +109,8 @@ if TYPE_CHECKING:
         CausalLMBackbonePool,
         CausalLMPool,
         CLIPVisionModelPool,
+        ConvNextForImageClassificationPool,
+        Dinov2ForImageClassificationPool,
         GPT2ForSequenceClassificationPool,
         HuggingFaceGPT2ClassificationPool,
         NYUv2ModelPool,

{fusion_bench-0.2.27 → fusion_bench-0.2.28}/fusion_bench/method/classification/image_classification_finetune.py

@@ -34,6 +34,13 @@ from torch.utils.data import random_split
 log = get_rankzero_logger(__name__)
 
 
+def _get_base_model_name(model) -> Optional[str]:
+    if hasattr(model, "config") and hasattr(model.config, "_name_or_path"):
+        return model.config._name_or_path
+    else:
+        return None
+
+
 @auto_register_config
 class ImageClassificationFineTuning(BaseAlgorithm):
     """Fine-tuning algorithm for image classification models.
@@ -107,6 +114,8 @@ class ImageClassificationFineTuning(BaseAlgorithm):
         """
         # load model and dataset
         model = modelpool.load_pretrained_or_first_model()
+        base_model_name = _get_base_model_name(model)
+
         assert isinstance(model, nn.Module), "Loaded model is not a nn.Module."
 
         assert (
@@ -135,6 +144,8 @@ class ImageClassificationFineTuning(BaseAlgorithm):
                 val_dataset, processor=modelpool.load_processor(stage="val")
             )
             val_loader = self.get_dataloader(val_dataset, stage="val")
+        else:
+            val_loader = None
 
         # configure optimizer
         optimizer = instantiate(self.optimizer, params=model.parameters())
@@ -210,6 +221,7 @@ class ImageClassificationFineTuning(BaseAlgorithm):
                 ),
                 algorithm_config=self.config,
                 description=f"Fine-tuned ResNet model on dataset {dataset_name}.",
+                base_model=base_model_name,
             )
         return model
 

{fusion_bench-0.2.27 → fusion_bench-0.2.28}/fusion_bench/method/task_arithmetic/task_arithmetic.py

@@ -149,7 +149,10 @@ class TaskArithmeticAlgorithm(
                     )
         with self.profile("merge weights"):
             # scale the task vector
-            task_vector = state_dict_mul(task_vector, self.config.scaling_factor)
+            # here we keep the dtype when the elements of value are all zeros to avoid dtype mismatch
+            task_vector = state_dict_mul(
+                task_vector, self.config.scaling_factor, keep_dtype_when_zero=True
+            )
             # add the task vector to the pretrained model
             state_dict = state_dict_add(pretrained_model.state_dict(), task_vector)
 

{fusion_bench-0.2.27 → fusion_bench-0.2.28}/fusion_bench/modelpool/__init__.py

@@ -8,6 +8,14 @@ _import_structure = {
     "base_pool": ["BaseModelPool"],
     "causal_lm": ["CausalLMPool", "CausalLMBackbonePool"],
     "clip_vision": ["CLIPVisionModelPool"],
+    "convnext_for_image_classification": [
+        "ConvNextForImageClassificationPool",
+        "load_transformers_convnext",
+    ],
+    "dinov2_for_image_classification": [
+        "Dinov2ForImageClassificationPool",
+        "load_transformers_dinov2",
+    ],
     "nyuv2_modelpool": ["NYUv2ModelPool"],
     "huggingface_automodel": ["AutoModelPool"],
     "seq2seq_lm": ["Seq2SeqLMPool"],
@@ -18,7 +26,10 @@ _import_structure = {
         "GPT2ForSequenceClassificationPool",
     ],
     "seq_classification_lm": ["SequenceClassificationModelPool"],
-    "resnet_for_image_classification": ["ResNetForImageClassificationPool"],
+    "resnet_for_image_classification": [
+        "ResNetForImageClassificationPool",
+        "load_transformers_resnet",
+    ],
 }
 
 
@@ -26,6 +37,14 @@ if TYPE_CHECKING:
     from .base_pool import BaseModelPool
     from .causal_lm import CausalLMBackbonePool, CausalLMPool
     from .clip_vision import CLIPVisionModelPool
+    from .convnext_for_image_classification import (
+        ConvNextForImageClassificationPool,
+        load_transformers_convnext,
+    )
+    from .dinov2_for_image_classification import (
+        Dinov2ForImageClassificationPool,
+        load_transformers_dinov2,
+    )
     from .huggingface_automodel import AutoModelPool
     from .huggingface_gpt2_classification import (
         GPT2ForSequenceClassificationPool,
@@ -34,7 +53,10 @@ if TYPE_CHECKING:
     from .nyuv2_modelpool import NYUv2ModelPool
     from .openclip_vision import OpenCLIPVisionModelPool
     from .PeftModelForSeq2SeqLM import PeftModelForSeq2SeqLMPool
-    from .resnet_for_image_classification import ResNetForImageClassificationPool
+    from .resnet_for_image_classification import (
+        ResNetForImageClassificationPool,
+        load_transformers_resnet,
+    )
     from .seq2seq_lm import Seq2SeqLMPool
     from .seq_classification_lm import SequenceClassificationModelPool
 

{fusion_bench-0.2.27 → fusion_bench-0.2.28}/fusion_bench/modelpool/base_pool.py

@@ -3,7 +3,7 @@ from copy import deepcopy
 from typing import Dict, Generator, List, Optional, Tuple, Union
 
 import torch
-from omegaconf import DictConfig
+from omegaconf import DictConfig, OmegaConf, UnsupportedValueType
 from torch import nn
 from torch.utils.data import Dataset
 
@@ -52,6 +52,13 @@ class BaseModelPool(
     ):
         if isinstance(models, List):
             models = {str(model_idx): model for model_idx, model in enumerate(models)}
+
+        if isinstance(models, dict):
+            try:  # try to convert to DictConfig
+                models = OmegaConf.create(models)
+            except UnsupportedValueType:
+                pass
+
         self._models = models
         self._train_datasets = train_datasets
         self._val_datasets = val_datasets

fusion_bench-0.2.28/fusion_bench/modelpool/convnext_for_image_classification.py

@@ -0,0 +1,198 @@
+"""
+Hugging Face ConvNeXt image classification model pool.
+
+This module provides a `BaseModelPool` implementation that loads and saves
+ConvNeXt models for image classification via `transformers`. It optionally
+reconfigures the classification head to match a dataset's class names and
+overrides `forward` to return logits only for simpler downstream usage.
+
+See also: `fusion_bench.modelpool.resnet_for_image_classification` for a
+parallel implementation for ResNet-based classifiers.
+"""
+
+import os
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Literal,
+    Optional,
+    TypeVar,
+    Union,
+    override,
+)
+
+import torch
+from lightning_utilities.core.rank_zero import rank_zero_only
+from omegaconf import DictConfig
+from torch import nn
+
+from fusion_bench import BaseModelPool, auto_register_config, get_rankzero_logger
+from fusion_bench.tasks.clip_classification import get_classnames, get_num_classes
+
+log = get_rankzero_logger(__name__)
+
+
+def load_transformers_convnext(
+    config_path: str, pretrained: bool, dataset_name: Optional[str]
+):
+    """Create a ConvNeXt image classification model from a config or checkpoint.
+
+    Args:
+        config_path: A model identifier or local path understood by
+            `transformers.AutoConfig/AutoModel` (e.g., "facebook/convnext-base-224").
+        pretrained: If True, load weights via `from_pretrained`; otherwise, build
+            the model from config only.
+        dataset_name: Optional dataset key used by FusionBench to derive class
+            names via `get_classnames`. When provided, the model's id/label maps
+            are updated and the classifier head is resized accordingly.
+
+    Returns:
+        ConvNextForImageClassification: A `transformers.ConvNextForImageClassification` instance. If
+            `dataset_name` is set, the classifier head is adapted to the number of
+            classes. The model's `config.id2label` and `config.label2id` are also
+            populated.
+
+    Notes:
+        The overall structure mirrors the ResNet implementation in
+        `fusion_bench.modelpool.resnet_for_image_classification`.
+    """
+    from transformers import AutoConfig, ConvNextForImageClassification
+
+    if pretrained:
+        model = ConvNextForImageClassification.from_pretrained(config_path)
+    else:
+        config = AutoConfig.from_pretrained(config_path)
+        model = ConvNextForImageClassification(config)
+
+    if dataset_name is None:
+        return model
+
+    classnames = get_classnames(dataset_name)
+    id2label = {i: c for i, c in enumerate(classnames)}
+    label2id = {c: i for i, c in enumerate(classnames)}
+    model.config.id2label = id2label
+    model.config.label2id = label2id
+    model.num_labels = model.config.num_labels
+
+    model.classifier = (
+        nn.Linear(
+            model.classifier.in_features,
+            len(classnames),
+            device=model.classifier.weight.device,
+            dtype=model.classifier.weight.dtype,
+        )
+        if model.config.num_labels > 0
+        else nn.Identity()
+    )
+    return model
+
+
+@auto_register_config
+class ConvNextForImageClassificationPool(BaseModelPool):
+    """Model pool for ConvNeXt image classification models (HF Transformers).
+
+    Responsibilities:
+    - Load an `AutoImageProcessor` compatible with the configured ConvNeXt model.
+    - Load ConvNeXt models either from a pretrained checkpoint or from config.
+    - Optionally adapt the classifier head to match dataset classnames.
+    - Override `forward` to return logits for consistent interfaces within
+      FusionBench.
+
+    See `fusion_bench.modelpool.resnet_for_image_classification` for a closely
+    related ResNet-based pool with analogous behavior.
+    """
+
+    def load_processor(self, *args, **kwargs):
+        from transformers import AutoImageProcessor
+
+        if self.has_pretrained:
+            config_path = self._models["_pretrained_"].config_path
+        else:
+            for model_cfg in self._models.values():
+                if isinstance(model_cfg, str):
+                    config_path = model_cfg
+                    break
+                if "config_path" in model_cfg:
+                    config_path = model_cfg["config_path"]
+                    break
+        return AutoImageProcessor.from_pretrained(config_path)
+
+    @override
+    def load_model(self, model_name_or_config: Union[str, DictConfig], *args, **kwargs):
+        """Load a ConvNeXt model described by a name, path, or DictConfig.
+
+        Accepts either a string (pretrained identifier or local path) or a
+        config mapping with keys: `config_path`, optional `pretrained` (bool),
+        and optional `dataset_name` to resize the classifier.
+
+        Returns:
+            A model whose `forward` is wrapped to return only logits to align
+            with FusionBench expectations.
+        """
+        log.debug(f"Loading model: {model_name_or_config}", stacklevel=2)
+        if (
+            isinstance(model_name_or_config, str)
+            and model_name_or_config in self._models
+        ):
+            model_name_or_config = self._models[model_name_or_config]
+
+        match model_name_or_config:
+            case str() as model_path:
+                from transformers import AutoModelForImageClassification
+
+                model = AutoModelForImageClassification.from_pretrained(model_path)
+            case dict() | DictConfig() as model_config:
+                model = load_transformers_convnext(
+                    model_config["config_path"],
+                    pretrained=model_config.get("pretrained", True),
+                    dataset_name=model_config.get("dataset_name", None),
+                )
+            case _:
+                raise ValueError(
+                    f"Unsupported model_name_or_config type: {type(model_name_or_config)}"
+                )
+
+        # override forward to return logits only
+        original_forward = model.forward
+        model.forward = lambda pixel_values, **kwargs: original_forward(
+            pixel_values=pixel_values, **kwargs
+        ).logits
+        model.original_forward = original_forward
+
+        return model
+
+    @override
+    def save_model(
+        self,
+        model,
+        path,
+        algorithm_config: Optional[DictConfig] = None,
+        description: Optional[str] = None,
+        base_model: Optional[str] = None,
+        *args,
+        **kwargs,
+    ):
+        """Save the model, processor, and an optional model card to disk.
+
+        Artifacts written to `path`:
+        - The ConvNeXt model via `model.save_pretrained`.
+        - The paired image processor via `AutoImageProcessor.save_pretrained`.
+        - If `algorithm_config` is provided and on rank-zero, a README model card
+          documenting the FusionBench configuration.
+        """
+        model.save_pretrained(path)
+        self.load_processor().save_pretrained(path)
+
+        if algorithm_config is not None and rank_zero_only.rank == 0:
+            from fusion_bench.models.hf_utils import create_default_model_card
+
+            model_card_str = create_default_model_card(
+                algorithm_config=algorithm_config,
+                description=description,
+                modelpool_config=self.config,
+                base_model=base_model,
+            )
+            with open(os.path.join(path, "README.md"), "w") as f:
+                f.write(model_card_str)

fusion_bench-0.2.28/fusion_bench/modelpool/dinov2_for_image_classification.py

@@ -0,0 +1,197 @@
+"""
+Hugging Face DINOv2 image classification model pool.
+
+This module provides a `BaseModelPool` implementation that loads and saves
+DINOv2 models for image classification via `transformers`. It optionally
+reconfigures the classification head to match a dataset's class names and
+overrides `forward` to return logits only for simpler downstream usage.
+
+See also: `fusion_bench.modelpool.convnext_for_image_classification` for a
+parallel implementation for ConvNeXt-based classifiers.
+"""
+
+import os
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Literal,
+    Optional,
+    TypeVar,
+    Union,
+    override,
+)
+
+import torch
+from lightning_utilities.core.rank_zero import rank_zero_only
+from omegaconf import DictConfig
+from torch import nn
+
+from fusion_bench import BaseModelPool, auto_register_config, get_rankzero_logger
+from fusion_bench.tasks.clip_classification import get_classnames, get_num_classes
+
+log = get_rankzero_logger(__name__)
+
+
+def load_transformers_dinov2(
+    config_path: str, pretrained: bool, dataset_name: Optional[str]
+):
+    """Create a DINOv2 image classification model from a config or checkpoint.
+
+    Args:
+        config_path: A model identifier or local path understood by
+            `transformers.AutoConfig/AutoModel` (e.g., "facebook/dinov2-base").
+        pretrained: If True, load weights via `from_pretrained`; otherwise, build
+            the model from config only.
+        dataset_name: Optional dataset key used by FusionBench to derive class
+            names via `get_classnames`. When provided, the model's id/label maps
+            are updated and the classifier head is resized accordingly.
+
+    Returns:
+        Dinov2ForImageClassification: A `transformers.Dinov2ForImageClassification` instance. If
+            `dataset_name` is set, the classifier head is adapted to the number of
+            classes. The model's `config.id2label` and `config.label2id` are also
+            populated.
+
+    Notes:
+        The overall structure mirrors the ConvNeXt implementation in
+        `fusion_bench.modelpool.convnext_for_image_classification`.
+    """
+    from transformers import AutoConfig, Dinov2ForImageClassification
+
+    if pretrained:
+        model = Dinov2ForImageClassification.from_pretrained(config_path)
+    else:
+        config = AutoConfig.from_pretrained(config_path)
+        model = Dinov2ForImageClassification(config)
+
+    if dataset_name is None:
+        return model
+
+    classnames = get_classnames(dataset_name)
+    id2label = {i: c for i, c in enumerate(classnames)}
+    label2id = {c: i for i, c in enumerate(classnames)}
+    model.config.id2label = id2label
+    model.config.label2id = label2id
+    model.num_labels = model.config.num_labels
+
+    # If the model is configured with a positive number of labels, resize the
+    # classifier to match the dataset classes; otherwise leave it as identity.
+    model.classifier = (
+        nn.Linear(
+            model.classifier.in_features,
+            len(classnames),
+            device=model.classifier.weight.device,
+            dtype=model.classifier.weight.dtype,
+        )
+        if model.config.num_labels > 0
+        else nn.Identity()
+    )
+    return model
+
+
+@auto_register_config
+class Dinov2ForImageClassificationPool(BaseModelPool):
+    """Model pool for DINOv2 image classification models (HF Transformers)."""
+
+    def load_processor(self, *args, **kwargs):
+        """Load the paired image processor for this model pool.
+
+        Uses the configured model's identifier or config path to retrieve the
+        appropriate `transformers.AutoImageProcessor` instance. If a pretrained
+        model entry exists in the pool configuration, it is preferred to derive
+        the processor to ensure tokenization/normalization parity.
+        """
+        from transformers import AutoImageProcessor
+
+        if self.has_pretrained:
+            config_path = self._models["_pretrained_"].config_path
+        else:
+            for model_cfg in self._models.values():
+                if isinstance(model_cfg, str):
+                    config_path = model_cfg
+                    break
+                if "config_path" in model_cfg:
+                    config_path = model_cfg["config_path"]
+                    break
+        return AutoImageProcessor.from_pretrained(config_path)
+
+    @override
+    def load_model(self, model_name_or_config: Union[str, DictConfig], *args, **kwargs):
+        """Load a DINOv2 model described by a name, path, or DictConfig.
+
+        Accepts either a string (pretrained identifier or local path) or a
+        config mapping with keys: `config_path`, optional `pretrained` (bool),
+        and optional `dataset_name` to resize the classifier.
+
+        Returns:
+            A model whose `forward` is wrapped to return only logits to align
+            with FusionBench expectations.
+        """
+        log.debug(f"Loading model: {model_name_or_config}", stacklevel=2)
+        if (
+            isinstance(model_name_or_config, str)
+            and model_name_or_config in self._models
+        ):
+            model_name_or_config = self._models[model_name_or_config]
+
+        match model_name_or_config:
+            case str() as model_path:
+                from transformers import AutoModelForImageClassification
+
+                model = AutoModelForImageClassification.from_pretrained(model_path)
+            case dict() | DictConfig() as model_config:
+                model = load_transformers_dinov2(
+                    model_config["config_path"],
+                    pretrained=model_config.get("pretrained", True),
+                    dataset_name=model_config.get("dataset_name", None),
+                )
+            case _:
+                raise ValueError(
+                    f"Unsupported model_name_or_config type: {type(model_name_or_config)}"
+                )
+
+        # Override forward to return logits only, to unify the interface across
+        # FusionBench model pools and simplify downstream usage.
+        original_forward = model.forward
+        model.forward = lambda pixel_values, **kwargs: original_forward(
+            pixel_values=pixel_values, **kwargs
+        ).logits
+        model.original_forward = original_forward
+
+        return model
+
+    @override
+    def save_model(
+        self,
+        model,
+        path,
+        algorithm_config: Optional[DictConfig] = None,
+        description: Optional[str] = None,
+        base_model: Optional[str] = None,
+        *args,
+        **kwargs,
+    ):
+        """Save the model, processor, and an optional model card to disk.
+
+        Artifacts written to `path`:
+        - The DINOv2 model via `model.save_pretrained`.
+        - The paired image processor via `AutoImageProcessor.save_pretrained`.
+        - If `algorithm_config` is provided and on rank-zero, a README model card
+          documenting the FusionBench configuration.
+        """
+        model.save_pretrained(path)
+        self.load_processor().save_pretrained(path)
+
+        if algorithm_config is not None and rank_zero_only.rank == 0:
+            from fusion_bench.models.hf_utils import create_default_model_card
+
+            model_card_str = create_default_model_card(
+                algorithm_config=algorithm_config,
+                description=description,
+                modelpool_config=self.config,
+                base_model=base_model,
+            )
+            with open(os.path.join(path, "README.md"), "w") as f:
+                f.write(model_card_str)

{fusion_bench-0.2.27 → fusion_bench-0.2.28}/fusion_bench/modelpool/resnet_for_image_classification.py

@@ -138,6 +138,7 @@ def load_transformers_resnet(
     label2id = {c: i for i, c in enumerate(classnames)}
     model.config.id2label = id2label
     model.config.label2id = label2id
+    model.num_labels = model.config.num_labels
 
     model.classifier[1] = (
         nn.Linear(
@@ -407,7 +408,7 @@ class ResNetForImageClassificationPool(BaseModelPool):
 
                     model = load_transformers_resnet(
                         config_path=model_config["config_path"],
-                        pretrained=model_config.get("pretrained", False),
+                        pretrained=model_config.get("pretrained", True),
                         dataset_name=model_config.get("dataset_name", None),
                     )
                 case _:
@@ -432,6 +433,7 @@ class ResNetForImageClassificationPool(BaseModelPool):
         path,
         algorithm_config: Optional[DictConfig] = None,
         description: Optional[str] = None,
+        base_model: Optional[str] = None,
         *args,
         **kwargs,
     ):
@@ -479,6 +481,7 @@ class ResNetForImageClassificationPool(BaseModelPool):
                 from fusion_bench.models.hf_utils import create_default_model_card
 
                 model_card_str = create_default_model_card(
+                    base_model=base_model,
                     algorithm_config=algorithm_config,
                     description=description,
                     modelpool_config=self.config,

{fusion_bench-0.2.27 → fusion_bench-0.2.28}/fusion_bench/utils/json.py

@@ -1,31 +1,72 @@
 import json
 from pathlib import Path
-from typing import Any, Union
+from typing import TYPE_CHECKING, Any, Union
 
+if TYPE_CHECKING:
+    from pyarrow.fs import FileSystem
 
-def save_to_json(obj, path: Union[str, Path]):
+
+def save_to_json(obj, path: Union[str, Path], filesystem: "FileSystem" = None):
     """
     save an object to a json file
 
     Args:
         obj (Any): the object to save
         path (Union[str, Path]): the path to save the object
+        filesystem (FileSystem, optional): PyArrow FileSystem to use for writing.
+            If None, uses local filesystem via standard Python open().
+            Can also be an s3fs.S3FileSystem or fsspec filesystem.
     """
-    with open(path, "w") as f:
-        json.dump(obj, f)
+    if filesystem is not None:
+        json_str = json.dumps(obj)
+        # Check if it's an fsspec-based filesystem (like s3fs)
+        if hasattr(filesystem, "open"):
+            # Direct fsspec/s3fs usage - more reliable for some endpoints
+            path_str = str(path)
+            with filesystem.open(path_str, "w") as f:
+                f.write(json_str)
+        else:
+            # Use PyArrow filesystem
+            path_str = str(path)
+            with filesystem.open_output_stream(path_str) as f:
+                f.write(json_str.encode("utf-8"))
+    else:
+        # Use standard Python file operations
+        with open(path, "w") as f:
+            json.dump(obj, f)
 
 
-def load_from_json(path: Union[str, Path]) -> Union[dict, list]:
+def load_from_json(
+    path: Union[str, Path], filesystem: "FileSystem" = None
+) -> Union[dict, list]:
     """load an object from a json file
 
     Args:
         path (Union[str, Path]): the path to load the object
+        filesystem (FileSystem, optional): PyArrow FileSystem to use for reading.
+            If None, uses local filesystem via standard Python open().
+            Can also be an s3fs.S3FileSystem or fsspec filesystem.
 
     Returns:
-        dict: the loaded object
+        Union[dict, list]: the loaded object
     """
-    with open(path, "r") as f:
-        return json.load(f)
+    if filesystem is not None:
+        # Check if it's an fsspec-based filesystem (like s3fs)
+        if hasattr(filesystem, "open"):
+            # Direct fsspec/s3fs usage
+            path_str = str(path)
+            with filesystem.open(path_str, "r") as f:
+                return json.load(f)
+        else:
+            # Use PyArrow filesystem
+            path_str = str(path)
+            with filesystem.open_input_stream(path_str) as f:
+                json_data = f.read().decode("utf-8")
+                return json.loads(json_data)
+    else:
+        # Use standard Python file operations
+        with open(path, "r") as f:
+            return json.load(f)
 
 
 def _is_list_of_dict(obj) -> bool:

{fusion_bench-0.2.27 → fusion_bench-0.2.28}/fusion_bench.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fusion-bench
-Version: 0.2.27
+Version: 0.2.28
 Summary: A Comprehensive Benchmark of Deep Model Fusion
 Author-email: Anke Tang <tang.anke@foxmail.com>
 Project-URL: Repository, https://github.com/tanganke/fusion_bench