Upload model

config.json

@@ -0,0 +1,26 @@
+{
+  "architectures": [
+    "ResnetModelForImageClassification"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_resnet.ResnetConfig",
+    "AutoModelForImageClassification": "modeling_resnet.ResnetModelForImageClassification"
+  },
+  "avg_down": true,
+  "base_width": 64,
+  "block_type": "bottleneck",
+  "cardinality": 1,
+  "input_channels": 3,
+  "layers": [
+    3,
+    4,
+    6,
+    3
+  ],
+  "model_type": "resnet",
+  "num_classes": 1000,
+  "stem_type": "deep",
+  "stem_width": 32,
+  "torch_dtype": "float32",
+  "transformers_version": "4.26.1"
+}

configuration_resnet.py

@@ -0,0 +1,79 @@
+from typing import List
+
+from transformers import PretrainedConfig
+
+"""
+The configuration of a model is an object that 
+will contain all the necessary information to build the model.
+
+The three important things to remember when writing you own configuration are the following:
+
+- you have to inherit from PretrainedConfig,
+- the __init__ of your PretrainedConfig must accept any kwargs,
+- those kwargs need to be passed to the superclass __init__.
+"""
+
+
+class ResnetConfig(PretrainedConfig):
+
+    """
+    Defining a model_type for your configuration (here model_type="resnet") is not mandatory,
+    unless you want to register your model with the auto classes (see last section)."""
+
+    model_type = "resnet"
+
+    def __init__(
+        self,
+        block_type="bottleneck",
+        layers: List[int] = [3, 4, 6, 3],
+        num_classes: int = 1000,
+        input_channels: int = 3,
+        cardinality: int = 1,
+        base_width: int = 64,
+        stem_width: int = 64,
+        stem_type: str = "",
+        avg_down: bool = False,
+        **kwargs,
+    ):
+        if block_type not in ["basic", "bottleneck"]:
+            raise ValueError(
+                f"`block_type` must be 'basic' or bottleneck', got {block_type}."
+            )
+        if stem_type not in ["", "deep", "deep-tiered"]:
+            raise ValueError(
+                f"`stem_type` must be '', 'deep' or 'deep-tiered', got {stem_type}."
+            )
+
+        self.block_type = block_type
+        self.layers = layers
+        self.num_classes = num_classes
+        self.input_channels = input_channels
+        self.cardinality = cardinality
+        self.base_width = base_width
+        self.stem_width = stem_width
+        self.stem_type = stem_type
+        self.avg_down = avg_down
+        super().__init__(**kwargs)
+
+
+if __name__ == "__main__":
+    """
+    With this done, you can easily create and save your configuration like
+    you would do with any other model config of the library.
+    Here is how we can create a resnet50d config and save it:
+    """
+    resnet50d_config = ResnetConfig(
+        block_type="bottleneck", stem_width=32, stem_type="deep", avg_down=True
+    )
+    resnet50d_config.save_pretrained("custom-resnet")
+
+    """
+    This will save a file named config.json inside the folder custom-resnet. 
+    You can then reload your config with the from_pretrained method:
+    """
+    resnet50d_config = ResnetConfig.from_pretrained("custom-resnet")
+
+    """
+    You can also use any other method of the PretrainedConfig class, 
+    like push_to_hub() to directly upload your config to the Hub.
+    """

modeling_resnet.py

@@ -0,0 +1,75 @@
+from typing import Dict
+
+import timm
+from timm.models.resnet import BasicBlock, Bottleneck, ResNet
+from torch import Tensor, nn
+from transformers import PreTrainedModel
+
+from .configuration_resnet import ResnetConfig
+
+BLOCK_MAPPING = {"basic": BasicBlock, "bottleneck": Bottleneck}
+
+
+class ResnetModel(PreTrainedModel):
+    """
+    The line that sets the config_class is not mandatory,
+    unless you want to register your model with the auto classes
+    """
+
+    config_class = ResnetConfig
+
+    def __init__(self, config: ResnetConfig):
+        super().__init__(config)
+        block_layer = BLOCK_MAPPING[config.block_type]
+        self.model = ResNet(
+            block_layer,
+            config.layers,
+            num_classes=config.num_classes,
+            in_chans=config.input_channels,
+            cardinality=config.cardinality,
+            base_width=config.base_width,
+            stem_width=config.stem_width,
+            stem_type=config.stem_type,
+            avg_down=config.avg_down,
+        )
+
+    def forward(self, tensor: Tensor) -> Tensor:
+        return self.model.forward_features(tensor)
+
+
+class ResnetModelForImageClassification(PreTrainedModel):
+    """
+    The line that sets the config_class is not mandatory,
+    unless you want to register your model with the auto classes
+    """
+
+    config_class = ResnetConfig
+
+    def __init__(self, config: ResnetConfig):
+        super().__init__(config)
+        self.model = ResnetModel(config)
+
+    """
+    You can have your model return anything you want, 
+    but returning a dictionary like we did for ResnetModelForImageClassification, 
+    with the loss included when labels are passed, 
+    will make your model directly usable inside the Trainer class. 
+    Using another output format is fine as long as you are planning on 
+    using your own training loop or another library for training.
+    """
+
+    def forward(self, tensor: Tensor, labels=None) -> Dict[str, Tensor]:
+        logits = self.model(tensor)
+        if labels is not None:
+            loss = nn.cross_entropy(logits, labels)
+            return {"loss": loss, "logits": logits}
+        return {"logits": logits}
+
+
+if __name__ == "__main__":
+    resnet50d_config = ResnetConfig.from_pretrained("custom-resnet")
+    resnet50d = ResnetModelForImageClassification(resnet50d_config)
+
+    # Load pretrained weights from timm
+    pretrained_model: nn.Module = timm.create_model("resnet50d", pretrained=True)
+    resnet50d.model.load_state_dict(pretrained_model.state_dict())

pytorch_model.bin

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