Upload folder using huggingface_hub

LICENSE

@@ -0,0 +1,47 @@
+This repository repackages, in HuggingFace format, the CSD style model from
+"Measuring Style Similarity in Diffusion Models" (Somepalli et al., 2024). It is a
+DERIVATIVE of the original CSD work and is NOT an official release by the CSD authors.
+
+The licensing is mixed — the port code and the model weights carry different licenses:
+
+============================================================================
+1) PORT CODE (modeling_csd.py, configuration, processing) — MIT License
+============================================================================
+    Copyright (c) 2026-present bigshanedogg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+============================================================================
+2) MODEL WEIGHTS (model.safetensors) — CC-BY-4.0
+============================================================================
+    Copyright (c) Somepalli, Gupta, Gupta, Shrivastava, Goldstein, Feizi /
+    University of Maryland.
+    Sourced from https://huggingface.co/tomg-group-umd/CSD-ViT-L (CC-BY-4.0).
+    You must give appropriate credit under the terms of the Creative Commons
+    Attribution 4.0 International License: https://creativecommons.org/licenses/by/4.0/
+
+----------------------------------------------------------------------------
+THIRD-PARTY NOTICES
+
+Original CSD code: MIT License, Copyright (c) 2023 the CSD authors
+    https://github.com/learn2phoenix/CSD
+
+Vendored ViT-L/14 vision tower in modeling_csd.py is adapted (MODIFIED: vision tower
+only, projection removed) from OpenAI CLIP, MIT License, Copyright (c) 2021 OpenAI
+    https://github.com/openai/CLIP

README.md

@@ -0,0 +1,57 @@
+---
+license: cc-by-4.0
+library_name: transformers
+tags:
+- style-similarity
+- feature-extraction
+- image-feature-extraction
+- csd
+pipeline_tag: image-feature-extraction
+---
+
+# CSD (ViT-L/14) — HuggingFace format
+
+Unofficial `transformers`-format port of the **CSD** style model from *"Measuring Style
+Similarity in Diffusion Models"* (Somepalli, Gupta, Gupta, Shrivastava, Goldstein, Feizi;
+2024). Loads via `trust_remote_code` with **no `clip` / `open_clip` runtime dependency** —
+the OpenAI CLIP ViT-L/14 vision tower is vendored into `modeling_csd.py` and the released
+CSD weights are stored as `model.safetensors`.
+
+> **Not an official release.** Original code: https://github.com/learn2phoenix/CSD (MIT).
+> Official checkpoint mirror: https://huggingface.co/tomg-group-umd/CSD-ViT-L (CC-BY-4.0).
+> This repo repackages that checkpoint for `AutoModel.from_pretrained`.
+
+## What it is
+
+A CLIP ViT-L/14 vision backbone (projection removed) whose pre-projection feature (1024-d)
+is mapped by a learned **style** head and a **content** head to 768-d descriptors, each
+L2-normalized. Style similarity between two images is the cosine of their style embeddings.
+
+## Usage
+
+```python
+import torch
+from PIL import Image
+from transformers import AutoModel, AutoImageProcessor
+
+model = AutoModel.from_pretrained("bigshanedogg/CSD", trust_remote_code=True).eval()
+proc = AutoImageProcessor.from_pretrained("bigshanedogg/CSD", trust_remote_code=True)
+
+px = proc(images=Image.open("a.png"), return_tensors="pt")["pixel_values"]
+out = model(pixel_values=px)
+style = out.embeddings            # (1, 768), L2-normalized style descriptor
+content = out.content_embeddings  # (1, 768), L2-normalized content descriptor
+```
+
+The image processor resizes the short side to 224 (BICUBIC), center-crops 224, and applies
+the CLIP mean/std — matching the upstream CSD preprocessing.
+
+## Licensing
+
+- Port (modeling/config/processing): **MIT** — Copyright (c) 2026 bigshanedogg.
+- CSD original code: **MIT** — Copyright (c) 2023 the CSD authors (https://github.com/learn2phoenix/CSD).
+- Released CSD weights (`model.safetensors`, from `tomg-group-umd/CSD-ViT-L`): **CC-BY-4.0** —
+  attribute Somepalli et al. / University of Maryland.
+- Vendored ViT tower: **MIT** — Copyright (c) 2021 OpenAI (https://github.com/openai/CLIP), MODIFIED.
+
+See `LICENSE` for the full notices.

config.json

@@ -0,0 +1,14 @@
+{
+  "architectures": ["CSDModel"],
+  "model_type": "csd",
+  "auto_map": {
+    "AutoConfig": "modeling_csd.CSDConfig",
+    "AutoModel": "modeling_csd.CSDModel"
+  },
+  "image_resolution": 224,
+  "patch_size": 14,
+  "width": 1024,
+  "layers": 24,
+  "heads": 16,
+  "embed_dim": 768
+}

model.safetensors

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

modeling_csd.py

@@ -0,0 +1,138 @@
+# CSD (HuggingFace format) — unofficial port. Copyright (c) 2026 bigshanedogg. MIT License.
+#
+# Self-contained transformers port of the CSD style model from
+#   "Measuring Style Similarity in Diffusion Models" (Somepalli et al., 2024)
+#   https://github.com/learn2phoenix/CSD  (code: MIT)
+# so it loads via AutoModel.from_pretrained(trust_remote_code=True) without the `clip`
+# package. The ViT-L/14 vision transformer below is vendored from OpenAI CLIP
+#   https://github.com/openai/CLIP  (MIT, (c) 2021 OpenAI) — MODIFIED: trimmed to the
+# vision tower, projection removed (folded into the CSD style/content heads).
+# The released CSD checkpoint (tomg-group-umd/CSD-ViT-L) is CC-BY-4.0.
+
+from collections import OrderedDict
+from typing import Optional
+
+import torch
+import torch.nn as nn
+from transformers import PretrainedConfig, PreTrainedModel
+from transformers.modeling_outputs import ModelOutput
+
+
+class CSDConfig(PretrainedConfig):
+    model_type = "csd"
+
+    def __init__(
+        self,
+        image_resolution: int = 224,
+        patch_size: int = 14,
+        width: int = 1024,
+        layers: int = 24,
+        heads: int = 16,
+        embed_dim: int = 768,
+        **kwargs,
+    ):
+        self.image_resolution = image_resolution
+        self.patch_size = patch_size
+        self.width = width
+        self.layers = layers
+        self.heads = heads
+        self.embed_dim = embed_dim  # style/content projection output dim
+        super().__init__(**kwargs)
+
+
+# ── vendored OpenAI CLIP vision tower (MIT, (c) 2021 OpenAI; MODIFIED) ──────────────
+class QuickGELU(nn.Module):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x * torch.sigmoid(1.702 * x)
+
+
+class ResidualAttentionBlock(nn.Module):
+    def __init__(self, d_model: int, n_head: int):
+        super().__init__()
+        self.attn = nn.MultiheadAttention(d_model, n_head)
+        self.ln_1 = nn.LayerNorm(d_model)
+        self.mlp = nn.Sequential(
+            OrderedDict(
+                [
+                    ("c_fc", nn.Linear(d_model, d_model * 4)),
+                    ("gelu", QuickGELU()),
+                    ("c_proj", nn.Linear(d_model * 4, d_model)),
+                ]
+            )
+        )
+        self.ln_2 = nn.LayerNorm(d_model)
+
+    def attention(self, x: torch.Tensor) -> torch.Tensor:
+        return self.attn(x, x, x, need_weights=False, attn_mask=None)[0]
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = x + self.attention(self.ln_1(x))
+        x = x + self.mlp(self.ln_2(x))
+        return x
+
+
+class Transformer(nn.Module):
+    def __init__(self, width: int, layers: int, heads: int):
+        super().__init__()
+        self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads) for _ in range(layers)])
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.resblocks(x)
+
+
+class VisionTransformer(nn.Module):
+    def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int):
+        super().__init__()
+        self.conv1 = nn.Conv2d(3, width, kernel_size=patch_size, stride=patch_size, bias=False)
+        _scale = width**-0.5
+        self.class_embedding = nn.Parameter(_scale * torch.randn(width))
+        _num_positions = (input_resolution // patch_size) ** 2 + 1
+        self.positional_embedding = nn.Parameter(_scale * torch.randn(_num_positions, width))
+        self.ln_pre = nn.LayerNorm(width)
+        self.transformer = Transformer(width, layers, heads)
+        self.ln_post = nn.LayerNorm(width)
+        # NOTE: CSD sets backbone.proj = None and folds projection into last_layer_{style,content}.
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.conv1(x)  # (B, width, grid, grid)
+        x = x.reshape(x.shape[0], x.shape[1], -1).permute(0, 2, 1)  # (B, grid**2, width)
+        _cls = self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device)
+        x = torch.cat([_cls, x], dim=1)  # (B, grid**2 + 1, width)
+        x = x + self.positional_embedding.to(x.dtype)
+        x = self.ln_pre(x)
+        x = x.permute(1, 0, 2)  # NLD -> LND
+        x = self.transformer(x)
+        x = x.permute(1, 0, 2)  # LND -> NLD
+        x = self.ln_post(x[:, 0, :])  # take the [CLS] token
+        return x
+
+
+class CSDOutput(ModelOutput):
+    embeddings: Optional[torch.FloatTensor] = None  # style embedding (L2-normalized)
+    content_embeddings: Optional[torch.FloatTensor] = None
+    last_hidden_states: Optional[torch.FloatTensor] = None  # pre-projection ViT feature
+
+
+class CSDModel(PreTrainedModel):
+    """CSD style/content encoder. ``embeddings`` is the L2-normalized style descriptor
+    (``feature @ last_layer_style``); the perceptual/style scoring lives in the caller."""
+
+    config_class = CSDConfig
+
+    def __init__(self, config: CSDConfig):
+        super().__init__(config)
+        self.backbone = VisionTransformer(
+            input_resolution=config.image_resolution,
+            patch_size=config.patch_size,
+            width=config.width,
+            layers=config.layers,
+            heads=config.heads,
+        )
+        self.last_layer_style = nn.Parameter(torch.empty(config.width, config.embed_dim))
+        self.last_layer_content = nn.Parameter(torch.empty(config.width, config.embed_dim))
+
+    def forward(self, pixel_values: torch.Tensor) -> CSDOutput:
+        _feature = self.backbone(pixel_values)
+        _style = nn.functional.normalize(_feature @ self.last_layer_style, dim=1, p=2)
+        _content = nn.functional.normalize(_feature @ self.last_layer_content, dim=1, p=2)
+        return CSDOutput(embeddings=_style, content_embeddings=_content, last_hidden_states=_feature)

preprocessor_config.json

@@ -0,0 +1,14 @@
+{
+  "image_processor_type": "CLIPImageProcessor",
+  "do_resize": true,
+  "size": {"shortest_edge": 224},
+  "resample": 3,
+  "do_center_crop": true,
+  "crop_size": {"height": 224, "width": 224},
+  "do_rescale": true,
+  "rescale_factor": 0.00392156862745098,
+  "do_normalize": true,
+  "image_mean": [0.48145466, 0.4578275, 0.40821073],
+  "image_std": [0.26862954, 0.26130258, 0.27577711],
+  "do_convert_rgb": true
+}