Add files using upload-large-folder tool

CCEdit-main/src/clip/.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: test
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+jobs:
+  CLIP-test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.8]
+        pytorch-version: [1.7.1, 1.9.1, 1.10.1]
+        include:
+          - python-version: 3.8
+            pytorch-version: 1.7.1
+            torchvision-version: 0.8.2
+          - python-version: 3.8
+            pytorch-version: 1.9.1
+            torchvision-version: 0.10.1
+          - python-version: 3.8
+            pytorch-version: 1.10.1
+            torchvision-version: 0.11.2
+    steps:
+      - uses: conda-incubator/setup-miniconda@v2
+      - run: conda install -n test python=${{ matrix.python-version }} pytorch=${{ matrix.pytorch-version }} torchvision=${{ matrix.torchvision-version }} cpuonly -c pytorch
+      - uses: actions/checkout@v2
+      - run: echo "$CONDA/envs/test/bin" >> $GITHUB_PATH
+      - run: pip install pytest
+      - run: pip install .
+      - run: pytest

CCEdit-main/src/clip/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info
+.pytest_cache
+.ipynb_checkpoints
+
+thumbs.db
+.DS_Store
+.idea

CCEdit-main/src/clip/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 OpenAI
+
+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.
+

CCEdit-main/src/clip/MANIFEST.in

@@ -0,0 +1 @@
+include clip/bpe_simple_vocab_16e6.txt.gz

CCEdit-main/src/clip/README.md

@@ -0,0 +1,199 @@
+# CLIP
+
+[[Blog]](https://openai.com/blog/clip/) [[Paper]](https://arxiv.org/abs/2103.00020) [[Model Card]](model-card.md) [[Colab]](https://colab.research.google.com/github/openai/clip/blob/master/notebooks/Interacting_with_CLIP.ipynb)
+
+CLIP (Contrastive Language-Image Pre-Training) is a neural network trained on a variety of (image, text) pairs. It can be instructed in natural language to predict the most relevant text snippet, given an image, without directly optimizing for the task, similarly to the zero-shot capabilities of GPT-2 and 3. We found CLIP matches the performance of the original ResNet50 on ImageNet “zero-shot” without using any of the original 1.28M labeled examples, overcoming several major challenges in computer vision.
+
+
+
+## Approach
+
+![CLIP](CLIP.png)
+
+
+
+## Usage
+
+First, [install PyTorch 1.7.1](https://pytorch.org/get-started/locally/) (or later) and torchvision, as well as small additional dependencies, and then install this repo as a Python package. On a CUDA GPU machine, the following will do the trick:
+
+```bash
+$ conda install --yes -c pytorch pytorch=1.7.1 torchvision cudatoolkit=11.0
+$ pip install ftfy regex tqdm
+$ pip install git+https://github.com/openai/CLIP.git
+```
+
+Replace `cudatoolkit=11.0` above with the appropriate CUDA version on your machine or `cpuonly` when installing on a machine without a GPU.
+
+```python
+import torch
+import clip
+from PIL import Image
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model, preprocess = clip.load("ViT-B/32", device=device)
+
+image = preprocess(Image.open("CLIP.png")).unsqueeze(0).to(device)
+text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device)
+
+with torch.no_grad():
+    image_features = model.encode_image(image)
+    text_features = model.encode_text(text)
+    
+    logits_per_image, logits_per_text = model(image, text)
+    probs = logits_per_image.softmax(dim=-1).cpu().numpy()
+
+print("Label probs:", probs)  # prints: [[0.9927937  0.00421068 0.00299572]]
+```
+
+
+## API
+
+The CLIP module `clip` provides the following methods:
+
+#### `clip.available_models()`
+
+Returns the names of the available CLIP models.
+
+#### `clip.load(name, device=..., jit=False)`
+
+Returns the model and the TorchVision transform needed by the model, specified by the model name returned by `clip.available_models()`. It will download the model as necessary. The `name` argument can also be a path to a local checkpoint.
+
+The device to run the model can be optionally specified, and the default is to use the first CUDA device if there is any, otherwise the CPU. When `jit` is `False`, a non-JIT version of the model will be loaded.
+
+#### `clip.tokenize(text: Union[str, List[str]], context_length=77)`
+
+Returns a LongTensor containing tokenized sequences of given text input(s). This can be used as the input to the model
+
+---
+
+The model returned by `clip.load()` supports the following methods:
+
+#### `model.encode_image(image: Tensor)`
+
+Given a batch of images, returns the image features encoded by the vision portion of the CLIP model.
+
+#### `model.encode_text(text: Tensor)`
+
+Given a batch of text tokens, returns the text features encoded by the language portion of the CLIP model.
+
+#### `model(image: Tensor, text: Tensor)`
+
+Given a batch of images and a batch of text tokens, returns two Tensors, containing the logit scores corresponding to each image and text input. The values are cosine similarities between the corresponding image and text features, times 100.
+
+
+
+## More Examples
+
+### Zero-Shot Prediction
+
+The code below performs zero-shot prediction using CLIP, as shown in Appendix B in the paper. This example takes an image from the [CIFAR-100 dataset](https://www.cs.toronto.edu/~kriz/cifar.html), and predicts the most likely labels among the 100 textual labels from the dataset.
+
+```python
+import os
+import clip
+import torch
+from torchvision.datasets import CIFAR100
+
+# Load the model
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model, preprocess = clip.load('ViT-B/32', device)
+
+# Download the dataset
+cifar100 = CIFAR100(root=os.path.expanduser("~/.cache"), download=True, train=False)
+
+# Prepare the inputs
+image, class_id = cifar100[3637]
+image_input = preprocess(image).unsqueeze(0).to(device)
+text_inputs = torch.cat([clip.tokenize(f"a photo of a {c}") for c in cifar100.classes]).to(device)
+
+# Calculate features
+with torch.no_grad():
+    image_features = model.encode_image(image_input)
+    text_features = model.encode_text(text_inputs)
+
+# Pick the top 5 most similar labels for the image
+image_features /= image_features.norm(dim=-1, keepdim=True)
+text_features /= text_features.norm(dim=-1, keepdim=True)
+similarity = (100.0 * image_features @ text_features.T).softmax(dim=-1)
+values, indices = similarity[0].topk(5)
+
+# Print the result
+print("\nTop predictions:\n")
+for value, index in zip(values, indices):
+    print(f"{cifar100.classes[index]:>16s}: {100 * value.item():.2f}%")
+```
+
+The output will look like the following (the exact numbers may be slightly different depending on the compute device):
+
+```
+Top predictions:
+
+           snake: 65.31%
+          turtle: 12.29%
+    sweet_pepper: 3.83%
+          lizard: 1.88%
+       crocodile: 1.75%
+```
+
+Note that this example uses the `encode_image()` and `encode_text()` methods that return the encoded features of given inputs.
+
+
+### Linear-probe evaluation
+
+The example below uses [scikit-learn](https://scikit-learn.org/) to perform logistic regression on image features.
+
+```python
+import os
+import clip
+import torch
+
+import numpy as np
+from sklearn.linear_model import LogisticRegression
+from torch.utils.data import DataLoader
+from torchvision.datasets import CIFAR100
+from tqdm import tqdm
+
+# Load the model
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model, preprocess = clip.load('ViT-B/32', device)
+
+# Load the dataset
+root = os.path.expanduser("~/.cache")
+train = CIFAR100(root, download=True, train=True, transform=preprocess)
+test = CIFAR100(root, download=True, train=False, transform=preprocess)
+
+
+def get_features(dataset):
+    all_features = []
+    all_labels = []
+    
+    with torch.no_grad():
+        for images, labels in tqdm(DataLoader(dataset, batch_size=100)):
+            features = model.encode_image(images.to(device))
+
+            all_features.append(features)
+            all_labels.append(labels)
+
+    return torch.cat(all_features).cpu().numpy(), torch.cat(all_labels).cpu().numpy()
+
+# Calculate the image features
+train_features, train_labels = get_features(train)
+test_features, test_labels = get_features(test)
+
+# Perform logistic regression
+classifier = LogisticRegression(random_state=0, C=0.316, max_iter=1000, verbose=1)
+classifier.fit(train_features, train_labels)
+
+# Evaluate using the logistic regression classifier
+predictions = classifier.predict(test_features)
+accuracy = np.mean((test_labels == predictions).astype(float)) * 100.
+print(f"Accuracy = {accuracy:.3f}")
+```
+
+Note that the `C` value should be determined via a hyperparameter sweep using a validation split.
+
+
+## See Also
+
+* [OpenCLIP](https://github.com/mlfoundations/open_clip): includes larger and independently trained CLIP models up to ViT-G/14
+* [Hugging Face implementation of CLIP](https://huggingface.co/docs/transformers/model_doc/clip): for easier integration with the HF ecosystem

CCEdit-main/src/clip/clip.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.2
+Name: clip
+Version: 1.0
+Author: OpenAI
+License-File: LICENSE
+Requires-Dist: ftfy
+Requires-Dist: packaging
+Requires-Dist: regex
+Requires-Dist: tqdm
+Requires-Dist: torch
+Requires-Dist: torchvision
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: author
+Dynamic: provides-extra
+Dynamic: requires-dist

CCEdit-main/src/clip/clip.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+clip/__init__.py
+clip/bpe_simple_vocab_16e6.txt.gz
+clip/clip.py
+clip/model.py
+clip/simple_tokenizer.py
+clip.egg-info/PKG-INFO
+clip.egg-info/SOURCES.txt
+clip.egg-info/dependency_links.txt
+clip.egg-info/requires.txt
+clip.egg-info/top_level.txt
+tests/test_consistency.py

CCEdit-main/src/clip/clip.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

CCEdit-main/src/clip/clip.egg-info/requires.txt

@@ -0,0 +1,9 @@
+ftfy
+packaging
+regex
+tqdm
+torch
+torchvision
+
+[dev]
+pytest

CCEdit-main/src/clip/clip.egg-info/top_level.txt

@@ -0,0 +1 @@
+clip

CCEdit-main/src/clip/clip/model.py

@@ -0,0 +1,436 @@
+from collections import OrderedDict
+from typing import Tuple, Union
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1):
+        super().__init__()
+
+        # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1
+        self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.relu1 = nn.ReLU(inplace=True)
+
+        self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.relu2 = nn.ReLU(inplace=True)
+
+        self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()
+
+        self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
+        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
+        self.relu3 = nn.ReLU(inplace=True)
+
+        self.downsample = None
+        self.stride = stride
+
+        if stride > 1 or inplanes != planes * Bottleneck.expansion:
+            # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1
+            self.downsample = nn.Sequential(OrderedDict([
+                ("-1", nn.AvgPool2d(stride)),
+                ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)),
+                ("1", nn.BatchNorm2d(planes * self.expansion))
+            ]))
+
+    def forward(self, x: torch.Tensor):
+        identity = x
+
+        out = self.relu1(self.bn1(self.conv1(x)))
+        out = self.relu2(self.bn2(self.conv2(out)))
+        out = self.avgpool(out)
+        out = self.bn3(self.conv3(out))
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu3(out)
+        return out
+
+
+class AttentionPool2d(nn.Module):
+    def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None):
+        super().__init__()
+        self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5)
+        self.k_proj = nn.Linear(embed_dim, embed_dim)
+        self.q_proj = nn.Linear(embed_dim, embed_dim)
+        self.v_proj = nn.Linear(embed_dim, embed_dim)
+        self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
+        self.num_heads = num_heads
+
+    def forward(self, x):
+        x = x.flatten(start_dim=2).permute(2, 0, 1)  # NCHW -> (HW)NC
+        x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)NC
+        x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)NC
+        x, _ = F.multi_head_attention_forward(
+            query=x[:1], key=x, value=x,
+            embed_dim_to_check=x.shape[-1],
+            num_heads=self.num_heads,
+            q_proj_weight=self.q_proj.weight,
+            k_proj_weight=self.k_proj.weight,
+            v_proj_weight=self.v_proj.weight,
+            in_proj_weight=None,
+            in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
+            bias_k=None,
+            bias_v=None,
+            add_zero_attn=False,
+            dropout_p=0,
+            out_proj_weight=self.c_proj.weight,
+            out_proj_bias=self.c_proj.bias,
+            use_separate_proj_weight=True,
+            training=self.training,
+            need_weights=False
+        )
+        return x.squeeze(0)
+
+
+class ModifiedResNet(nn.Module):
+    """
+    A ResNet class that is similar to torchvision's but contains the following changes:
+    - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool.
+    - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1
+    - The final pooling layer is a QKV attention instead of an average pool
+    """
+
+    def __init__(self, layers, output_dim, heads, input_resolution=224, width=64):
+        super().__init__()
+        self.output_dim = output_dim
+        self.input_resolution = input_resolution
+
+        # the 3-layer stem
+        self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(width // 2)
+        self.relu1 = nn.ReLU(inplace=True)
+        self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(width // 2)
+        self.relu2 = nn.ReLU(inplace=True)
+        self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(width)
+        self.relu3 = nn.ReLU(inplace=True)
+        self.avgpool = nn.AvgPool2d(2)
+
+        # residual layers
+        self._inplanes = width  # this is a *mutable* variable used during construction
+        self.layer1 = self._make_layer(width, layers[0])
+        self.layer2 = self._make_layer(width * 2, layers[1], stride=2)
+        self.layer3 = self._make_layer(width * 4, layers[2], stride=2)
+        self.layer4 = self._make_layer(width * 8, layers[3], stride=2)
+
+        embed_dim = width * 32  # the ResNet feature dimension
+        self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim, heads, output_dim)
+
+    def _make_layer(self, planes, blocks, stride=1):
+        layers = [Bottleneck(self._inplanes, planes, stride)]
+
+        self._inplanes = planes * Bottleneck.expansion
+        for _ in range(1, blocks):
+            layers.append(Bottleneck(self._inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        def stem(x):
+            x = self.relu1(self.bn1(self.conv1(x)))
+            x = self.relu2(self.bn2(self.conv2(x)))
+            x = self.relu3(self.bn3(self.conv3(x)))
+            x = self.avgpool(x)
+            return x
+
+        x = x.type(self.conv1.weight.dtype)
+        x = stem(x)
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        x = self.attnpool(x)
+
+        return x
+
+
+class LayerNorm(nn.LayerNorm):
+    """Subclass torch's LayerNorm to handle fp16."""
+
+    def forward(self, x: torch.Tensor):
+        orig_type = x.dtype
+        ret = super().forward(x.type(torch.float32))
+        return ret.type(orig_type)
+
+
+class QuickGELU(nn.Module):
+    def forward(self, x: torch.Tensor):
+        return x * torch.sigmoid(1.702 * x)
+
+
+class ResidualAttentionBlock(nn.Module):
+    def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None):
+        super().__init__()
+
+        self.attn = nn.MultiheadAttention(d_model, n_head)
+        self.ln_1 = 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 = LayerNorm(d_model)
+        self.attn_mask = attn_mask
+
+    def attention(self, x: torch.Tensor):
+        self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None
+        return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]
+
+    def forward(self, x: 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, attn_mask: torch.Tensor = None):
+        super().__init__()
+        self.width = width
+        self.layers = layers
+        self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)])
+
+    def forward(self, x: 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, output_dim: int):
+        super().__init__()
+        self.input_resolution = input_resolution
+        self.output_dim = output_dim
+        self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False)
+
+        scale = width ** -0.5
+        self.class_embedding = nn.Parameter(scale * torch.randn(width))
+        self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width))
+        self.ln_pre = LayerNorm(width)
+
+        self.transformer = Transformer(width, layers, heads)
+
+        self.ln_post = LayerNorm(width)
+        self.proj = nn.Parameter(scale * torch.randn(width, output_dim))
+
+    def forward(self, x: torch.Tensor):
+        x = self.conv1(x)  # shape = [*, width, grid, grid]
+        x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]
+        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
+        x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1)  # shape = [*, 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, :])
+
+        if self.proj is not None:
+            x = x @ self.proj
+
+        return x
+
+
+class CLIP(nn.Module):
+    def __init__(self,
+                 embed_dim: int,
+                 # vision
+                 image_resolution: int,
+                 vision_layers: Union[Tuple[int, int, int, int], int],
+                 vision_width: int,
+                 vision_patch_size: int,
+                 # text
+                 context_length: int,
+                 vocab_size: int,
+                 transformer_width: int,
+                 transformer_heads: int,
+                 transformer_layers: int
+                 ):
+        super().__init__()
+
+        self.context_length = context_length
+
+        if isinstance(vision_layers, (tuple, list)):
+            vision_heads = vision_width * 32 // 64
+            self.visual = ModifiedResNet(
+                layers=vision_layers,
+                output_dim=embed_dim,
+                heads=vision_heads,
+                input_resolution=image_resolution,
+                width=vision_width
+            )
+        else:
+            vision_heads = vision_width // 64
+            self.visual = VisionTransformer(
+                input_resolution=image_resolution,
+                patch_size=vision_patch_size,
+                width=vision_width,
+                layers=vision_layers,
+                heads=vision_heads,
+                output_dim=embed_dim
+            )
+
+        self.transformer = Transformer(
+            width=transformer_width,
+            layers=transformer_layers,
+            heads=transformer_heads,
+            attn_mask=self.build_attention_mask()
+        )
+
+        self.vocab_size = vocab_size
+        self.token_embedding = nn.Embedding(vocab_size, transformer_width)
+        self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width))
+        self.ln_final = LayerNorm(transformer_width)
+
+        self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim))
+        self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))
+
+        self.initialize_parameters()
+
+    def initialize_parameters(self):
+        nn.init.normal_(self.token_embedding.weight, std=0.02)
+        nn.init.normal_(self.positional_embedding, std=0.01)
+
+        if isinstance(self.visual, ModifiedResNet):
+            if self.visual.attnpool is not None:
+                std = self.visual.attnpool.c_proj.in_features ** -0.5
+                nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std)
+                nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std)
+                nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std)
+                nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std)
+
+            for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]:
+                for name, param in resnet_block.named_parameters():
+                    if name.endswith("bn3.weight"):
+                        nn.init.zeros_(param)
+
+        proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5)
+        attn_std = self.transformer.width ** -0.5
+        fc_std = (2 * self.transformer.width) ** -0.5
+        for block in self.transformer.resblocks:
+            nn.init.normal_(block.attn.in_proj_weight, std=attn_std)
+            nn.init.normal_(block.attn.out_proj.weight, std=proj_std)
+            nn.init.normal_(block.mlp.c_fc.weight, std=fc_std)
+            nn.init.normal_(block.mlp.c_proj.weight, std=proj_std)
+
+        if self.text_projection is not None:
+            nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5)
+
+    def build_attention_mask(self):
+        # lazily create causal attention mask, with full attention between the vision tokens
+        # pytorch uses additive attention mask; fill with -inf
+        mask = torch.empty(self.context_length, self.context_length)
+        mask.fill_(float("-inf"))
+        mask.triu_(1)  # zero out the lower diagonal
+        return mask
+
+    @property
+    def dtype(self):
+        return self.visual.conv1.weight.dtype
+
+    def encode_image(self, image):
+        return self.visual(image.type(self.dtype))
+
+    def encode_text(self, text):
+        x = self.token_embedding(text).type(self.dtype)  # [batch_size, n_ctx, d_model]
+
+        x = x + self.positional_embedding.type(self.dtype)
+        x = x.permute(1, 0, 2)  # NLD -> LND
+        x = self.transformer(x)
+        x = x.permute(1, 0, 2)  # LND -> NLD
+        x = self.ln_final(x).type(self.dtype)
+
+        # x.shape = [batch_size, n_ctx, transformer.width]
+        # take features from the eot embedding (eot_token is the highest number in each sequence)
+        x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection
+
+        return x
+
+    def forward(self, image, text):
+        image_features = self.encode_image(image)
+        text_features = self.encode_text(text)
+
+        # normalized features
+        image_features = image_features / image_features.norm(dim=1, keepdim=True)
+        text_features = text_features / text_features.norm(dim=1, keepdim=True)
+
+        # cosine similarity as logits
+        logit_scale = self.logit_scale.exp()
+        logits_per_image = logit_scale * image_features @ text_features.t()
+        logits_per_text = logits_per_image.t()
+
+        # shape = [global_batch_size, global_batch_size]
+        return logits_per_image, logits_per_text
+
+
+def convert_weights(model: nn.Module):
+    """Convert applicable model parameters to fp16"""
+
+    def _convert_weights_to_fp16(l):
+        if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):
+            l.weight.data = l.weight.data.half()
+            if l.bias is not None:
+                l.bias.data = l.bias.data.half()
+
+        if isinstance(l, nn.MultiheadAttention):
+            for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]:
+                tensor = getattr(l, attr)
+                if tensor is not None:
+                    tensor.data = tensor.data.half()
+
+        for name in ["text_projection", "proj"]:
+            if hasattr(l, name):
+                attr = getattr(l, name)
+                if attr is not None:
+                    attr.data = attr.data.half()
+
+    model.apply(_convert_weights_to_fp16)
+
+
+def build_model(state_dict: dict):
+    vit = "visual.proj" in state_dict
+
+    if vit:
+        vision_width = state_dict["visual.conv1.weight"].shape[0]
+        vision_layers = len([k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")])
+        vision_patch_size = state_dict["visual.conv1.weight"].shape[-1]
+        grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5)
+        image_resolution = vision_patch_size * grid_size
+    else:
+        counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]]
+        vision_layers = tuple(counts)
+        vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0]
+        output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5)
+        vision_patch_size = None
+        assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0]
+        image_resolution = output_width * 32
+
+    embed_dim = state_dict["text_projection"].shape[1]
+    context_length = state_dict["positional_embedding"].shape[0]
+    vocab_size = state_dict["token_embedding.weight"].shape[0]
+    transformer_width = state_dict["ln_final.weight"].shape[0]
+    transformer_heads = transformer_width // 64
+    transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith("transformer.resblocks")))
+
+    model = CLIP(
+        embed_dim,
+        image_resolution, vision_layers, vision_width, vision_patch_size,
+        context_length, vocab_size, transformer_width, transformer_heads, transformer_layers
+    )
+
+    for key in ["input_resolution", "context_length", "vocab_size"]:
+        if key in state_dict:
+            del state_dict[key]
+
+    convert_weights(model)
+    model.load_state_dict(state_dict)
+    return model.eval()

CCEdit-main/src/clip/data/yfcc100m.md

@@ -0,0 +1,14 @@
+# The YFCC100M Subset
+
+In the paper, we performed a dataset ablation using a subset of the YFCC100M dataset and showed that the performance remained largely similar. 
+
+The subset contains 14,829,396 images, about 15% of the full dataset, which have been filtered to only keep those with natural languag titles and/or descriptions in English.
+
+We provide the list of (line number, photo identifier, photo hash) of each image contained in this subset. These correspond to the first three columns in the dataset's metadata TSV file.
+
+```bash
+wget https://openaipublic.azureedge.net/clip/data/yfcc100m_subset_data.tsv.bz2
+bunzip2 yfcc100m_subset_data.tsv.bz2
+```
+
+Use of the underlying media files is subject to the Creative Commons licenses chosen by their creators/uploaders. For more information about the YFCC100M dataset, visit [the official website](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/).

CCEdit-main/src/clip/hubconf.py

@@ -0,0 +1,42 @@
+from clip.clip import tokenize as _tokenize, load as _load, available_models as _available_models
+import re
+import string
+
+dependencies = ["torch", "torchvision", "ftfy", "regex", "tqdm"]
+
+# For compatibility (cannot include special characters in function name)
+model_functions = { model: re.sub(f'[{string.punctuation}]', '_', model) for model in _available_models()}
+
+def _create_hub_entrypoint(model):
+    def entrypoint(**kwargs):      
+        return _load(model, **kwargs)
+    
+    entrypoint.__doc__ = f"""Loads the {model} CLIP model
+
+        Parameters
+        ----------
+        device : Union[str, torch.device]
+            The device to put the loaded model
+
+        jit : bool
+            Whether to load the optimized JIT model or more hackable non-JIT model (default).
+
+        download_root: str
+            path to download the model files; by default, it uses "~/.cache/clip"
+
+        Returns
+        -------
+        model : torch.nn.Module
+            The {model} CLIP model
+
+        preprocess : Callable[[PIL.Image], torch.Tensor]
+            A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input
+        """
+    return entrypoint
+
+def tokenize():
+    return _tokenize
+
+_entrypoints = {model_functions[model]: _create_hub_entrypoint(model) for model in _available_models()}
+
+globals().update(_entrypoints)

CCEdit-main/src/clip/model-card.md

@@ -0,0 +1,120 @@
+# Model Card: CLIP
+
+Inspired by [Model Cards for Model Reporting (Mitchell et al.)](https://arxiv.org/abs/1810.03993) and [Lessons from Archives (Jo & Gebru)](https://arxiv.org/pdf/1912.10389.pdf), we’re providing some accompanying information about the multimodal model.
+
+## Model Details
+
+The CLIP model was developed by researchers at OpenAI to learn about what contributes to robustness in computer vision tasks. The model was also developed to test the ability of models to generalize to arbitrary image classification tasks in a zero-shot manner. It was not developed for general model deployment - to deploy models like CLIP, researchers will first need to carefully study their capabilities in relation to the specific context they’re being deployed within.
+
+### Model Date
+
+January 2021
+
+### Model Type
+
+The base model uses a ResNet50 with several modifications as an image encoder and uses a masked self-attention Transformer as a text encoder. These encoders are trained to maximize the similarity of (image, text) pairs via a contrastive loss. There is also a variant of the model where the ResNet image encoder is replaced with a Vision Transformer.
+
+### Model Versions
+
+Initially, we’ve released one CLIP model based on the Vision Transformer architecture equivalent to ViT-B/32, along with the RN50 model, using the architecture equivalent to ResNet-50.
+
+As part of the staged release process, we have also released the RN101 model, as well as RN50x4, a RN50 scaled up 4x according to the [EfficientNet](https://arxiv.org/abs/1905.11946) scaling rule. In July 2021, we additionally released the RN50x16 and ViT-B/16 models, and in January 2022, the RN50x64 and ViT-L/14 models were released. Lastly, the ViT-L/14@336px model was released in April 2022.
+
+Please see the paper linked below for further details about their specification.
+
+### Documents
+
+- [Blog Post](https://openai.com/blog/clip/)
+- [CLIP Paper](https://arxiv.org/abs/2103.00020)
+
+
+
+## Model Use
+
+### Intended Use
+
+The model is intended as a research output for research communities. We hope that this model will enable researchers to better understand and explore zero-shot, arbitrary image classification. We also hope it can be used for interdisciplinary studies of the potential impact of such models - the CLIP paper includes a discussion of potential downstream impacts to provide an example for this sort of analysis.
+
+#### Primary intended uses
+
+The primary intended users of these models are AI researchers.
+
+We primarily imagine the model will be used by researchers to better understand robustness, generalization, and other capabilities, biases, and constraints of computer vision models.
+
+### Out-of-Scope Use Cases
+
+**Any** deployed use case of the model - whether commercial or not - is currently out of scope. Non-deployed use cases such as image search in a constrained environment, are also not recommended unless there is thorough in-domain testing of the model with a specific, fixed class taxonomy. This is because our safety assessment demonstrated a high need for task specific testing especially given the variability of CLIP’s performance with different class taxonomies. This makes untested and unconstrained deployment of the model in any use case currently potentially harmful. 
+
+Certain use cases which would fall under the domain of surveillance and facial recognition are always out-of-scope regardless of performance of the model. This is because the use of artificial intelligence for tasks such as these can be premature currently given the lack of testing norms and checks to ensure its fair use.
+
+Since the model has not been purposefully trained in or evaluated on any languages other than English, its use should be limited to English language use cases.
+
+
+
+## Data
+
+The model was trained on publicly available image-caption data. This was done through a combination of crawling a handful of websites and using commonly-used pre-existing image datasets such as [YFCC100M](http://projects.dfki.uni-kl.de/yfcc100m/). A large portion of the data comes from our crawling of the internet. This means that the data is more representative of people and societies most connected to the internet which tend to skew towards more developed nations, and younger, male users.
+
+### Data Mission Statement
+
+Our goal with building this dataset was to test out robustness and generalizability in computer vision tasks. As a result, the focus was on gathering large quantities of data from different publicly-available internet data sources. The data was gathered in a mostly non-interventionist manner. However, we only crawled websites that had policies against excessively violent and adult images and allowed us to filter out such content. We do not intend for this dataset to be used as the basis for any commercial or deployed model and will not be releasing the dataset.
+
+
+
+## Performance and Limitations
+
+### Performance
+
+We have evaluated the performance of CLIP on a wide range of benchmarks across a variety of computer vision datasets such as OCR to texture recognition to fine-grained classification. The paper describes model performance on the following datasets:
+
+- Food101
+- CIFAR10   
+- CIFAR100   
+- Birdsnap
+- SUN397
+- Stanford Cars
+- FGVC Aircraft
+- VOC2007
+- DTD
+- Oxford-IIIT Pet dataset
+- Caltech101
+- Flowers102
+- MNIST   
+- SVHN 
+- IIIT5K   
+- Hateful Memes   
+- SST-2
+- UCF101
+- Kinetics700
+- Country211
+- CLEVR Counting
+- KITTI Distance
+- STL-10
+- RareAct
+- Flickr30
+- MSCOCO
+- ImageNet
+- ImageNet-A
+- ImageNet-R
+- ImageNet Sketch
+- ObjectNet (ImageNet Overlap)
+- Youtube-BB
+- ImageNet-Vid
+
+## Limitations
+
+CLIP and our analysis of it have a number of limitations. CLIP currently struggles with respect to certain tasks such as fine grained classification and counting objects. CLIP also poses issues with regards to fairness and bias which we discuss in the paper and briefly in the next section. Additionally, our approach to testing CLIP also has an important limitation- in many cases we have used linear probes to evaluate the performance of CLIP and there is evidence suggesting that linear probes can underestimate model performance.
+
+### Bias and Fairness
+
+We find that the performance of CLIP - and the specific biases it exhibits - can depend significantly on class design and the choices one makes for categories to include and exclude. We tested the risk of certain kinds of denigration with CLIP by classifying images of people from [Fairface](https://arxiv.org/abs/1908.04913) into crime-related and non-human animal categories. We found significant disparities with respect to race and gender. Additionally, we found that these disparities could shift based on how the classes were constructed. (Details captured in the Broader Impacts Section in the paper).
+
+We also tested the performance of CLIP on gender, race and age classification using the Fairface dataset (We default to using race categories as they are constructed in the Fairface dataset.) in order to assess quality of performance across different demographics. We found accuracy >96% across all races for gender classification with ‘Middle Eastern’ having the highest accuracy (98.4%) and ‘White’ having the lowest (96.5%). Additionally, CLIP averaged ~93% for racial classification and ~63% for age classification. Our use of evaluations to test for gender, race and age classification as well as denigration harms is simply to evaluate performance of the model across people and surface potential risks and not to demonstrate an endorsement/enthusiasm for such tasks.
+
+
+
+## Feedback
+
+### Where to send questions or comments about the model
+
+Please use [this Google Form](https://forms.gle/Uv7afRH5dvY34ZEs9)

CCEdit-main/src/clip/notebooks/Prompt_Engineering_for_ImageNet.ipynb

@@ -0,0 +1,1107 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "Prompt Engineering for ImageNet.ipynb",
+      "provenance": [],
+      "collapsed_sections": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "accelerator": "GPU",
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "66a1639713ae441d8a9b873381f9d774": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "state": {
+            "_view_name": "HBoxView",
+            "_dom_classes": [],
+            "_model_name": "HBoxModel",
+            "_view_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_view_count": null,
+            "_view_module_version": "1.5.0",
+            "box_style": "",
+            "layout": "IPY_MODEL_610b775178c645e2b4663b77cc0c67b6",
+            "_model_module": "@jupyter-widgets/controls",
+            "children": [
+              "IPY_MODEL_412dd15f0d8542f5ab2730f8616fb582",
+              "IPY_MODEL_5e6315f36b4e4eeea5c6294b024e0c97"
+            ]
+          }
+        },
+        "610b775178c645e2b4663b77cc0c67b6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "state": {
+            "_view_name": "LayoutView",
+            "grid_template_rows": null,
+            "right": null,
+            "justify_content": null,
+            "_view_module": "@jupyter-widgets/base",
+            "overflow": null,
+            "_model_module_version": "1.2.0",
+            "_view_count": null,
+            "flex_flow": null,
+            "width": null,
+            "min_width": null,
+            "border": null,
+            "align_items": null,
+            "bottom": null,
+            "_model_module": "@jupyter-widgets/base",
+            "top": null,
+            "grid_column": null,
+            "overflow_y": null,
+            "overflow_x": null,
+            "grid_auto_flow": null,
+            "grid_area": null,
+            "grid_template_columns": null,
+            "flex": null,
+            "_model_name": "LayoutModel",
+            "justify_items": null,
+            "grid_row": null,
+            "max_height": null,
+            "align_content": null,
+            "visibility": null,
+            "align_self": null,
+            "height": null,
+            "min_height": null,
+            "padding": null,
+            "grid_auto_rows": null,
+            "grid_gap": null,
+            "max_width": null,
+            "order": null,
+            "_view_module_version": "1.2.0",
+            "grid_template_areas": null,
+            "object_position": null,
+            "object_fit": null,
+            "grid_auto_columns": null,
+            "margin": null,
+            "display": null,
+            "left": null
+          }
+        },
+        "412dd15f0d8542f5ab2730f8616fb582": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_view_name": "ProgressView",
+            "style": "IPY_MODEL_085d5388abda4202bfa66d0c088452f8",
+            "_dom_classes": [],
+            "description": "100%",
+            "_model_name": "FloatProgressModel",
+            "bar_style": "success",
+            "max": 1000,
+            "_view_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "value": 1000,
+            "_view_count": null,
+            "_view_module_version": "1.5.0",
+            "orientation": "horizontal",
+            "min": 0,
+            "description_tooltip": null,
+            "_model_module": "@jupyter-widgets/controls",
+            "layout": "IPY_MODEL_f75124b64aa147c693c67a78f8e3a231"
+          }
+        },
+        "5e6315f36b4e4eeea5c6294b024e0c97": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "state": {
+            "_view_name": "HTMLView",
+            "style": "IPY_MODEL_6e5676a054874243b55fc6d120a07d01",
+            "_dom_classes": [],
+            "description": "",
+            "_model_name": "HTMLModel",
+            "placeholder": "​",
+            "_view_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "value": " 1000/1000 [16:51<00:00,  1.01s/it]",
+            "_view_count": null,
+            "_view_module_version": "1.5.0",
+            "description_tooltip": null,
+            "_model_module": "@jupyter-widgets/controls",
+            "layout": "IPY_MODEL_dc6d1416c01a4047935ee15c3fd2eb1c"
+          }
+        },
+        "085d5388abda4202bfa66d0c088452f8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_view_name": "StyleView",
+            "_model_name": "ProgressStyleModel",
+            "description_width": "initial",
+            "_view_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.5.0",
+            "_view_count": null,
+            "_view_module_version": "1.2.0",
+            "bar_color": null,
+            "_model_module": "@jupyter-widgets/controls"
+          }
+        },
+        "f75124b64aa147c693c67a78f8e3a231": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "state": {
+            "_view_name": "LayoutView",
+            "grid_template_rows": null,
+            "right": null,
+            "justify_content": null,
+            "_view_module": "@jupyter-widgets/base",
+            "overflow": null,
+            "_model_module_version": "1.2.0",
+            "_view_count": null,
+            "flex_flow": null,
+            "width": null,
+            "min_width": null,
+            "border": null,
+            "align_items": null,
+            "bottom": null,
+            "_model_module": "@jupyter-widgets/base",
+            "top": null,
+            "grid_column": null,
+            "overflow_y": null,
+            "overflow_x": null,
+            "grid_auto_flow": null,
+            "grid_area": null,
+            "grid_template_columns": null,
+            "flex": null,
+            "_model_name": "LayoutModel",
+            "justify_items": null,
+            "grid_row": null,
+            "max_height": null,
+            "align_content": null,
+            "visibility": null,
+            "align_self": null,
+            "height": null,
+            "min_height": null,
+            "padding": null,
+            "grid_auto_rows": null,
+            "grid_gap": null,
+            "max_width": null,
+            "order": null,
+            "_view_module_version": "1.2.0",
+            "grid_template_areas": null,
+            "object_position": null,
+            "object_fit": null,
+            "grid_auto_columns": null,
+            "margin": null,
+            "display": null,
+            "left": null
+          }
+        },
+        "6e5676a054874243b55fc6d120a07d01": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_view_name": "StyleView",
+            "_model_name": "DescriptionStyleModel",
+            "description_width": "",
+            "_view_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.5.0",
+            "_view_count": null,
+            "_view_module_version": "1.2.0",
+            "_model_module": "@jupyter-widgets/controls"
+          }
+        },
+        "dc6d1416c01a4047935ee15c3fd2eb1c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "state": {
+            "_view_name": "LayoutView",
+            "grid_template_rows": null,
+            "right": null,
+            "justify_content": null,
+            "_view_module": "@jupyter-widgets/base",
+            "overflow": null,
+            "_model_module_version": "1.2.0",
+            "_view_count": null,
+            "flex_flow": null,
+            "width": null,
+            "min_width": null,
+            "border": null,
+            "align_items": null,
+            "bottom": null,
+            "_model_module": "@jupyter-widgets/base",
+            "top": null,
+            "grid_column": null,
+            "overflow_y": null,
+            "overflow_x": null,
+            "grid_auto_flow": null,
+            "grid_area": null,
+            "grid_template_columns": null,
+            "flex": null,
+            "_model_name": "LayoutModel",
+            "justify_items": null,
+            "grid_row": null,
+            "max_height": null,
+            "align_content": null,
+            "visibility": null,
+            "align_self": null,
+            "height": null,
+            "min_height": null,
+            "padding": null,
+            "grid_auto_rows": null,
+            "grid_gap": null,
+            "max_width": null,
+            "order": null,
+            "_view_module_version": "1.2.0",
+            "grid_template_areas": null,
+            "object_position": null,
+            "object_fit": null,
+            "grid_auto_columns": null,
+            "margin": null,
+            "display": null,
+            "left": null
+          }
+        },
+        "84f80a7f3e764346969a347b0f71b24e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "state": {
+            "_view_name": "HBoxView",
+            "_dom_classes": [],
+            "_model_name": "HBoxModel",
+            "_view_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_view_count": null,
+            "_view_module_version": "1.5.0",
+            "box_style": "",
+            "layout": "IPY_MODEL_392656f01b2945f3bd7903783ed8cc96",
+            "_model_module": "@jupyter-widgets/controls",
+            "children": [
+              "IPY_MODEL_8e47a435519b4ce090879b4be2f61f99",
+              "IPY_MODEL_41b1ed6b0a9745c1a595377670b15ff4"
+            ]
+          }
+        },
+        "392656f01b2945f3bd7903783ed8cc96": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "state": {
+            "_view_name": "LayoutView",
+            "grid_template_rows": null,
+            "right": null,
+            "justify_content": null,
+            "_view_module": "@jupyter-widgets/base",
+            "overflow": null,
+            "_model_module_version": "1.2.0",
+            "_view_count": null,
+            "flex_flow": null,
+            "width": null,
+            "min_width": null,
+            "border": null,
+            "align_items": null,
+            "bottom": null,
+            "_model_module": "@jupyter-widgets/base",
+            "top": null,
+            "grid_column": null,
+            "overflow_y": null,
+            "overflow_x": null,
+            "grid_auto_flow": null,
+            "grid_area": null,
+            "grid_template_columns": null,
+            "flex": null,
+            "_model_name": "LayoutModel",
+            "justify_items": null,
+            "grid_row": null,
+            "max_height": null,
+            "align_content": null,
+            "visibility": null,
+            "align_self": null,
+            "height": null,
+            "min_height": null,
+            "padding": null,
+            "grid_auto_rows": null,
+            "grid_gap": null,
+            "max_width": null,
+            "order": null,
+            "_view_module_version": "1.2.0",
+            "grid_template_areas": null,
+            "object_position": null,
+            "object_fit": null,
+            "grid_auto_columns": null,
+            "margin": null,
+            "display": null,
+            "left": null
+          }
+        },
+        "8e47a435519b4ce090879b4be2f61f99": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_view_name": "ProgressView",
+            "style": "IPY_MODEL_179b8ae1eb7f4a828f953e889b141725",
+            "_dom_classes": [],
+            "description": "100%",
+            "_model_name": "FloatProgressModel",
+            "bar_style": "success",
+            "max": 313,
+            "_view_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "value": 313,
+            "_view_count": null,
+            "_view_module_version": "1.5.0",
+            "orientation": "horizontal",
+            "min": 0,
+            "description_tooltip": null,
+            "_model_module": "@jupyter-widgets/controls",
+            "layout": "IPY_MODEL_d8708e8414fd44f4abd6590c9b57996f"
+          }
+        },
+        "41b1ed6b0a9745c1a595377670b15ff4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "state": {
+            "_view_name": "HTMLView",
+            "style": "IPY_MODEL_800e30f5b4f24475a2b0046da0703631",
+            "_dom_classes": [],
+            "description": "",
+            "_model_name": "HTMLModel",
+            "placeholder": "​",
+            "_view_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "value": " 313/313 [02:31<00:00,  2.07it/s]",
+            "_view_count": null,
+            "_view_module_version": "1.5.0",
+            "description_tooltip": null,
+            "_model_module": "@jupyter-widgets/controls",
+            "layout": "IPY_MODEL_8764308b948745f1a677332fd21fcaf0"
+          }
+        },
+        "179b8ae1eb7f4a828f953e889b141725": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_view_name": "StyleView",
+            "_model_name": "ProgressStyleModel",
+            "description_width": "initial",
+            "_view_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.5.0",
+            "_view_count": null,
+            "_view_module_version": "1.2.0",
+            "bar_color": null,
+            "_model_module": "@jupyter-widgets/controls"
+          }
+        },
+        "d8708e8414fd44f4abd6590c9b57996f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "state": {
+            "_view_name": "LayoutView",
+            "grid_template_rows": null,
+            "right": null,
+            "justify_content": null,
+            "_view_module": "@jupyter-widgets/base",
+            "overflow": null,
+            "_model_module_version": "1.2.0",
+            "_view_count": null,
+            "flex_flow": null,
+            "width": null,
+            "min_width": null,
+            "border": null,
+            "align_items": null,
+            "bottom": null,
+            "_model_module": "@jupyter-widgets/base",
+            "top": null,
+            "grid_column": null,
+            "overflow_y": null,
+            "overflow_x": null,
+            "grid_auto_flow": null,
+            "grid_area": null,
+            "grid_template_columns": null,
+            "flex": null,
+            "_model_name": "LayoutModel",
+            "justify_items": null,
+            "grid_row": null,
+            "max_height": null,
+            "align_content": null,
+            "visibility": null,
+            "align_self": null,
+            "height": null,
+            "min_height": null,
+            "padding": null,
+            "grid_auto_rows": null,
+            "grid_gap": null,
+            "max_width": null,
+            "order": null,
+            "_view_module_version": "1.2.0",
+            "grid_template_areas": null,
+            "object_position": null,
+            "object_fit": null,
+            "grid_auto_columns": null,
+            "margin": null,
+            "display": null,
+            "left": null
+          }
+        },
+        "800e30f5b4f24475a2b0046da0703631": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_view_name": "StyleView",
+            "_model_name": "DescriptionStyleModel",
+            "description_width": "",
+            "_view_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.5.0",
+            "_view_count": null,
+            "_view_module_version": "1.2.0",
+            "_model_module": "@jupyter-widgets/controls"
+          }
+        },
+        "8764308b948745f1a677332fd21fcaf0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "state": {
+            "_view_name": "LayoutView",
+            "grid_template_rows": null,
+            "right": null,
+            "justify_content": null,
+            "_view_module": "@jupyter-widgets/base",
+            "overflow": null,
+            "_model_module_version": "1.2.0",
+            "_view_count": null,
+            "flex_flow": null,
+            "width": null,
+            "min_width": null,
+            "border": null,
+            "align_items": null,
+            "bottom": null,
+            "_model_module": "@jupyter-widgets/base",
+            "top": null,
+            "grid_column": null,
+            "overflow_y": null,
+            "overflow_x": null,
+            "grid_auto_flow": null,
+            "grid_area": null,
+            "grid_template_columns": null,
+            "flex": null,
+            "_model_name": "LayoutModel",
+            "justify_items": null,
+            "grid_row": null,
+            "max_height": null,
+            "align_content": null,
+            "visibility": null,
+            "align_self": null,
+            "height": null,
+            "min_height": null,
+            "padding": null,
+            "grid_auto_rows": null,
+            "grid_gap": null,
+            "max_width": null,
+            "order": null,
+            "_view_module_version": "1.2.0",
+            "grid_template_areas": null,
+            "object_position": null,
+            "object_fit": null,
+            "grid_auto_columns": null,
+            "margin": null,
+            "display": null,
+            "left": null
+          }
+        }
+      }
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "53N4k0pj_9qL"
+      },
+      "source": [
+        "# Preparation for Colab\n",
+        "\n",
+        "Make sure you're running a GPU runtime; if not, select \"GPU\" as the hardware accelerator in Runtime > Change Runtime Type in the menu. The next cells will install the `clip` package and its dependencies, and check if PyTorch 1.7.1 or later is installed."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0BpdJkdBssk9",
+        "outputId": "41a4070f-5321-4fc4-bd4d-0b5c1f476d56"
+      },
+      "source": [
+        "! pip install ftfy regex tqdm\n",
+        "! pip install git+https://github.com/openai/CLIP.git"
+      ],
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Collecting ftfy\n",
+            "  Downloading ftfy-6.0.3.tar.gz (64 kB)\n",
+            "\u001b[?25l\r\u001b[K     |█████                           | 10 kB 14.9 MB/s eta 0:00:01\r\u001b[K     |██████████▏                     | 20 kB 18.7 MB/s eta 0:00:01\r\u001b[K     |███████████████▎                | 30 kB 9.0 MB/s eta 0:00:01\r\u001b[K     |████████████████████▍           | 40 kB 4.1 MB/s eta 0:00:01\r\u001b[K     |█████████████████████████▌      | 51 kB 4.6 MB/s eta 0:00:01\r\u001b[K     |██████████████████████████████▋ | 61 kB 4.7 MB/s eta 0:00:01\r\u001b[K     |████████████████████████████████| 64 kB 1.3 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (2019.12.20)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (4.41.1)\n",
+            "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy) (0.2.5)\n",
+            "Building wheels for collected packages: ftfy\n",
+            "  Building wheel for ftfy (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for ftfy: filename=ftfy-6.0.3-py3-none-any.whl size=41934 sha256=90ec193331444b2c4ff1cd81935e7de42065b89d304db7efac67bcfd87c27873\n",
+            "  Stored in directory: /root/.cache/pip/wheels/19/f5/38/273eb3b5e76dfd850619312f693716ac4518b498f5ffb6f56d\n",
+            "Successfully built ftfy\n",
+            "Installing collected packages: ftfy\n",
+            "Successfully installed ftfy-6.0.3\n",
+            "Collecting git+https://github.com/openai/CLIP.git\n",
+            "  Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-hqnbveqi\n",
+            "  Running command git clone -q https://github.com/openai/CLIP.git /tmp/pip-req-build-hqnbveqi\n",
+            "Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (6.0.3)\n",
+            "Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (2019.12.20)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (4.41.1)\n",
+            "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (1.9.0+cu102)\n",
+            "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (0.10.0+cu102)\n",
+            "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->clip==1.0) (0.2.5)\n",
+            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch->clip==1.0) (3.7.4.3)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (1.19.5)\n",
+            "Requirement already satisfied: pillow>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (7.1.2)\n",
+            "Building wheels for collected packages: clip\n",
+            "  Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369080 sha256=fda43d2b80cfb2b33c2d43e23ea5f53293a9a8b48d5f9e341de527f6adfbf5a3\n",
+            "  Stored in directory: /tmp/pip-ephem-wheel-cache-kmmplf44/wheels/fd/b9/c3/5b4470e35ed76e174bff77c92f91da82098d5e35fd5bc8cdac\n",
+            "Successfully built clip\n",
+            "Installing collected packages: clip\n",
+            "Successfully installed clip-1.0\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "C1hkDT38hSaP",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "e10d4f17-8fa6-4b75-a18f-f0c38990b5a3"
+      },
+      "source": [
+        "import numpy as np\n",
+        "import torch\n",
+        "import clip\n",
+        "from tqdm.notebook import tqdm\n",
+        "from pkg_resources import packaging\n",
+        "\n",
+        "print(\"Torch version:\", torch.__version__)\n"
+      ],
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Torch version: 1.9.0+cu102\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "eFxgLV5HAEEw"
+      },
+      "source": [
+        "# Loading the model\n",
+        "\n",
+        "Download and instantiate a CLIP model using the `clip` module that we just installed."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "uLFS29hnhlY4",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "09abb234-693e-4efb-953f-e1847ba95758"
+      },
+      "source": [
+        "clip.available_models()"
+      ],
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "['RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16']"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 3
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "cboKZocQlSYX",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "240acdd0-ca62-45db-8418-9e4ef73e8aff"
+      },
+      "source": [
+        "model, preprocess = clip.load(\"ViT-B/32\")"
+      ],
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "100%|███████████████████████████████████████| 338M/338M [00:05<00:00, 63.6MiB/s]\n"
+          ],
+          "name": "stderr"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IBRVTY9lbGm8",
+        "outputId": "785019a1-1f40-45b0-e349-b0d4ec3173bf"
+      },
+      "source": [
+        "input_resolution = model.visual.input_resolution\n",
+        "context_length = model.context_length\n",
+        "vocab_size = model.vocab_size\n",
+        "\n",
+        "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n",
+        "print(\"Input resolution:\", input_resolution)\n",
+        "print(\"Context length:\", context_length)\n",
+        "print(\"Vocab size:\", vocab_size)"
+      ],
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Model parameters: 151,277,313\n",
+            "Input resolution: 224\n",
+            "Context length: 77\n",
+            "Vocab size: 49408\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "LhO3OtOmF8M4"
+      },
+      "source": [
+        "# Preparing ImageNet labels and prompts\n",
+        "\n",
+        "The following cell contains the 1,000 labels for the ImageNet dataset, followed by the text templates we'll use as \"prompt engineering\"."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "R2HbOZrqa0jF"
+      },
+      "source": [
+        "imagenet_classes = [\"tench\", \"goldfish\", \"great white shark\", \"tiger shark\", \"hammerhead shark\", \"electric ray\", \"stingray\", \"rooster\", \"hen\", \"ostrich\", \"brambling\", \"goldfinch\", \"house finch\", \"junco\", \"indigo bunting\", \"American robin\", \"bulbul\", \"jay\", \"magpie\", \"chickadee\", \"American dipper\", \"kite (bird of prey)\", \"bald eagle\", \"vulture\", \"great grey owl\", \"fire salamander\", \"smooth newt\", \"newt\", \"spotted salamander\", \"axolotl\", \"American bullfrog\", \"tree frog\", \"tailed frog\", \"loggerhead sea turtle\", \"leatherback sea turtle\", \"mud turtle\", \"terrapin\", \"box turtle\", \"banded gecko\", \"green iguana\", \"Carolina anole\", \"desert grassland whiptail lizard\", \"agama\", \"frilled-necked lizard\", \"alligator lizard\", \"Gila monster\", \"European green lizard\", \"chameleon\", \"Komodo dragon\", \"Nile crocodile\", \"American alligator\", \"triceratops\", \"worm snake\", \"ring-necked snake\", \"eastern hog-nosed snake\", \"smooth green snake\", \"kingsnake\", \"garter snake\", \"water snake\", \"vine snake\", \"night snake\", \"boa constrictor\", \"African rock python\", \"Indian cobra\", \"green mamba\", \"sea snake\", \"Saharan horned viper\", \"eastern diamondback rattlesnake\", \"sidewinder rattlesnake\", \"trilobite\", \"harvestman\", \"scorpion\", \"yellow garden spider\", \"barn spider\", \"European garden spider\", \"southern black widow\", \"tarantula\", \"wolf spider\", \"tick\", \"centipede\", \"black grouse\", \"ptarmigan\", \"ruffed grouse\", \"prairie grouse\", \"peafowl\", \"quail\", \"partridge\", \"african grey parrot\", \"macaw\", \"sulphur-crested cockatoo\", \"lorikeet\", \"coucal\", \"bee eater\", \"hornbill\", \"hummingbird\", \"jacamar\", \"toucan\", \"duck\", \"red-breasted merganser\", \"goose\", \"black swan\", \"tusker\", \"echidna\", \"platypus\", \"wallaby\", \"koala\", \"wombat\", \"jellyfish\", \"sea anemone\", \"brain coral\", \"flatworm\", \"nematode\", \"conch\", \"snail\", \"slug\", \"sea slug\", \"chiton\", \"chambered nautilus\", \"Dungeness crab\", \"rock crab\", \"fiddler crab\", \"red king crab\", \"American lobster\", \"spiny lobster\", \"crayfish\", \"hermit crab\", \"isopod\", \"white stork\", \"black stork\", \"spoonbill\", \"flamingo\", \"little blue heron\", \"great egret\", \"bittern bird\", \"crane bird\", \"limpkin\", \"common gallinule\", \"American coot\", \"bustard\", \"ruddy turnstone\", \"dunlin\", \"common redshank\", \"dowitcher\", \"oystercatcher\", \"pelican\", \"king penguin\", \"albatross\", \"grey whale\", \"killer whale\", \"dugong\", \"sea lion\", \"Chihuahua\", \"Japanese Chin\", \"Maltese\", \"Pekingese\", \"Shih Tzu\", \"King Charles Spaniel\", \"Papillon\", \"toy terrier\", \"Rhodesian Ridgeback\", \"Afghan Hound\", \"Basset Hound\", \"Beagle\", \"Bloodhound\", \"Bluetick Coonhound\", \"Black and Tan Coonhound\", \"Treeing Walker Coonhound\", \"English foxhound\", \"Redbone Coonhound\", \"borzoi\", \"Irish Wolfhound\", \"Italian Greyhound\", \"Whippet\", \"Ibizan Hound\", \"Norwegian Elkhound\", \"Otterhound\", \"Saluki\", \"Scottish Deerhound\", \"Weimaraner\", \"Staffordshire Bull Terrier\", \"American Staffordshire Terrier\", \"Bedlington Terrier\", \"Border Terrier\", \"Kerry Blue Terrier\", \"Irish Terrier\", \"Norfolk Terrier\", \"Norwich Terrier\", \"Yorkshire Terrier\", \"Wire Fox Terrier\", \"Lakeland Terrier\", \"Sealyham Terrier\", \"Airedale Terrier\", \"Cairn Terrier\", \"Australian Terrier\", \"Dandie Dinmont Terrier\", \"Boston Terrier\", \"Miniature Schnauzer\", \"Giant Schnauzer\", \"Standard Schnauzer\", \"Scottish Terrier\", \"Tibetan Terrier\", \"Australian Silky Terrier\", \"Soft-coated Wheaten Terrier\", \"West Highland White Terrier\", \"Lhasa Apso\", \"Flat-Coated Retriever\", \"Curly-coated Retriever\", \"Golden Retriever\", \"Labrador Retriever\", \"Chesapeake Bay Retriever\", \"German Shorthaired Pointer\", \"Vizsla\", \"English Setter\", \"Irish Setter\", \"Gordon Setter\", \"Brittany dog\", \"Clumber Spaniel\", \"English Springer Spaniel\", \"Welsh Springer Spaniel\", \"Cocker Spaniel\", \"Sussex Spaniel\", \"Irish Water Spaniel\", \"Kuvasz\", \"Schipperke\", \"Groenendael dog\", \"Malinois\", \"Briard\", \"Australian Kelpie\", \"Komondor\", \"Old English Sheepdog\", \"Shetland Sheepdog\", \"collie\", \"Border Collie\", \"Bouvier des Flandres dog\", \"Rottweiler\", \"German Shepherd Dog\", \"Dobermann\", \"Miniature Pinscher\", \"Greater Swiss Mountain Dog\", \"Bernese Mountain Dog\", \"Appenzeller Sennenhund\", \"Entlebucher Sennenhund\", \"Boxer\", \"Bullmastiff\", \"Tibetan Mastiff\", \"French Bulldog\", \"Great Dane\", \"St. Bernard\", \"husky\", \"Alaskan Malamute\", \"Siberian Husky\", \"Dalmatian\", \"Affenpinscher\", \"Basenji\", \"pug\", \"Leonberger\", \"Newfoundland dog\", \"Great Pyrenees dog\", \"Samoyed\", \"Pomeranian\", \"Chow Chow\", \"Keeshond\", \"brussels griffon\", \"Pembroke Welsh Corgi\", \"Cardigan Welsh Corgi\", \"Toy Poodle\", \"Miniature Poodle\", \"Standard Poodle\", \"Mexican hairless dog (xoloitzcuintli)\", \"grey wolf\", \"Alaskan tundra wolf\", \"red wolf or maned wolf\", \"coyote\", \"dingo\", \"dhole\", \"African wild dog\", \"hyena\", \"red fox\", \"kit fox\", \"Arctic fox\", \"grey fox\", \"tabby cat\", \"tiger cat\", \"Persian cat\", \"Siamese cat\", \"Egyptian Mau\", \"cougar\", \"lynx\", \"leopard\", \"snow leopard\", \"jaguar\", \"lion\", \"tiger\", \"cheetah\", \"brown bear\", \"American black bear\", \"polar bear\", \"sloth bear\", \"mongoose\", \"meerkat\", \"tiger beetle\", \"ladybug\", \"ground beetle\", \"longhorn beetle\", \"leaf beetle\", \"dung beetle\", \"rhinoceros beetle\", \"weevil\", \"fly\", \"bee\", \"ant\", \"grasshopper\", \"cricket insect\", \"stick insect\", \"cockroach\", \"praying mantis\", \"cicada\", \"leafhopper\", \"lacewing\", \"dragonfly\", \"damselfly\", \"red admiral butterfly\", \"ringlet butterfly\", \"monarch butterfly\", \"small white butterfly\", \"sulphur butterfly\", \"gossamer-winged butterfly\", \"starfish\", \"sea urchin\", \"sea cucumber\", \"cottontail rabbit\", \"hare\", \"Angora rabbit\", \"hamster\", \"porcupine\", \"fox squirrel\", \"marmot\", \"beaver\", \"guinea pig\", \"common sorrel horse\", \"zebra\", \"pig\", \"wild boar\", \"warthog\", \"hippopotamus\", \"ox\", \"water buffalo\", \"bison\", \"ram (adult male sheep)\", \"bighorn sheep\", \"Alpine ibex\", \"hartebeest\", \"impala (antelope)\", \"gazelle\", \"arabian camel\", \"llama\", \"weasel\", \"mink\", \"European polecat\", \"black-footed ferret\", \"otter\", \"skunk\", \"badger\", \"armadillo\", \"three-toed sloth\", \"orangutan\", \"gorilla\", \"chimpanzee\", \"gibbon\", \"siamang\", \"guenon\", \"patas monkey\", \"baboon\", \"macaque\", \"langur\", \"black-and-white colobus\", \"proboscis monkey\", \"marmoset\", \"white-headed capuchin\", \"howler monkey\", \"titi monkey\", \"Geoffroy's spider monkey\", \"common squirrel monkey\", \"ring-tailed lemur\", \"indri\", \"Asian elephant\", \"African bush elephant\", \"red panda\", \"giant panda\", \"snoek fish\", \"eel\", \"silver salmon\", \"rock beauty fish\", \"clownfish\", \"sturgeon\", \"gar fish\", \"lionfish\", \"pufferfish\", \"abacus\", \"abaya\", \"academic gown\", \"accordion\", \"acoustic guitar\", \"aircraft carrier\", \"airliner\", \"airship\", \"altar\", \"ambulance\", \"amphibious vehicle\", \"analog clock\", \"apiary\", \"apron\", \"trash can\", \"assault rifle\", \"backpack\", \"bakery\", \"balance beam\", \"balloon\", \"ballpoint pen\", \"Band-Aid\", \"banjo\", \"baluster / handrail\", \"barbell\", \"barber chair\", \"barbershop\", \"barn\", \"barometer\", \"barrel\", \"wheelbarrow\", \"baseball\", \"basketball\", \"bassinet\", \"bassoon\", \"swimming cap\", \"bath towel\", \"bathtub\", \"station wagon\", \"lighthouse\", \"beaker\", \"military hat (bearskin or shako)\", \"beer bottle\", \"beer glass\", \"bell tower\", \"baby bib\", \"tandem bicycle\", \"bikini\", \"ring binder\", \"binoculars\", \"birdhouse\", \"boathouse\", \"bobsleigh\", \"bolo tie\", \"poke bonnet\", \"bookcase\", \"bookstore\", \"bottle cap\", \"hunting bow\", \"bow tie\", \"brass memorial plaque\", \"bra\", \"breakwater\", \"breastplate\", \"broom\", \"bucket\", \"buckle\", \"bulletproof vest\", \"high-speed train\", \"butcher shop\", \"taxicab\", \"cauldron\", \"candle\", \"cannon\", \"canoe\", \"can opener\", \"cardigan\", \"car mirror\", \"carousel\", \"tool kit\", \"cardboard box / carton\", \"car wheel\", \"automated teller machine\", \"cassette\", \"cassette player\", \"castle\", \"catamaran\", \"CD player\", \"cello\", \"mobile phone\", \"chain\", \"chain-link fence\", \"chain mail\", \"chainsaw\", \"storage chest\", \"chiffonier\", \"bell or wind chime\", \"china cabinet\", \"Christmas stocking\", \"church\", \"movie theater\", \"cleaver\", \"cliff dwelling\", \"cloak\", \"clogs\", \"cocktail shaker\", \"coffee mug\", \"coffeemaker\", \"spiral or coil\", \"combination lock\", \"computer keyboard\", \"candy store\", \"container ship\", \"convertible\", \"corkscrew\", \"cornet\", \"cowboy boot\", \"cowboy hat\", \"cradle\", \"construction crane\", \"crash helmet\", \"crate\", \"infant bed\", \"Crock Pot\", \"croquet ball\", \"crutch\", \"cuirass\", \"dam\", \"desk\", \"desktop computer\", \"rotary dial telephone\", \"diaper\", \"digital clock\", \"digital watch\", \"dining table\", \"dishcloth\", \"dishwasher\", \"disc brake\", \"dock\", \"dog sled\", \"dome\", \"doormat\", \"drilling rig\", \"drum\", \"drumstick\", \"dumbbell\", \"Dutch oven\", \"electric fan\", \"electric guitar\", \"electric locomotive\", \"entertainment center\", \"envelope\", \"espresso machine\", \"face powder\", \"feather boa\", \"filing cabinet\", \"fireboat\", \"fire truck\", \"fire screen\", \"flagpole\", \"flute\", \"folding chair\", \"football helmet\", \"forklift\", \"fountain\", \"fountain pen\", \"four-poster bed\", \"freight car\", \"French horn\", \"frying pan\", \"fur coat\", \"garbage truck\", \"gas mask or respirator\", \"gas pump\", \"goblet\", \"go-kart\", \"golf ball\", \"golf cart\", \"gondola\", \"gong\", \"gown\", \"grand piano\", \"greenhouse\", \"radiator grille\", \"grocery store\", \"guillotine\", \"hair clip\", \"hair spray\", \"half-track\", \"hammer\", \"hamper\", \"hair dryer\", \"hand-held computer\", \"handkerchief\", \"hard disk drive\", \"harmonica\", \"harp\", \"combine harvester\", \"hatchet\", \"holster\", \"home theater\", \"honeycomb\", \"hook\", \"hoop skirt\", \"gymnastic horizontal bar\", \"horse-drawn vehicle\", \"hourglass\", \"iPod\", \"clothes iron\", \"carved pumpkin\", \"jeans\", \"jeep\", \"T-shirt\", \"jigsaw puzzle\", \"rickshaw\", \"joystick\", \"kimono\", \"knee pad\", \"knot\", \"lab coat\", \"ladle\", \"lampshade\", \"laptop computer\", \"lawn mower\", \"lens cap\", \"letter opener\", \"library\", \"lifeboat\", \"lighter\", \"limousine\", \"ocean liner\", \"lipstick\", \"slip-on shoe\", \"lotion\", \"music speaker\", \"loupe magnifying glass\", \"sawmill\", \"magnetic compass\", \"messenger bag\", \"mailbox\", \"tights\", \"one-piece bathing suit\", \"manhole cover\", \"maraca\", \"marimba\", \"mask\", \"matchstick\", \"maypole\", \"maze\", \"measuring cup\", \"medicine cabinet\", \"megalith\", \"microphone\", \"microwave oven\", \"military uniform\", \"milk can\", \"minibus\", \"miniskirt\", \"minivan\", \"missile\", \"mitten\", \"mixing bowl\", \"mobile home\", \"ford model t\", \"modem\", \"monastery\", \"monitor\", \"moped\", \"mortar and pestle\", \"graduation cap\", \"mosque\", \"mosquito net\", \"vespa\", \"mountain bike\", \"tent\", \"computer mouse\", \"mousetrap\", \"moving van\", \"muzzle\", \"metal nail\", \"neck brace\", \"necklace\", \"baby pacifier\", \"notebook computer\", \"obelisk\", \"oboe\", \"ocarina\", \"odometer\", \"oil filter\", \"pipe organ\", \"oscilloscope\", \"overskirt\", \"bullock cart\", \"oxygen mask\", \"product packet / packaging\", \"paddle\", \"paddle wheel\", \"padlock\", \"paintbrush\", \"pajamas\", \"palace\", \"pan flute\", \"paper towel\", \"parachute\", \"parallel bars\", \"park bench\", \"parking meter\", \"railroad car\", \"patio\", \"payphone\", \"pedestal\", \"pencil case\", \"pencil sharpener\", \"perfume\", \"Petri dish\", \"photocopier\", \"plectrum\", \"Pickelhaube\", \"picket fence\", \"pickup truck\", \"pier\", \"piggy bank\", \"pill bottle\", \"pillow\", \"ping-pong ball\", \"pinwheel\", \"pirate ship\", \"drink pitcher\", \"block plane\", \"planetarium\", \"plastic bag\", \"plate rack\", \"farm plow\", \"plunger\", \"Polaroid camera\", \"pole\", \"police van\", \"poncho\", \"pool table\", \"soda bottle\", \"plant pot\", \"potter's wheel\", \"power drill\", \"prayer rug\", \"printer\", \"prison\", \"missile\", \"projector\", \"hockey puck\", \"punching bag\", \"purse\", \"quill\", \"quilt\", \"race car\", \"racket\", \"radiator\", \"radio\", \"radio telescope\", \"rain barrel\", \"recreational vehicle\", \"fishing casting reel\", \"reflex camera\", \"refrigerator\", \"remote control\", \"restaurant\", \"revolver\", \"rifle\", \"rocking chair\", \"rotisserie\", \"eraser\", \"rugby ball\", \"ruler measuring stick\", \"sneaker\", \"safe\", \"safety pin\", \"salt shaker\", \"sandal\", \"sarong\", \"saxophone\", \"scabbard\", \"weighing scale\", \"school bus\", \"schooner\", \"scoreboard\", \"CRT monitor\", \"screw\", \"screwdriver\", \"seat belt\", \"sewing machine\", \"shield\", \"shoe store\", \"shoji screen / room divider\", \"shopping basket\", \"shopping cart\", \"shovel\", \"shower cap\", \"shower curtain\", \"ski\", \"balaclava ski mask\", \"sleeping bag\", \"slide rule\", \"sliding door\", \"slot machine\", \"snorkel\", \"snowmobile\", \"snowplow\", \"soap dispenser\", \"soccer ball\", \"sock\", \"solar thermal collector\", \"sombrero\", \"soup bowl\", \"keyboard space bar\", \"space heater\", \"space shuttle\", \"spatula\", \"motorboat\", \"spider web\", \"spindle\", \"sports car\", \"spotlight\", \"stage\", \"steam locomotive\", \"through arch bridge\", \"steel drum\", \"stethoscope\", \"scarf\", \"stone wall\", \"stopwatch\", \"stove\", \"strainer\", \"tram\", \"stretcher\", \"couch\", \"stupa\", \"submarine\", \"suit\", \"sundial\", \"sunglasses\", \"sunglasses\", \"sunscreen\", \"suspension bridge\", \"mop\", \"sweatshirt\", \"swim trunks / shorts\", \"swing\", \"electrical switch\", \"syringe\", \"table lamp\", \"tank\", \"tape player\", \"teapot\", \"teddy bear\", \"television\", \"tennis ball\", \"thatched roof\", \"front curtain\", \"thimble\", \"threshing machine\", \"throne\", \"tile roof\", \"toaster\", \"tobacco shop\", \"toilet seat\", \"torch\", \"totem pole\", \"tow truck\", \"toy store\", \"tractor\", \"semi-trailer truck\", \"tray\", \"trench coat\", \"tricycle\", \"trimaran\", \"tripod\", \"triumphal arch\", \"trolleybus\", \"trombone\", \"hot tub\", \"turnstile\", \"typewriter keyboard\", \"umbrella\", \"unicycle\", \"upright piano\", \"vacuum cleaner\", \"vase\", \"vaulted or arched ceiling\", \"velvet fabric\", \"vending machine\", \"vestment\", \"viaduct\", \"violin\", \"volleyball\", \"waffle iron\", \"wall clock\", \"wallet\", \"wardrobe\", \"military aircraft\", \"sink\", \"washing machine\", \"water bottle\", \"water jug\", \"water tower\", \"whiskey jug\", \"whistle\", \"hair wig\", \"window screen\", \"window shade\", \"Windsor tie\", \"wine bottle\", \"airplane wing\", \"wok\", \"wooden spoon\", \"wool\", \"split-rail fence\", \"shipwreck\", \"sailboat\", \"yurt\", \"website\", \"comic book\", \"crossword\", \"traffic or street sign\", \"traffic light\", \"dust jacket\", \"menu\", \"plate\", \"guacamole\", \"consomme\", \"hot pot\", \"trifle\", \"ice cream\", \"popsicle\", \"baguette\", \"bagel\", \"pretzel\", \"cheeseburger\", \"hot dog\", \"mashed potatoes\", \"cabbage\", \"broccoli\", \"cauliflower\", \"zucchini\", \"spaghetti squash\", \"acorn squash\", \"butternut squash\", \"cucumber\", \"artichoke\", \"bell pepper\", \"cardoon\", \"mushroom\", \"Granny Smith apple\", \"strawberry\", \"orange\", \"lemon\", \"fig\", \"pineapple\", \"banana\", \"jackfruit\", \"cherimoya (custard apple)\", \"pomegranate\", \"hay\", \"carbonara\", \"chocolate syrup\", \"dough\", \"meatloaf\", \"pizza\", \"pot pie\", \"burrito\", \"red wine\", \"espresso\", \"tea cup\", \"eggnog\", \"mountain\", \"bubble\", \"cliff\", \"coral reef\", \"geyser\", \"lakeshore\", \"promontory\", \"sandbar\", \"beach\", \"valley\", \"volcano\", \"baseball player\", \"bridegroom\", \"scuba diver\", \"rapeseed\", \"daisy\", \"yellow lady's slipper\", \"corn\", \"acorn\", \"rose hip\", \"horse chestnut seed\", \"coral fungus\", \"agaric\", \"gyromitra\", \"stinkhorn mushroom\", \"earth star fungus\", \"hen of the woods mushroom\", \"bolete\", \"corn cob\", \"toilet paper\"]"
+      ],
+      "execution_count": 6,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "eMQSCuBta2G6"
+      },
+      "source": [
+        "A subset of these class names are modified from the default ImageNet class names sourced from Anish Athalye's imagenet-simple-labels.\n",
+        "\n",
+        "These edits were made via trial and error and concentrated on the lowest performing classes according to top_1 and top_5 accuracy on the ImageNet training set for the RN50, RN101, and RN50x4 models. These tweaks improve top_1 by 1.5% on ViT-B/32 over using the default class names. Alec got bored somewhere along the way as gains started to diminish and never finished updating / tweaking the list. He also didn't revisit this with the better performing RN50x16, RN50x64, or any of the ViT models. He thinks it's likely another 0.5% to 1% top_1 could be gained from further work here. It'd be interesting to more rigorously study / understand this.\n",
+        "\n",
+        "Some examples beyond the crane/crane -> construction crane / bird crane issue mentioned in Section 3.1.4 of the paper include:\n",
+        "\n",
+        "- CLIP interprets \"nail\" as \"fingernail\" so we changed the label to \"metal nail\".\n",
+        "- ImageNet kite class refers to the bird of prey, not the flying toy, so we changed \"kite\" to \"kite (bird of prey)\"\n",
+        "- The ImageNet class for red wolf seems to include a lot of mislabeled maned wolfs so we changed \"red wolf\" to \"red wolf or maned wolf\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "toGtcd-Ji_MD",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "b6eb0753-2bee-4144-abe3-fbd23f35f555"
+      },
+      "source": [
+        "imagenet_templates = [\n",
+        "    'a bad photo of a {}.',\n",
+        "    'a photo of many {}.',\n",
+        "    'a sculpture of a {}.',\n",
+        "    'a photo of the hard to see {}.',\n",
+        "    'a low resolution photo of the {}.',\n",
+        "    'a rendering of a {}.',\n",
+        "    'graffiti of a {}.',\n",
+        "    'a bad photo of the {}.',\n",
+        "    'a cropped photo of the {}.',\n",
+        "    'a tattoo of a {}.',\n",
+        "    'the embroidered {}.',\n",
+        "    'a photo of a hard to see {}.',\n",
+        "    'a bright photo of a {}.',\n",
+        "    'a photo of a clean {}.',\n",
+        "    'a photo of a dirty {}.',\n",
+        "    'a dark photo of the {}.',\n",
+        "    'a drawing of a {}.',\n",
+        "    'a photo of my {}.',\n",
+        "    'the plastic {}.',\n",
+        "    'a photo of the cool {}.',\n",
+        "    'a close-up photo of a {}.',\n",
+        "    'a black and white photo of the {}.',\n",
+        "    'a painting of the {}.',\n",
+        "    'a painting of a {}.',\n",
+        "    'a pixelated photo of the {}.',\n",
+        "    'a sculpture of the {}.',\n",
+        "    'a bright photo of the {}.',\n",
+        "    'a cropped photo of a {}.',\n",
+        "    'a plastic {}.',\n",
+        "    'a photo of the dirty {}.',\n",
+        "    'a jpeg corrupted photo of a {}.',\n",
+        "    'a blurry photo of the {}.',\n",
+        "    'a photo of the {}.',\n",
+        "    'a good photo of the {}.',\n",
+        "    'a rendering of the {}.',\n",
+        "    'a {} in a video game.',\n",
+        "    'a photo of one {}.',\n",
+        "    'a doodle of a {}.',\n",
+        "    'a close-up photo of the {}.',\n",
+        "    'a photo of a {}.',\n",
+        "    'the origami {}.',\n",
+        "    'the {} in a video game.',\n",
+        "    'a sketch of a {}.',\n",
+        "    'a doodle of the {}.',\n",
+        "    'a origami {}.',\n",
+        "    'a low resolution photo of a {}.',\n",
+        "    'the toy {}.',\n",
+        "    'a rendition of the {}.',\n",
+        "    'a photo of the clean {}.',\n",
+        "    'a photo of a large {}.',\n",
+        "    'a rendition of a {}.',\n",
+        "    'a photo of a nice {}.',\n",
+        "    'a photo of a weird {}.',\n",
+        "    'a blurry photo of a {}.',\n",
+        "    'a cartoon {}.',\n",
+        "    'art of a {}.',\n",
+        "    'a sketch of the {}.',\n",
+        "    'a embroidered {}.',\n",
+        "    'a pixelated photo of a {}.',\n",
+        "    'itap of the {}.',\n",
+        "    'a jpeg corrupted photo of the {}.',\n",
+        "    'a good photo of a {}.',\n",
+        "    'a plushie {}.',\n",
+        "    'a photo of the nice {}.',\n",
+        "    'a photo of the small {}.',\n",
+        "    'a photo of the weird {}.',\n",
+        "    'the cartoon {}.',\n",
+        "    'art of the {}.',\n",
+        "    'a drawing of the {}.',\n",
+        "    'a photo of the large {}.',\n",
+        "    'a black and white photo of a {}.',\n",
+        "    'the plushie {}.',\n",
+        "    'a dark photo of a {}.',\n",
+        "    'itap of a {}.',\n",
+        "    'graffiti of the {}.',\n",
+        "    'a toy {}.',\n",
+        "    'itap of my {}.',\n",
+        "    'a photo of a cool {}.',\n",
+        "    'a photo of a small {}.',\n",
+        "    'a tattoo of the {}.',\n",
+        "]\n",
+        "\n",
+        "print(f\"{len(imagenet_classes)} classes, {len(imagenet_templates)} templates\")"
+      ],
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "1000 classes, 80 templates\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aRB5OzgpHwqQ"
+      },
+      "source": [
+        "A similar, intuition-guided trial and error based on the ImageNet training set was used for templates. This list is pretty haphazard and was gradually made / expanded over the course of about a year of the project and was revisited / tweaked every few months. A surprising / weird thing was adding templates intended to help ImageNet-R performance (specifying different possible renditions of an object) improved standard ImageNet accuracy too.\n",
+        "\n",
+        "After the 80 templates were \"locked\" for the paper, we ran sequential forward selection over the list of 80 templates. The search terminated after ensembling 7 templates and selected them in the order below.\n",
+        "\n",
+        "1. itap of a {}.\n",
+        "2. a bad photo of the {}.\n",
+        "3. a origami {}.\n",
+        "4. a photo of the large {}.\n",
+        "5. a {} in a video game.\n",
+        "6. art of the {}.\n",
+        "7. a photo of the small {}.\n",
+        "\n",
+        "Speculating, we think it's interesting to see different scales (large and small), a difficult view (a bad photo), and \"abstract\" versions (origami, video game, art), were all selected for, but we haven't studied this in any detail. This subset performs a bit better than the full 80 ensemble reported in the paper, especially for the smaller models."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "4W8ARJVqBJXs"
+      },
+      "source": [
+        "# Loading the Images\n",
+        "\n",
+        "The ILSVRC2012 datasets are no longer available for download publicly. We instead download the ImageNet-V2 dataset by [Recht et al.](https://arxiv.org/abs/1902.10811).\n",
+        "\n",
+        "If you have the ImageNet dataset downloaded, you can replace the dataset with the official torchvision loader, e.g.:\n",
+        "\n",
+        "```python\n",
+        "images = torchvision.datasets.ImageNet(\"path/to/imagenet\", split='val', transform=preprocess)\n",
+        "```"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "moHR4UlHKsDc",
+        "outputId": "40731297-edc7-4cd0-be75-ed426c8fb005"
+      },
+      "source": [
+        "! pip install git+https://github.com/modestyachts/ImageNetV2_pytorch\n",
+        "\n",
+        "from imagenetv2_pytorch import ImageNetV2Dataset\n",
+        "\n",
+        "images = ImageNetV2Dataset(transform=preprocess)\n",
+        "loader = torch.utils.data.DataLoader(images, batch_size=32, num_workers=2)"
+      ],
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Collecting git+https://github.com/modestyachts/ImageNetV2_pytorch\n",
+            "  Cloning https://github.com/modestyachts/ImageNetV2_pytorch to /tmp/pip-req-build-0kih0kn2\n",
+            "  Running command git clone -q https://github.com/modestyachts/ImageNetV2_pytorch /tmp/pip-req-build-0kih0kn2\n",
+            "Building wheels for collected packages: imagenetv2-pytorch\n",
+            "  Building wheel for imagenetv2-pytorch (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for imagenetv2-pytorch: filename=imagenetv2_pytorch-0.1-py3-none-any.whl size=2663 sha256=ac31e0ed9c61afc5e0271eed315d3a82844a79ae64f8ce43fc1c98928cec129f\n",
+            "  Stored in directory: /tmp/pip-ephem-wheel-cache-745b5n1m/wheels/ab/ee/f4/73bce5c7f68d28ce632ef33ae87ce60aaca021eb2b3b31a6fa\n",
+            "Successfully built imagenetv2-pytorch\n",
+            "Installing collected packages: imagenetv2-pytorch\n",
+            "Successfully installed imagenetv2-pytorch-0.1\n",
+            "Dataset matched-frequency not found on disk, downloading....\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 1.26G/1.26G [01:02<00:00, 20.2MiB/s]\n"
+          ],
+          "name": "stderr"
+        },
+        {
+          "output_type": "stream",
+          "text": [
+            "Extracting....\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fz6D-F-Wbrtp"
+      },
+      "source": [
+        "# Creating zero-shot classifier weights"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 67,
+          "referenced_widgets": [
+            "66a1639713ae441d8a9b873381f9d774",
+            "610b775178c645e2b4663b77cc0c67b6",
+            "412dd15f0d8542f5ab2730f8616fb582",
+            "5e6315f36b4e4eeea5c6294b024e0c97",
+            "085d5388abda4202bfa66d0c088452f8",
+            "f75124b64aa147c693c67a78f8e3a231",
+            "6e5676a054874243b55fc6d120a07d01",
+            "dc6d1416c01a4047935ee15c3fd2eb1c"
+          ]
+        },
+        "id": "sRqDoz1Gbsii",
+        "outputId": "312b8ebf-3961-4903-d8cb-3b7a94cc97b6"
+      },
+      "source": [
+        "def zeroshot_classifier(classnames, templates):\n",
+        "    with torch.no_grad():\n",
+        "        zeroshot_weights = []\n",
+        "        for classname in tqdm(classnames):\n",
+        "            texts = [template.format(classname) for template in templates] #format with class\n",
+        "            texts = clip.tokenize(texts).cuda() #tokenize\n",
+        "            class_embeddings = model.encode_text(texts) #embed with text encoder\n",
+        "            class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True)\n",
+        "            class_embedding = class_embeddings.mean(dim=0)\n",
+        "            class_embedding /= class_embedding.norm()\n",
+        "            zeroshot_weights.append(class_embedding)\n",
+        "        zeroshot_weights = torch.stack(zeroshot_weights, dim=1).cuda()\n",
+        "    return zeroshot_weights\n",
+        "\n",
+        "\n",
+        "zeroshot_weights = zeroshot_classifier(imagenet_classes, imagenet_templates)"
+      ],
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "66a1639713ae441d8a9b873381f9d774",
+              "version_minor": 0,
+              "version_major": 2
+            },
+            "text/plain": [
+              "HBox(children=(FloatProgress(value=0.0, max=1000.0), HTML(value='')))"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          }
+        },
+        {
+          "output_type": "stream",
+          "text": [
+            "\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1fZo7hG8iJP5"
+      },
+      "source": [
+        "# Zero-shot prediction"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "j4kPSZoShQxN"
+      },
+      "source": [
+        "def accuracy(output, target, topk=(1,)):\n",
+        "    pred = output.topk(max(topk), 1, True, True)[1].t()\n",
+        "    correct = pred.eq(target.view(1, -1).expand_as(pred))\n",
+        "    return [float(correct[:k].reshape(-1).float().sum(0, keepdim=True).cpu().numpy()) for k in topk]"
+      ],
+      "execution_count": 10,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 102,
+          "referenced_widgets": [
+            "84f80a7f3e764346969a347b0f71b24e",
+            "392656f01b2945f3bd7903783ed8cc96",
+            "8e47a435519b4ce090879b4be2f61f99",
+            "41b1ed6b0a9745c1a595377670b15ff4",
+            "179b8ae1eb7f4a828f953e889b141725",
+            "d8708e8414fd44f4abd6590c9b57996f",
+            "800e30f5b4f24475a2b0046da0703631",
+            "8764308b948745f1a677332fd21fcaf0"
+          ]
+        },
+        "id": "wKJ7YsdlkDXo",
+        "outputId": "ab824854-38e4-4d37-ad40-2a7ce3c5fd43"
+      },
+      "source": [
+        "with torch.no_grad():\n",
+        "    top1, top5, n = 0., 0., 0.\n",
+        "    for i, (images, target) in enumerate(tqdm(loader)):\n",
+        "        images = images.cuda()\n",
+        "        target = target.cuda()\n",
+        "        \n",
+        "        # predict\n",
+        "        image_features = model.encode_image(images)\n",
+        "        image_features /= image_features.norm(dim=-1, keepdim=True)\n",
+        "        logits = 100. * image_features @ zeroshot_weights\n",
+        "\n",
+        "        # measure accuracy\n",
+        "        acc1, acc5 = accuracy(logits, target, topk=(1, 5))\n",
+        "        top1 += acc1\n",
+        "        top5 += acc5\n",
+        "        n += images.size(0)\n",
+        "\n",
+        "top1 = (top1 / n) * 100\n",
+        "top5 = (top5 / n) * 100 \n",
+        "\n",
+        "print(f\"Top-1 accuracy: {top1:.2f}\")\n",
+        "print(f\"Top-5 accuracy: {top5:.2f}\")"
+      ],
+      "execution_count": 11,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "84f80a7f3e764346969a347b0f71b24e",
+              "version_minor": 0,
+              "version_major": 2
+            },
+            "text/plain": [
+              "HBox(children=(FloatProgress(value=0.0, max=313.0), HTML(value='')))"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          }
+        },
+        {
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "Top-1 accuracy: 55.93\n",
+            "Top-5 accuracy: 83.36\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    }
+  ]
+}

CCEdit-main/src/clip/requirements.txt

@@ -0,0 +1,6 @@
+ftfy
+packaging
+regex
+tqdm
+torch
+torchvision

CCEdit-main/src/clip/setup.py

@@ -0,0 +1,21 @@
+import os
+
+import pkg_resources
+from setuptools import setup, find_packages
+
+setup(
+    name="clip",
+    py_modules=["clip"],
+    version="1.0",
+    description="",
+    author="OpenAI",
+    packages=find_packages(exclude=["tests*"]),
+    install_requires=[
+        str(r)
+        for r in pkg_resources.parse_requirements(
+            open(os.path.join(os.path.dirname(__file__), "requirements.txt"))
+        )
+    ],
+    include_package_data=True,
+    extras_require={'dev': ['pytest']},
+)

CCEdit-main/src/clip/tests/test_consistency.py

@@ -0,0 +1,25 @@
+import numpy as np
+import pytest
+import torch
+from PIL import Image
+
+import clip
+
+
+@pytest.mark.parametrize('model_name', clip.available_models())
+def test_consistency(model_name):
+    device = "cpu"
+    jit_model, transform = clip.load(model_name, device=device, jit=True)
+    py_model, _ = clip.load(model_name, device=device, jit=False)
+
+    image = transform(Image.open("CLIP.png")).unsqueeze(0).to(device)
+    text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device)
+
+    with torch.no_grad():
+        logits_per_image, _ = jit_model(image, text)
+        jit_probs = logits_per_image.softmax(dim=-1).cpu().numpy()
+
+        logits_per_image, _ = py_model(image, text)
+        py_probs = logits_per_image.softmax(dim=-1).cpu().numpy()
+
+    assert np.allclose(jit_probs, py_probs, atol=0.01, rtol=0.1)

CCEdit-main/src/pnp-diffusers/README.md

@@ -0,0 +1,60 @@
+# Plug-and-Play Diffusion Features for Text-Driven Image-to-Image Translation (CVPR 2023)
+
+## [<a href="https://pnp-diffusion.github.io/" target="_blank">Project Page</a>]
+
+[![arXiv](https://img.shields.io/badge/arXiv-PnP-b31b1b.svg)](https://arxiv.org/abs/2211.12572) [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/hysts/PnP-diffusion-features) <a href="https://replicate.com/arielreplicate/plug_and_play_image_translation"><img src="https://replicate.com/arielreplicate/plug_and_play_image_translation/badge"></a> [![TI2I](https://img.shields.io/badge/benchmarks-TI2I-blue)](https://www.dropbox.com/sh/8giw0uhfekft47h/AAAF1frwakVsQocKczZZSX6La?dl=0)
+
+![teaser](assets/teaser.png)
+
+
+**To plug-and-play diffusion features, please follow these steps:**
+
+1. [Setup](#setup)
+2. [Latent extraction](#latent-extraction)
+3. [Running PnP](#running-pnp)
+
+
+## Setup
+
+Create the environment and install the dependencies by running:
+
+```
+conda create -n pnp-diffusers python=3.9
+conda activate pnp-diffusers
+pip install -r requirements.txt
+```
+
+
+## Latent Extraction
+
+We first compute the intermediate noisy latents of the structure guidance image. To do that, run:
+
+```
+python preprocess.py --data_path <path_to_guidance_image> --inversion_prompt <inversion_prompt>
+```
+
+where `<inversion_prompt>` should describe the content of the guidance image. The intermediate noisy latents will be saved under the path `latents_forward/<image_name>`, where `<image_name>` is the filename of the provided guidance image.
+
+
+## Running PnP
+
+Run the following command for applying PnP on the structure guidance image:
+
+```
+python pnp.py --config_path <pnp_config_path>
+```
+
+where `<pnp_config_path>` is a path to a yaml config file. The config includes fields for providing the guidance image path, the PnP output path, translation prompt, guidance scale, PnP feature and self-attention injection thresholds, and additional hyperparameters. See an example config in `config_pnp.yaml`.
+
+
+## Citation
+```
+@InProceedings{Tumanyan_2023_CVPR,
+    author    = {Tumanyan, Narek and Geyer, Michal and Bagon, Shai and Dekel, Tali},
+    title     = {Plug-and-Play Diffusion Features for Text-Driven Image-to-Image Translation},
+    booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
+    month     = {June},
+    year      = {2023},
+    pages     = {1921-1930}
+}
+```

CCEdit-main/src/pnp-diffusers/config_pnp.yaml

@@ -0,0 +1,19 @@
+# general
+seed: 1
+device: 'cuda'
+output_path: 'PNP-results/horse'
+
+# data
+image_path: 'data/horse.jpg'
+latents_path: 'latents_forward'
+
+# diffusion
+sd_version: '2.1'
+guidance_scale: 7.5
+n_timesteps: 50
+prompt: a photo of a pink toy horse on the beach
+negative_prompt: ugly, blurry, black, low res, unrealistic
+
+# pnp injection thresholds, ∈ [0, 1]
+pnp_attn_t: 0.5
+pnp_f_t: 0.8

CCEdit-main/src/pnp-diffusers/pnp_utils.py

@@ -0,0 +1,153 @@
+import torch
+import os
+import random
+import numpy as np
+
+def seed_everything(seed):
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    random.seed(seed)
+    np.random.seed(seed)
+
+def register_time(model, t):
+    conv_module = model.unet.up_blocks[1].resnets[1]
+    setattr(conv_module, 't', t)
+    down_res_dict = {0: [0, 1], 1: [0, 1], 2: [0, 1]}
+    up_res_dict = {1: [0, 1, 2], 2: [0, 1, 2], 3: [0, 1, 2]}
+    for res in up_res_dict:
+        for block in up_res_dict[res]:
+            module = model.unet.up_blocks[res].attentions[block].transformer_blocks[0].attn1
+            setattr(module, 't', t)
+    for res in down_res_dict:
+        for block in down_res_dict[res]:
+            module = model.unet.down_blocks[res].attentions[block].transformer_blocks[0].attn1
+            setattr(module, 't', t)
+    module = model.unet.mid_block.attentions[0].transformer_blocks[0].attn1
+    setattr(module, 't', t)
+
+
+def load_source_latents_t(t, latents_path):
+    latents_t_path = os.path.join(latents_path, f'noisy_latents_{t}.pt')
+    assert os.path.exists(latents_t_path), f'Missing latents at t {t} path {latents_t_path}'
+    latents = torch.load(latents_t_path)
+    return latents
+
+def register_attention_control_efficient(model, injection_schedule):
+    def sa_forward(self):
+        to_out = self.to_out
+        if type(to_out) is torch.nn.modules.container.ModuleList:
+            to_out = self.to_out[0]
+        else:
+            to_out = self.to_out
+
+        def forward(x, encoder_hidden_states=None, attention_mask=None):
+            batch_size, sequence_length, dim = x.shape
+            h = self.heads
+
+            is_cross = encoder_hidden_states is not None
+            encoder_hidden_states = encoder_hidden_states if is_cross else x
+            if not is_cross and self.injection_schedule is not None and (
+                    self.t in self.injection_schedule or self.t == 1000):
+                q = self.to_q(x)
+                k = self.to_k(encoder_hidden_states)
+
+                source_batch_size = int(q.shape[0] // 3)
+                # inject unconditional
+                q[source_batch_size:2 * source_batch_size] = q[:source_batch_size]
+                k[source_batch_size:2 * source_batch_size] = k[:source_batch_size]
+                # inject conditional
+                q[2 * source_batch_size:] = q[:source_batch_size]
+                k[2 * source_batch_size:] = k[:source_batch_size]
+
+                q = self.head_to_batch_dim(q)
+                k = self.head_to_batch_dim(k)
+            else:
+                q = self.to_q(x)
+                k = self.to_k(encoder_hidden_states)
+                q = self.head_to_batch_dim(q)
+                k = self.head_to_batch_dim(k)
+
+            v = self.to_v(encoder_hidden_states)
+            v = self.head_to_batch_dim(v)
+
+            sim = torch.einsum("b i d, b j d -> b i j", q, k) * self.scale
+
+            if attention_mask is not None:
+                attention_mask = attention_mask.reshape(batch_size, -1)
+                max_neg_value = -torch.finfo(sim.dtype).max
+                attention_mask = attention_mask[:, None, :].repeat(h, 1, 1)
+                sim.masked_fill_(~attention_mask, max_neg_value)
+
+            # attention, what we cannot get enough of
+            attn = sim.softmax(dim=-1)
+            out = torch.einsum("b i j, b j d -> b i d", attn, v)
+            out = self.batch_to_head_dim(out)
+
+            return to_out(out)
+
+        return forward
+
+    res_dict = {1: [1, 2], 2: [0, 1, 2], 3: [0, 1, 2]}  # we are injecting attention in blocks 4 - 11 of the decoder, so not in the first block of the lowest resolution
+    for res in res_dict:
+        for block in res_dict[res]:
+            module = model.unet.up_blocks[res].attentions[block].transformer_blocks[0].attn1
+            module.forward = sa_forward(module)
+            setattr(module, 'injection_schedule', injection_schedule)
+
+
+def register_conv_control_efficient(model, injection_schedule):
+    def conv_forward(self):
+        def forward(input_tensor, temb):
+            hidden_states = input_tensor
+
+            hidden_states = self.norm1(hidden_states)
+            hidden_states = self.nonlinearity(hidden_states)
+
+            if self.upsample is not None:
+                # upsample_nearest_nhwc fails with large batch sizes. see https://github.com/huggingface/diffusers/issues/984
+                if hidden_states.shape[0] >= 64:
+                    input_tensor = input_tensor.contiguous()
+                    hidden_states = hidden_states.contiguous()
+                input_tensor = self.upsample(input_tensor)
+                hidden_states = self.upsample(hidden_states)
+            elif self.downsample is not None:
+                input_tensor = self.downsample(input_tensor)
+                hidden_states = self.downsample(hidden_states)
+
+            hidden_states = self.conv1(hidden_states)
+
+            if temb is not None:
+                temb = self.time_emb_proj(self.nonlinearity(temb))[:, :, None, None]
+
+            if temb is not None and self.time_embedding_norm == "default":
+                hidden_states = hidden_states + temb
+
+            hidden_states = self.norm2(hidden_states)
+
+            if temb is not None and self.time_embedding_norm == "scale_shift":
+                scale, shift = torch.chunk(temb, 2, dim=1)
+                hidden_states = hidden_states * (1 + scale) + shift
+
+            hidden_states = self.nonlinearity(hidden_states)
+
+            hidden_states = self.dropout(hidden_states)
+            hidden_states = self.conv2(hidden_states)
+            if self.injection_schedule is not None and (self.t in self.injection_schedule or self.t == 1000):
+                source_batch_size = int(hidden_states.shape[0] // 3)
+                # inject unconditional
+                hidden_states[source_batch_size:2 * source_batch_size] = hidden_states[:source_batch_size]
+                # inject conditional
+                hidden_states[2 * source_batch_size:] = hidden_states[:source_batch_size]
+
+            if self.conv_shortcut is not None:
+                input_tensor = self.conv_shortcut(input_tensor)
+
+            output_tensor = (input_tensor + hidden_states) / self.output_scale_factor
+
+            return output_tensor
+
+        return forward
+
+    conv_module = model.unet.up_blocks[1].resnets[1]
+    conv_module.forward = conv_forward(conv_module)
+    setattr(conv_module, 'injection_schedule', injection_schedule)

CCEdit-main/src/pnp-diffusers/preprocess.py

@@ -0,0 +1,216 @@
+from transformers import CLIPTextModel, CLIPTokenizer, logging
+from diffusers import AutoencoderKL, UNet2DConditionModel, DDIMScheduler
+
+# suppress partial model loading warning
+logging.set_verbosity_error()
+
+import os
+from PIL import Image
+from tqdm import tqdm, trange
+import torch
+import torch.nn as nn
+import argparse
+from pathlib import Path
+from pnp_utils import *
+import torchvision.transforms as T
+
+
+def get_timesteps(scheduler, num_inference_steps, strength, device):
+    # get the original timestep using init_timestep
+    init_timestep = min(int(num_inference_steps * strength), num_inference_steps)
+
+    t_start = max(num_inference_steps - init_timestep, 0)
+    timesteps = scheduler.timesteps[t_start:]
+
+    return timesteps, num_inference_steps - t_start
+
+
+class Preprocess(nn.Module):
+    def __init__(self, device, sd_version='2.0', hf_key=None):
+        super().__init__()
+
+        self.device = device
+        self.sd_version = sd_version
+        self.use_depth = False
+
+        print(f'[INFO] loading stable diffusion...')
+        if hf_key is not None:
+            print(f'[INFO] using hugging face custom model key: {hf_key}')
+            model_key = hf_key
+        elif self.sd_version == '2.1':
+            model_key = "stabilityai/stable-diffusion-2-1-base"
+        elif self.sd_version == '2.0':
+            model_key = "stabilityai/stable-diffusion-2-base"
+        elif self.sd_version == '1.5':
+            model_key = "runwayml/stable-diffusion-v1-5"
+        elif self.sd_version == 'depth':
+            model_key = "stabilityai/stable-diffusion-2-depth"
+            self.use_depth = True
+        else:
+            raise ValueError(f'Stable-diffusion version {self.sd_version} not supported.')
+
+        # Create model
+        self.vae = AutoencoderKL.from_pretrained(model_key, subfolder="vae", revision="fp16",
+                                                 torch_dtype=torch.float16).to(self.device)
+        self.tokenizer = CLIPTokenizer.from_pretrained(model_key, subfolder="tokenizer")
+        self.text_encoder = CLIPTextModel.from_pretrained(model_key, subfolder="text_encoder", revision="fp16",
+                                                          torch_dtype=torch.float16).to(self.device)
+        self.unet = UNet2DConditionModel.from_pretrained(model_key, subfolder="unet", revision="fp16",
+                                                         torch_dtype=torch.float16).to(self.device)
+        self.scheduler = DDIMScheduler.from_pretrained(model_key, subfolder="scheduler")
+        print(f'[INFO] loaded stable diffusion!')
+
+        self.inversion_func = self.ddim_inversion
+
+    @torch.no_grad()
+    def get_text_embeds(self, prompt, negative_prompt, device="cuda"):
+        text_input = self.tokenizer(prompt, padding='max_length', max_length=self.tokenizer.model_max_length,
+                                    truncation=True, return_tensors='pt')
+        text_embeddings = self.text_encoder(text_input.input_ids.to(device))[0]
+        uncond_input = self.tokenizer(negative_prompt, padding='max_length', max_length=self.tokenizer.model_max_length,
+                                      return_tensors='pt')
+        uncond_embeddings = self.text_encoder(uncond_input.input_ids.to(device))[0]
+        text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
+        return text_embeddings
+
+    @torch.no_grad()
+    def decode_latents(self, latents):
+        with torch.autocast(device_type='cuda', dtype=torch.float32):
+            latents = 1 / 0.18215 * latents
+            imgs = self.vae.decode(latents).sample
+            imgs = (imgs / 2 + 0.5).clamp(0, 1)
+        return imgs
+
+    def load_img(self, image_path):
+        image_pil = T.Resize(512)(Image.open(image_path).convert("RGB"))
+        image = T.ToTensor()(image_pil).unsqueeze(0).to(device)
+        return image
+
+    @torch.no_grad()
+    def encode_imgs(self, imgs):
+        with torch.autocast(device_type='cuda', dtype=torch.float32):
+            imgs = 2 * imgs - 1
+            posterior = self.vae.encode(imgs).latent_dist
+            latents = posterior.mean * 0.18215
+        return latents
+
+    @torch.no_grad()
+    def ddim_inversion(self, cond, latent, save_path, save_latents=True,
+                                timesteps_to_save=None):
+        timesteps = reversed(self.scheduler.timesteps)
+        with torch.autocast(device_type='cuda', dtype=torch.float32):
+            for i, t in enumerate(tqdm(timesteps)):
+                cond_batch = cond.repeat(latent.shape[0], 1, 1)
+
+                alpha_prod_t = self.scheduler.alphas_cumprod[t]
+                alpha_prod_t_prev = (
+                    self.scheduler.alphas_cumprod[timesteps[i - 1]]
+                    if i > 0 else self.scheduler.final_alpha_cumprod
+                )
+
+                mu = alpha_prod_t ** 0.5
+                mu_prev = alpha_prod_t_prev ** 0.5
+                sigma = (1 - alpha_prod_t) ** 0.5
+                sigma_prev = (1 - alpha_prod_t_prev) ** 0.5
+
+                eps = self.unet(latent, t, encoder_hidden_states=cond_batch).sample
+
+                pred_x0 = (latent - sigma_prev * eps) / mu_prev
+                latent = mu * pred_x0 + sigma * eps
+                if save_latents:
+                    torch.save(latent, os.path.join(save_path, f'noisy_latents_{t}.pt'))
+        torch.save(latent, os.path.join(save_path, f'noisy_latents_{t}.pt'))
+        return latent
+
+    @torch.no_grad()
+    def ddim_sample(self, x, cond, save_path, save_latents=False, timesteps_to_save=None):
+        timesteps = self.scheduler.timesteps
+        with torch.autocast(device_type='cuda', dtype=torch.float32):
+            for i, t in enumerate(tqdm(timesteps)):
+                    cond_batch = cond.repeat(x.shape[0], 1, 1)
+                    alpha_prod_t = self.scheduler.alphas_cumprod[t]
+                    alpha_prod_t_prev = (
+                        self.scheduler.alphas_cumprod[timesteps[i + 1]]
+                        if i < len(timesteps) - 1
+                        else self.scheduler.final_alpha_cumprod
+                    )
+                    mu = alpha_prod_t ** 0.5
+                    sigma = (1 - alpha_prod_t) ** 0.5
+                    mu_prev = alpha_prod_t_prev ** 0.5
+                    sigma_prev = (1 - alpha_prod_t_prev) ** 0.5
+
+                    eps = self.unet(x, t, encoder_hidden_states=cond_batch).sample
+
+                    pred_x0 = (x - sigma * eps) / mu
+                    x = mu_prev * pred_x0 + sigma_prev * eps
+
+            if save_latents:
+                torch.save(x, os.path.join(save_path, f'noisy_latents_{t}.pt'))
+        return x
+
+    @torch.no_grad()
+    def extract_latents(self, num_steps, data_path, save_path, timesteps_to_save,
+                        inversion_prompt='', extract_reverse=False):
+        self.scheduler.set_timesteps(num_steps)
+
+        cond = self.get_text_embeds(inversion_prompt, "")[1].unsqueeze(0)
+        image = self.load_img(data_path)
+        latent = self.encode_imgs(image)
+
+        inverted_x = self.inversion_func(cond, latent, save_path, save_latents=not extract_reverse,
+                                         timesteps_to_save=timesteps_to_save)
+        latent_reconstruction = self.ddim_sample(inverted_x, cond, save_path, save_latents=extract_reverse,
+                                                 timesteps_to_save=timesteps_to_save)
+        rgb_reconstruction = self.decode_latents(latent_reconstruction)
+
+        return rgb_reconstruction  # , latent_reconstruction
+
+
+def run(opt):
+    # timesteps to save
+    if opt.sd_version == '2.1':
+        model_key = "stabilityai/stable-diffusion-2-1-base"
+    elif opt.sd_version == '2.0':
+        model_key = "stabilityai/stable-diffusion-2-base"
+    elif opt.sd_version == '1.5':
+        model_key = "runwayml/stable-diffusion-v1-5"
+    elif opt.sd_version == 'depth':
+        model_key = "stabilityai/stable-diffusion-2-depth"
+    toy_scheduler = DDIMScheduler.from_pretrained(model_key, subfolder="scheduler")
+    toy_scheduler.set_timesteps(opt.save_steps)
+    timesteps_to_save, num_inference_steps = get_timesteps(toy_scheduler, num_inference_steps=opt.save_steps,
+                                                           strength=1.0,
+                                                           device=device)
+
+    seed_everything(opt.seed)
+
+    extraction_path_prefix = "_reverse" if opt.extract_reverse else "_forward"
+    save_path = os.path.join(opt.save_dir + extraction_path_prefix, os.path.splitext(os.path.basename(opt.data_path))[0])
+    os.makedirs(save_path, exist_ok=True)
+
+    model = Preprocess(device, sd_version=opt.sd_version, hf_key=None)
+    recon_image = model.extract_latents(data_path=opt.data_path,
+                                         num_steps=opt.steps,
+                                         save_path=save_path,
+                                         timesteps_to_save=timesteps_to_save,
+                                         inversion_prompt=opt.inversion_prompt,
+                                         extract_reverse=opt.extract_reverse)
+
+    T.ToPILImage()(recon_image[0]).save(os.path.join(save_path, f'recon.jpg'))
+
+
+if __name__ == "__main__":
+    device = 'cuda'
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data_path', type=str,
+                        default='data/horse.jpg')
+    parser.add_argument('--save_dir', type=str, default='latents')
+    parser.add_argument('--sd_version', type=str, default='2.1', choices=['1.5', '2.0', '2.1'],
+                        help="stable diffusion version")
+    parser.add_argument('--seed', type=int, default=1)
+    parser.add_argument('--steps', type=int, default=999)
+    parser.add_argument('--save-steps', type=int, default=1000)
+    parser.add_argument('--inversion_prompt', type=str, default='')
+    parser.add_argument('--extract-reverse', default=False, action='store_true', help="extract features during the denoising process")
+    opt = parser.parse_args()
+    run(opt)

CCEdit-main/src/pnp-diffusers/requirements.txt

@@ -0,0 +1,7 @@
+torch==2.0.1
+torchvision==0.15.2
+numpy==1.25.0
+diffusers==0.17.1
+xformers==0.0.20
+transformers==4.30.2
+accelerate==0.20.3

CCEdit-main/src/sdata/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 StabilityAI
+
+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.

CCEdit-main/src/sdata/examples/configs/example.yaml

@@ -0,0 +1,31 @@
+dataset:
+  urls:
+    # USER: adapt this path the root of your custom dataset
+    - "/path/to/data"
+  pipeline_config:
+    shardshuffle: 10000
+    sample_shuffle: 1000 # USER: you might wanna adapt depending on your available RAM
+
+  decoders:
+    - "pil"
+
+  postprocessors:
+    - target: sdata.mappers.TorchVisionImageTransforms
+      params:
+        key: 'jpg' # USER: you might wanna adapt this for your custom dataset
+        transforms:
+          - target: torchvision.transforms.Resize
+            params:
+              size: 256
+              interpolation: 3
+          - target: torchvision.transforms.ToTensor
+    - target: sdata.mappers.Rescaler
+
+    - target: sdata.mappers.AddOriginalImageSizeAsTupleAndCropToSquare
+      params:
+        h_key: height # USER: you might wanna adapt this for your custom dataset
+        w_key: width # USER: you might wanna adapt this for your custom dataset
+
+loader:
+  batch_size: 64
+  num_workers: 6

CCEdit-main/src/sdata/examples/image_simple.py

@@ -0,0 +1,37 @@
+import os
+from typing import List
+
+import torch
+from omegaconf import OmegaConf
+import numpy as np
+
+from sdata import create_dataset, create_loader
+
+num_it = 100
+max_vis = 3
+
+if __name__ == "__main__":
+    filedir = os.path.realpath(os.path.dirname(__file__))
+    config_path = os.path.join(filedir, "configs", "example.yaml")
+    config = OmegaConf.load(config_path)
+
+    # build config
+    datapipeline = create_dataset(**config.dataset)
+
+    # build loader
+    loader = create_loader(datapipeline, **config.loader)
+
+    print(f"Yielding {num_it} batches")
+
+    for i, batch in enumerate(loader):
+        if i >= num_it:
+            break
+
+        for key in batch:
+            if isinstance(batch[key], (torch.Tensor, np.ndarray)):
+                print(key, batch[key].shape)
+            elif isinstance(batch[key], (List)):
+                print(key)
+                print(batch[key][:max_vis])
+
+    print("ciao")

CCEdit-main/src/sdata/requirements_pt1.txt

@@ -0,0 +1,13 @@
+omegaconf
+einops
+fire
+tqdm
+webdataset>=0.2.33
+--extra-index-url https://download.pytorch.org/whl/cu117
+torch==1.13.1
+torchdata==0.5.1
+torchaudio==0.13.1
+torchvision==0.14.1+cu117
+torchmetrics
+opencv-python==4.6.0.66
+-e .

CCEdit-main/src/sdata/sdata.egg-info/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.2
+Name: sdata
+Version: 0.0.1
+License-File: LICENSE

CCEdit-main/src/sdata/sdata.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+setup.py
+sdata/__init__.py
+sdata/custom_datapipes.py
+sdata/datapipeline.py
+sdata/dataset.py
+sdata/dummy.py
+sdata.egg-info/PKG-INFO
+sdata.egg-info/SOURCES.txt
+sdata.egg-info/dependency_links.txt
+sdata.egg-info/top_level.txt
+sdata/filters/__init__.py
+sdata/filters/base.py
+sdata/filters/metadata_filters.py
+sdata/mappers/__init__.py
+sdata/mappers/base.py
+sdata/mappers/batched_mappers.py
+sdata/mappers/sample_mappers.py

CCEdit-main/src/sdata/sdata.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

CCEdit-main/src/sdata/sdata.egg-info/top_level.txt

@@ -0,0 +1 @@
+sdata

CCEdit-main/src/sdata/sdata/__init__.py

@@ -0,0 +1,14 @@
+from .dataset import create_dataset, create_loader
+from .datapipeline import warn_and_continue
+from . import mappers, filters
+from .dummy import create_dummy_dataset
+
+
+__all__ = [
+    "filters",
+    "mappers",
+    "create_loader",
+    "create_dataset",
+    "warn_and_continue",
+    "create_dummy_dataset",
+]

CCEdit-main/src/sdata/sdata/datapipeline.py

@@ -0,0 +1,536 @@
+import importlib
+import os
+from typing import Callable, Optional, Union, List, Any, Dict
+import re
+from packaging import version
+from operator import itemgetter
+import functools
+import time
+import warnings
+import threading
+
+
+from omegaconf import ListConfig, DictConfig
+import torchdata
+import torch.distributed as dist
+
+from torch.utils.data.datapipes.iter import IterableWrapper, FileOpener
+from torchdata.datapipes.iter import IterKeyZipper
+import webdataset as wds
+
+from .custom_datapipes import (
+    CustomShardExpanderIterDataPipe,
+    SplitByWorker,
+    PrefixResampler,
+    TarArchiveLoaderAndCloser,
+    SeedSetter,
+    Dataset2SamplesConverter,
+    _is_stream_handle,
+)
+
+class TimeoutError(Exception):
+    pass
+
+
+def timeout_wrapper(func):
+    def wrapper(*args, **kwargs):
+        if (
+            "SDATA_MAX_EXC_TIME" not in os.environ
+            or not os.environ["SDATA_MAX_EXC_TIME"]
+        ):
+            res = func(*args, **kwargs)
+            del args
+            del kwargs
+            return res
+
+        timeout = float(os.environ["SDATA_MAX_EXC_TIME"])
+
+        result = [None]
+        exception = [None]
+        event = threading.Event()
+
+        def wrapped_func():
+            try:
+                result[0] = func(*args, **kwargs)
+            except Exception as e:
+                exception[0] = e
+            finally:
+                event.set()
+
+        thread = threading.Thread(target=wrapped_func)
+        thread.start()
+        event.wait(timeout)
+
+        if not event.is_set():
+            raise TimeoutError(
+                f"Function call timed out (longer than {timeout  } secs)."
+            )
+
+        thread.join()
+
+        if exception[0] is not None:
+            raise exception[0]
+
+        del thread
+        del exception
+        del wrapped_func
+        del event
+        del args
+        del kwargs
+
+        return result[0]
+
+    return wrapper
+
+
+def warn_and_continue(exn):
+    """Call in an exception handler to ignore any exception, isssue a warning, and continue."""
+    print(exn)
+    warnings.warn(repr(exn))
+    time.sleep(0.05)
+    return True
+
+
+def time_measure(name: str = "function"):
+    def wrapper(fn):
+        def measure_time(*args, **kwargs):
+            start = time.perf_counter()
+            r = fn(*args, **kwargs)
+            end = time.perf_counter()
+            if "SDATA_PROFILE" in os.environ and os.environ["SDATA_PROFILE"]:
+                if r is None:
+                    return r
+                try:
+                    if isinstance(r, Dict):
+                        r[f"{name}-time"] = end - start
+                    else:
+                        args[1][f"{name}-time"] = end - start
+
+                except Exception as e:
+                    print(f"Exception raised when measuring time for {name}")
+                    raise e
+
+            del args
+            del kwargs
+
+            return r
+
+        return measure_time
+
+    return wrapper
+
+
+def instantiate(config: Union[Dict, DictConfig]) -> Any:
+    if not "target" in config:
+        if config == "__is_first_stage__":
+            return None
+        elif config == "__is_unconditional__":
+            return None
+        raise KeyError("Expected key `target` to instantiate.")
+    return create_obj(config["target"])(**config.get("params", dict()))
+
+
+def make_callable(config):
+    return functools.partial(
+        create_obj(config["target"]), **config.get("params", dict())
+    )
+
+
+def create_obj(string: str, reload: bool = False, invalidate_cache: bool = True) -> Any:
+    module, cls = string.rsplit(".", 1)
+    if invalidate_cache:
+        importlib.invalidate_caches()
+    if reload:
+        module_imp = importlib.import_module(module)
+        importlib.reload(module_imp)
+    return getattr(importlib.import_module(module, package=None), cls)
+
+
+class KeyPassThroughDecoder(wds.Decoder):
+    def __init__(self, *args, passthrough_keys=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.passthrough_keys = passthrough_keys
+        if self.passthrough_keys is None:
+            self.passthrough_keys = []
+
+    def decode1(self, key, data):
+        # if data is a stream handle, we need to read all the content before decoding
+        if _is_stream_handle(data):
+            ds = data
+            # The behavior of .read can differ between streams (e.g. HTTPResponse), hence this is used instead
+            data = b"".join(data)
+            ds.close()
+
+        key = "." + key
+        for f in self.handlers:
+            result = f(key, data)
+            if isinstance(result, wds.autodecode.Continue):
+                key, data = result.key, result.data
+                continue
+            if result is not None:
+                del data
+                return result
+        return data
+
+    @timeout_wrapper
+    @time_measure(name="KeyPassThroughDecoder")
+    def decode(self, sample):
+        """Decode an entire sample.
+
+        :param sample: the sample, a dictionary of key value pairs
+        """
+        result = {}
+        assert isinstance(sample, dict), sample
+        for k, v in list(sample.items()):
+            if k[0] == "_":
+                if isinstance(v, bytes):
+                    v = v.decode("utf-8")
+                result[k] = v
+                continue
+            if self.only is not None and k not in self.only:
+                result[k] = v
+                continue
+            assert v is not None
+            if self.partial:
+                if isinstance(v, bytes) or k in self.passthrough_keys:
+                    result[k] = self.decode1(k, v)
+                else:
+                    result[k] = v
+            else:
+                assert (
+                    isinstance(v, bytes) or k in self.passthrough_keys
+                ), f"key: {k}; passthrough_keys: {self.passthrough_keys}"
+                result[k] = self.decode1(k, v)
+        return result
+
+
+def tarfilter(x):
+    ret = x.endswith(".tar")
+    del x
+    return ret
+
+
+def grouper(x):
+    key = x[0].split("/")[-1].split(".")[0]
+    del x
+    return key
+
+
+def tuple_grouper(x):
+    key = x[0][0].split("/")[-1].split(".")[0]
+    del x
+    return key
+
+
+def merge_samples(s1, s2, meta_urls):
+    s1_files = [os.path.splitext(s[0])[1] for s in s1]
+    meta_key_list = [mk for mk in meta_urls if mk in s2[0][0]]
+    if len(meta_key_list) == 0:
+        raise ValueError(
+            f"no matching meta key found for the following file(s): {os.path.splitext(s2[0][0])[0]}"
+        )
+    elif len(meta_key_list) > 1:
+        raise ValueError(
+            f"More than one matching meta key found for the following file(s): {os.path.splitext(s2[0][0])[0]}"
+        )
+
+    meta_key = meta_key_list[0]
+    outs2 = [
+        s
+        if os.path.splitext(s[0])[1] not in s1_files
+        else (os.path.splitext(s[0])[0] + meta_key + os.path.splitext(s[0])[1], s[1])
+        for s in s2
+    ]
+    del s2
+    return list(s1) + outs2
+
+
+def merge_them(u1, u2):
+    # concat lists: these lists should contain all tarfiles from the same prefix but
+    # with different filenames
+    return u1[1] + [
+        u2,
+    ]
+
+
+def identity(x):
+    return True
+
+
+def map_to_tuple(x):
+    return (
+        os.path.join(os.path.split(x)[0], os.path.splitext(os.path.split(x)[1])[0]),
+        [
+            x,
+        ],
+    )
+
+
+def filter_with_meta_set(x, meta_set):
+    return itemgetter(0)(x) in meta_set
+
+
+def get_ref_key(x, suffix):
+    return os.path.splitext(x.replace("_" + suffix, ""))[0]
+
+
+def list_files_in_datapipe(
+    urls: Union[List, ListConfig],
+    is_braceexpand: bool,
+    tar_sampler: Callable = identity,
+) -> torchdata.datapipes.iter.IterDataPipe:
+    """
+
+    :param datapipe:
+    :param is_braceexpand:
+    :return:
+    """
+    datapipe = IterableWrapper(urls)
+
+    if version.parse(torchdata.__version__) >= version.parse("0.6.0"):
+        if is_braceexpand:
+            datapipe = CustomShardExpanderIterDataPipe(datapipe)
+        else:
+            datapipe = datapipe.list_files(recursive=True).filter(tarfilter)
+    else:
+        if is_braceexpand:
+            datapipe = CustomShardExpanderIterDataPipe(datapipe)
+        else:
+            datapipe = datapipe.list_files(recursive=True).filter(tarfilter)
+
+    datapipe = datapipe.filter(tar_sampler)
+
+    return datapipe
+
+
+class StableDataPipeline(wds.DataPipeline, wds.compat.FluidInterface):
+    """
+    Central class for reading data from tars on local fs and building samples based on consecutive files with the same keys
+    """
+
+    def __init__(
+        self,
+        urls: Union[List[str], str, ListConfig],
+        meta_urls: Optional[Union[List[str], str]] = None,
+        metadata_buffer_size: Union[int, None] = 10000,
+        repeat: int = None,
+        shardshuffle: int = 10000,
+        sample_shuffle: int = 1,
+        resample_prefixes: bool = False,
+        prefix_probs: Optional[List[float]] = None,
+        split_data_by_worker: bool = True,
+        tar_sampler: Optional[Union[DictConfig, Dict, Callable]] = identity,
+        handler: Union[Callable, DictConfig] = wds.reraise_exception,
+        debug: bool = False,
+        n_shards: int = 100000,
+    ):
+        """
+
+        :param urls: folders to load the shards from, can be a list of different prefoxes for dataset mixing
+        :param meta_urls: can be used for aligned metadata files stored as tars
+        :param metadata_buffer_size:
+        :param repeat: number of repetitions in the training data. Default is None which means looping perpetually.
+        :param shardshuffle: Shuffle buffer size for shard shuffling. size 1 means no shufflin. Default is 10k.
+        :param sample_shuffle: Shuffle buffer for sample-level-shuffling. Default is 1 which means no shuffling
+        :param resample_prefixes: Whether to resample when different prefixes are in the entire dataset.
+         This can be useful in combination with prefix probs when training on merged datasets of non-equal size.
+        :param prefix_probs: list containing resampling probabilities for every prefix in `urls`
+        :param split_data_by_worker: Whether to split shards across worker threads for num_workers > 0
+        :param handler: handler for handling exceptions as in webdataset
+        """
+        super().__init__()
+
+        if isinstance(urls, (List, ListConfig, list)):
+            pass
+        elif isinstance(urls, str):
+            urls = [urls]
+        else:
+            raise TypeError(
+                "urls need to be path to a S3 prefix or list of paths to more than one prefixes"
+            )
+
+        if isinstance(handler, (DictConfig, Dict)):
+            handler = make_callable(handler)
+
+
+        # get some information abt fs where shards live in and the way shards are specified
+        is_braceexpand = any(["{" in u for u in urls])
+
+        if is_braceexpand:
+            brace_expansion = re.compile(r"\{[0-9]+\.\.[0-9]+\}")
+            assert all(len(re.findall(brace_expansion, u)) == 1 for u in urls), (
+                "Specifiying tars in listed prefixes should be consistent. "
+                "It should be either braceexpand notation or just using some "
+                "base prefix. If this still fails, you might have some urls with "
+                "multiple or malformed braceexpands."
+            )
+
+        if isinstance(tar_sampler, (Dict, dict, DictConfig)):
+            tar_sampler = instantiate(tar_sampler)
+
+        main_datapipe = list_files_in_datapipe(
+            urls,
+            is_braceexpand=is_braceexpand,
+            tar_sampler=tar_sampler,
+        ).map(fn=map_to_tuple)
+
+        if meta_urls:
+            print(
+                f"Zipping together {len(meta_urls)} meta datapipes with the following suffixes {meta_urls} "
+                f"and adding this to the main datapipes "
+            )
+
+            if isinstance(meta_urls, str):
+                meta_urls = [meta_urls]
+
+            meta_urls_base = [os.path.split(m) for m in urls]
+            # meta_urls = [[os.path.join(m[0], os.path.splitext(m[1])[0]+f"_{suffix}"+os.path.splitext(m[1])[1]) for m in meta_urls_base] for suffix in meta_urls]
+            meta_files = [
+                [os.path.join(m[0] + f"_{suffix}", m[1]) for m in meta_urls_base]
+                for suffix in meta_urls
+            ]
+
+            for suffix, meta_url_collection in zip(meta_urls, meta_files):
+                # this is the meta data which will be added to the man data
+                meta_datapipe = list_files_in_datapipe(
+                    meta_url_collection,
+                    is_braceexpand=is_braceexpand,
+                    tar_sampler=tar_sampler,
+                )
+                # filter out non-exisiting shards
+                meta_set = set([get_ref_key(pth, suffix) for pth in meta_datapipe])
+                main_datapipe = main_datapipe.filter(
+                    functools.partial(filter_with_meta_set, meta_set=meta_set)
+                )
+
+                # cycle in side branch to avoid exhausting after iterating over the entire dataset
+                meta_datapipe = meta_datapipe.cycle()
+                # merging always based on filenames where the metadata shards are expected to have <main_shard_id>.tar,
+                # e.g. for a main shard "0000.tar" and an optical flow metadatashard we'd have "0000.tar" for the metadata shard
+                # and the resulting key would be /path/to/prefix/0000
+                main_datapipe = IterKeyZipper(
+                    main_datapipe,
+                    ref_datapipe=meta_datapipe,
+                    key_fn=itemgetter(0),
+                    ref_key_fn=functools.partial(get_ref_key, suffix=suffix),
+                    keep_key=True,
+                    merge_fn=merge_them,
+                    buffer_size=metadata_buffer_size,
+                )
+        # main_datapipe = main_datapipe
+
+        # start shuffling accross shards for the first time to mix different datasets
+        # (can be the same for all workers, just as an additional shuffled initialization)
+        if shardshuffle > 1 and not resample_prefixes and len(urls) > 1:
+            # back to datapipes. We further apply a map to remove the key, so that the result is the sames than
+            # for the prefix subsampler
+            main_datapipe = main_datapipe.shuffle(buffer_size=n_shards).map(
+                fn=itemgetter(1)
+            )
+        elif resample_prefixes:
+            main_datapipe = PrefixResampler(
+                main_datapipe.shuffle(buffer_size=n_shards),
+                ps=prefix_probs,
+                prefixes=urls,
+                is_braceexpand=is_braceexpand,
+                custom_seeding=split_data_by_worker,
+                debug=debug
+            )
+        else:
+            main_datapipe = main_datapipe.map(itemgetter(1))
+
+        if not resample_prefixes:
+            shardshuffle = max(shardshuffle, 1)
+            main_datapipe = main_datapipe.shuffle(buffer_size=shardshuffle)
+
+        main_datapipe = main_datapipe.sharding_filter()
+
+        # after this operation datapipes in the distinct processes contain different tars
+        if dist.is_available() and dist.is_initialized():
+            # after this operation datapipes in the distinct processes contain different tars
+
+            global_rank = dist.get_rank()
+            world_size = dist.get_world_size()
+            main_datapipe.apply_sharding(world_size, global_rank)
+            print("#" * 100)
+            print(f"distributing shards for worker with global rank {global_rank}")
+            print("#" * 100)
+
+        else:
+            print(
+                f"torch distributed not used, not applying sharding in {self.__class__.__name__}"
+            )
+
+        if split_data_by_worker:
+            print("Distributing shards across the worker threads in every process")
+            main_datapipe = SplitByWorker(
+                datapipe=main_datapipe, debug=debug
+            )
+        else:
+            main_datapipe = SeedSetter(main_datapipe, debug=debug)
+
+        main_datapipe = main_datapipe.cycle(count=repeat)
+
+        # unzip before loading, since here we can be sure that all shards are distributed and shuffled
+        # aligned with their corresponding metadata shards
+        meta_len = len(meta_urls) if meta_urls else 0
+        main_datapipe, *meta_datapipes = main_datapipe.unzip(
+            sequence_length=meta_len + 1
+        )
+
+
+        # regular fileopener
+        main_datapipe = FileOpener(main_datapipe, mode="b")
+        meta_datapipes = [FileOpener(m, mode="b") for m in meta_datapipes]
+
+        # adapted TarLoader which closes open tarfile handles after exceeding them
+        # main_datapipe = TarArchiveLoaderAndCloser(datapipe=main_datapipe).groupby(grouper)
+        #
+        main_datapipe = TarArchiveLoaderAndCloser(
+            datapipe=main_datapipe, handler=handler
+        ).groupby(grouper)
+        meta_datapipes = [
+            TarArchiveLoaderAndCloser(datapipe=m, handler=handler).groupby(grouper)
+            for m in meta_datapipes
+        ]
+
+        # zip again, this time we're searching based on the same keys
+        for meta_dp in meta_datapipes:
+            # here we da
+            main_datapipe = IterKeyZipper(
+                main_datapipe,
+                ref_datapipe=meta_dp,
+                key_fn=tuple_grouper,
+                merge_fn=functools.partial(merge_samples, meta_urls=meta_urls),
+                buffer_size=metadata_buffer_size,
+            )
+
+        if sample_shuffle > 0:
+            main_datapipe = main_datapipe.shuffle(buffer_size=sample_shuffle)
+
+        main_datapipe = Dataset2SamplesConverter(main_datapipe, handler=handler)
+        self.append(main_datapipe)
+        # self.append(dataset2samples(handler=handler))
+
+    def decode(
+        self,
+        *args,
+        pre=None,
+        post=None,
+        only=None,
+        partial=False,
+        passthrough_keys=None,
+        handler=wds.reraise_exception,
+    ):
+        handlers = [
+            wds.autodecode.ImageHandler(x) if isinstance(x, str) else x for x in args
+        ]
+        decoder = KeyPassThroughDecoder(
+            handlers,
+            passthrough_keys=passthrough_keys,
+            pre=pre,
+            post=post,
+            only=only,
+            partial=partial,
+        )
+        return self.map(decoder, handler=handler)

CCEdit-main/src/sdata/sdata/filters/__init__.py

@@ -0,0 +1,12 @@
+from .base import AbstractFilter, LambdaFilter
+from .metadata_filters import (
+    SimpleSizeFilter,
+    SimpleKeyFilter,
+)
+
+__all__ = [
+    "AbstractFilter",
+    "SimpleSizeFilter",
+    "SimpleKeyFilter",
+    "LambdaFilter"
+]

CCEdit-main/src/sdata/sdata/filters/base.py

@@ -0,0 +1,64 @@
+from abc import abstractmethod
+from typing import Dict, Union, List, Optional, Callable
+
+from omegaconf import ListConfig, DictConfig
+
+from ..datapipeline import time_measure, make_callable
+
+
+class AbstractFilter:
+    def __init__(
+        self,
+        exclude_keys: Optional[Union[List[str], ListConfig, str]] = None,
+        verbose: bool = False,
+    ):
+        if not exclude_keys:
+            exclude_keys = []
+
+        if isinstance(exclude_keys, str):
+            exclude_keys = [exclude_keys]
+        self.exclude_keys = exclude_keys
+
+        self.verbose = verbose
+
+    def skip_this_sample(self, sample: Dict) -> bool:
+        res = any(map(lambda x: x in sample["__url__"], self.exclude_keys))
+        del sample
+        return res
+
+    @abstractmethod
+    def __call__(self, sample: Dict) -> bool:
+        raise NotImplementedError("AbstractFilter should not be called but overwritten")
+
+
+class LambdaFilter(AbstractFilter):
+    def __init__(
+        self,
+        keys: Union[str, List[str], ListConfig],
+        fn: Union[Dict, DictConfig, Callable],
+        *args,
+        **kwargs
+    ):
+        super().__init__(*args, **kwargs)
+        if isinstance(keys, str):
+            keys = [keys]
+
+        self.keys = keys
+
+        if isinstance(fn, Union[Dict, DictConfig]):
+            fn = make_callable(fn)
+
+        self.fn = fn
+
+    @time_measure("LambdaMapper")
+    def __call__(self, sample: Dict) -> bool:
+        if self.skip_this_sample(sample):
+            del sample
+            return True
+
+        let_pass = True
+        for key in self.keys:
+            let_pass &= self.fn(sample[key])
+
+        del sample
+        return let_pass

CCEdit-main/src/sdata/sdata/filters/metadata_filters.py

@@ -0,0 +1,104 @@
+from typing import Dict, Optional, List, Union, Tuple
+
+from omegaconf import DictConfig
+
+from .base import AbstractFilter
+from sdata.datapipeline import time_measure, timeout_wrapper
+
+
+class SimpleKeyFilter(AbstractFilter):
+    def __init__(self, keys: Union[str, List[str]], *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if isinstance(keys, str):
+            keys = [keys]
+
+        self.keys = set(keys)
+
+    @timeout_wrapper
+    @time_measure("SimpleKeyFilter")
+    def __call__(self, sample: Dict) -> bool:
+        try:
+            if self.skip_this_sample(sample):
+                return True
+            result = all(map(lambda x: x in sample, self.keys))
+            del sample
+            return result
+        except Exception as e:
+            print(f"{e.__class__.__name__} in {self.__class__.__name__}: {e}")
+            return False
+
+
+class SimpleSizeFilter(AbstractFilter):
+    def __init__(
+        self,
+        size: Union[int, Tuple[int, int], List[int]],
+        mode: str = "min",
+        strict: Optional[Union[bool, Dict]] = None,
+        width_key: str = "original_width",
+        height_key: str = "original_height",
+        *args,
+        **kwargs,
+    ):
+        """
+        Simple size filter based on metadata which is already decoded
+        :param size: The desired min or max size
+        :param mode: either to filter out all above a min size (min) or all below a max size (max)
+        :param key: indicates the field in the sample, the field should be a dict
+        :param subkeys: list of strings defining subkeys for nested dict, i.e. ['foo','bar'] would result
+        in sample[self.key]['foo']['bar'] being the entry in a nested dict, where the size information sits
+        :param strict: whether to return True or False when the key is not present
+        :param width_key: the width key at the final level in the metadata dict i.e. for key='json',
+        subkeys=['foo','bar'] and width_key = 'original_width', the entry sample['json']['foo']['bar']['original_width']
+        would be used
+        :param height_key: same as above but with width
+        """
+        super().__init__(*args, **kwargs)
+        if isinstance(size, int):
+            size = [size, size]
+
+        self.size = size
+
+        if mode == "min":
+            self.relation = self.filter_min
+        else:
+            self.relation = self.filter_max
+
+        self.strict = strict
+        if not isinstance(self.strict, (bool, dict, DictConfig)):
+            raise TypeError(
+                f"strict in {self.__class__.__name__} should be bool or Dict"
+            )
+
+        self.height_key = height_key
+        self.width_key = width_key
+
+    def filter_min(self, height: int, width: int) -> bool:
+        return height >= self.size[0] and width >= self.size[1]
+
+    def filter_max(self, height: int, width: int) -> bool:
+        return height <= self.size[0] and width <= self.size[1]
+
+    @timeout_wrapper
+    @time_measure("SimpleSizeFilter")
+    def __call__(self, sample: Dict) -> bool:
+        try:
+            if self.skip_this_sample(sample):
+                return True
+            # get height and width
+            original_width = sample[self.width_key]
+            original_height = sample[self.height_key]
+
+            result = self.relation(original_height, original_width)
+            return result
+        except Exception as e:
+            if isinstance(self.strict, bool):
+                return not self.strict
+            elif isinstance(self.strict, (dict, DictConfig)):
+                url = sample["__url__"]
+                key = [k for k in self.strict if k in url][0]
+                result = not self.strict[key]
+                return result
+            else:
+                raise TypeError(
+                    f"strict in {self.__class__.__name__} should be bool or Dict"
+                )

CCEdit-main/src/sdata/sdata/mappers/__init__.py

@@ -0,0 +1,15 @@
+from .base import AbstractMapper
+from .batched_mappers import BatchedEinopsTransform
+from .sample_mappers import (
+    TorchVisionImageTransforms,
+    Rescaler,
+    AddOriginalImageSizeAsTupleAndCropToSquare,
+)
+
+__all__ = [
+    "AbstractMapper",
+    "AddOriginalImageSizeAsTupleAndCropToSquare",
+    "BatchedEinopsTransform",
+    "TorchVisionImageTransforms",
+    "Rescaler",
+]