fusion-bench 0.2.27__py3-none-any.whl → 0.2.28__py3-none-any.whl

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/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/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/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/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/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/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/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/models/model_card_templates/default.md

@@ -1,6 +1,6 @@
 ---
-base_model:
 {%- if base_model is not none %}
+base_model:
 - {{ base_model }}
 {%- endif %}
 {%- for model in models %}

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.dist-info → fusion_bench-0.2.28.dist-info}/METADATA

@@ -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.dist-info → fusion_bench-0.2.28.dist-info}/RECORD

@@ -1,4 +1,4 @@
-fusion_bench/__init__.py,sha256=Rw9sT2ZegKMxZAG7FBDgqVOqBGlJ-43C5p_EarRHd1M,5816
+fusion_bench/__init__.py,sha256=C-0-HgZFdRjscXqpfNsz7iGUijUeSoP4GFRnFxuxQ7M,5992
 fusion_bench/__main__.py,sha256=weUjxpP3ULnDgUxCehdbmoCM9cqfkhDhGB85tAF5qoE,81
 fusion_bench/_get_started/__init__.py,sha256=Ht6OK6Luei2kdY9jRZzRQfzBlm3Yfm64BkXxpzeRg9Q,40
 fusion_bench/_get_started/greeting_program.py,sha256=wvVsPa7Djwx5Z5spAI6F9Kvv9KwfNkjIgJVH8oXR3Bo,1233
@@ -80,7 +80,7 @@ fusion_bench/method/bitdelta/bitdelta_utils/diff.py,sha256=o3ib5sgGDYLgnL8YTfX0Y
 fusion_bench/method/classification/__init__.py,sha256=byVJ574JQ_DUvsDv8S6ZM6BKAv4ZZ964Ej4btm0aC7k,867
 fusion_bench/method/classification/clip_finetune.py,sha256=5q5Sr3eVVh8DfYdeSoGjwaKDksC8F2dY2r8Dl-wRaDg,15844
 fusion_bench/method/classification/continual_clip_finetune.py,sha256=OLhZKS-6aCnafevZkZYcNMKTWDDj3DATB27eZl_i8EY,11530
-fusion_bench/method/classification/image_classification_finetune.py,sha256=ExUwsBsDHX6Kq1G9arapgf3xQZJLBcNoRfCIXqIsbD0,14967
+fusion_bench/method/classification/image_classification_finetune.py,sha256=xWSspEuiyM9mz7nTFCLMbJMvkuD-k3B7mx-KMvq7nEU,15310
 fusion_bench/method/concrete_subspace/__init__.py,sha256=jJoFcjnQe-jvccsm9DuCXna378m9XBT9vV1fEZbdfR0,464
 fusion_bench/method/concrete_subspace/clip_concrete_adamerging.py,sha256=UkLOkaa_Dzlb4Q5ES69Y9GV1bodTnD7DzZFreykt65s,24706
 fusion_bench/method/concrete_subspace/clip_concrete_task_arithmetic.py,sha256=Nx-3AiAeIt5zmcC21Ta2_-4cAQg9hOWvThurXNZzA-w,10580
@@ -229,7 +229,7 @@ fusion_bench/method/tall_mask/__init__.py,sha256=XINPP8PqGQ01he9p2RyHaKGyrcYoJuY
 fusion_bench/method/tall_mask/task_arithmetic.py,sha256=RX_JgEPwG52EPYGXWYGuq0LBeyJHMbVZn7Qy_4QmSsQ,4373
 fusion_bench/method/tall_mask/utils.py,sha256=Wlp8WcPwR_lCaBIZ9rgG6ewLfSzz3G7kPk9yj13pvls,8817
 fusion_bench/method/task_arithmetic/__init__.py,sha256=pSx_NV5Ra_6UXpyYWCi6ANQoAnEtymZt_X1dDN9wT4Y,96
-fusion_bench/method/task_arithmetic/task_arithmetic.py,sha256=KsSBshf04MUwIjoc0HAAmY6cWMqjZwZOYXbUuU4EaL0,6320
+fusion_bench/method/task_arithmetic/task_arithmetic.py,sha256=yGMWk2--VlXTcQjDjnPdiug1q_rpjzu5SFvgCYDfTQ0,6479
 fusion_bench/method/task_singular_vector/TSVC.py,sha256=yn4SrZNvtA6PoGYJmbmtNeDyDbGnRCgfZ7ZCg914AZU,410
 fusion_bench/method/task_singular_vector/TSVM.py,sha256=Sdgoi8xT0Hl19pmGdIuUS3D1DsVqSVD-Hipp-Sj_HoA,13652
 fusion_bench/method/task_singular_vector/__init__.py,sha256=WMucyl9pu_Ev2kcdrfT4moqMMbzD7hHQVFME5Su5jMA,298
@@ -280,13 +280,15 @@ fusion_bench/mixins/simple_profiler.py,sha256=QA4fZhD-uL06fZaoqBQowI0c_qrAUhWszF
 fusion_bench/mixins/optim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fusion_bench/mixins/optim/adamw_with_warmup.py,sha256=qTnRl8GVVIfaplOFBHnJFuZUbxPZRWRGHGNzm_EDhDE,1421
 fusion_bench/modelpool/PeftModelForSeq2SeqLM.py,sha256=rxPKTTWno3KAcTTEfydPpXx1b0EJa8PLbqrberweFF8,2108
-fusion_bench/modelpool/__init__.py,sha256=wKAkEgit_1ZtDAOKOntzrUKdCjOFIxnPMYN02B970Wg,1671
-fusion_bench/modelpool/base_pool.py,sha256=5snzTmqn1Xs_dy0Ws5QWxs9uCAXMwIuclrwfikKPh9o,12298
+fusion_bench/modelpool/__init__.py,sha256=qDlBPrWFW-Z-LByzmfqP1ozYhWx2lYAEjhqjKF4EAbY,2307
+fusion_bench/modelpool/base_pool.py,sha256=7v01al93RjJ5CynUM-HnM6mCgCX9asUmaqPNmxioNoA,12531
+fusion_bench/modelpool/convnext_for_image_classification.py,sha256=m9MxFgfzNjGnHOU6gufaTPgkk67lifNNwW03nHUxXKo,7377
+fusion_bench/modelpool/dinov2_for_image_classification.py,sha256=Wd60J5Ji4KwXUYTPcYYXuYWrcpDlh7pjGZ-zjjRqYio,7496
 fusion_bench/modelpool/huggingface_automodel.py,sha256=OJ6EyYyjNv1_Bhjn-zli-e__BJ0xVa4Fx9lhXVb-DJo,552
 fusion_bench/modelpool/huggingface_gpt2_classification.py,sha256=j8nicVwtoLXY4RPE2dcepeEB3agBKkkH-xA3yMj1czw,2014
 fusion_bench/modelpool/lazy_state_dict_pool.py,sha256=HtEA85rqSCHfsIddI5sKDcZf5kSuHNwrb8fF1TUSTr0,652
 fusion_bench/modelpool/nyuv2_modelpool.py,sha256=btuXmYxwfjI6MnGakhoOf53Iyb9fxYH20CavGTrTcnA,1375
-fusion_bench/modelpool/resnet_for_image_classification.py,sha256=1Q79oj3FIBQBOr13zCvIcscBKLA0PHbPmTarwVlhIww,19873
+fusion_bench/modelpool/resnet_for_image_classification.py,sha256=drSQt6xMZnag2drrjepCu8jpORF_ui8MJj_CipqoRCU,20004
 fusion_bench/modelpool/causal_lm/__init__.py,sha256=F432-aDIgAbUITj4GNZS9dgUKKhaDMCbTeHB-9MecaQ,99
 fusion_bench/modelpool/causal_lm/causal_lm.py,sha256=FbatPI6aAJbaT5qa4Get2I0i8fxmbq0N6xwajolXpdg,19993
 fusion_bench/modelpool/clip_vision/__init__.py,sha256=3b9gN2bWUsoA1EmpitnIMnIlX7nklxbkn4WJ0QJtS2c,43
@@ -329,7 +331,7 @@ fusion_bench/models/llama/model_utils/mod.py,sha256=xzNOgTRfOK9q8kml4Q2nmSOl23f3
 fusion_bench/models/llama/model_utils/visual.py,sha256=wpqWqEASyA7WhJLCfC26h0Cdn5CXnwC1qPJUlSXggo4,8310
 fusion_bench/models/masks/__init__.py,sha256=vXG6jrBkDbPsnrX6nMEYAW1rQuGEWDgdjID7cKzXvrs,69
 fusion_bench/models/masks/mask_model.py,sha256=YXNZ_CGp6VPshZH__Znh6Z07BqOK53G-Ltc1LVy1E3I,5502
-fusion_bench/models/model_card_templates/default.md,sha256=DJXwDODCsqIOhkgP57-iCShxLYK_jnsDsJYH1GfbBY8,1028
+fusion_bench/models/model_card_templates/default.md,sha256=OoU83l1hip1gKsoA08hoKx-nCrOYbKaVTVCjK0pt9WY,1028
 fusion_bench/models/modeling_deepseek_v2/__init__.py,sha256=trXrhtKb_gIxXVo7wSZ-il5sLJtDTiNZezRrEt3M8zM,505
 fusion_bench/models/modeling_deepseek_v2/configuration_deepseek.py,sha256=TblFOCfNwaXUnXnD-sxFhSn5Df-_yy2LMcrth-sBPFI,10301
 fusion_bench/models/modeling_deepseek_v2/modeling_deepseek.py,sha256=PtfkfPrfmQVoLiVhgqlp5toJAnCinPWfeZYeJJtWWBs,78676
@@ -464,7 +466,7 @@ fusion_bench/utils/fabric.py,sha256=NxquO_rVJyE2w4V3raMElNMr1-wT01QZWPuIfL2rgdQ,
 fusion_bench/utils/functools.py,sha256=7_tYJ2WD88_2DDuOOj5aZz3cYuslYH5tsVyIgCeLtmk,1318
 fusion_bench/utils/hydra_utils.py,sha256=TklUDKDEZlg4keI-TEZiqh4gFjr9-61Rt1RMlqkoSGk,1174
 fusion_bench/utils/instantiate_utils.py,sha256=OXkfhq_o3Sgy5n3Psf-HI-dIfbK9oD2GBdfcx3gT63Q,17526
-fusion_bench/utils/json.py,sha256=sVCqbm9mmyHybiui-O57KFt_ULrjLtN2wipSo6VDvqE,2533
+fusion_bench/utils/json.py,sha256=LXmlqdUxgBepaFjf2JoLrOHQ7CdFAcKLzHL8LaSkPog,4359
 fusion_bench/utils/lazy_imports.py,sha256=s-1ABhPyyHs7gW4aodCzu3NySzILzTL7kVNZ0DZRXJA,6156
 fusion_bench/utils/lazy_state_dict.py,sha256=mJaiAtKB1vlNUAoQILnnCmU80FGJ8MSwmdPpmdhOyDE,22206
 fusion_bench/utils/misc.py,sha256=_7BaS9dNKyySGU0qmTmE0Tk8WK82TEm7IBJxVRkuEAw,5315
@@ -486,7 +488,7 @@ fusion_bench/utils/plot/token_notebook.py,sha256=bsntXf46Zz_RavTxNiB9c3-KvHw7LFw
 fusion_bench/utils/strenum/__init__.py,sha256=id9ORi1uXrDxhbmVxitJ1KDwLS4H3AAwFpaK5h1cQzw,8531
 fusion_bench/utils/strenum/_name_mangler.py,sha256=o11M5-bURW2RBvRTYXFQIPNeqLzburdoWLIqk8X3ydw,3397
 fusion_bench/utils/strenum/_version.py,sha256=6JQRo9LcvODbCOeVFYQb9HNJ_J9XiG_Zbn8ws2A3BV8,18466
-fusion_bench-0.2.27.dist-info/licenses/LICENSE,sha256=nhnOJlw4CPuPVE0qvkGmxfFgHmKi-6nzXvTu8t0NUdg,1066
+fusion_bench-0.2.28.dist-info/licenses/LICENSE,sha256=nhnOJlw4CPuPVE0qvkGmxfFgHmKi-6nzXvTu8t0NUdg,1066
 fusion_bench_config/README.md,sha256=Lc8YSBJ5oxf9KV5kKDivJ9LRyGuraGQPmBbgbdVA-j4,703
 fusion_bench_config/clip-vit-base-patch32_robustness_corrupted.yaml,sha256=7IxLQoLRz-sRWyV8Vqc5kQcmYE_9YQz2_77pmvAkum8,1207
 fusion_bench_config/fabric_model_fusion.yaml,sha256=kSQbhBsKypVFA3rmkdhY9BITnZWDXJof-I35t473_U0,2646
@@ -887,6 +889,8 @@ fusion_bench_config/modelpool/CausalLMPool/mergebench/gemma-2-2b-it.yaml,sha256=
 fusion_bench_config/modelpool/CausalLMPool/mergebench/gemma-2-2b.yaml,sha256=SODG0kcnAP6yC0_J_SpSVMRV-v5qGV22gcWdiBaZo1I,368
 fusion_bench_config/modelpool/CausalLMPool/mergebench/gemma-2-9b-it.yaml,sha256=zwInWJS8yrhch4vOL1ypRKNWWpJKlhQsyY0Ln14CC-M,389
 fusion_bench_config/modelpool/CausalLMPool/mergebench/gemma-2-9b.yaml,sha256=ufmu4b3lyxn2XLDMVYxP-bKwYaGTjB5-JoYXLG8v8tY,368
+fusion_bench_config/modelpool/ConvNextForImageClassification/convnext-base-224.yaml,sha256=gcXV5WIYe9Ep-54fjgT9HqbCBY7UiqbqkHvoNCQx62Y,259
+fusion_bench_config/modelpool/Dinov2ForImageClassification/dinov2-base-imagenet1k-1-layer.yaml,sha256=jxe6rvV37FBGsV-Pdnyxe-G-Vw-HzOXuT2NMHKBSBOU,270
 fusion_bench_config/modelpool/OpenCLIPVisionModelPool/README.md,sha256=DC0HF-isCHshipHTC0Rof6GvjTUa0i2DVQZKrklQQlU,2416
 fusion_bench_config/modelpool/OpenCLIPVisionModelPool/ViT-B-16_TA8.yaml,sha256=jbJqqciORJQknpSzh2zKiFm6VKDOsmaSk9XfPCVmHGg,1220
 fusion_bench_config/modelpool/OpenCLIPVisionModelPool/ViT-B-32_TA8.yaml,sha256=q2_E2R1wIOdxd-AF-wjXkPO64gJgD27YXsZ8FFLWUIo,1607
@@ -1011,8 +1015,8 @@ fusion_bench_config/taskpool/LMEvalHarnessTaskPool/lm_eval.yaml,sha256=3q-KMuFaM
 fusion_bench_config/taskpool/OpenCLIPVisionModelTaskPool/ViT-B-16_TA8.yaml,sha256=GjpiiRownrBCpl-TNwWRW2PYePbF-Cl99jlLNPrK5T4,1017
 fusion_bench_config/taskpool/OpenCLIPVisionModelTaskPool/ViT-B-32_TA8.yaml,sha256=WwiYMQKehtJixDPnu5o3vcWe4yJksXTWRqOzm3uVWXQ,1017
 fusion_bench_config/taskpool/OpenCLIPVisionModelTaskPool/ViT-L-14_TA8.yaml,sha256=xGRt0J9joXTzWUew6DvoYprAWlPXhaVFw5AX4im5VQw,1017
-fusion_bench-0.2.27.dist-info/METADATA,sha256=TnLxGqALTnvyF-GXwk-iGvl-eNvBjNvZzkDODdkVLVo,24307
-fusion_bench-0.2.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fusion_bench-0.2.27.dist-info/entry_points.txt,sha256=iUQ8MCJvda7HP4vYh2n1Teoapb4G9PBVYZkAfcc5SHU,116
-fusion_bench-0.2.27.dist-info/top_level.txt,sha256=BuO4TL6iHL_2yPBUX9-LlIrHRczA_BNMIFwweK0PQEI,13
-fusion_bench-0.2.27.dist-info/RECORD,,
+fusion_bench-0.2.28.dist-info/METADATA,sha256=2m3tF3J5gbcupGjZt_0Md77Tb7h3oDxwwp_Q_sZsdIM,24307
+fusion_bench-0.2.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fusion_bench-0.2.28.dist-info/entry_points.txt,sha256=iUQ8MCJvda7HP4vYh2n1Teoapb4G9PBVYZkAfcc5SHU,116
+fusion_bench-0.2.28.dist-info/top_level.txt,sha256=BuO4TL6iHL_2yPBUX9-LlIrHRczA_BNMIFwweK0PQEI,13
+fusion_bench-0.2.28.dist-info/RECORD,,

fusion_bench_config/modelpool/ConvNextForImageClassification/convnext-base-224.yaml

@@ -0,0 +1,10 @@
+_target_: fusion_bench.modelpool.ConvNextForImageClassificationPool
+_recursive_: False
+models:
+  _pretrained_:
+    config_path: facebook/convnext-base-224
+    pretrained: true
+    dataset_name: null
+train_datasets: null
+val_datasets: null
+test_datasets: null

fusion_bench_config/modelpool/Dinov2ForImageClassification/dinov2-base-imagenet1k-1-layer.yaml

@@ -0,0 +1,10 @@
+_target_: fusion_bench.modelpool.Dinov2ForImageClassificationPool
+_recursive_: False
+models:
+  _pretrained_:
+    config_path: facebook/dinov2-base-imagenet1k-1-layer
+    pretrained: true
+    dataset_name: null
+train_datasets: null
+val_datasets: null
+test_datasets: null