Publish Trendyol DinoV2.1 ecommerce 256d (GeM run_12 epoch=09)

LICENSE

@@ -0,0 +1,41 @@
+# Copyright (c) 2025 Trendyol
+
+This work, including the model weights and code, is licensed under the
+Creative Commons Attribution-ShareAlike 4.0 International License.
+A copy of the license is available at:
+http://creativecommons.org/licenses/by-sa/4.0/
+================================================================================
+
+---
+
+### Human-Readable Summary of the License:
+
+---
+
+This is a summary of the CC BY-SA 4.0 license and not a substitute for the full license text.
+**You are free to:**
+
+- **Share** — copy and redistribute the material in any medium or format for any purpose, even commercially.
+- **Adapt** — remix, transform, and build upon the material for any purpose, even commercially.
+  The licensor cannot revoke these freedoms as long as you follow the license terms.
+  **Under the following terms:**
+- **Attribution (BY)** — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
+- **ShareAlike (SA)** — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.
+- **No additional restrictions** — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
+
+---
+
+### Attribution Requirements
+
+---
+
+If you use this model or its derivatives, you must provide proper attribution. Please cite our work as follows:
+"Trendyol DinoV2 Image Similarity Model, licensed under CC BY-SA 4.0. Available at: https://huggingface.co/Trendyol/trendyol-dino-v2-ecommerce-256d"
+
+---
+
+### Disclaimer of Warranty
+
+---
+
+Unless required by applicable law or agreed to in writing, the Work is provided on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with your exercise of permissions under this License.

README.md

@@ -0,0 +1,104 @@
+---
+language:
+  - en
+license: cc-by-sa-4.0
+library_name: transformers
+tags:
+  - image-similarity
+  - image-retrieval
+  - computer-vision
+  - e-commerce
+  - dinov2
+  - gem-pooling
+  - pytorch
+  - safetensors
+datasets:
+  - e-commerce-product-images
+pipeline_tag: feature-extraction
+base_model: Trendyol/trendyol-dino-v2-ecommerce-256d
+---
+
+# Trendyol DinoV2.1 Image Similarity Model
+
+Fine-tuned DinoV2 (ViT-B/14) with **GeM pooling** for e-commerce product image retrieval.
+This is the successor to [`Trendyol/trendyol-dino-v2-ecommerce-256d`](https://huggingface.co/Trendyol/trendyol-dino-v2-ecommerce-256d).
+
+## Model Details
+
+- **Model Type**: Image Similarity / Retrieval
+- **Architecture**: DinoV2 ViT-B/14 + GeM pooling + linear projection (ArcFace-trained)
+- **Embedding Dimension**: 256
+- **Input Size**: 224×224
+- **Checkpoint**: `ray-dinov2-full_catalog_1000_20-pfc-gem-mlp-run_12` epoch **09**
+- **Framework**: PyTorch / SafeTensors
+
+## What's new vs v2
+
+| | v2 | **v2.1** |
+|---|---|---|
+| Pooling / head | Flatten spatial tokens → Linear(196608→256) | **GeM** → Linear(768→256) |
+| Training data | full_catalog_300_20 style | **full_catalog_1000_20** |
+| Preprocess | Lanczos/JPEG/332 pad pipeline | Scale+pad to 224 (training inference preprocess) |
+
+## Quick Start
+
+```python
+import torch
+from PIL import Image
+from transformers import AutoModel, AutoImageProcessor
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+repo = "Trendyol/trendyol-dino-v2.1-ecommerce-256d"
+
+processor = AutoImageProcessor.from_pretrained(repo, trust_remote_code=True)
+model = AutoModel.from_pretrained(repo, trust_remote_code=True).to(device).eval()
+
+image = Image.open("your_image.jpg").convert("RGB")
+inputs = processor(images=image, return_tensors="pt")
+inputs = {k: v.to(device) for k, v in inputs.items()}
+
+with torch.no_grad():
+    embeddings = model(**inputs).last_hidden_state  # [1, 256]
+
+print(embeddings.shape)
+```
+
+## Preprocessing Pipeline
+
+1. **ScaleImage**: resize so max side = 224 (keep aspect ratio)
+2. **PadToSquare**: pad with color 255
+3. **Resize**: 224×224
+4. **ToTensor** + **ImageNet Normalize** (mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+
+## Installation
+
+```bash
+pip install transformers torch torchvision safetensors pillow numpy
+```
+
+## Intended Use
+
+- Product image similarity search
+- Visual recommendations / duplicate detection
+- Content-based retrieval in e-commerce
+
+## Limitations
+
+- Optimized for product / e-commerce images
+- Requires `trust_remote_code=True`
+- Classification heads from training are **not** included in this Hub export (embeddings only)
+
+## License
+
+See [LICENSE](LICENSE). Same terms as the v2 release: source-available; commercial use requires attribution and prior notification to Trendyol (`scr.datascience@trendyol.com`).
+
+## Citation
+
+```
+@misc{trendyol-dinov2-ecommerce-v21,
+  title={Trendyol DinoV2.1 E-commerce Image Similarity Model},
+  author={Trendyol Data Science Team},
+  year={2026},
+  url={https://huggingface.co/Trendyol/trendyol-dino-v2.1-ecommerce-256d}
+}
+```

__init__.py

@@ -0,0 +1,21 @@
+"""
+Trendyol DinoV2.1 Image Similarity Model (GeM)
+
+Hugging Face transformers-compatible package.
+"""
+
+from transformers import AutoConfig, AutoImageProcessor, AutoModel
+
+from .image_processing_trendyol_dinov2_v21 import TrendyolDinoV21ImageProcessor
+from .modeling_trendyol_dinov2_v21 import TrendyolDinoV21Config, TrendyolDinoV21Model
+
+AutoConfig.register("trendyol_dinov2_v21", TrendyolDinoV21Config)
+AutoModel.register(TrendyolDinoV21Config, TrendyolDinoV21Model)
+AutoImageProcessor.register(TrendyolDinoV21Config, TrendyolDinoV21ImageProcessor)
+
+__version__ = "2.1.0"
+__all__ = [
+    "TrendyolDinoV21Model",
+    "TrendyolDinoV21Config",
+    "TrendyolDinoV21ImageProcessor",
+]

config.json

@@ -0,0 +1,44 @@
+{
+  "model_type": "trendyol_dinov2_v21",
+  "architectures": [
+    "TrendyolDinoV21Model"
+  ],
+  "auto_map": {
+    "AutoConfig": "modeling_trendyol_dinov2_v21.TrendyolDinoV21Config",
+    "AutoModel": "modeling_trendyol_dinov2_v21.TrendyolDinoV21Model",
+    "AutoImageProcessor": "image_processing_trendyol_dinov2_v21.TrendyolDinoV21ImageProcessor"
+  },
+  "backbone_name": "dinov2_vitb14",
+  "embedding_dim": 256,
+  "hidden_size": 256,
+  "in_features": 768,
+  "gem_p": 2.9,
+  "dropout": 0.3,
+  "input_size": 224,
+  "pad_color": 255,
+  "pooling": "GeM",
+  "normalization": {
+    "mean": [0.485, 0.456, 0.406],
+    "std": [0.229, 0.224, 0.225]
+  },
+  "preprocessing": {
+    "input_size": 224,
+    "pad_color": 255,
+    "transforms": [
+      "ScaleImage",
+      "PadToSquare",
+      "Resize",
+      "ToTensor",
+      "Normalize"
+    ]
+  },
+  "task_type": "image-retrieval",
+  "training_info": {
+    "experiment": "ray-dinov2-full_catalog_1000_20-pfc-gem-mlp-run_12",
+    "epoch": "9",
+    "dataset": "full_catalog_1000_20",
+    "torch_version": "2.8.0"
+  },
+  "torch_dtype": "float32",
+  "transformers_version": "4.20.0"
+}

image_processing_trendyol_dinov2_v21.py

@@ -0,0 +1,116 @@
+"""
+Hugging Face image processor for Trendyol DinoV2.1 (GeM).
+
+Matches training/inference preprocess used by SimilarityInferenceModel /
+dino_v2_gem.Preprocessor: scale-to-max(224), pad-to-square(255), resize 224,
+ImageNet normalize. (No JPEG / 332 downscale stage.)
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+import numpy as np
+import torch
+from PIL import Image
+from torchvision import transforms
+from torchvision.transforms import functional as TF
+from transformers import BatchFeature, ImageProcessingMixin
+from transformers.utils import TensorType
+
+
+def resize_keep_ratio(img: Image.Image, size: int) -> Image.Image:
+    w, h = img.size
+    max_size = max(h, w)
+    scale = size / max_size
+    new_size = int(w * scale), int(h * scale)
+    return img.resize(new_size, Image.BILINEAR)
+
+
+class ScaleImage:
+    def __init__(self, target_size: int):
+        self.target_size = target_size
+
+    def __call__(self, img: Image.Image) -> Image.Image:
+        return resize_keep_ratio(img, self.target_size)
+
+
+class PadToSquare:
+    def __init__(self, color: int = 255):
+        self.color = color
+
+    def __call__(self, img: Image.Image) -> Image.Image:
+        width, height = img.size
+        padding = abs(width - height) // 2
+        if width < height:
+            return TF.pad(
+                img,
+                (padding, 0, padding + (height - width) % 2, 0),
+                fill=self.color,
+                padding_mode="constant",
+            )
+        if width > height:
+            return TF.pad(
+                img,
+                (0, padding, 0, padding + (width - height) % 2),
+                fill=self.color,
+                padding_mode="constant",
+            )
+        return img
+
+
+class TrendyolDinoV21ImageProcessor(ImageProcessingMixin):
+    model_input_names = ["pixel_values"]
+
+    def __init__(
+        self,
+        input_size: int = 224,
+        pad_color: int = 255,
+        do_normalize: bool = True,
+        image_mean=(0.485, 0.456, 0.406),
+        image_std=(0.229, 0.224, 0.225),
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.input_size = input_size
+        self.pad_color = pad_color
+        self.do_normalize = do_normalize
+        self.image_mean = list(image_mean)
+        self.image_std = list(image_std)
+
+    def _get_preprocess_fn(self):
+        steps = [
+            ScaleImage(self.input_size),
+            PadToSquare(self.pad_color),
+            transforms.Resize((self.input_size, self.input_size)),
+            transforms.ToTensor(),
+        ]
+        if self.do_normalize:
+            steps.append(transforms.Normalize(self.image_mean, self.image_std))
+        return transforms.Compose(steps)
+
+    def __call__(
+        self,
+        images: Union[Image.Image, np.ndarray, List],
+        return_tensors: Optional[Union[str, TensorType]] = None,
+        **kwargs,
+    ) -> BatchFeature:
+        if not isinstance(images, list):
+            images = [images]
+        preprocess_fn = self._get_preprocess_fn()
+        processed = []
+        for image in images:
+            if isinstance(image, str):
+                image = Image.open(image).convert("RGB")
+            elif isinstance(image, np.ndarray):
+                image = Image.fromarray(image).convert("RGB")
+            elif not isinstance(image, Image.Image):
+                raise ValueError(f"Unsupported image type: {type(image)}")
+            else:
+                image = image.convert("RGB")
+            processed.append(preprocess_fn(image))
+        data = {"pixel_values": torch.stack(processed)}
+        return BatchFeature(data=data, tensor_type=return_tensors)
+
+
+TrendyolDinoV21ImageProcessor.register_for_auto_class("AutoImageProcessor")

model.safetensors

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

modeling_trendyol_dinov2_v21.py

@@ -0,0 +1,136 @@
+"""
+Hugging Face compatible model for Trendyol DinoV2.1 (GeM pooling).
+
+Checkpoint source:
+  ray-dinov2-full_catalog_1000_20-pfc-gem-mlp-run_12 / epoch=09
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import PretrainedConfig, PreTrainedModel
+from transformers.modeling_outputs import BaseModelOutput
+
+
+class TrendyolDinoV21Config(PretrainedConfig):
+    model_type = "trendyol_dinov2_v21"
+
+    def __init__(
+        self,
+        embedding_dim: int = 256,
+        input_size: int = 224,
+        backbone_name: str = "dinov2_vitb14",
+        in_features: int = 768,
+        gem_p: float = 2.9,
+        dropout: float = 0.3,
+        pad_color: int = 255,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.embedding_dim = embedding_dim
+        self.input_size = input_size
+        self.backbone_name = backbone_name
+        self.in_features = in_features
+        self.gem_p = gem_p
+        self.dropout = dropout
+        self.pad_color = pad_color
+        self.hidden_size = embedding_dim
+
+
+class GeM(nn.Module):
+    def __init__(self, p: float = 2.9, eps: float = 1e-6):
+        super().__init__()
+        self.register_buffer("p", torch.tensor(float(p)))
+        self.eps = eps
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = x.clamp(min=self.eps).pow(self.p)
+        x = F.adaptive_avg_pool2d(x, (1, 1))
+        x = x.pow(1.0 / self.p)
+        return x.squeeze(-1).squeeze(-1)
+
+
+class DinoV2Backbone(nn.Module):
+    """Matches training ``Backbone`` wrapper: ``self.model = hub dinov2``."""
+
+    def __init__(self, backbone_name: str = "dinov2_vitb14"):
+        super().__init__()
+        try:
+            self.model = torch.hub.load("facebookresearch/dinov2", backbone_name)
+        except Exception as exc:  # noqa: BLE001
+            raise RuntimeError(f"Failed to load DinoV2 backbone: {exc}") from exc
+        self.model.requires_grad_(False)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        features = self.model.get_intermediate_layers(
+            x, return_class_token=True, reshape=True
+        )
+        return features[0][0]
+
+
+class TYGeMDinoV2(nn.Module):
+    """Core GeM retrieval trunk used in run_12 (embeddings only)."""
+
+    def __init__(self, config: TrendyolDinoV21Config):
+        super().__init__()
+        self.config = config
+        self.backbone = DinoV2Backbone(config.backbone_name)
+        self.pooling = GeM(p=config.gem_p)
+        self.feature = nn.Sequential(
+            nn.Linear(config.in_features, config.embedding_dim, bias=False),
+            nn.BatchNorm1d(config.embedding_dim),
+            nn.Dropout(config.dropout),
+        )
+
+    def forward(self, pixel_values: torch.Tensor) -> torch.Tensor:
+        feats = self.backbone(pixel_values)
+        feats = self.pooling(feats)
+        feats = self.feature(feats)
+        return F.normalize(feats, p=2, dim=1)
+
+
+class TrendyolDinoV21Model(PreTrainedModel):
+    config_class = TrendyolDinoV21Config
+    base_model_prefix = "model"
+
+    def __init__(self, config: TrendyolDinoV21Config):
+        super().__init__(config)
+        self.model = TYGeMDinoV2(config)
+        self.post_init()
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):
+        # torch.hub DinoV2 backbone is incompatible with meta-device init.
+        kwargs.setdefault("low_cpu_mem_usage", False)
+        return super().from_pretrained(pretrained_model_name_or_path, *model_args, **kwargs)
+
+    def forward(
+        self,
+        pixel_values: Optional[torch.Tensor] = None,
+        return_dict: Optional[bool] = None,
+        **kwargs,
+    ):
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        if pixel_values is None:
+            raise ValueError("pixel_values cannot be None")
+
+        embeddings = self.model(pixel_values)
+        if not return_dict:
+            return (embeddings,)
+        return BaseModelOutput(
+            last_hidden_state=embeddings,
+            hidden_states=None,
+            attentions=None,
+        )
+
+    def get_embeddings(self, pixel_values: torch.Tensor) -> torch.Tensor:
+        with torch.no_grad():
+            return self.forward(pixel_values, return_dict=True).last_hidden_state
+
+
+TrendyolDinoV21Config.register_for_auto_class()
+TrendyolDinoV21Model.register_for_auto_class("AutoModel")

preprocessor_config.json

@@ -0,0 +1,22 @@
+{
+  "image_processor_type": "TrendyolDinoV21ImageProcessor",
+  "processor_class": "TrendyolDinoV21ImageProcessor",
+  "auto_map": {
+    "AutoImageProcessor": "image_processing_trendyol_dinov2_v21.TrendyolDinoV21ImageProcessor"
+  },
+  "input_size": 224,
+  "pad_color": 255,
+  "do_normalize": true,
+  "image_mean": [0.485, 0.456, 0.406],
+  "image_std": [0.229, 0.224, 0.225],
+  "do_resize": true,
+  "size": {"height": 224, "width": 224},
+  "do_convert_rgb": true,
+  "transforms": [
+    "ScaleImage",
+    "PadToSquare",
+    "Resize",
+    "ToTensor",
+    "Normalize"
+  ]
+}

pytorch_model.bin

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

requirements.txt

@@ -0,0 +1,7 @@
+torch>=1.9.0
+torchvision>=0.10.0
+safetensors>=0.3.0
+Pillow>=8.0.0
+numpy>=1.20.0
+opencv-python>=4.5.0
+transformers>=4.20.0