diff --git a/CLIP/.github/workflows/test.yml b/CLIP/.github/workflows/test.yml new file mode 100644 index 0000000000000000000000000000000000000000..570a54198bb0d012a585c3999d5281c07cd339e9 --- /dev/null +++ b/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 diff --git a/CLIP/.gitignore b/CLIP/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..321f181f917b03529a05fc27aee81a0bd6fba32d --- /dev/null +++ b/CLIP/.gitignore @@ -0,0 +1,10 @@ +__pycache__/ +*.py[cod] +*$py.class +*.egg-info +.pytest_cache +.ipynb_checkpoints + +thumbs.db +.DS_Store +.idea diff --git a/CLIP/CLIP.png b/CLIP/CLIP.png new file mode 100644 index 0000000000000000000000000000000000000000..a1b5ec9171fd7a51e36e845a02304eb837142ba1 Binary files /dev/null and b/CLIP/CLIP.png differ diff --git a/CLIP/LICENSE b/CLIP/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..4e97f0b45803b7c04ae89548934af4f257a97501 --- /dev/null +++ b/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. + diff --git a/CLIP/MANIFEST.in b/CLIP/MANIFEST.in new file mode 100644 index 0000000000000000000000000000000000000000..effd8d995ff1842a48c69d2a0f7c8dce4423d7a2 --- /dev/null +++ b/CLIP/MANIFEST.in @@ -0,0 +1 @@ +include clip/bpe_simple_vocab_16e6.txt.gz diff --git a/CLIP/README.md b/CLIP/README.md new file mode 100644 index 0000000000000000000000000000000000000000..db56b56e29258cc871fe0e6297bde00436d9180b --- /dev/null +++ b/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 diff --git a/CLIP/clip/__init__.py b/CLIP/clip/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dcc5619538c0f7c782508bdbd9587259d805e0d9 --- /dev/null +++ b/CLIP/clip/__init__.py @@ -0,0 +1 @@ +from .clip import * diff --git a/CLIP/clip/bpe_simple_vocab_16e6.txt.gz b/CLIP/clip/bpe_simple_vocab_16e6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..36a15856e00a06a9fbed8cdd34d2393fea4a3113 --- /dev/null +++ b/CLIP/clip/bpe_simple_vocab_16e6.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:924691ac288e54409236115652ad4aa250f48203de50a9e4722a6ecd48d6804a +size 1356917 diff --git a/CLIP/clip/clip.py b/CLIP/clip/clip.py new file mode 100644 index 0000000000000000000000000000000000000000..f7a5da5e69e0a3b41383734711ccfff1923a9ef9 --- /dev/null +++ b/CLIP/clip/clip.py @@ -0,0 +1,245 @@ +import hashlib +import os +import urllib +import warnings +from typing import Any, Union, List +from pkg_resources import packaging + +import torch +from PIL import Image +from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize +from tqdm import tqdm + +from .model import build_model +from .simple_tokenizer import SimpleTokenizer as _Tokenizer + +try: + from torchvision.transforms import InterpolationMode + BICUBIC = InterpolationMode.BICUBIC +except ImportError: + BICUBIC = Image.BICUBIC + + +if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"): + warnings.warn("PyTorch version 1.7.1 or higher is recommended") + + +__all__ = ["available_models", "load", "tokenize"] +_tokenizer = _Tokenizer() + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", + "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt", + "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt", +} + + +def _download(url: str, root: str): + os.makedirs(root, exist_ok=True) + filename = os.path.basename(url) + + expected_sha256 = url.split("/")[-2] + download_target = os.path.join(root, filename) + + if os.path.exists(download_target) and not os.path.isfile(download_target): + raise RuntimeError(f"{download_target} exists and is not a regular file") + + if os.path.isfile(download_target): + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256: + return download_target + else: + warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file") + + with urllib.request.urlopen(url) as source, open(download_target, "wb") as output: + with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True, unit_divisor=1024) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256: + raise RuntimeError("Model has been downloaded but the SHA256 checksum does not not match") + + return download_target + + +def _convert_image_to_rgb(image): + return image.convert("RGB") + + +def _transform(n_px): + return Compose([ + Resize(n_px, interpolation=BICUBIC), + CenterCrop(n_px), + _convert_image_to_rgb, + ToTensor(), + Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) + + +def available_models() -> List[str]: + """Returns the names of available CLIP models""" + return list(_MODELS.keys()) + + +def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", jit: bool = False, download_root: str = None): + """Load a CLIP model + + Parameters + ---------- + name : str + A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict + + 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 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 + """ + if name in _MODELS: + model_path = _download(_MODELS[name], download_root or os.path.expanduser("~/.cache/clip")) + elif os.path.isfile(name): + model_path = name + else: + raise RuntimeError(f"Model {name} not found; available models = {available_models()}") + + with open(model_path, 'rb') as opened_file: + try: + # loading JIT archive + model = torch.jit.load(opened_file, map_location=device if jit else "cpu").eval() + state_dict = None + except RuntimeError: + # loading saved state dict + if jit: + warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead") + jit = False + state_dict = torch.load(opened_file, map_location="cpu") + + if not jit: + model = build_model(state_dict or model.state_dict()).to(device) + if str(device) == "cpu": + model.float() + return model, _transform(model.visual.input_resolution) + + # patch the device names + device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[]) + device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1] + + def _node_get(node: torch._C.Node, key: str): + """Gets attributes of a node which is polymorphic over return type. + + From https://github.com/pytorch/pytorch/pull/82628 + """ + sel = node.kindOf(key) + return getattr(node, sel)(key) + + def patch_device(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("prim::Constant"): + if "value" in node.attributeNames() and str(_node_get(node, "value")).startswith("cuda"): + node.copyAttributes(device_node) + + model.apply(patch_device) + patch_device(model.encode_image) + patch_device(model.encode_text) + + # patch dtype to float32 on CPU + if str(device) == "cpu": + float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[]) + float_input = list(float_holder.graph.findNode("aten::to").inputs())[1] + float_node = float_input.node() + + def patch_float(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("aten::to"): + inputs = list(node.inputs()) + for i in [1, 2]: # dtype can be the second or third argument to aten::to() + if _node_get(inputs[i].node(), "value") == 5: + inputs[i].node().copyAttributes(float_node) + + model.apply(patch_float) + patch_float(model.encode_image) + patch_float(model.encode_text) + + model.float() + + return model, _transform(model.input_resolution.item()) + + +def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> Union[torch.IntTensor, torch.LongTensor]: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + + context_length : int + The context length to use; all CLIP models use 77 as the context length + + truncate: bool + Whether to truncate the text in case its encoding is longer than the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length]. + We return LongTensor when torch version is <1.8.0, since older index_select requires indices to be long. + """ + if isinstance(texts, str): + texts = [texts] + + sot_token = _tokenizer.encoder["<|startoftext|>"] + eot_token = _tokenizer.encoder["<|endoftext|>"] + all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts] + if packaging.version.parse(torch.__version__) < packaging.version.parse("1.8.0"): + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + else: + result = torch.zeros(len(all_tokens), context_length, dtype=torch.int) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + if truncate: + tokens = tokens[:context_length] + tokens[-1] = eot_token + else: + raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}") + result[i, :len(tokens)] = torch.tensor(tokens) + + return result diff --git a/CLIP/clip/model.py b/CLIP/clip/model.py new file mode 100644 index 0000000000000000000000000000000000000000..232b7792eb97440642547bd462cf128df9243933 --- /dev/null +++ b/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() diff --git a/CLIP/clip/simple_tokenizer.py b/CLIP/clip/simple_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..0a66286b7d5019c6e221932a813768038f839c91 --- /dev/null +++ b/CLIP/clip/simple_tokenizer.py @@ -0,0 +1,132 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + vocab.extend(['<|startoftext|>', '<|endoftext|>']) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'} + self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '',) + pairs = get_pairs(word) + + if not pairs: + return token+'' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('', ' ') + return text diff --git a/CLIP/data/country211.md b/CLIP/data/country211.md new file mode 100644 index 0000000000000000000000000000000000000000..4cd096005c8e5777e0706d97d182c3bd87b651a9 --- /dev/null +++ b/CLIP/data/country211.md @@ -0,0 +1,12 @@ +# The Country211 Dataset + +In the paper, we used an image classification dataset called Country211, to evaluate the model's capability on geolocation. To do so, we filtered the YFCC100m dataset that have GPS coordinate corresponding to a [ISO-3166 country code](https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes) and created a balanced dataset by sampling 150 train images, 50 validation images, and 100 test images images for each country. + +The following command will download an 11GB archive countaining the images and extract into a subdirectory `country211`: + +```bash +wget https://openaipublic.azureedge.net/clip/data/country211.tgz +tar zxvf country211.tgz +``` + +These images are a subset of the YFCC100m dataset. 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/). \ No newline at end of file diff --git a/CLIP/data/prompts.md b/CLIP/data/prompts.md new file mode 100644 index 0000000000000000000000000000000000000000..6d8aaf7b13f04031e7ea00d58a1c131b98bdfe20 --- /dev/null +++ b/CLIP/data/prompts.md @@ -0,0 +1,3401 @@ +# Prompts for Image Classification + +Below are the class names and templates that are used for collecting the zero-shot classification scores in the paper. Each dataset has two lists `classes` and `templates`, where the string `{}` in the template is to be replaced with the corresponding class names. For the Facial Emotion Recognition 2013 dataset specifically, we used multiple class names for certain classes. + +This file contains prompt data for 26 of the 27 datasets shown in Table 9 of the paper; the text prompts for ImageNet (as well as other [ImageNet Testbed](https://modestyachts.github.io/imagenet-testbed/) datasets in Figure 13) can be found in [this notebook](https://github.com/openai/CLIP/blob/main/notebooks/Prompt_Engineering_for_ImageNet.ipynb), as well as how to ensemble predictions from multiple prompts using these templates. + +If you are viewing this document on GitHub, use the table of contents icon at the upper left to browse the datasets. + + +## Birdsnap + +```bash +classes = [ + 'Acadian Flycatcher', + 'Acorn Woodpecker', + 'Alder Flycatcher', + 'Allens Hummingbird', + 'Altamira Oriole', + 'American Avocet', + 'American Bittern', + 'American Black Duck', + 'American Coot', + 'American Crow', + 'American Dipper', + 'American Golden Plover', + 'American Goldfinch', + 'American Kestrel', + 'American Oystercatcher', + 'American Pipit', + 'American Redstart', + 'American Robin', + 'American Three toed Woodpecker', + 'American Tree Sparrow', + 'American White Pelican', + 'American Wigeon', + 'American Woodcock', + 'Anhinga', + 'Annas Hummingbird', + 'Arctic Tern', + 'Ash throated Flycatcher', + 'Audubons Oriole', + 'Bairds Sandpiper', + 'Bald Eagle', + 'Baltimore Oriole', + 'Band tailed Pigeon', + 'Barn Swallow', + 'Barred Owl', + 'Barrows Goldeneye', + 'Bay breasted Warbler', + 'Bells Vireo', + 'Belted Kingfisher', + 'Bewicks Wren', + 'Black Guillemot', + 'Black Oystercatcher', + 'Black Phoebe', + 'Black Rosy Finch', + 'Black Scoter', + 'Black Skimmer', + 'Black Tern', + 'Black Turnstone', + 'Black Vulture', + 'Black and white Warbler', + 'Black backed Woodpecker', + 'Black bellied Plover', + 'Black billed Cuckoo', + 'Black billed Magpie', + 'Black capped Chickadee', + 'Black chinned Hummingbird', + 'Black chinned Sparrow', + 'Black crested Titmouse', + 'Black crowned Night Heron', + 'Black headed Grosbeak', + 'Black legged Kittiwake', + 'Black necked Stilt', + 'Black throated Blue Warbler', + 'Black throated Gray Warbler', + 'Black throated Green Warbler', + 'Black throated Sparrow', + 'Blackburnian Warbler', + 'Blackpoll Warbler', + 'Blue Grosbeak', + 'Blue Jay', + 'Blue gray Gnatcatcher', + 'Blue headed Vireo', + 'Blue winged Teal', + 'Blue winged Warbler', + 'Boat tailed Grackle', + 'Bobolink', + 'Bohemian Waxwing', + 'Bonapartes Gull', + 'Boreal Chickadee', + 'Brandts Cormorant', + 'Brant', + 'Brewers Blackbird', + 'Brewers Sparrow', + 'Bridled Titmouse', + 'Broad billed Hummingbird', + 'Broad tailed Hummingbird', + 'Broad winged Hawk', + 'Bronzed Cowbird', + 'Brown Creeper', + 'Brown Pelican', + 'Brown Thrasher', + 'Brown capped Rosy Finch', + 'Brown crested Flycatcher', + 'Brown headed Cowbird', + 'Brown headed Nuthatch', + 'Bufflehead', + 'Bullocks Oriole', + 'Burrowing Owl', + 'Bushtit', + 'Cackling Goose', + 'Cactus Wren', + 'California Gull', + 'California Quail', + 'California Thrasher', + 'California Towhee', + 'Calliope Hummingbird', + 'Canada Goose', + 'Canada Warbler', + 'Canvasback', + 'Canyon Towhee', + 'Canyon Wren', + 'Cape May Warbler', + 'Carolina Chickadee', + 'Carolina Wren', + 'Caspian Tern', + 'Cassins Finch', + 'Cassins Kingbird', + 'Cassins Sparrow', + 'Cassins Vireo', + 'Cattle Egret', + 'Cave Swallow', + 'Cedar Waxwing', + 'Cerulean Warbler', + 'Chestnut backed Chickadee', + 'Chestnut collared Longspur', + 'Chestnut sided Warbler', + 'Chihuahuan Raven', + 'Chimney Swift', + 'Chipping Sparrow', + 'Cinnamon Teal', + 'Clapper Rail', + 'Clarks Grebe', + 'Clarks Nutcracker', + 'Clay colored Sparrow', + 'Cliff Swallow', + 'Common Black Hawk', + 'Common Eider', + 'Common Gallinule', + 'Common Goldeneye', + 'Common Grackle', + 'Common Ground Dove', + 'Common Loon', + 'Common Merganser', + 'Common Murre', + 'Common Nighthawk', + 'Common Raven', + 'Common Redpoll', + 'Common Tern', + 'Common Yellowthroat', + 'Connecticut Warbler', + 'Coopers Hawk', + 'Cordilleran Flycatcher', + 'Costas Hummingbird', + 'Couchs Kingbird', + 'Crested Caracara', + 'Curve billed Thrasher', + 'Dark eyed Junco', + 'Dickcissel', + 'Double crested Cormorant', + 'Downy Woodpecker', + 'Dunlin', + 'Dusky Flycatcher', + 'Dusky Grouse', + 'Eared Grebe', + 'Eastern Bluebird', + 'Eastern Kingbird', + 'Eastern Meadowlark', + 'Eastern Phoebe', + 'Eastern Screech Owl', + 'Eastern Towhee', + 'Eastern Wood Pewee', + 'Elegant Trogon', + 'Elf Owl', + 'Eurasian Collared Dove', + 'Eurasian Wigeon', + 'European Starling', + 'Evening Grosbeak', + 'Ferruginous Hawk', + 'Ferruginous Pygmy Owl', + 'Field Sparrow', + 'Fish Crow', + 'Florida Scrub Jay', + 'Forsters Tern', + 'Fox Sparrow', + 'Franklins Gull', + 'Fulvous Whistling Duck', + 'Gadwall', + 'Gambels Quail', + 'Gila Woodpecker', + 'Glaucous Gull', + 'Glaucous winged Gull', + 'Glossy Ibis', + 'Golden Eagle', + 'Golden crowned Kinglet', + 'Golden crowned Sparrow', + 'Golden fronted Woodpecker', + 'Golden winged Warbler', + 'Grasshopper Sparrow', + 'Gray Catbird', + 'Gray Flycatcher', + 'Gray Jay', + 'Gray Kingbird', + 'Gray cheeked Thrush', + 'Gray crowned Rosy Finch', + 'Great Black backed Gull', + 'Great Blue Heron', + 'Great Cormorant', + 'Great Crested Flycatcher', + 'Great Egret', + 'Great Gray Owl', + 'Great Horned Owl', + 'Great Kiskadee', + 'Great tailed Grackle', + 'Greater Prairie Chicken', + 'Greater Roadrunner', + 'Greater Sage Grouse', + 'Greater Scaup', + 'Greater White fronted Goose', + 'Greater Yellowlegs', + 'Green Jay', + 'Green tailed Towhee', + 'Green winged Teal', + 'Groove billed Ani', + 'Gull billed Tern', + 'Hairy Woodpecker', + 'Hammonds Flycatcher', + 'Harlequin Duck', + 'Harriss Hawk', + 'Harriss Sparrow', + 'Heermanns Gull', + 'Henslows Sparrow', + 'Hepatic Tanager', + 'Hermit Thrush', + 'Herring Gull', + 'Hoary Redpoll', + 'Hooded Merganser', + 'Hooded Oriole', + 'Hooded Warbler', + 'Horned Grebe', + 'Horned Lark', + 'House Finch', + 'House Sparrow', + 'House Wren', + 'Huttons Vireo', + 'Iceland Gull', + 'Inca Dove', + 'Indigo Bunting', + 'Killdeer', + 'King Rail', + 'Ladder backed Woodpecker', + 'Lapland Longspur', + 'Lark Bunting', + 'Lark Sparrow', + 'Laughing Gull', + 'Lazuli Bunting', + 'Le Contes Sparrow', + 'Least Bittern', + 'Least Flycatcher', + 'Least Grebe', + 'Least Sandpiper', + 'Least Tern', + 'Lesser Goldfinch', + 'Lesser Nighthawk', + 'Lesser Scaup', + 'Lesser Yellowlegs', + 'Lewiss Woodpecker', + 'Limpkin', + 'Lincolns Sparrow', + 'Little Blue Heron', + 'Loggerhead Shrike', + 'Long billed Curlew', + 'Long billed Dowitcher', + 'Long billed Thrasher', + 'Long eared Owl', + 'Long tailed Duck', + 'Louisiana Waterthrush', + 'Magnificent Frigatebird', + 'Magnolia Warbler', + 'Mallard', + 'Marbled Godwit', + 'Marsh Wren', + 'Merlin', + 'Mew Gull', + 'Mexican Jay', + 'Mississippi Kite', + 'Monk Parakeet', + 'Mottled Duck', + 'Mountain Bluebird', + 'Mountain Chickadee', + 'Mountain Plover', + 'Mourning Dove', + 'Mourning Warbler', + 'Muscovy Duck', + 'Mute Swan', + 'Nashville Warbler', + 'Nelsons Sparrow', + 'Neotropic Cormorant', + 'Northern Bobwhite', + 'Northern Cardinal', + 'Northern Flicker', + 'Northern Gannet', + 'Northern Goshawk', + 'Northern Harrier', + 'Northern Hawk Owl', + 'Northern Mockingbird', + 'Northern Parula', + 'Northern Pintail', + 'Northern Rough winged Swallow', + 'Northern Saw whet Owl', + 'Northern Shrike', + 'Northern Waterthrush', + 'Nuttalls Woodpecker', + 'Oak Titmouse', + 'Olive Sparrow', + 'Olive sided Flycatcher', + 'Orange crowned Warbler', + 'Orchard Oriole', + 'Osprey', + 'Ovenbird', + 'Pacific Golden Plover', + 'Pacific Loon', + 'Pacific Wren', + 'Pacific slope Flycatcher', + 'Painted Bunting', + 'Painted Redstart', + 'Palm Warbler', + 'Pectoral Sandpiper', + 'Peregrine Falcon', + 'Phainopepla', + 'Philadelphia Vireo', + 'Pied billed Grebe', + 'Pigeon Guillemot', + 'Pileated Woodpecker', + 'Pine Grosbeak', + 'Pine Siskin', + 'Pine Warbler', + 'Piping Plover', + 'Plumbeous Vireo', + 'Prairie Falcon', + 'Prairie Warbler', + 'Prothonotary Warbler', + 'Purple Finch', + 'Purple Gallinule', + 'Purple Martin', + 'Purple Sandpiper', + 'Pygmy Nuthatch', + 'Pyrrhuloxia', + 'Red Crossbill', + 'Red Knot', + 'Red Phalarope', + 'Red bellied Woodpecker', + 'Red breasted Merganser', + 'Red breasted Nuthatch', + 'Red breasted Sapsucker', + 'Red cockaded Woodpecker', + 'Red eyed Vireo', + 'Red headed Woodpecker', + 'Red naped Sapsucker', + 'Red necked Grebe', + 'Red necked Phalarope', + 'Red shouldered Hawk', + 'Red tailed Hawk', + 'Red throated Loon', + 'Red winged Blackbird', + 'Reddish Egret', + 'Redhead', + 'Ring billed Gull', + 'Ring necked Duck', + 'Ring necked Pheasant', + 'Rock Pigeon', + 'Rock Ptarmigan', + 'Rock Sandpiper', + 'Rock Wren', + 'Rose breasted Grosbeak', + 'Roseate Tern', + 'Rosss Goose', + 'Rough legged Hawk', + 'Royal Tern', + 'Ruby crowned Kinglet', + 'Ruby throated Hummingbird', + 'Ruddy Duck', + 'Ruddy Turnstone', + 'Ruffed Grouse', + 'Rufous Hummingbird', + 'Rufous crowned Sparrow', + 'Rusty Blackbird', + 'Sage Thrasher', + 'Saltmarsh Sparrow', + 'Sanderling', + 'Sandhill Crane', + 'Sandwich Tern', + 'Says Phoebe', + 'Scaled Quail', + 'Scarlet Tanager', + 'Scissor tailed Flycatcher', + 'Scotts Oriole', + 'Seaside Sparrow', + 'Sedge Wren', + 'Semipalmated Plover', + 'Semipalmated Sandpiper', + 'Sharp shinned Hawk', + 'Sharp tailed Grouse', + 'Short billed Dowitcher', + 'Short eared Owl', + 'Snail Kite', + 'Snow Bunting', + 'Snow Goose', + 'Snowy Egret', + 'Snowy Owl', + 'Snowy Plover', + 'Solitary Sandpiper', + 'Song Sparrow', + 'Sooty Grouse', + 'Sora', + 'Spotted Owl', + 'Spotted Sandpiper', + 'Spotted Towhee', + 'Spruce Grouse', + 'Stellers Jay', + 'Stilt Sandpiper', + 'Summer Tanager', + 'Surf Scoter', + 'Surfbird', + 'Swainsons Hawk', + 'Swainsons Thrush', + 'Swallow tailed Kite', + 'Swamp Sparrow', + 'Tennessee Warbler', + 'Thayers Gull', + 'Townsends Solitaire', + 'Townsends Warbler', + 'Tree Swallow', + 'Tricolored Heron', + 'Tropical Kingbird', + 'Trumpeter Swan', + 'Tufted Titmouse', + 'Tundra Swan', + 'Turkey Vulture', + 'Upland Sandpiper', + 'Varied Thrush', + 'Veery', + 'Verdin', + 'Vermilion Flycatcher', + 'Vesper Sparrow', + 'Violet green Swallow', + 'Virginia Rail', + 'Wandering Tattler', + 'Warbling Vireo', + 'Western Bluebird', + 'Western Grebe', + 'Western Gull', + 'Western Kingbird', + 'Western Meadowlark', + 'Western Sandpiper', + 'Western Screech Owl', + 'Western Scrub Jay', + 'Western Tanager', + 'Western Wood Pewee', + 'Whimbrel', + 'White Ibis', + 'White breasted Nuthatch', + 'White crowned Sparrow', + 'White eyed Vireo', + 'White faced Ibis', + 'White headed Woodpecker', + 'White rumped Sandpiper', + 'White tailed Hawk', + 'White tailed Kite', + 'White tailed Ptarmigan', + 'White throated Sparrow', + 'White throated Swift', + 'White winged Crossbill', + 'White winged Dove', + 'White winged Scoter', + 'Wild Turkey', + 'Willet', + 'Williamsons Sapsucker', + 'Willow Flycatcher', + 'Willow Ptarmigan', + 'Wilsons Phalarope', + 'Wilsons Plover', + 'Wilsons Snipe', + 'Wilsons Warbler', + 'Winter Wren', + 'Wood Stork', + 'Wood Thrush', + 'Worm eating Warbler', + 'Wrentit', + 'Yellow Warbler', + 'Yellow bellied Flycatcher', + 'Yellow bellied Sapsucker', + 'Yellow billed Cuckoo', + 'Yellow billed Magpie', + 'Yellow breasted Chat', + 'Yellow crowned Night Heron', + 'Yellow eyed Junco', + 'Yellow headed Blackbird', + 'Yellow rumped Warbler', + 'Yellow throated Vireo', + 'Yellow throated Warbler', + 'Zone tailed Hawk', +] + +templates = [ + 'a photo of a {}, a type of bird.', +] +``` + + + +## CIFAR10 + +```bash +classes = [ + 'airplane', + 'automobile', + 'bird', + 'cat', + 'deer', + 'dog', + 'frog', + 'horse', + 'ship', + 'truck', +] + +templates = [ + 'a photo of a {}.', + 'a blurry photo of a {}.', + 'a black and white photo of a {}.', + 'a low contrast photo of a {}.', + 'a high contrast photo of a {}.', + 'a bad photo of a {}.', + 'a good photo of a {}.', + 'a photo of a small {}.', + 'a photo of a big {}.', + 'a photo of the {}.', + 'a blurry photo of the {}.', + 'a black and white photo of the {}.', + 'a low contrast photo of the {}.', + 'a high contrast photo of the {}.', + 'a bad photo of the {}.', + 'a good photo of the {}.', + 'a photo of the small {}.', + 'a photo of the big {}.', +] +``` + + + +## CIFAR100 + +```bash +classes = [ + 'apple', + 'aquarium fish', + 'baby', + 'bear', + 'beaver', + 'bed', + 'bee', + 'beetle', + 'bicycle', + 'bottle', + 'bowl', + 'boy', + 'bridge', + 'bus', + 'butterfly', + 'camel', + 'can', + 'castle', + 'caterpillar', + 'cattle', + 'chair', + 'chimpanzee', + 'clock', + 'cloud', + 'cockroach', + 'couch', + 'crab', + 'crocodile', + 'cup', + 'dinosaur', + 'dolphin', + 'elephant', + 'flatfish', + 'forest', + 'fox', + 'girl', + 'hamster', + 'house', + 'kangaroo', + 'keyboard', + 'lamp', + 'lawn mower', + 'leopard', + 'lion', + 'lizard', + 'lobster', + 'man', + 'maple tree', + 'motorcycle', + 'mountain', + 'mouse', + 'mushroom', + 'oak tree', + 'orange', + 'orchid', + 'otter', + 'palm tree', + 'pear', + 'pickup truck', + 'pine tree', + 'plain', + 'plate', + 'poppy', + 'porcupine', + 'possum', + 'rabbit', + 'raccoon', + 'ray', + 'road', + 'rocket', + 'rose', + 'sea', + 'seal', + 'shark', + 'shrew', + 'skunk', + 'skyscraper', + 'snail', + 'snake', + 'spider', + 'squirrel', + 'streetcar', + 'sunflower', + 'sweet pepper', + 'table', + 'tank', + 'telephone', + 'television', + 'tiger', + 'tractor', + 'train', + 'trout', + 'tulip', + 'turtle', + 'wardrobe', + 'whale', + 'willow tree', + 'wolf', + 'woman', + 'worm', +] + +templates = [ + 'a photo of a {}.', + 'a blurry photo of a {}.', + 'a black and white photo of a {}.', + 'a low contrast photo of a {}.', + 'a high contrast photo of a {}.', + 'a bad photo of a {}.', + 'a good photo of a {}.', + 'a photo of a small {}.', + 'a photo of a big {}.', + 'a photo of the {}.', + 'a blurry photo of the {}.', + 'a black and white photo of the {}.', + 'a low contrast photo of the {}.', + 'a high contrast photo of the {}.', + 'a bad photo of the {}.', + 'a good photo of the {}.', + 'a photo of the small {}.', + 'a photo of the big {}.', +] +``` + + + +## CLEVRCounts + +```bash +classes = [ + '10', + '3', + '4', + '5', + '6', + '7', + '8', + '9', +] + +templates = [ + 'a photo of {} objects.', +] +``` + + + +## Caltech101 + +```bash +classes = [ + 'background', + 'off-center face', + 'centered face', + 'leopard', + 'motorbike', + 'accordion', + 'airplane', + 'anchor', + 'ant', + 'barrel', + 'bass', + 'beaver', + 'binocular', + 'bonsai', + 'brain', + 'brontosaurus', + 'buddha', + 'butterfly', + 'camera', + 'cannon', + 'side of a car', + 'ceiling fan', + 'cellphone', + 'chair', + 'chandelier', + 'body of a cougar cat', + 'face of a cougar cat', + 'crab', + 'crayfish', + 'crocodile', + 'head of a crocodile', + 'cup', + 'dalmatian', + 'dollar bill', + 'dolphin', + 'dragonfly', + 'electric guitar', + 'elephant', + 'emu', + 'euphonium', + 'ewer', + 'ferry', + 'flamingo', + 'head of a flamingo', + 'garfield', + 'gerenuk', + 'gramophone', + 'grand piano', + 'hawksbill', + 'headphone', + 'hedgehog', + 'helicopter', + 'ibis', + 'inline skate', + 'joshua tree', + 'kangaroo', + 'ketch', + 'lamp', + 'laptop', + 'llama', + 'lobster', + 'lotus', + 'mandolin', + 'mayfly', + 'menorah', + 'metronome', + 'minaret', + 'nautilus', + 'octopus', + 'okapi', + 'pagoda', + 'panda', + 'pigeon', + 'pizza', + 'platypus', + 'pyramid', + 'revolver', + 'rhino', + 'rooster', + 'saxophone', + 'schooner', + 'scissors', + 'scorpion', + 'sea horse', + 'snoopy (cartoon beagle)', + 'soccer ball', + 'stapler', + 'starfish', + 'stegosaurus', + 'stop sign', + 'strawberry', + 'sunflower', + 'tick', + 'trilobite', + 'umbrella', + 'watch', + 'water lilly', + 'wheelchair', + 'wild cat', + 'windsor chair', + 'wrench', + 'yin and yang symbol', +] + +templates = [ + 'a photo of a {}.', + 'a painting of a {}.', + 'a plastic {}.', + 'a sculpture of a {}.', + 'a sketch of a {}.', + 'a tattoo of a {}.', + 'a toy {}.', + 'a rendition of a {}.', + 'a embroidered {}.', + 'a cartoon {}.', + 'a {} in a video game.', + 'a plushie {}.', + 'a origami {}.', + 'art of a {}.', + 'graffiti of a {}.', + 'a drawing of a {}.', + 'a doodle of a {}.', + 'a photo of the {}.', + 'a painting of the {}.', + 'the plastic {}.', + 'a sculpture of the {}.', + 'a sketch of the {}.', + 'a tattoo of the {}.', + 'the toy {}.', + 'a rendition of the {}.', + 'the embroidered {}.', + 'the cartoon {}.', + 'the {} in a video game.', + 'the plushie {}.', + 'the origami {}.', + 'art of the {}.', + 'graffiti of the {}.', + 'a drawing of the {}.', + 'a doodle of the {}.', +] +``` + + + +## Country211 + +```bash +classes = [ + 'Andorra', + 'United Arab Emirates', + 'Afghanistan', + 'Antigua and Barbuda', + 'Anguilla', + 'Albania', + 'Armenia', + 'Angola', + 'Antarctica', + 'Argentina', + 'Austria', + 'Australia', + 'Aruba', + 'Aland Islands', + 'Azerbaijan', + 'Bosnia and Herzegovina', + 'Barbados', + 'Bangladesh', + 'Belgium', + 'Burkina Faso', + 'Bulgaria', + 'Bahrain', + 'Benin', + 'Bermuda', + 'Brunei Darussalam', + 'Bolivia', + 'Bonaire, Saint Eustatius and Saba', + 'Brazil', + 'Bahamas', + 'Bhutan', + 'Botswana', + 'Belarus', + 'Belize', + 'Canada', + 'DR Congo', + 'Central African Republic', + 'Switzerland', + "Cote d'Ivoire", + 'Cook Islands', + 'Chile', + 'Cameroon', + 'China', + 'Colombia', + 'Costa Rica', + 'Cuba', + 'Cabo Verde', + 'Curacao', + 'Cyprus', + 'Czech Republic', + 'Germany', + 'Denmark', + 'Dominica', + 'Dominican Republic', + 'Algeria', + 'Ecuador', + 'Estonia', + 'Egypt', + 'Spain', + 'Ethiopia', + 'Finland', + 'Fiji', + 'Falkland Islands', + 'Faeroe Islands', + 'France', + 'Gabon', + 'United Kingdom', + 'Grenada', + 'Georgia', + 'French Guiana', + 'Guernsey', + 'Ghana', + 'Gibraltar', + 'Greenland', + 'Gambia', + 'Guadeloupe', + 'Greece', + 'South Georgia and South Sandwich Is.', + 'Guatemala', + 'Guam', + 'Guyana', + 'Hong Kong', + 'Honduras', + 'Croatia', + 'Haiti', + 'Hungary', + 'Indonesia', + 'Ireland', + 'Israel', + 'Isle of Man', + 'India', + 'Iraq', + 'Iran', + 'Iceland', + 'Italy', + 'Jersey', + 'Jamaica', + 'Jordan', + 'Japan', + 'Kenya', + 'Kyrgyz Republic', + 'Cambodia', + 'St. Kitts and Nevis', + 'North Korea', + 'South Korea', + 'Kuwait', + 'Cayman Islands', + 'Kazakhstan', + 'Laos', + 'Lebanon', + 'St. Lucia', + 'Liechtenstein', + 'Sri Lanka', + 'Liberia', + 'Lithuania', + 'Luxembourg', + 'Latvia', + 'Libya', + 'Morocco', + 'Monaco', + 'Moldova', + 'Montenegro', + 'Saint-Martin', + 'Madagascar', + 'Macedonia', + 'Mali', + 'Myanmar', + 'Mongolia', + 'Macau', + 'Martinique', + 'Mauritania', + 'Malta', + 'Mauritius', + 'Maldives', + 'Malawi', + 'Mexico', + 'Malaysia', + 'Mozambique', + 'Namibia', + 'New Caledonia', + 'Nigeria', + 'Nicaragua', + 'Netherlands', + 'Norway', + 'Nepal', + 'New Zealand', + 'Oman', + 'Panama', + 'Peru', + 'French Polynesia', + 'Papua New Guinea', + 'Philippines', + 'Pakistan', + 'Poland', + 'Puerto Rico', + 'Palestine', + 'Portugal', + 'Palau', + 'Paraguay', + 'Qatar', + 'Reunion', + 'Romania', + 'Serbia', + 'Russia', + 'Rwanda', + 'Saudi Arabia', + 'Solomon Islands', + 'Seychelles', + 'Sudan', + 'Sweden', + 'Singapore', + 'St. Helena', + 'Slovenia', + 'Svalbard and Jan Mayen Islands', + 'Slovakia', + 'Sierra Leone', + 'San Marino', + 'Senegal', + 'Somalia', + 'South Sudan', + 'El Salvador', + 'Sint Maarten', + 'Syria', + 'Eswatini', + 'Togo', + 'Thailand', + 'Tajikistan', + 'Timor-Leste', + 'Turkmenistan', + 'Tunisia', + 'Tonga', + 'Turkey', + 'Trinidad and Tobago', + 'Taiwan', + 'Tanzania', + 'Ukraine', + 'Uganda', + 'United States', + 'Uruguay', + 'Uzbekistan', + 'Vatican', + 'Venezuela', + 'British Virgin Islands', + 'United States Virgin Islands', + 'Vietnam', + 'Vanuatu', + 'Samoa', + 'Kosovo', + 'Yemen', + 'South Africa', + 'Zambia', + 'Zimbabwe', +] + +templates = [ + 'a photo i took in {}.', + 'a photo i took while visiting {}.', + 'a photo from my home country of {}.', + 'a photo from my visit to {}.', + 'a photo showing the country of {}.', +] +``` + + + +## DescribableTextures + +```bash +classes = [ + 'banded', + 'blotchy', + 'braided', + 'bubbly', + 'bumpy', + 'chequered', + 'cobwebbed', + 'cracked', + 'crosshatched', + 'crystalline', + 'dotted', + 'fibrous', + 'flecked', + 'freckled', + 'frilly', + 'gauzy', + 'grid', + 'grooved', + 'honeycombed', + 'interlaced', + 'knitted', + 'lacelike', + 'lined', + 'marbled', + 'matted', + 'meshed', + 'paisley', + 'perforated', + 'pitted', + 'pleated', + 'polka-dotted', + 'porous', + 'potholed', + 'scaly', + 'smeared', + 'spiralled', + 'sprinkled', + 'stained', + 'stratified', + 'striped', + 'studded', + 'swirly', + 'veined', + 'waffled', + 'woven', + 'wrinkled', + 'zigzagged', +] + +templates = [ + 'a photo of a {} texture.', + 'a photo of a {} pattern.', + 'a photo of a {} thing.', + 'a photo of a {} object.', + 'a photo of the {} texture.', + 'a photo of the {} pattern.', + 'a photo of the {} thing.', + 'a photo of the {} object.', +] +``` + + + +## EuroSAT + +```bash +classes = [ + 'forest', + 'permanent crop land', + 'residential buildings or homes or apartments', + 'river', + 'pasture land', + 'lake or sea', + 'brushland or shrubland', + 'annual crop land', + 'industrial buildings or commercial buildings', + 'highway or road', +] + +templates = [ + 'a centered satellite photo of {}.', + 'a centered satellite photo of a {}.', + 'a centered satellite photo of the {}.', +] +``` + + + +## FGVCAircraft + +```bash +classes = [ + '707-320', + '727-200', + '737-200', + '737-300', + '737-400', + '737-500', + '737-600', + '737-700', + '737-800', + '737-900', + '747-100', + '747-200', + '747-300', + '747-400', + '757-200', + '757-300', + '767-200', + '767-300', + '767-400', + '777-200', + '777-300', + 'A300B4', + 'A310', + 'A318', + 'A319', + 'A320', + 'A321', + 'A330-200', + 'A330-300', + 'A340-200', + 'A340-300', + 'A340-500', + 'A340-600', + 'A380', + 'ATR-42', + 'ATR-72', + 'An-12', + 'BAE 146-200', + 'BAE 146-300', + 'BAE-125', + 'Beechcraft 1900', + 'Boeing 717', + 'C-130', + 'C-47', + 'CRJ-200', + 'CRJ-700', + 'CRJ-900', + 'Cessna 172', + 'Cessna 208', + 'Cessna 525', + 'Cessna 560', + 'Challenger 600', + 'DC-10', + 'DC-3', + 'DC-6', + 'DC-8', + 'DC-9-30', + 'DH-82', + 'DHC-1', + 'DHC-6', + 'DHC-8-100', + 'DHC-8-300', + 'DR-400', + 'Dornier 328', + 'E-170', + 'E-190', + 'E-195', + 'EMB-120', + 'ERJ 135', + 'ERJ 145', + 'Embraer Legacy 600', + 'Eurofighter Typhoon', + 'F-16A/B', + 'F/A-18', + 'Falcon 2000', + 'Falcon 900', + 'Fokker 100', + 'Fokker 50', + 'Fokker 70', + 'Global Express', + 'Gulfstream IV', + 'Gulfstream V', + 'Hawk T1', + 'Il-76', + 'L-1011', + 'MD-11', + 'MD-80', + 'MD-87', + 'MD-90', + 'Metroliner', + 'Model B200', + 'PA-28', + 'SR-20', + 'Saab 2000', + 'Saab 340', + 'Spitfire', + 'Tornado', + 'Tu-134', + 'Tu-154', + 'Yak-42', +] + +templates = [ + 'a photo of a {}, a type of aircraft.', + 'a photo of the {}, a type of aircraft.', +] +``` + + + +## FacialEmotionRecognition2013 + +```bash +classes = [ + ['angry'], + ['disgusted'], + ['fearful'], + ['happy', 'smiling'], + ['sad', 'depressed'], + ['surprised', 'shocked', 'spooked'], + ['neutral', 'bored'], +] + +templates = [ + 'a photo of a {} looking face.', + 'a photo of a face showing the emotion: {}.', + 'a photo of a face looking {}.', + 'a face that looks {}.', + 'they look {}.', + 'look at how {} they are.', +] +``` + + + +## Flowers102 + +```bash +classes = [ + 'pink primrose', + 'hard-leaved pocket orchid', + 'canterbury bells', + 'sweet pea', + 'english marigold', + 'tiger lily', + 'moon orchid', + 'bird of paradise', + 'monkshood', + 'globe thistle', + 'snapdragon', + "colt's foot", + 'king protea', + 'spear thistle', + 'yellow iris', + 'globe flower', + 'purple coneflower', + 'peruvian lily', + 'balloon flower', + 'giant white arum lily', + 'fire lily', + 'pincushion flower', + 'fritillary', + 'red ginger', + 'grape hyacinth', + 'corn poppy', + 'prince of wales feathers', + 'stemless gentian', + 'artichoke', + 'sweet william', + 'carnation', + 'garden phlox', + 'love in the mist', + 'mexican aster', + 'alpine sea holly', + 'ruby-lipped cattleya', + 'cape flower', + 'great masterwort', + 'siam tulip', + 'lenten rose', + 'barbeton daisy', + 'daffodil', + 'sword lily', + 'poinsettia', + 'bolero deep blue', + 'wallflower', + 'marigold', + 'buttercup', + 'oxeye daisy', + 'common dandelion', + 'petunia', + 'wild pansy', + 'primula', + 'sunflower', + 'pelargonium', + 'bishop of llandaff', + 'gaura', + 'geranium', + 'orange dahlia', + 'pink and yellow dahlia', + 'cautleya spicata', + 'japanese anemone', + 'black-eyed susan', + 'silverbush', + 'californian poppy', + 'osteospermum', + 'spring crocus', + 'bearded iris', + 'windflower', + 'tree poppy', + 'gazania', + 'azalea', + 'water lily', + 'rose', + 'thorn apple', + 'morning glory', + 'passion flower', + 'lotus', + 'toad lily', + 'anthurium', + 'frangipani', + 'clematis', + 'hibiscus', + 'columbine', + 'desert-rose', + 'tree mallow', + 'magnolia', + 'cyclamen', + 'watercress', + 'canna lily', + 'hippeastrum', + 'bee balm', + 'air plant', + 'foxglove', + 'bougainvillea', + 'camellia', + 'mallow', + 'mexican petunia', + 'bromelia', + 'blanket flower', + 'trumpet creeper', + 'blackberry lily', +] + +templates = [ + 'a photo of a {}, a type of flower.', +] +``` + + + +## Food101 + +```bash +classes = [ + 'apple pie', + 'baby back ribs', + 'baklava', + 'beef carpaccio', + 'beef tartare', + 'beet salad', + 'beignets', + 'bibimbap', + 'bread pudding', + 'breakfast burrito', + 'bruschetta', + 'caesar salad', + 'cannoli', + 'caprese salad', + 'carrot cake', + 'ceviche', + 'cheese plate', + 'cheesecake', + 'chicken curry', + 'chicken quesadilla', + 'chicken wings', + 'chocolate cake', + 'chocolate mousse', + 'churros', + 'clam chowder', + 'club sandwich', + 'crab cakes', + 'creme brulee', + 'croque madame', + 'cup cakes', + 'deviled eggs', + 'donuts', + 'dumplings', + 'edamame', + 'eggs benedict', + 'escargots', + 'falafel', + 'filet mignon', + 'fish and chips', + 'foie gras', + 'french fries', + 'french onion soup', + 'french toast', + 'fried calamari', + 'fried rice', + 'frozen yogurt', + 'garlic bread', + 'gnocchi', + 'greek salad', + 'grilled cheese sandwich', + 'grilled salmon', + 'guacamole', + 'gyoza', + 'hamburger', + 'hot and sour soup', + 'hot dog', + 'huevos rancheros', + 'hummus', + 'ice cream', + 'lasagna', + 'lobster bisque', + 'lobster roll sandwich', + 'macaroni and cheese', + 'macarons', + 'miso soup', + 'mussels', + 'nachos', + 'omelette', + 'onion rings', + 'oysters', + 'pad thai', + 'paella', + 'pancakes', + 'panna cotta', + 'peking duck', + 'pho', + 'pizza', + 'pork chop', + 'poutine', + 'prime rib', + 'pulled pork sandwich', + 'ramen', + 'ravioli', + 'red velvet cake', + 'risotto', + 'samosa', + 'sashimi', + 'scallops', + 'seaweed salad', + 'shrimp and grits', + 'spaghetti bolognese', + 'spaghetti carbonara', + 'spring rolls', + 'steak', + 'strawberry shortcake', + 'sushi', + 'tacos', + 'takoyaki', + 'tiramisu', + 'tuna tartare', + 'waffles', +] + +templates = [ + 'a photo of {}, a type of food.', +] +``` + + + +## GTSRB + +```bash +classes = [ + 'red and white circle 20 kph speed limit', + 'red and white circle 30 kph speed limit', + 'red and white circle 50 kph speed limit', + 'red and white circle 60 kph speed limit', + 'red and white circle 70 kph speed limit', + 'red and white circle 80 kph speed limit', + 'end / de-restriction of 80 kph speed limit', + 'red and white circle 100 kph speed limit', + 'red and white circle 120 kph speed limit', + 'red and white circle red car and black car no passing', + 'red and white circle red truck and black car no passing', + 'red and white triangle road intersection warning', + 'white and yellow diamond priority road', + 'red and white upside down triangle yield right-of-way', + 'stop', + 'empty red and white circle', + 'red and white circle no truck entry', + 'red circle with white horizonal stripe no entry', + 'red and white triangle with exclamation mark warning', + 'red and white triangle with black left curve approaching warning', + 'red and white triangle with black right curve approaching warning', + 'red and white triangle with black double curve approaching warning', + 'red and white triangle rough / bumpy road warning', + 'red and white triangle car skidding / slipping warning', + 'red and white triangle with merging / narrow lanes warning', + 'red and white triangle with person digging / construction / road work warning', + 'red and white triangle with traffic light approaching warning', + 'red and white triangle with person walking warning', + 'red and white triangle with child and person walking warning', + 'red and white triangle with bicyle warning', + 'red and white triangle with snowflake / ice warning', + 'red and white triangle with deer warning', + 'white circle with gray strike bar no speed limit', + 'blue circle with white right turn arrow mandatory', + 'blue circle with white left turn arrow mandatory', + 'blue circle with white forward arrow mandatory', + 'blue circle with white forward or right turn arrow mandatory', + 'blue circle with white forward or left turn arrow mandatory', + 'blue circle with white keep right arrow mandatory', + 'blue circle with white keep left arrow mandatory', + 'blue circle with white arrows indicating a traffic circle', + 'white circle with gray strike bar indicating no passing for cars has ended', + 'white circle with gray strike bar indicating no passing for trucks has ended', +] + +templates = [ + 'a zoomed in photo of a "{}" traffic sign.', + 'a centered photo of a "{}" traffic sign.', + 'a close up photo of a "{}" traffic sign.', +] +``` + + + +## HatefulMemes + +```bash +classes = [ + 'meme', + 'hatespeech meme', +] + +templates = [ + 'a {}.', +] +``` + + + +## KITTI + +```bash +classes = [ + 'a photo i took of a car on my left or right side.', + 'a photo i took with a car nearby.', + 'a photo i took with a car in the distance.', + 'a photo i took with no car.', +] + +templates = [ + '{}', +] +``` + + + +## Kinetics700 + +```bash +classes = [ + 'abseiling', + 'acting in play', + 'adjusting glasses', + 'air drumming', + 'alligator wrestling', + 'answering questions', + 'applauding', + 'applying cream', + 'archaeological excavation', + 'archery', + 'arguing', + 'arm wrestling', + 'arranging flowers', + 'arresting', + 'assembling bicycle', + 'assembling computer', + 'attending conference', + 'auctioning', + 'baby waking up', + 'backflip (human)', + 'baking cookies', + 'bandaging', + 'barbequing', + 'bartending', + 'base jumping', + 'bathing dog', + 'battle rope training', + 'beatboxing', + 'bee keeping', + 'being excited', + 'being in zero gravity', + 'belly dancing', + 'bench pressing', + 'bending back', + 'bending metal', + 'biking through snow', + 'blasting sand', + 'blending fruit', + 'blowdrying hair', + 'blowing bubble gum', + 'blowing glass', + 'blowing leaves', + 'blowing nose', + 'blowing out candles', + 'bobsledding', + 'bodysurfing', + 'bookbinding', + 'bottling', + 'bouncing ball (not juggling)', + 'bouncing on bouncy castle', + 'bouncing on trampoline', + 'bowling', + 'braiding hair', + 'breading or breadcrumbing', + 'breakdancing', + 'breaking boards', + 'breaking glass', + 'breathing fire', + 'brush painting', + 'brushing floor', + 'brushing hair', + 'brushing teeth', + 'building cabinet', + 'building lego', + 'building sandcastle', + 'building shed', + 'bulldozing', + 'bungee jumping', + 'burping', + 'busking', + 'calculating', + 'calligraphy', + 'canoeing or kayaking', + 'capoeira', + 'capsizing', + 'card stacking', + 'card throwing', + 'carrying baby', + 'carrying weight', + 'cartwheeling', + 'carving ice', + 'carving marble', + 'carving pumpkin', + 'carving wood with a knife', + 'casting fishing line', + 'catching fish', + 'catching or throwing baseball', + 'catching or throwing frisbee', + 'catching or throwing softball', + 'celebrating', + 'changing gear in car', + 'changing oil', + 'changing wheel (not on bike)', + 'chasing', + 'checking tires', + 'checking watch', + 'cheerleading', + 'chewing gum', + 'chiseling stone', + 'chiseling wood', + 'chopping meat', + 'chopping wood', + 'clam digging', + 'clapping', + 'clay pottery making', + 'clean and jerk', + 'cleaning gutters', + 'cleaning pool', + 'cleaning shoes', + 'cleaning toilet', + 'cleaning windows', + 'climbing a rope', + 'climbing ladder', + 'climbing tree', + 'closing door', + 'coloring in', + 'combing hair', + 'contact juggling', + 'contorting', + 'cooking chicken', + 'cooking egg', + 'cooking on campfire', + 'cooking sausages (not on barbeque)', + 'cooking scallops', + 'cosplaying', + 'coughing', + 'counting money', + 'country line dancing', + 'cracking back', + 'cracking knuckles', + 'cracking neck', + 'crawling baby', + 'crocheting', + 'crossing eyes', + 'crossing river', + 'crying', + 'cumbia', + 'curling (sport)', + 'curling eyelashes', + 'curling hair', + 'cutting apple', + 'cutting cake', + 'cutting nails', + 'cutting orange', + 'cutting pineapple', + 'cutting watermelon', + 'dancing ballet', + 'dancing charleston', + 'dancing gangnam style', + 'dancing macarena', + 'deadlifting', + 'dealing cards', + 'decorating the christmas tree', + 'decoupage', + 'delivering mail', + 'digging', + 'dining', + 'directing traffic', + 'disc golfing', + 'diving cliff', + 'docking boat', + 'dodgeball', + 'doing aerobics', + 'doing jigsaw puzzle', + 'doing laundry', + 'doing nails', + 'doing sudoku', + 'drawing', + 'dribbling basketball', + 'drinking shots', + 'driving car', + 'driving tractor', + 'drooling', + 'drop kicking', + 'drumming fingers', + 'dumpster diving', + 'dunking basketball', + 'dyeing eyebrows', + 'dyeing hair', + 'eating burger', + 'eating cake', + 'eating carrots', + 'eating chips', + 'eating doughnuts', + 'eating hotdog', + 'eating ice cream', + 'eating nachos', + 'eating spaghetti', + 'eating watermelon', + 'egg hunting', + 'embroidering', + 'entering church', + 'exercising arm', + 'exercising with an exercise ball', + 'extinguishing fire', + 'faceplanting', + 'falling off bike', + 'falling off chair', + 'feeding birds', + 'feeding fish', + 'feeding goats', + 'fencing (sport)', + 'fidgeting', + 'filling cake', + 'filling eyebrows', + 'finger snapping', + 'fixing bicycle', + 'fixing hair', + 'flint knapping', + 'flipping bottle', + 'flipping pancake', + 'fly tying', + 'flying kite', + 'folding clothes', + 'folding napkins', + 'folding paper', + 'front raises', + 'frying vegetables', + 'gargling', + 'geocaching', + 'getting a haircut', + 'getting a piercing', + 'getting a tattoo', + 'giving or receiving award', + 'gold panning', + 'golf chipping', + 'golf driving', + 'golf putting', + 'gospel singing in church', + 'grinding meat', + 'grooming cat', + 'grooming dog', + 'grooming horse', + 'gymnastics tumbling', + 'hammer throw', + 'hand washing clothes', + 'head stand', + 'headbanging', + 'headbutting', + 'helmet diving', + 'herding cattle', + 'high fiving', + 'high jump', + 'high kick', + 'historical reenactment', + 'hitting baseball', + 'hockey stop', + 'holding snake', + 'home roasting coffee', + 'hopscotch', + 'hoverboarding', + 'huddling', + 'hugging (not baby)', + 'hugging baby', + 'hula hooping', + 'hurdling', + 'hurling (sport)', + 'ice climbing', + 'ice fishing', + 'ice skating', + 'ice swimming', + 'inflating balloons', + 'installing carpet', + 'ironing', + 'ironing hair', + 'javelin throw', + 'jaywalking', + 'jetskiing', + 'jogging', + 'juggling balls', + 'juggling fire', + 'juggling soccer ball', + 'jumping bicycle', + 'jumping into pool', + 'jumping jacks', + 'jumping sofa', + 'jumpstyle dancing', + 'karaoke', + 'kicking field goal', + 'kicking soccer ball', + 'kissing', + 'kitesurfing', + 'knitting', + 'krumping', + 'land sailing', + 'laughing', + 'lawn mower racing', + 'laying bricks', + 'laying concrete', + 'laying decking', + 'laying stone', + 'laying tiles', + 'leatherworking', + 'letting go of balloon', + 'licking', + 'lifting hat', + 'lighting candle', + 'lighting fire', + 'listening with headphones', + 'lock picking', + 'long jump', + 'longboarding', + 'looking at phone', + 'looking in mirror', + 'luge', + 'lunge', + 'making a cake', + 'making a sandwich', + 'making balloon shapes', + 'making bubbles', + 'making cheese', + 'making horseshoes', + 'making jewelry', + 'making latte art', + 'making paper aeroplanes', + 'making pizza', + 'making slime', + 'making snowman', + 'making sushi', + 'making tea', + 'making the bed', + 'marching', + 'marriage proposal', + 'massaging back', + 'massaging feet', + 'massaging legs', + 'massaging neck', + "massaging person's head", + 'metal detecting', + 'milking cow', + 'milking goat', + 'mixing colours', + 'moon walking', + 'mopping floor', + 'mosh pit dancing', + 'motorcycling', + 'mountain climber (exercise)', + 'moving baby', + 'moving child', + 'moving furniture', + 'mowing lawn', + 'mushroom foraging', + 'needle felting', + 'news anchoring', + 'opening bottle (not wine)', + 'opening coconuts', + 'opening door', + 'opening present', + 'opening refrigerator', + 'opening wine bottle', + 'packing', + 'paragliding', + 'parasailing', + 'parkour', + 'passing American football (in game)', + 'passing American football (not in game)', + 'passing soccer ball', + 'peeling apples', + 'peeling banana', + 'peeling potatoes', + 'person collecting garbage', + 'petting animal (not cat)', + 'petting cat', + 'petting horse', + 'photobombing', + 'photocopying', + 'picking apples', + 'picking blueberries', + 'pillow fight', + 'pinching', + 'pirouetting', + 'planing wood', + 'planting trees', + 'plastering', + 'playing accordion', + 'playing american football', + 'playing badminton', + 'playing bagpipes', + 'playing basketball', + 'playing bass guitar', + 'playing beer pong', + 'playing billiards', + 'playing blackjack', + 'playing cards', + 'playing cello', + 'playing checkers', + 'playing chess', + 'playing clarinet', + 'playing controller', + 'playing cricket', + 'playing cymbals', + 'playing darts', + 'playing didgeridoo', + 'playing dominoes', + 'playing drums', + 'playing field hockey', + 'playing flute', + 'playing gong', + 'playing guitar', + 'playing hand clapping games', + 'playing harmonica', + 'playing harp', + 'playing ice hockey', + 'playing keyboard', + 'playing kickball', + 'playing laser tag', + 'playing lute', + 'playing mahjong', + 'playing maracas', + 'playing marbles', + 'playing monopoly', + 'playing netball', + 'playing nose flute', + 'playing oboe', + 'playing ocarina', + 'playing organ', + 'playing paintball', + 'playing pan pipes', + 'playing piano', + 'playing piccolo', + 'playing pinball', + 'playing ping pong', + 'playing poker', + 'playing polo', + 'playing recorder', + 'playing road hockey', + 'playing rounders', + 'playing rubiks cube', + 'playing saxophone', + 'playing scrabble', + 'playing shuffleboard', + 'playing slot machine', + 'playing squash or racquetball', + 'playing tennis', + 'playing trombone', + 'playing trumpet', + 'playing ukulele', + 'playing violin', + 'playing volleyball', + 'playing with trains', + 'playing xylophone', + 'poaching eggs', + 'poking bellybutton', + 'pole vault', + 'polishing furniture', + 'polishing metal', + 'popping balloons', + 'pouring beer', + 'pouring milk', + 'pouring wine', + 'preparing salad', + 'presenting weather forecast', + 'pretending to be a statue', + 'pull ups', + 'pulling espresso shot', + 'pulling rope (game)', + 'pumping fist', + 'pumping gas', + 'punching bag', + 'punching person (boxing)', + 'push up', + 'pushing car', + 'pushing cart', + 'pushing wheelbarrow', + 'pushing wheelchair', + 'putting in contact lenses', + 'putting on eyeliner', + 'putting on foundation', + 'putting on lipstick', + 'putting on mascara', + 'putting on sari', + 'putting on shoes', + 'putting wallpaper on wall', + 'raising eyebrows', + 'reading book', + 'reading newspaper', + 'recording music', + 'repairing puncture', + 'riding a bike', + 'riding camel', + 'riding elephant', + 'riding mechanical bull', + 'riding mule', + 'riding or walking with horse', + 'riding scooter', + 'riding snow blower', + 'riding unicycle', + 'ripping paper', + 'roasting marshmallows', + 'roasting pig', + 'robot dancing', + 'rock climbing', + 'rock scissors paper', + 'roller skating', + 'rolling eyes', + 'rolling pastry', + 'rope pushdown', + 'running on treadmill', + 'sailing', + 'salsa dancing', + 'saluting', + 'sanding floor', + 'sanding wood', + 'sausage making', + 'sawing wood', + 'scrambling eggs', + 'scrapbooking', + 'scrubbing face', + 'scuba diving', + 'seasoning food', + 'separating eggs', + 'setting table', + 'sewing', + 'shaking hands', + 'shaking head', + 'shaping bread dough', + 'sharpening knives', + 'sharpening pencil', + 'shaving head', + 'shaving legs', + 'shearing sheep', + 'shining flashlight', + 'shining shoes', + 'shoot dance', + 'shooting basketball', + 'shooting goal (soccer)', + 'shooting off fireworks', + 'shopping', + 'shot put', + 'shouting', + 'shoveling snow', + 'shredding paper', + 'shucking oysters', + 'shuffling cards', + 'shuffling feet', + 'side kick', + 'sieving', + 'sign language interpreting', + 'silent disco', + 'singing', + 'sipping cup', + 'situp', + 'skateboarding', + 'ski ballet', + 'ski jumping', + 'skiing crosscountry', + 'skiing mono', + 'skiing slalom', + 'skipping rope', + 'skipping stone', + 'skydiving', + 'slacklining', + 'slapping', + 'sled dog racing', + 'sleeping', + 'slicing onion', + 'smashing', + 'smelling feet', + 'smoking', + 'smoking hookah', + 'smoking pipe', + 'snatch weight lifting', + 'sneezing', + 'snorkeling', + 'snowboarding', + 'snowkiting', + 'snowmobiling', + 'somersaulting', + 'spelunking', + 'spinning plates', + 'spinning poi', + 'splashing water', + 'spray painting', + 'spraying', + 'springboard diving', + 'square dancing', + 'squat', + 'squeezing orange', + 'stacking cups', + 'stacking dice', + 'standing on hands', + 'staring', + 'steer roping', + 'steering car', + 'sticking tongue out', + 'stomping grapes', + 'stretching arm', + 'stretching leg', + 'sucking lolly', + 'surfing crowd', + 'surfing water', + 'surveying', + 'sweeping floor', + 'swimming backstroke', + 'swimming breast stroke', + 'swimming butterfly stroke', + 'swimming front crawl', + 'swimming with dolphins', + 'swimming with sharks', + 'swing dancing', + 'swinging baseball bat', + 'swinging on something', + 'sword fighting', + 'sword swallowing', + 'tackling', + 'tagging graffiti', + 'tai chi', + 'taking photo', + 'talking on cell phone', + 'tango dancing', + 'tap dancing', + 'tapping guitar', + 'tapping pen', + 'tasting beer', + 'tasting food', + 'tasting wine', + 'testifying', + 'texting', + 'threading needle', + 'throwing axe', + 'throwing ball (not baseball or American football)', + 'throwing discus', + 'throwing knife', + 'throwing snowballs', + 'throwing tantrum', + 'throwing water balloon', + 'tickling', + 'tie dying', + 'tightrope walking', + 'tiptoeing', + 'tobogganing', + 'tossing coin', + 'tossing salad', + 'training dog', + 'trapezing', + 'treating wood', + 'trimming or shaving beard', + 'trimming shrubs', + 'trimming trees', + 'triple jump', + 'twiddling fingers', + 'tying bow tie', + 'tying knot (not on a tie)', + 'tying necktie', + 'tying shoe laces', + 'unboxing', + 'uncorking champagne', + 'unloading truck', + 'using a microscope', + 'using a paint roller', + 'using a power drill', + 'using a sledge hammer', + 'using a wrench', + 'using atm', + 'using bagging machine', + 'using circular saw', + 'using inhaler', + 'using megaphone', + 'using puppets', + 'using remote controller (not gaming)', + 'using segway', + 'vacuuming car', + 'vacuuming floor', + 'visiting the zoo', + 'wading through mud', + 'wading through water', + 'waiting in line', + 'waking up', + 'walking on stilts', + 'walking the dog', + 'walking through snow', + 'walking with crutches', + 'washing dishes', + 'washing feet', + 'washing hair', + 'washing hands', + 'watching tv', + 'water skiing', + 'water sliding', + 'watering plants', + 'waving hand', + 'waxing armpits', + 'waxing back', + 'waxing chest', + 'waxing eyebrows', + 'waxing legs', + 'weaving basket', + 'weaving fabric', + 'welding', + 'whistling', + 'windsurfing', + 'winking', + 'wood burning (art)', + 'wrapping present', + 'wrestling', + 'writing', + 'yarn spinning', + 'yawning', + 'yoga', + 'zumba' +] + +templates = [ + 'a photo of {}.', + 'a photo of a person {}.', + 'a photo of a person using {}.', + 'a photo of a person doing {}.', + 'a photo of a person during {}.', + 'a photo of a person performing {}.', + 'a photo of a person practicing {}.', + 'a video of {}.', + 'a video of a person {}.', + 'a video of a person using {}.', + 'a video of a person doing {}.', + 'a video of a person during {}.', + 'a video of a person performing {}.', + 'a video of a person practicing {}.', + 'a example of {}.', + 'a example of a person {}.', + 'a example of a person using {}.', + 'a example of a person doing {}.', + 'a example of a person during {}.', + 'a example of a person performing {}.', + 'a example of a person practicing {}.', + 'a demonstration of {}.', + 'a demonstration of a person {}.', + 'a demonstration of a person using {}.', + 'a demonstration of a person doing {}.', + 'a demonstration of a person during {}.', + 'a demonstration of a person performing {}.', + 'a demonstration of a person practicing {}.', +] +``` + + + +## MNIST + +```bash +classes = [ + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '7', + '8', + '9', +] + +templates = [ + 'a photo of the number: "{}".', +] +``` + + + +## OxfordPets + +```bash +classes = [ + 'Abyssinian', + 'Bengal', + 'Birman', + 'Bombay', + 'British Shorthair', + 'Egyptian Mau', + 'Maine Coon', + 'Persian', + 'Ragdoll', + 'Russian Blue', + 'Siamese', + 'Sphynx', + 'american bulldog', + 'american pit bull terrier', + 'basset hound', + 'beagle', + 'boxer', + 'chihuahua', + 'english cocker spaniel', + 'english setter', + 'german shorthaired', + 'great pyrenees', + 'havanese', + 'japanese chin', + 'keeshond', + 'leonberger', + 'miniature pinscher', + 'newfoundland', + 'pomeranian', + 'pug', + 'saint bernard', + 'samoyed', + 'scottish terrier', + 'shiba inu', + 'staffordshire bull terrier', + 'wheaten terrier', + 'yorkshire terrier', +] + +templates = [ + 'a photo of a {}, a type of pet.', +] +``` + + + +## PascalVOC2007 + +```bash +classes = [ + 'aeroplane', + 'bicycle', + 'bird', + 'boat', + 'bottle', + 'bus', + 'car', + 'cat', + 'chair', + 'cow', + 'dog', + 'horse', + 'motorbike', + 'person', + 'sheep', + 'sofa', + 'diningtable', + 'pottedplant', + 'train', + 'tvmonitor', +] + +templates = [ + 'a photo of a {}.', +] +``` + + + +## PatchCamelyon + +```bash +classes = [ + 'lymph node', + 'lymph node containing metastatic tumor tissue', +] + +templates = [ + 'this is a photo of {}', +] +``` + + + +## RESISC45 + +```bash +classes = [ + 'airplane', + 'airport', + 'baseball diamond', + 'basketball court', + 'beach', + 'bridge', + 'chaparral', + 'church', + 'circular farmland', + 'cloud', + 'commercial area', + 'dense residential', + 'desert', + 'forest', + 'freeway', + 'golf course', + 'ground track field', + 'harbor', + 'industrial area', + 'intersection', + 'island', + 'lake', + 'meadow', + 'medium residential', + 'mobile home park', + 'mountain', + 'overpass', + 'palace', + 'parking lot', + 'railway', + 'railway station', + 'rectangular farmland', + 'river', + 'roundabout', + 'runway', + 'sea ice', + 'ship', + 'snowberg', + 'sparse residential', + 'stadium', + 'storage tank', + 'tennis court', + 'terrace', + 'thermal power station', + 'wetland', +] + +templates = [ + 'satellite imagery of {}.', + 'aerial imagery of {}.', + 'satellite photo of {}.', + 'aerial photo of {}.', + 'satellite view of {}.', + 'aerial view of {}.', + 'satellite imagery of a {}.', + 'aerial imagery of a {}.', + 'satellite photo of a {}.', + 'aerial photo of a {}.', + 'satellite view of a {}.', + 'aerial view of a {}.', + 'satellite imagery of the {}.', + 'aerial imagery of the {}.', + 'satellite photo of the {}.', + 'aerial photo of the {}.', + 'satellite view of the {}.', + 'aerial view of the {}.', +] +``` + + + +## SST2 + +```bash +classes = [ + 'negative', + 'positive', +] + +templates = [ + 'a {} review of a movie.', +] +``` + + + +## STL10 + +```bash +classes = [ + 'airplane', + 'bird', + 'car', + 'cat', + 'deer', + 'dog', + 'horse', + 'monkey', + 'ship', + 'truck', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', +] +``` + + + +## SUN397 + +```bash +classes = [ + 'abbey', + 'airplane cabin', + 'airport terminal', + 'alley', + 'amphitheater', + 'amusement arcade', + 'amusement park', + 'anechoic chamber', + 'apartment building outdoor', + 'apse indoor', + 'aquarium', + 'aqueduct', + 'arch', + 'archive', + 'arrival gate outdoor', + 'art gallery', + 'art school', + 'art studio', + 'assembly line', + 'athletic field outdoor', + 'atrium public', + 'attic', + 'auditorium', + 'auto factory', + 'badlands', + 'badminton court indoor', + 'baggage claim', + 'bakery shop', + 'balcony exterior', + 'balcony interior', + 'ball pit', + 'ballroom', + 'bamboo forest', + 'banquet hall', + 'bar', + 'barn', + 'barndoor', + 'baseball field', + 'basement', + 'basilica', + 'basketball court outdoor', + 'bathroom', + 'batters box', + 'bayou', + 'bazaar indoor', + 'bazaar outdoor', + 'beach', + 'beauty salon', + 'bedroom', + 'berth', + 'biology laboratory', + 'bistro indoor', + 'boardwalk', + 'boat deck', + 'boathouse', + 'bookstore', + 'booth indoor', + 'botanical garden', + 'bow window indoor', + 'bow window outdoor', + 'bowling alley', + 'boxing ring', + 'brewery indoor', + 'bridge', + 'building facade', + 'bullring', + 'burial chamber', + 'bus interior', + 'butchers shop', + 'butte', + 'cabin outdoor', + 'cafeteria', + 'campsite', + 'campus', + 'canal natural', + 'canal urban', + 'candy store', + 'canyon', + 'car interior backseat', + 'car interior frontseat', + 'carrousel', + 'casino indoor', + 'castle', + 'catacomb', + 'cathedral indoor', + 'cathedral outdoor', + 'cavern indoor', + 'cemetery', + 'chalet', + 'cheese factory', + 'chemistry lab', + 'chicken coop indoor', + 'chicken coop outdoor', + 'childs room', + 'church indoor', + 'church outdoor', + 'classroom', + 'clean room', + 'cliff', + 'cloister indoor', + 'closet', + 'clothing store', + 'coast', + 'cockpit', + 'coffee shop', + 'computer room', + 'conference center', + 'conference room', + 'construction site', + 'control room', + 'control tower outdoor', + 'corn field', + 'corral', + 'corridor', + 'cottage garden', + 'courthouse', + 'courtroom', + 'courtyard', + 'covered bridge exterior', + 'creek', + 'crevasse', + 'crosswalk', + 'cubicle office', + 'dam', + 'delicatessen', + 'dentists office', + 'desert sand', + 'desert vegetation', + 'diner indoor', + 'diner outdoor', + 'dinette home', + 'dinette vehicle', + 'dining car', + 'dining room', + 'discotheque', + 'dock', + 'doorway outdoor', + 'dorm room', + 'driveway', + 'driving range outdoor', + 'drugstore', + 'electrical substation', + 'elevator door', + 'elevator interior', + 'elevator shaft', + 'engine room', + 'escalator indoor', + 'excavation', + 'factory indoor', + 'fairway', + 'fastfood restaurant', + 'field cultivated', + 'field wild', + 'fire escape', + 'fire station', + 'firing range indoor', + 'fishpond', + 'florist shop indoor', + 'food court', + 'forest broadleaf', + 'forest needleleaf', + 'forest path', + 'forest road', + 'formal garden', + 'fountain', + 'galley', + 'game room', + 'garage indoor', + 'garbage dump', + 'gas station', + 'gazebo exterior', + 'general store indoor', + 'general store outdoor', + 'gift shop', + 'golf course', + 'greenhouse indoor', + 'greenhouse outdoor', + 'gymnasium indoor', + 'hangar indoor', + 'hangar outdoor', + 'harbor', + 'hayfield', + 'heliport', + 'herb garden', + 'highway', + 'hill', + 'home office', + 'hospital', + 'hospital room', + 'hot spring', + 'hot tub outdoor', + 'hotel outdoor', + 'hotel room', + 'house', + 'hunting lodge outdoor', + 'ice cream parlor', + 'ice floe', + 'ice shelf', + 'ice skating rink indoor', + 'ice skating rink outdoor', + 'iceberg', + 'igloo', + 'industrial area', + 'inn outdoor', + 'islet', + 'jacuzzi indoor', + 'jail cell', + 'jail indoor', + 'jewelry shop', + 'kasbah', + 'kennel indoor', + 'kennel outdoor', + 'kindergarden classroom', + 'kitchen', + 'kitchenette', + 'labyrinth outdoor', + 'lake natural', + 'landfill', + 'landing deck', + 'laundromat', + 'lecture room', + 'library indoor', + 'library outdoor', + 'lido deck outdoor', + 'lift bridge', + 'lighthouse', + 'limousine interior', + 'living room', + 'lobby', + 'lock chamber', + 'locker room', + 'mansion', + 'manufactured home', + 'market indoor', + 'market outdoor', + 'marsh', + 'martial arts gym', + 'mausoleum', + 'medina', + 'moat water', + 'monastery outdoor', + 'mosque indoor', + 'mosque outdoor', + 'motel', + 'mountain', + 'mountain snowy', + 'movie theater indoor', + 'museum indoor', + 'music store', + 'music studio', + 'nuclear power plant outdoor', + 'nursery', + 'oast house', + 'observatory outdoor', + 'ocean', + 'office', + 'office building', + 'oil refinery outdoor', + 'oilrig', + 'operating room', + 'orchard', + 'outhouse outdoor', + 'pagoda', + 'palace', + 'pantry', + 'park', + 'parking garage indoor', + 'parking garage outdoor', + 'parking lot', + 'parlor', + 'pasture', + 'patio', + 'pavilion', + 'pharmacy', + 'phone booth', + 'physics laboratory', + 'picnic area', + 'pilothouse indoor', + 'planetarium outdoor', + 'playground', + 'playroom', + 'plaza', + 'podium indoor', + 'podium outdoor', + 'pond', + 'poolroom establishment', + 'poolroom home', + 'power plant outdoor', + 'promenade deck', + 'pub indoor', + 'pulpit', + 'putting green', + 'racecourse', + 'raceway', + 'raft', + 'railroad track', + 'rainforest', + 'reception', + 'recreation room', + 'residential neighborhood', + 'restaurant', + 'restaurant kitchen', + 'restaurant patio', + 'rice paddy', + 'riding arena', + 'river', + 'rock arch', + 'rope bridge', + 'ruin', + 'runway', + 'sandbar', + 'sandbox', + 'sauna', + 'schoolhouse', + 'sea cliff', + 'server room', + 'shed', + 'shoe shop', + 'shopfront', + 'shopping mall indoor', + 'shower', + 'skatepark', + 'ski lodge', + 'ski resort', + 'ski slope', + 'sky', + 'skyscraper', + 'slum', + 'snowfield', + 'squash court', + 'stable', + 'stadium baseball', + 'stadium football', + 'stage indoor', + 'staircase', + 'street', + 'subway interior', + 'subway station platform', + 'supermarket', + 'sushi bar', + 'swamp', + 'swimming pool indoor', + 'swimming pool outdoor', + 'synagogue indoor', + 'synagogue outdoor', + 'television studio', + 'temple east asia', + 'temple south asia', + 'tennis court indoor', + 'tennis court outdoor', + 'tent outdoor', + 'theater indoor procenium', + 'theater indoor seats', + 'thriftshop', + 'throne room', + 'ticket booth', + 'toll plaza', + 'topiary garden', + 'tower', + 'toyshop', + 'track outdoor', + 'train railway', + 'train station platform', + 'tree farm', + 'tree house', + 'trench', + 'underwater coral reef', + 'utility room', + 'valley', + 'van interior', + 'vegetable garden', + 'veranda', + 'veterinarians office', + 'viaduct', + 'videostore', + 'village', + 'vineyard', + 'volcano', + 'volleyball court indoor', + 'volleyball court outdoor', + 'waiting room', + 'warehouse indoor', + 'water tower', + 'waterfall block', + 'waterfall fan', + 'waterfall plunge', + 'watering hole', + 'wave', + 'wet bar', + 'wheat field', + 'wind farm', + 'windmill', + 'wine cellar barrel storage', + 'wine cellar bottle storage', + 'wrestling ring indoor', + 'yard', + 'youth hostel', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', +] +``` + + + +## StanfordCars + +```bash +classes = [ + 'AM General Hummer SUV 2000', + 'Acura RL Sedan 2012', + 'Acura TL Sedan 2012', + 'Acura TL Type-S 2008', + 'Acura TSX Sedan 2012', + 'Acura Integra Type R 2001', + 'Acura ZDX Hatchback 2012', + 'Aston Martin V8 Vantage Convertible 2012', + 'Aston Martin V8 Vantage Coupe 2012', + 'Aston Martin Virage Convertible 2012', + 'Aston Martin Virage Coupe 2012', + 'Audi RS 4 Convertible 2008', + 'Audi A5 Coupe 2012', + 'Audi TTS Coupe 2012', + 'Audi R8 Coupe 2012', + 'Audi V8 Sedan 1994', + 'Audi 100 Sedan 1994', + 'Audi 100 Wagon 1994', + 'Audi TT Hatchback 2011', + 'Audi S6 Sedan 2011', + 'Audi S5 Convertible 2012', + 'Audi S5 Coupe 2012', + 'Audi S4 Sedan 2012', + 'Audi S4 Sedan 2007', + 'Audi TT RS Coupe 2012', + 'BMW ActiveHybrid 5 Sedan 2012', + 'BMW 1 Series Convertible 2012', + 'BMW 1 Series Coupe 2012', + 'BMW 3 Series Sedan 2012', + 'BMW 3 Series Wagon 2012', + 'BMW 6 Series Convertible 2007', + 'BMW X5 SUV 2007', + 'BMW X6 SUV 2012', + 'BMW M3 Coupe 2012', + 'BMW M5 Sedan 2010', + 'BMW M6 Convertible 2010', + 'BMW X3 SUV 2012', + 'BMW Z4 Convertible 2012', + 'Bentley Continental Supersports Conv. Convertible 2012', + 'Bentley Arnage Sedan 2009', + 'Bentley Mulsanne Sedan 2011', + 'Bentley Continental GT Coupe 2012', + 'Bentley Continental GT Coupe 2007', + 'Bentley Continental Flying Spur Sedan 2007', + 'Bugatti Veyron 16.4 Convertible 2009', + 'Bugatti Veyron 16.4 Coupe 2009', + 'Buick Regal GS 2012', + 'Buick Rainier SUV 2007', + 'Buick Verano Sedan 2012', + 'Buick Enclave SUV 2012', + 'Cadillac CTS-V Sedan 2012', + 'Cadillac SRX SUV 2012', + 'Cadillac Escalade EXT Crew Cab 2007', + 'Chevrolet Silverado 1500 Hybrid Crew Cab 2012', + 'Chevrolet Corvette Convertible 2012', + 'Chevrolet Corvette ZR1 2012', + 'Chevrolet Corvette Ron Fellows Edition Z06 2007', + 'Chevrolet Traverse SUV 2012', + 'Chevrolet Camaro Convertible 2012', + 'Chevrolet HHR SS 2010', + 'Chevrolet Impala Sedan 2007', + 'Chevrolet Tahoe Hybrid SUV 2012', + 'Chevrolet Sonic Sedan 2012', + 'Chevrolet Express Cargo Van 2007', + 'Chevrolet Avalanche Crew Cab 2012', + 'Chevrolet Cobalt SS 2010', + 'Chevrolet Malibu Hybrid Sedan 2010', + 'Chevrolet TrailBlazer SS 2009', + 'Chevrolet Silverado 2500HD Regular Cab 2012', + 'Chevrolet Silverado 1500 Classic Extended Cab 2007', + 'Chevrolet Express Van 2007', + 'Chevrolet Monte Carlo Coupe 2007', + 'Chevrolet Malibu Sedan 2007', + 'Chevrolet Silverado 1500 Extended Cab 2012', + 'Chevrolet Silverado 1500 Regular Cab 2012', + 'Chrysler Aspen SUV 2009', + 'Chrysler Sebring Convertible 2010', + 'Chrysler Town and Country Minivan 2012', + 'Chrysler 300 SRT-8 2010', + 'Chrysler Crossfire Convertible 2008', + 'Chrysler PT Cruiser Convertible 2008', + 'Daewoo Nubira Wagon 2002', + 'Dodge Caliber Wagon 2012', + 'Dodge Caliber Wagon 2007', + 'Dodge Caravan Minivan 1997', + 'Dodge Ram Pickup 3500 Crew Cab 2010', + 'Dodge Ram Pickup 3500 Quad Cab 2009', + 'Dodge Sprinter Cargo Van 2009', + 'Dodge Journey SUV 2012', + 'Dodge Dakota Crew Cab 2010', + 'Dodge Dakota Club Cab 2007', + 'Dodge Magnum Wagon 2008', + 'Dodge Challenger SRT8 2011', + 'Dodge Durango SUV 2012', + 'Dodge Durango SUV 2007', + 'Dodge Charger Sedan 2012', + 'Dodge Charger SRT-8 2009', + 'Eagle Talon Hatchback 1998', + 'FIAT 500 Abarth 2012', + 'FIAT 500 Convertible 2012', + 'Ferrari FF Coupe 2012', + 'Ferrari California Convertible 2012', + 'Ferrari 458 Italia Convertible 2012', + 'Ferrari 458 Italia Coupe 2012', + 'Fisker Karma Sedan 2012', + 'Ford F-450 Super Duty Crew Cab 2012', + 'Ford Mustang Convertible 2007', + 'Ford Freestar Minivan 2007', + 'Ford Expedition EL SUV 2009', + 'Ford Edge SUV 2012', + 'Ford Ranger SuperCab 2011', + 'Ford GT Coupe 2006', + 'Ford F-150 Regular Cab 2012', + 'Ford F-150 Regular Cab 2007', + 'Ford Focus Sedan 2007', + 'Ford E-Series Wagon Van 2012', + 'Ford Fiesta Sedan 2012', + 'GMC Terrain SUV 2012', + 'GMC Savana Van 2012', + 'GMC Yukon Hybrid SUV 2012', + 'GMC Acadia SUV 2012', + 'GMC Canyon Extended Cab 2012', + 'Geo Metro Convertible 1993', + 'HUMMER H3T Crew Cab 2010', + 'HUMMER H2 SUT Crew Cab 2009', + 'Honda Odyssey Minivan 2012', + 'Honda Odyssey Minivan 2007', + 'Honda Accord Coupe 2012', + 'Honda Accord Sedan 2012', + 'Hyundai Veloster Hatchback 2012', + 'Hyundai Santa Fe SUV 2012', + 'Hyundai Tucson SUV 2012', + 'Hyundai Veracruz SUV 2012', + 'Hyundai Sonata Hybrid Sedan 2012', + 'Hyundai Elantra Sedan 2007', + 'Hyundai Accent Sedan 2012', + 'Hyundai Genesis Sedan 2012', + 'Hyundai Sonata Sedan 2012', + 'Hyundai Elantra Touring Hatchback 2012', + 'Hyundai Azera Sedan 2012', + 'Infiniti G Coupe IPL 2012', + 'Infiniti QX56 SUV 2011', + 'Isuzu Ascender SUV 2008', + 'Jaguar XK XKR 2012', + 'Jeep Patriot SUV 2012', + 'Jeep Wrangler SUV 2012', + 'Jeep Liberty SUV 2012', + 'Jeep Grand Cherokee SUV 2012', + 'Jeep Compass SUV 2012', + 'Lamborghini Reventon Coupe 2008', + 'Lamborghini Aventador Coupe 2012', + 'Lamborghini Gallardo LP 570-4 Superleggera 2012', + 'Lamborghini Diablo Coupe 2001', + 'Land Rover Range Rover SUV 2012', + 'Land Rover LR2 SUV 2012', + 'Lincoln Town Car Sedan 2011', + 'MINI Cooper Roadster Convertible 2012', + 'Maybach Landaulet Convertible 2012', + 'Mazda Tribute SUV 2011', + 'McLaren MP4-12C Coupe 2012', + 'Mercedes-Benz 300-Class Convertible 1993', + 'Mercedes-Benz C-Class Sedan 2012', + 'Mercedes-Benz SL-Class Coupe 2009', + 'Mercedes-Benz E-Class Sedan 2012', + 'Mercedes-Benz S-Class Sedan 2012', + 'Mercedes-Benz Sprinter Van 2012', + 'Mitsubishi Lancer Sedan 2012', + 'Nissan Leaf Hatchback 2012', + 'Nissan NV Passenger Van 2012', + 'Nissan Juke Hatchback 2012', + 'Nissan 240SX Coupe 1998', + 'Plymouth Neon Coupe 1999', + 'Porsche Panamera Sedan 2012', + 'Ram C/V Cargo Van Minivan 2012', + 'Rolls-Royce Phantom Drophead Coupe Convertible 2012', + 'Rolls-Royce Ghost Sedan 2012', + 'Rolls-Royce Phantom Sedan 2012', + 'Scion xD Hatchback 2012', + 'Spyker C8 Convertible 2009', + 'Spyker C8 Coupe 2009', + 'Suzuki Aerio Sedan 2007', + 'Suzuki Kizashi Sedan 2012', + 'Suzuki SX4 Hatchback 2012', + 'Suzuki SX4 Sedan 2012', + 'Tesla Model S Sedan 2012', + 'Toyota Sequoia SUV 2012', + 'Toyota Camry Sedan 2012', + 'Toyota Corolla Sedan 2012', + 'Toyota 4Runner SUV 2012', + 'Volkswagen Golf Hatchback 2012', + 'Volkswagen Golf Hatchback 1991', + 'Volkswagen Beetle Hatchback 2012', + 'Volvo C30 Hatchback 2012', + 'Volvo 240 Sedan 1993', + 'Volvo XC90 SUV 2007', + 'smart fortwo Convertible 2012', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', + 'a photo of my {}.', + 'i love my {}!', + 'a photo of my dirty {}.', + 'a photo of my clean {}.', + 'a photo of my new {}.', + 'a photo of my old {}.', +] +``` + + + +## UCF101 + +```bash +classes = [ + 'Apply Eye Makeup', + 'Apply Lipstick', + 'Archery', + 'Baby Crawling', + 'Balance Beam', + 'Band Marching', + 'Baseball Pitch', + 'Basketball', + 'Basketball Dunk', + 'Bench Press', + 'Biking', + 'Billiards', + 'Blow Dry Hair', + 'Blowing Candles', + 'Body Weight Squats', + 'Bowling', + 'Boxing Punching Bag', + 'Boxing Speed Bag', + 'Breast Stroke', + 'Brushing Teeth', + 'Clean And Jerk', + 'Cliff Diving', + 'Cricket Bowling', + 'Cricket Shot', + 'Cutting In Kitchen', + 'Diving', + 'Drumming', + 'Fencing', + 'Field Hockey Penalty', + 'Floor Gymnastics', + 'Frisbee Catch', + 'Front Crawl', + 'Golf Swing', + 'Haircut', + 'Hammer Throw', + 'Hammering', + 'Hand Stand Pushups', + 'Handstand Walking', + 'Head Massage', + 'High Jump', + 'Horse Race', + 'Horse Riding', + 'Hula Hoop', + 'Ice Dancing', + 'Javelin Throw', + 'Juggling Balls', + 'Jump Rope', + 'Jumping Jack', + 'Kayaking', + 'Knitting', + 'Long Jump', + 'Lunges', + 'Military Parade', + 'Mixing', + 'Mopping Floor', + 'Nunchucks', + 'Parallel Bars', + 'Pizza Tossing', + 'Playing Cello', + 'Playing Daf', + 'Playing Dhol', + 'Playing Flute', + 'Playing Guitar', + 'Playing Piano', + 'Playing Sitar', + 'Playing Tabla', + 'Playing Violin', + 'Pole Vault', + 'Pommel Horse', + 'Pull Ups', + 'Punch', + 'Push Ups', + 'Rafting', + 'Rock Climbing Indoor', + 'Rope Climbing', + 'Rowing', + 'Salsa Spin', + 'Shaving Beard', + 'Shotput', + 'Skate Boarding', + 'Skiing', + 'Skijet', + 'Sky Diving', + 'Soccer Juggling', + 'Soccer Penalty', + 'Still Rings', + 'Sumo Wrestling', + 'Surfing', + 'Swing', + 'Table Tennis Shot', + 'Tai Chi', + 'Tennis Swing', + 'Throw Discus', + 'Trampoline Jumping', + 'Typing', + 'Uneven Bars', + 'Volleyball Spiking', + 'Walking With Dog', + 'Wall Pushups', + 'Writing On Board', + 'Yo Yo', +] + +templates = [ + 'a photo of a person {}.', + 'a video of a person {}.', + 'a example of a person {}.', + 'a demonstration of a person {}.', + 'a photo of the person {}.', + 'a video of the person {}.', + 'a example of the person {}.', + 'a demonstration of the person {}.', + 'a photo of a person using {}.', + 'a video of a person using {}.', + 'a example of a person using {}.', + 'a demonstration of a person using {}.', + 'a photo of the person using {}.', + 'a video of the person using {}.', + 'a example of the person using {}.', + 'a demonstration of the person using {}.', + 'a photo of a person doing {}.', + 'a video of a person doing {}.', + 'a example of a person doing {}.', + 'a demonstration of a person doing {}.', + 'a photo of the person doing {}.', + 'a video of the person doing {}.', + 'a example of the person doing {}.', + 'a demonstration of the person doing {}.', + 'a photo of a person during {}.', + 'a video of a person during {}.', + 'a example of a person during {}.', + 'a demonstration of a person during {}.', + 'a photo of the person during {}.', + 'a video of the person during {}.', + 'a example of the person during {}.', + 'a demonstration of the person during {}.', + 'a photo of a person performing {}.', + 'a video of a person performing {}.', + 'a example of a person performing {}.', + 'a demonstration of a person performing {}.', + 'a photo of the person performing {}.', + 'a video of the person performing {}.', + 'a example of the person performing {}.', + 'a demonstration of the person performing {}.', + 'a photo of a person practicing {}.', + 'a video of a person practicing {}.', + 'a example of a person practicing {}.', + 'a demonstration of a person practicing {}.', + 'a photo of the person practicing {}.', + 'a video of the person practicing {}.', + 'a example of the person practicing {}.', + 'a demonstration of the person practicing {}.', +] +``` + + diff --git a/CLIP/data/rendered-sst2.md b/CLIP/data/rendered-sst2.md new file mode 100644 index 0000000000000000000000000000000000000000..d27454caf046d8d699f87b8cb8404a05e488dbef --- /dev/null +++ b/CLIP/data/rendered-sst2.md @@ -0,0 +1,11 @@ +# The Rendered SST2 Dataset + +In the paper, we used an image classification dataset called Rendered SST2, to evaluate the model's capability on optical character recognition. To do so, we rendered the sentences in the [Standford Sentiment Treebank v2](https://nlp.stanford.edu/sentiment/treebank.html) dataset and used those as the input to the CLIP image encoder. + +The following command will download a 131MB archive countaining the images and extract into a subdirectory `rendered-sst2`: + +```bash +wget https://openaipublic.azureedge.net/clip/data/rendered-sst2.tgz +tar zxvf rendered-sst2.tgz +``` + diff --git a/CLIP/data/yfcc100m.md b/CLIP/data/yfcc100m.md new file mode 100644 index 0000000000000000000000000000000000000000..06083ef9a613b5d360e87c3f395c2a16c6e9208e --- /dev/null +++ b/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/). \ No newline at end of file diff --git a/CLIP/hubconf.py b/CLIP/hubconf.py new file mode 100644 index 0000000000000000000000000000000000000000..520b354b62ab4d199d49462e9c65890d924c69e6 --- /dev/null +++ b/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) \ No newline at end of file diff --git a/CLIP/model-card.md b/CLIP/model-card.md new file mode 100644 index 0000000000000000000000000000000000000000..6db1ca46f0706d2276e0c95578f4aa4dc0136e58 --- /dev/null +++ b/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) diff --git a/CLIP/notebooks/Interacting_with_CLIP.ipynb b/CLIP/notebooks/Interacting_with_CLIP.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..1043f2389d3aa8dde666036ce7221bea2cce6754 --- /dev/null +++ b/CLIP/notebooks/Interacting_with_CLIP.ipynb @@ -0,0 +1,925 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Interacting with CLIP.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "1369964d45004b5e95a058910b2a33e6": { + "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_12e23e2819094ee0a079d4eb77cfc4f9", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_7a5f52e56ede4ac3abe37a3ece007dc9", + "IPY_MODEL_ce8b0faa1a1340b5a504d7b3546b3ccb" + ] + } + }, + "12e23e2819094ee0a079d4eb77cfc4f9": { + "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 + } + }, + "7a5f52e56ede4ac3abe37a3ece007dc9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_5e6adc4592124a4581b85f4c1f3bab4d", + "_dom_classes": [], + "description": "", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 169001437, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 169001437, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_4a61c10fc00c4f04bb00b82e942da210" + } + }, + "ce8b0faa1a1340b5a504d7b3546b3ccb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_b597cd6f6cd443aba4bf4491ac7f957e", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 169001984/? [00:06<00:00, 25734958.25it/s]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_161969cae25a49f38aacd1568d3cac6c" + } + }, + "5e6adc4592124a4581b85f4c1f3bab4d": { + "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" + } + }, + "4a61c10fc00c4f04bb00b82e942da210": { + "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 + } + }, + "b597cd6f6cd443aba4bf4491ac7f957e": { + "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" + } + }, + "161969cae25a49f38aacd1568d3cac6c": { + "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": "YPHN7PJgKOzb" + }, + "source": [ + "# Interacting with CLIP\n", + "\n", + "This is a self-contained notebook that shows how to download and run CLIP models, calculate the similarity between arbitrary image and text inputs, and perform zero-shot image classifications." + ] + }, + { + "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": "4d9b51f8-d255-4868-97f6-be0a67dadfae" + }, + "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 34.6 MB/s eta 0:00:01\r\u001b[K |██████████▏ | 20 kB 20.7 MB/s eta 0:00:01\r\u001b[K |███████████████▎ | 30 kB 16.4 MB/s eta 0:00:01\r\u001b[K |████████████████████▍ | 40 kB 15.2 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▌ | 51 kB 7.0 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▋ | 61 kB 8.2 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 64 kB 2.6 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=ce00f21233e5e1a5c3e84204d651ae0c17403484418c330c69ebae7297ca7003\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-tbmjxrgj\n", + " Running command git clone -q https://github.com/openai/CLIP.git /tmp/pip-req-build-tbmjxrgj\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: pillow>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (7.1.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (1.19.5)\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=9059060f3a406b8268cfcbbf03647ab9b59e660d03f86c6120a9dd06f2b82cec\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-7v3mrcvj/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": "70a44964-883d-4fd0-b95a-2c7f2b19aca9" + }, + "source": [ + "import numpy as np\n", + "import torch\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", + "`clip.available_models()` will list the names of available CLIP models." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uLFS29hnhlY4", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "11779e1e-8bdd-4167-c18e-d26bdd6b67db" + }, + "source": [ + "import clip\n", + "\n", + "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": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IBRVTY9lbGm8", + "outputId": "f06fd2fd-6126-475b-87d0-b10aa3b7da49" + }, + "source": [ + "model, preprocess = clip.load(\"ViT-B/32\")\n", + "model.cuda().eval()\n", + "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": 4, + "outputs": [ + { + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 338M/338M [00:05<00:00, 63.0MiB/s]\n" + ], + "name": "stderr" + }, + { + "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": "21slhZGCqANb" + }, + "source": [ + "# Image Preprocessing\n", + "\n", + "We resize the input images and center-crop them to conform with the image resolution that the model expects. Before doing so, we will normalize the pixel intensity using the dataset mean and standard deviation.\n", + "\n", + "The second return value from `clip.load()` contains a torchvision `Transform` that performs this preprocessing.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "d6cpiIFHp9N6", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "880cb98e-1e5e-430e-8b59-4bf35fa554f9" + }, + "source": [ + "preprocess" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Compose(\n", + " Resize(size=224, interpolation=bicubic, max_size=None, antialias=None)\n", + " CenterCrop(size=(224, 224))\n", + " . at 0x7f3a24ffb440>\n", + " ToTensor()\n", + " Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711))\n", + ")" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xwSB5jZki3Cj" + }, + "source": [ + "# Text Preprocessing\n", + "\n", + "We use a case-insensitive tokenizer, which can be invoked using `clip.tokenize()`. By default, the outputs are padded to become 77 tokens long, which is what the CLIP models expects." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qGom156-i2kL", + "outputId": "050b0ce1-caba-47e1-f4ac-dba994599718" + }, + "source": [ + "clip.tokenize(\"Hello World!\")" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[49406, 3306, 1002, 256, 49407, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4W8ARJVqBJXs" + }, + "source": [ + "# Setting up input images and texts\n", + "\n", + "We are going to feed 8 example images and their textual descriptions to the model, and compare the similarity between the corresponding features.\n", + "\n", + "The tokenizer is case-insensitive, and we can freely give any suitable textual descriptions." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tMc1AXzBlhzm" + }, + "source": [ + "import os\n", + "import skimage\n", + "import IPython.display\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "from collections import OrderedDict\n", + "import torch\n", + "\n", + "%matplotlib inline\n", + "%config InlineBackend.figure_format = 'retina'\n", + "\n", + "# images in skimage to use and their textual descriptions\n", + "descriptions = {\n", + " \"page\": \"a page of text about segmentation\",\n", + " \"chelsea\": \"a facial photo of a tabby cat\",\n", + " \"astronaut\": \"a portrait of an astronaut with the American flag\",\n", + " \"rocket\": \"a rocket standing on a launchpad\",\n", + " \"motorcycle_right\": \"a red motorcycle standing in a garage\",\n", + " \"camera\": \"a person looking at a camera on a tripod\",\n", + " \"horse\": \"a black-and-white silhouette of a horse\", \n", + " \"coffee\": \"a cup of coffee on a saucer\"\n", + "}" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "NSSrLY185jSf", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 368 + }, + "outputId": "06451963-5ecb-4ddc-d0a8-24e9b110af7d" + }, + "source": [ + "original_images = []\n", + "images = []\n", + "texts = []\n", + "plt.figure(figsize=(16, 5))\n", + "\n", + "for filename in [filename for filename in os.listdir(skimage.data_dir) if filename.endswith(\".png\") or filename.endswith(\".jpg\")]:\n", + " name = os.path.splitext(filename)[0]\n", + " if name not in descriptions:\n", + " continue\n", + "\n", + " image = Image.open(os.path.join(skimage.data_dir, filename)).convert(\"RGB\")\n", + " \n", + " plt.subplot(2, 4, len(images) + 1)\n", + " plt.imshow(image)\n", + " plt.title(f\"{filename}\\n{descriptions[name]}\")\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + "\n", + " original_images.append(image)\n", + " images.append(preprocess(image))\n", + " texts.append(descriptions[name])\n", + "\n", + "plt.tight_layout()\n" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 1116, + "height": 351 + } + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WEVKsji6WOIX" + }, + "source": [ + "## Building features\n", + "\n", + "We normalize the images, tokenize each text input, and run the forward pass of the model to get the image and text features." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "HBgCanxi8JKw" + }, + "source": [ + "image_input = torch.tensor(np.stack(images)).cuda()\n", + "text_tokens = clip.tokenize([\"This is \" + desc for desc in texts]).cuda()" + ], + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZN9I0nIBZ_vW" + }, + "source": [ + "with torch.no_grad():\n", + " image_features = model.encode_image(image_input).float()\n", + " text_features = model.encode_text(text_tokens).float()" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cuxm2Gt4Wvzt" + }, + "source": [ + "## Calculating cosine similarity\n", + "\n", + "We normalize the features and calculate the dot product of each pair." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yKAxkQR7bf3A" + }, + "source": [ + "image_features /= image_features.norm(dim=-1, keepdim=True)\n", + "text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "similarity = text_features.cpu().numpy() @ image_features.cpu().numpy().T" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "C5zvMxh8cU6m", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 831 + }, + "outputId": "22bca748-ab42-4888-c9da-8f22c21c6185" + }, + "source": [ + "count = len(descriptions)\n", + "\n", + "plt.figure(figsize=(20, 14))\n", + "plt.imshow(similarity, vmin=0.1, vmax=0.3)\n", + "# plt.colorbar()\n", + "plt.yticks(range(count), texts, fontsize=18)\n", + "plt.xticks([])\n", + "for i, image in enumerate(original_images):\n", + " plt.imshow(image, extent=(i - 0.5, i + 0.5, -1.6, -0.6), origin=\"lower\")\n", + "for x in range(similarity.shape[1]):\n", + " for y in range(similarity.shape[0]):\n", + " plt.text(x, y, f\"{similarity[y, x]:.2f}\", ha=\"center\", va=\"center\", size=12)\n", + "\n", + "for side in [\"left\", \"top\", \"right\", \"bottom\"]:\n", + " plt.gca().spines[side].set_visible(False)\n", + "\n", + "plt.xlim([-0.5, count - 0.5])\n", + "plt.ylim([count + 0.5, -2])\n", + "\n", + "plt.title(\"Cosine similarity between text and image features\", size=20)" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Cosine similarity between text and image features')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 12 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 1038, + "height": 796 + }, + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "alePijoXy6AH" + }, + "source": [ + "# Zero-Shot Image Classification\n", + "\n", + "You can classify images using the cosine similarity (times 100) as the logits to the softmax operation." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Nqu4GlfPfr-p", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102, + "referenced_widgets": [ + "1369964d45004b5e95a058910b2a33e6", + "12e23e2819094ee0a079d4eb77cfc4f9", + "7a5f52e56ede4ac3abe37a3ece007dc9", + "ce8b0faa1a1340b5a504d7b3546b3ccb", + "5e6adc4592124a4581b85f4c1f3bab4d", + "4a61c10fc00c4f04bb00b82e942da210", + "b597cd6f6cd443aba4bf4491ac7f957e", + "161969cae25a49f38aacd1568d3cac6c" + ] + }, + "outputId": "ca7a0e3c-e267-4e6e-8a1b-bbab3c0a2462" + }, + "source": [ + "from torchvision.datasets import CIFAR100\n", + "\n", + "cifar100 = CIFAR100(os.path.expanduser(\"~/.cache\"), transform=preprocess, download=True)" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Downloading https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz to /root/.cache/cifar-100-python.tar.gz\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1369964d45004b5e95a058910b2a33e6", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=169001437.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n", + "Extracting /root/.cache/cifar-100-python.tar.gz to /root/.cache\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C4S__zCGy2MT" + }, + "source": [ + "text_descriptions = [f\"This is a photo of a {label}\" for label in cifar100.classes]\n", + "text_tokens = clip.tokenize(text_descriptions).cuda()" + ], + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "c4z1fm9vCpSR" + }, + "source": [ + "with torch.no_grad():\n", + " text_features = model.encode_text(text_tokens).float()\n", + " text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "\n", + "text_probs = (100.0 * image_features @ text_features.T).softmax(dim=-1)\n", + "top_probs, top_labels = text_probs.cpu().topk(5, dim=-1)" + ], + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 931 + }, + "id": "T6Ju_6IBE2Iz", + "outputId": "e1a155dc-474d-409c-e03d-d41b804648c3" + }, + "source": [ + "plt.figure(figsize=(16, 16))\n", + "\n", + "for i, image in enumerate(original_images):\n", + " plt.subplot(4, 4, 2 * i + 1)\n", + " plt.imshow(image)\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(4, 4, 2 * i + 2)\n", + " y = np.arange(top_probs.shape[-1])\n", + " plt.grid()\n", + " plt.barh(y, top_probs[i])\n", + " plt.gca().invert_yaxis()\n", + " plt.gca().set_axisbelow(True)\n", + " plt.yticks(y, [cifar100.classes[index] for index in top_labels[i].numpy()])\n", + " plt.xlabel(\"probability\")\n", + "\n", + "plt.subplots_adjust(wspace=0.5)\n", + "plt.show()" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 917, + "height": 914 + }, + "needs_background": "light" + } + } + ] + } + ] +} diff --git a/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb b/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..dba7fb654f4bed7adff1da1e7d4297670ea51469 --- /dev/null +++ b/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" + } + ] + } + ] +} diff --git a/CLIP/requirements.txt b/CLIP/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..6b98c33f3a0e09ddf982606430472de3061c6e9f --- /dev/null +++ b/CLIP/requirements.txt @@ -0,0 +1,5 @@ +ftfy +regex +tqdm +torch +torchvision diff --git a/CLIP/setup.py b/CLIP/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..c9ea7d0d2f3d2fcf66d6f6e2aa0eb1a97a524bb6 --- /dev/null +++ b/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']}, +) diff --git a/CLIP/tests/test_consistency.py b/CLIP/tests/test_consistency.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c6fd4fe9074143803e0eb6c99fa02a47632094 --- /dev/null +++ b/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) diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..bca18735afd3a66b3c7564d9b6367ddc12f6ce36 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,6 @@ +FROM --platform=linux/amd64 python:3.9.2-slim +WORKDIR /workspace +#COPY requirements.txt ./ +RUN apt-get update && apt-get install -y gcc g++ +# COPY . /workspace +CMD ["bash"] diff --git a/Dockerfile~ b/Dockerfile~ new file mode 100644 index 0000000000000000000000000000000000000000..d38b09b1430989174857ad5d13ec5928164e60ee --- /dev/null +++ b/Dockerfile~ @@ -0,0 +1,6 @@ +FROM --platform=linux/amd64 python:3.9-slim +WORKDIR /workspace +#COPY requirements.txt ./ +RUN apt update && apt install gcc +COPY . /workspace +CMD ["bash"] diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..eae037336a3e9ec94a70a9436403a4fd7fecbd20 --- /dev/null +++ b/LICENSE @@ -0,0 +1,33 @@ +The Clear BSD License + +Copyright (c) 2024 Yuiga Wada + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted (subject to the limitations in the disclaimer +below) provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from this + software without specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY +THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR +BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER +IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/README.md b/README.md index 063a5504240ab97abe7ad417f47a25f2968bb7e7..7ff7fc017215a7a23c8e6da1e80a6db7a0bac242 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,11 @@ ---- -title: Polos -emoji: 🖼 -colorFrom: purple -colorTo: red -sdk: gradio -sdk_version: 4.26.0 -app_file: app.py -pinned: false -license: bsd-3-clause-clear ---- +## Get Started on M1 Mac +```bash +git submodule update --init --recursive +docker build . -t polos_demo +docker run -it -d -v `pwd`:/workspace -p 8080:8080 --platform linux/amd64 polos_demo +docker exec -it $process_id bash -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference +root@28cb354f7609:~# sh install.sh +root@28cb354f7609:~# poetry run python test.py +root@28cb354f7609:~# poetry run streamlit run test.py --server.port 8080 +``` diff --git a/app.py b/app.py index 7fd71f3866eed8b72f1a4c5185fb07ff5de7cb8d..9a4d2143ddc8f817de5bf403714ce0e95b3530d9 100644 --- a/app.py +++ b/app.py @@ -1,146 +1,38 @@ -import gradio as gr -import numpy as np -import random -from diffusers import DiffusionPipeline -import torch - -device = "cuda" if torch.cuda.is_available() else "cpu" - -if torch.cuda.is_available(): - torch.cuda.max_memory_allocated(device=device) - pipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl-turbo", torch_dtype=torch.float16, variant="fp16", use_safetensors=True) - pipe.enable_xformers_memory_efficient_attention() - pipe = pipe.to(device) -else: - pipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl-turbo", use_safetensors=True) - pipe = pipe.to(device) - -MAX_SEED = np.iinfo(np.int32).max -MAX_IMAGE_SIZE = 1024 - -def infer(prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps): - - if randomize_seed: - seed = random.randint(0, MAX_SEED) - - generator = torch.Generator().manual_seed(seed) - - image = pipe( - prompt = prompt, - negative_prompt = negative_prompt, - guidance_scale = guidance_scale, - num_inference_steps = num_inference_steps, - width = width, - height = height, - generator = generator - ).images[0] - - return image - -examples = [ - "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", - "An astronaut riding a green horse", - "A delicious ceviche cheesecake slice", +import streamlit as st +from PIL import Image +from polos.models import download_model, load_checkpoint + +@st.cache(allow_output_mutation=True) +def load_model(): + model_path = download_model("polos") + model = load_checkpoint(model_path) + return model + +model = load_model() + +default_image = Image.open("test.jpg").convert("RGB") +default_refs = [ + "there is a dog sitting on a couch with a person reaching out", + "a dog laying on a couch with a person", + 'a dog is laying on a couch with a person' ] -css=""" -#col-container { - margin: 0 auto; - max-width: 520px; -} -""" - -if torch.cuda.is_available(): - power_device = "GPU" -else: - power_device = "CPU" - -with gr.Blocks(css=css) as demo: - - with gr.Column(elem_id="col-container"): - gr.Markdown(f""" - # Text-to-Image Gradio Template - Currently running on {power_device}. - """) - - with gr.Row(): - - prompt = gr.Text( - label="Prompt", - show_label=False, - max_lines=1, - placeholder="Enter your prompt", - container=False, - ) - - run_button = gr.Button("Run", scale=0) - - result = gr.Image(label="Result", show_label=False) +data = [ + { + "img": default_image, + "mt": "", + "refs": default_refs + } +] - with gr.Accordion("Advanced Settings", open=False): - - negative_prompt = gr.Text( - label="Negative prompt", - max_lines=1, - placeholder="Enter a negative prompt", - visible=False, - ) - - seed = gr.Slider( - label="Seed", - minimum=0, - maximum=MAX_SEED, - step=1, - value=0, - ) - - randomize_seed = gr.Checkbox(label="Randomize seed", value=True) - - with gr.Row(): - - width = gr.Slider( - label="Width", - minimum=256, - maximum=MAX_IMAGE_SIZE, - step=32, - value=512, - ) - - height = gr.Slider( - label="Height", - minimum=256, - maximum=MAX_IMAGE_SIZE, - step=32, - value=512, - ) - - with gr.Row(): - - guidance_scale = gr.Slider( - label="Guidance scale", - minimum=0.0, - maximum=10.0, - step=0.1, - value=0.0, - ) - - num_inference_steps = gr.Slider( - label="Number of inference steps", - minimum=1, - maximum=12, - step=1, - value=2, - ) - - gr.Examples( - examples = examples, - inputs = [prompt] - ) +# Streamlitインターフェースの設定 +st.title('Polos Demo') - run_button.click( - fn = infer, - inputs = [prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps], - outputs = [result] - ) +# ユーザー入力のテキストフィールド +user_input = st.text_input("Enter the input sentence:", '') -demo.queue().launch() \ No newline at end of file +# 入力がある場合、モデルを使用してスコアを計算 +if user_input: + data[0]['mt'] = user_input + _, scores = model.predict(data, batch_size=1, cuda=False) + st.write("Score:", scores) \ No newline at end of file diff --git a/configs/polos-trainer.yaml b/configs/polos-trainer.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b56e46ef686ddb8e3c4e9396f04d6a740216ce06 --- /dev/null +++ b/configs/polos-trainer.yaml @@ -0,0 +1,46 @@ +seed: 42 +monitor: pearson +metric_mode: max +early_stopping: True +patience: 1 +min_delta: 0.0 +save_top_k: 2 +save_weights_only: False +min_epochs: 1 +max_epochs: 100 +gradient_clip_val: 1.0 +gpus: 1 +precision: 32 + +batch_size: 64 +accumulate_grad_batches: 4 +loader_workers: 4 + +optimizer: Adam +learning_rate: 3.0e-05 +encoder_learning_rate: 1.0e-05 +layerwise_decay: 0.95 +nr_frozen_epochs: 100000 +scheduler: constant + +train_path: data_en/polaris/polaris_train.csv +val_path: data_en/polaris/polaris_val.csv +test_path: data_en/polaris/polaris_test.csv +train_img_dir_path: data_en/polaris/images +val_img_dir_path: data_en/polaris/images +test_img_dir_path: data_en/polaris/images + +model: PolosEstimator +loss: mse +encoder_model: BERT +# pretrained_model: princeton-nlp/sup-simcse-roberta-large +pretrained_model: princeton-nlp/sup-simcse-roberta-base + +layer: mix +scalar_mix_dropout: 0.1 +pool: cls + +dropout: 0.1 +activations: Tanh +hidden_sizes: "2304,1152" +final_activation: False diff --git a/docker.sh b/docker.sh new file mode 100644 index 0000000000000000000000000000000000000000..d0b02476586ea24d306f7bc73dcf7f72861d558e --- /dev/null +++ b/docker.sh @@ -0,0 +1,4 @@ +# Run the following scripts +#docker build . +#docker run -it -d --platform linux/amd64 c330 +#docker exec -it 56fec4a536ceee5e76706dde62e4f7d706cf96941a27771b53d7589d882b8ce9 bash diff --git a/install.sh b/install.sh new file mode 100644 index 0000000000000000000000000000000000000000..35b94e7b74a2b1171c7eb698093c7ac69b803673 --- /dev/null +++ b/install.sh @@ -0,0 +1,4 @@ +git submodule update --init --recursive +pip install poetry +poetry install +#pip install torch==2.0.0+cu117 torchvision==0.15.1+cu117 torchaudio==2.0.1 --index-url https://download.pytorch.org/whl/cu117 diff --git a/pacscore/README.md b/pacscore/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7fec9d11ec5a8260b8e15753bcb0cf7d04103f5d --- /dev/null +++ b/pacscore/README.md @@ -0,0 +1,135 @@ +
+

PAC-Score: Positive-Augmented Contrastive Learning for Image and Video Captioning Evaluation (CVPR 2023)

+ + +PyTorch +[![Conference](https://img.shields.io/badge/CVPR-2023(Highlight)-f9f107.svg)](https://openaccess.thecvf.com/content/CVPR2023/html/Sarto_Positive-Augmented_Contrastive_Learning_for_Image_and_Video_Captioning_Evaluation_CVPR_2023_paper.html) +[![Paper](https://img.shields.io/badge/Paper-arxiv.2303.12112-B31B1B.svg)](https://arxiv.org/abs/2303.12112) + +
+ +This repository contains the reference code for the paper [Positive-Augmented Contrastive Learning for Image and Video Captioning Evaluation](https://arxiv.org/abs/2303.12112), **CVPR 2023 Highlight✨** (top 2.5% of initial submissions and top 10% of accepted papers). + +Please cite with the following BibTeX: +``` +@inproceedings{sarto2023positive, + title={{Positive-Augmented Contrastive Learning for Image and Video Captioning Evaluation}}, + author={Sarto, Sara and Barraco, Manuele and Cornia, Marcella and Baraldi, Lorenzo and Cucchiara, Rita}, + booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition}, + year={2023} +} +``` + +

+ PACS +

+ +Try out the [Web demo](https://ailb-web.ing.unimore.it/pacscore), using [Gradio](https://github.com/gradio-app/gradio). + +## Environment Setup +Clone the repository and create the ```pacs``` conda environment using the ```environment.yml``` file: + + +``` +conda env create -f environment.yml +conda activate pacs +``` + +## Loading CLIP Models and Data Preparation +Checkpoints of different backbones are available at [this link](https://drive.google.com/drive/folders/15Da_nh7CYv8xfryIdETG6dPFSqcBiqpd?usp=sharing). + +Once you have downloaded the checkpoints, place them under the ```checkpoints/``` folder. + +| **Backbone** | **Checkpoint** | +| -------------- | ------------- | +| **CLIP ViT-B-32** | clip_ViT-B-32.pth | +| **OpenCLIP ViT-L-14** | openClip_ViT-L-14.pth | + +An example set of inputs, including a candidate json, image directory, and references json is provided in this repository under ```example/```. The input files are formatted as follows. + +The candidates json should be a dictionary that maps from {"image_identifier": "candidate_captions"}: +``` +{"image1": "A white dog is laying on the ground with its head on its paws .", + ...} +``` +The image directory should be a directory containing the images that act as the keys in the candidates json: +``` +images/ +├── image1.jpg +└── image2.jpg +``` +The references json should be a dictionary that maps from {"image_identifier": ["list", "of", "references"]}: +``` +{"image1": + [ + "A closeup of a white dog that is laying its head on its paws .", + "a large white dog lying on the floor .", + "A white dog has its head on the ground .", + "A white dog is resting its head on a tiled floor with its eyes open .", + "A white dog rests its head on the patio bricks ." + ]} +``` +## Quick Start: Compute PAC-S + +Run ```python -u compute_metrics.py``` to obtain standard captioning metrics (_e.g._ BLEU, METEOR, etc.) and PAC-S. + +To compute RefPAC-S run ```python -u compute_metrics.py --compute_refpac```. + +The default backbone used is the CLIP ViT-B-32 model. To use a different backcbone (_e.g._ OpenCLIP ViT-L/14 backbone) specify in the command input ```--clip_model open_clip_ViT-L/14```. + +``` +BLEU-1: 0.6400 +BLEU-4: 0.3503 +METEOR: 0.3057 +ROUGE: 0.5012 +CIDER: 1.4918 +PAC-S: 0.8264 +RefPAC-S: 0.8393 +``` +Worse captions should get lower scores: + +``` +python -u compute_metrics.py --candidates_json example/bad_captions.json --compute_refpac + +BLEU-1: 0.4500 +BLEU-4: 0.0000 +METEOR: 0.0995 +ROUGE: 0.3268 +CIDER: 0.4259 +PAC-S: 0.5772 +RefPAC-S: 0.6357 + +``` +## Human Correlation Scores + +#### Flickr8k + +The Flickr8k dataset can be downloaded at [this link](https://drive.google.com/drive/folders/1oQY8zVCmf0ZGUfsJQ_OnqP2_kw1jGIXp?usp=sharing). + +Once you have downloaded the dataset, place them under the ```datasets/flickr8k``` folder. + + +#### Run Code and Expected Output + +Run ```python -u compute_correlations.py``` to compute correlation scores on **Flickr8k-Expert** and **Flickr8k-CF** datasets. + + +``` +Computing correlation scores on dataset: flickr8k_expert +BLEU-1 Kendall Tau-b: 32.175 Kendall Tau-c: 32.324 +BLEU-4 Kendall Tau-b: 30.599 Kendall Tau-c: 30.776 +METEOR Kendall Tau-b: 41.538 Kendall Tau-c: 41.822 +ROUGE Kendall Tau-b: 32.139 Kendall Tau-c: 32.314 +CIDER Kendall Tau-b: 43.602 Kendall Tau-c: 43.891 +PAC-S Kendall Tau-b: 53.919 Kendall Tau-c: 54.292 + +Computing correlation scores on dataset: flickr8k_cf +BLEU-1 Kendall Tau-b: 17.946 Kendall Tau-c: 9.256 +BLEU-4 Kendall Tau-b: 16.863 Kendall Tau-c: 8.710 +METEOR Kendall Tau-b: 22.269 Kendall Tau-c: 11.510 +ROUGE Kendall Tau-b: 19.903 Kendall Tau-c: 10.274 +CIDER Kendall Tau-b: 24.619 Kendall Tau-c: 12.724 +PAC-S Kendall Tau-b: 36.037 Kendall Tau-c: 18.628 +``` + +For the reference based version of the PACScore, add ```--compute_refpac```. diff --git a/pacscore/compute_correlations.py b/pacscore/compute_correlations.py new file mode 100644 index 0000000000000000000000000000000000000000..e8a835727c1b1a7b0ddb8c21990769578c8e4025 --- /dev/null +++ b/pacscore/compute_correlations.py @@ -0,0 +1,111 @@ +import argparse +import torch +import evaluation +import scipy.stats + +from models.clip import clip +from utils import collate_fn +from evaluation import PACScore, RefPACScore +from models import open_clip +from data import Flickr8k +from torch.utils.data import DataLoader + + +_MODELS = { + "ViT-B/32": "checkpoints/clip_ViT-B-32.pth", + "open_clip_ViT-L/14": "checkpoints/openClip_ViT-L-14.pth" +} + +def compute_correlation_scores(dataloader, model, preprocess, args): + gen = {} + gts = {} + + human_scores = list() + ims_cs = list() + gen_cs = list() + gts_cs = list() + all_scores = dict() + model.eval() + + for it, (images, candidates, references, scores) in enumerate(iter(dataloader)): + for i, (im_i, gts_i, gen_i, score_i) in enumerate(zip(images, references, candidates, scores)): + gen['%d_%d' % (it, i)] = [gen_i, ] + gts['%d_%d' % (it, i)] = gts_i + + ims_cs.append(im_i) + gen_cs.append(gen_i) + gts_cs.append(gts_i) + human_scores.append(score_i) + + gts = evaluation.PTBTokenizer.tokenize(gts) + gen = evaluation.PTBTokenizer.tokenize(gen) + all_scores_metrics = evaluation.get_all_metrics(gts, gen, return_per_cap=True) + + for k, v in all_scores_metrics.items(): + if k == 'BLEU': + all_scores['BLEU-1'] = v[0] + all_scores['BLEU-4'] = v[-1] + else: + all_scores[k] = v + + # PAC-S + _, pac_scores, candidate_feats, len_candidates = PACScore(model, preprocess, ims_cs, gen_cs, device, w=2.0) + all_scores['PAC-S'] = pac_scores + + # RefPAC-S + if args.compute_refpac: + _, per_instance_text_text = RefPACScore(model, gts_cs, candidate_feats, device, torch.tensor(len_candidates)) + refpac_scores = 2 * pac_scores * per_instance_text_text / (pac_scores + per_instance_text_text) + all_scores['RefPAC-S'] = refpac_scores + + for k, v in all_scores.items(): + kendalltau_b = 100 * scipy.stats.kendalltau(v, human_scores, variant='b')[0] + kendalltau_c = 100 * scipy.stats.kendalltau(v, human_scores, variant='c')[0] + print('%s \t Kendall Tau-b: %.3f \t Kendall Tau-c: %.3f' + % (k, kendalltau_b, kendalltau_c)) + + +def compute_scores(model, preprocess, args): + args.datasets = ['flickr8k_expert', 'flickr8k_cf'] + + args.batch_size_compute_score = 10 + for d in args.datasets: + print("Computing correlation scores on dataset: " + d) + if d == 'flickr8k_expert': + dataset = Flickr8k(json_file='flickr8k.json') + dataloader = DataLoader(dataset, batch_size=args.batch_size_compute_score, shuffle=False, collate_fn=collate_fn) + elif d == 'flickr8k_cf': + dataset = Flickr8k(json_file='crowdflower_flickr8k.json') + dataloader = DataLoader(dataset, batch_size=args.batch_size_compute_score, shuffle=False, collate_fn=collate_fn) + + compute_correlation_scores(dataloader, model, preprocess, args) + + + +if __name__ == '__main__': + # Argument parsing + parser = argparse.ArgumentParser(description='PAC-S evaluation') + parser.add_argument('--clip_model', type=str, default='ViT-B/32', + choices=['ViT-B/32', 'open_clip_ViT-L/14']) + parser.add_argument('--compute_refpac', action='store_true') + + args = parser.parse_args() + + device = "cuda" if torch.cuda.is_available() else "cpu" + + if args.clip_model.startswith('open_clip'): + print("Using Open CLIP Model: " + args.clip_model) + model, _, preprocess = open_clip.create_model_and_transforms('ViT-L-14', pretrained='laion2b_s32b_b82k') + else: + print("Using CLIP Model: " + args.clip_model) + model, preprocess = clip.load(args.clip_model, device=device) + + model = model.to(device) + model = model.float() + + checkpoint = torch.load(_MODELS[args.clip_model]) + model.load_state_dict(checkpoint['state_dict']) + model.eval() + + compute_scores(model, preprocess, args) + \ No newline at end of file diff --git a/pacscore/compute_metrics.py b/pacscore/compute_metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..ed011dab625ebc8e8e1b9d9b61092a75a57e1031 --- /dev/null +++ b/pacscore/compute_metrics.py @@ -0,0 +1,110 @@ +import os +import argparse +import torch +import json +import evaluation +import numpy as np + +from models.clip import clip +from evaluation import PACScore, RefPACScore +from models import open_clip + +_MODELS = { + "ViT-B/32": "checkpoints/clip_ViT-B-32.pth", + "open_clip_ViT-L/14": "checkpoints/openClip_ViT-L-14.pth" +} + + +def compute_scores(model, preprocess, image_ids, candidates, references, args): + gen = {} + gts = {} + + ims_cs = list() + gen_cs = list() + gts_cs = list() + all_scores = dict() + model.eval() + + for i, (im_i, gts_i, gen_i) in enumerate(zip(image_ids, references, candidates)): + gen['%d' % (i)] = [gen_i, ] + gts['%d' % (i)] = gts_i + + ims_cs.append(im_i) + gen_cs.append(gen_i) + gts_cs.append(gts_i) + + gts = evaluation.PTBTokenizer.tokenize(gts) + gen = evaluation.PTBTokenizer.tokenize(gen) + + all_scores_metrics = evaluation.get_all_metrics(gts, gen) + + for k, v in all_scores_metrics.items(): + if k == 'BLEU': + all_scores['BLEU-1'] = v[0] + all_scores['BLEU-4'] = v[-1] + else: + all_scores[k] = v + + # PAC-S + _, pac_scores, candidate_feats, len_candidates = PACScore( + model, preprocess, ims_cs, gen_cs, device, w=2.0) + all_scores['PAC-S'] = np.mean(pac_scores) + + # RefPAC-S + if args.compute_refpac: + _, per_instance_text_text = RefPACScore( + model, gts_cs, candidate_feats, device, torch.tensor(len_candidates)) + refpac_scores = 2 * pac_scores * per_instance_text_text / \ + (pac_scores + per_instance_text_text) + all_scores['RefPAC-S'] = np.mean(refpac_scores) + + return all_scores + + +if __name__ == '__main__': + # Argument parsing + parser = argparse.ArgumentParser(description='PAC-S evaluation') + parser.add_argument('--clip_model', type=str, default='ViT-B/32', + choices=['ViT-B/32', 'open_clip_ViT-L/14']) + parser.add_argument('--image_dir', type=str, default='example/images') + parser.add_argument('--candidates_json', type=str, + default='example/good_captions.json') + parser.add_argument('--references_json', type=str, default='example/refs.json') + parser.add_argument('--compute_refpac', action='store_true') + + args = parser.parse_args() + + device = "cuda" if torch.cuda.is_available() else "cpu" + + image_ids = [img_id for img_id in os.listdir(args.image_dir)] + + with open(args.candidates_json) as f: + candidates = json.load(f) + candidates = [candidates[cid.split('.')[0]] for cid in image_ids] + + with open(args.references_json) as f: + references = json.load(f) + references = [references[cid.split('.')[0]] for cid in image_ids] + + image_ids = [os.path.join(args.image_dir, img_id) for img_id in image_ids] + + if args.clip_model.startswith('open_clip'): + print("Using Open CLIP Model: " + args.clip_model) + model, _, preprocess = open_clip.create_model_and_transforms( + 'ViT-L-14', pretrained='laion2b_s32b_b82k') + else: + print("Using CLIP Model: " + args.clip_model) + model, preprocess = clip.load(args.clip_model, device=device) + + model = model.to(device) + model = model.float() + + checkpoint = torch.load(_MODELS[args.clip_model]) + model.load_state_dict(checkpoint['state_dict']) + model.eval() + + all_scores = compute_scores( + model, preprocess, image_ids, candidates, references, args) + + for k, v in all_scores.items(): + print('%s: %.4f' % (k, v)) diff --git a/pacscore/data/__init__.py b/pacscore/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6be98f4ecea6e98958026d9eebaee20bcd363318 --- /dev/null +++ b/pacscore/data/__init__.py @@ -0,0 +1,6 @@ +from .dataset import * +from torch.utils.data import DataLoader as TorchDataLoader + +class DataLoader(TorchDataLoader): + def __init__(self, dataset, *args, **kwargs): + super(DataLoader, self).__init__(dataset, *args, collate_fn=dataset.collate_fn(), **kwargs) diff --git a/pacscore/data/dataset.py b/pacscore/data/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..58c1ed5fedfc316901f549594c045f635518c800 --- /dev/null +++ b/pacscore/data/dataset.py @@ -0,0 +1,55 @@ +import torch +import os +from PIL import Image +import json +import numpy as np +import torch + +class Flickr8k(torch.utils.data.Dataset): + def __init__(self, json_file, root='datasets/flickr8k/', + transform=None, load_images=False): + self.im_folder = os.path.join(root, 'images') + self.transform = transform + self.load_images = load_images + + with open(os.path.join(root, json_file)) as fp: + data = json.load(fp) + + self.data = list() + for i in data: + for human_judgement in data[i]['human_judgement']: + if np.isnan(human_judgement['rating']): + print('NaN') + continue + d = { + 'image': data[i]['image_path'].split('/')[-1], + 'references': [' '.join(gt.split()) for gt in data[i]['ground_truth']], + 'candidate': ' '.join(human_judgement['caption'].split()), + 'human_score': human_judgement['rating'] + } + self.data.append(d) + + def get_image(self, filename): + img = Image.open(os.path.join(self.im_folder, filename)).convert('RGB') + if self.transform: + img = self.transform(img) + return img + + def __len__(self): + return len(self.data) + + def __getitem__(self, idx): + im_idx = self.data[idx]['image'] + candidate = self.data[idx]['candidate'] + references = self.data[idx]['references'] + score = self.data[idx]['human_score'] + + if self.load_images: + im = self.get_image(im_idx) + else: + im = os.path.join(self.im_folder, im_idx) + + return im, candidate, references, score + + + diff --git a/pacscore/data/tokenizer/__init__.py b/pacscore/data/tokenizer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/pacscore/data/tokenizer/bpe_simple_vocab_16e6.txt.gz b/pacscore/data/tokenizer/bpe_simple_vocab_16e6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..36a15856e00a06a9fbed8cdd34d2393fea4a3113 --- /dev/null +++ b/pacscore/data/tokenizer/bpe_simple_vocab_16e6.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:924691ac288e54409236115652ad4aa250f48203de50a9e4722a6ecd48d6804a +size 1356917 diff --git a/pacscore/data/tokenizer/simple_tokenizer.py b/pacscore/data/tokenizer/simple_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..1c58a7890588b1553d12b4e1bbb8fc2df96edc1b --- /dev/null +++ b/pacscore/data/tokenizer/simple_tokenizer.py @@ -0,0 +1,144 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + vocab.extend(['<|startoftext|>', '<|endoftext|>']) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'} + self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + @property + def vocab_size(self): + return len(self.encoder) + + @property + def eos_idx(self): + return self.encoder['<|endoftext|>'] + + @property + def bos_idx(self): + return self.encoder['<|startoftext|>'] + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '',) + pairs = get_pairs(word) + + if not pairs: + return token+'' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('', ' ') + return text \ No newline at end of file diff --git a/pacscore/environment.yml b/pacscore/environment.yml new file mode 100644 index 0000000000000000000000000000000000000000..8916e11a564ecb2c55a49a557e0292f70650a54d --- /dev/null +++ b/pacscore/environment.yml @@ -0,0 +1,92 @@ +name: pacs +channels: + - defaults +dependencies: + - _libgcc_mutex=0.1=main + - _openmp_mutex=5.1=1_gnu + - blas=1.0=mkl + - brotlipy=0.7.0=py39h27cfd23_1003 + - ca-certificates=2023.01.10=h06a4308_0 + - certifi=2022.12.7=py39h06a4308_0 + - cffi=1.15.1=py39h5eee18b_3 + - charset-normalizer=2.0.4=pyhd3eb1b0_0 + - cryptography=38.0.4=py39h9ce1e76_0 + - cudatoolkit=11.3.1=h2bc3f7f_2 + - cudnn=8.2.1=cuda11.3_0 + - cupti=11.3.1=0 + - flit-core=3.6.0=pyhd3eb1b0_0 + - freetype=2.12.1=h4a9f257_0 + - future=0.18.2=py39h06a4308_1 + - giflib=5.2.1=h5eee18b_1 + - idna=3.4=py39h06a4308_0 + - intel-openmp=2021.4.0=h06a4308_3561 + - jpeg=9e=h7f8727e_0 + - lcms2=2.12=h3be6417_0 + - ld_impl_linux-64=2.38=h1181459_1 + - lerc=3.0=h295c915_0 + - libdeflate=1.8=h7f8727e_5 + - libffi=3.4.2=h6a678d5_6 + - libgcc-ng=11.2.0=h1234567_1 + - libgomp=11.2.0=h1234567_1 + - libpng=1.6.37=hbc83047_0 + - libprotobuf=3.20.1=h4ff587b_0 + - libstdcxx-ng=11.2.0=h1234567_1 + - libtiff=4.5.0=hecacb30_0 + - libwebp=1.2.4=h11a3e52_0 + - libwebp-base=1.2.4=h5eee18b_0 + - lz4-c=1.9.4=h6a678d5_0 + - magma=2.7.0=h8db6258_0 + - mkl=2021.4.0=h06a4308_640 + - mkl-service=2.4.0=py39h7f8727e_0 + - mkl_fft=1.3.1=py39hd3c417c_0 + - mkl_random=1.2.2=py39h51133e4_0 + - ncurses=6.4=h6a678d5_0 + - ninja=1.10.2=h06a4308_5 + - ninja-base=1.10.2=hd09550d_5 + - numpy=1.23.5=py39h14f4228_0 + - numpy-base=1.23.5=py39h31eccc5_0 + - openssl=1.1.1s=h7f8727e_0 + - pillow=9.3.0=py39hace64e9_1 + - pip=22.3.1=py39h06a4308_0 + - pycparser=2.21=pyhd3eb1b0_0 + - pyopenssl=22.0.0=pyhd3eb1b0_0 + - pysocks=1.7.1=py39h06a4308_0 + - python=3.9.16=h7a1cb2a_0 + - pytorch=1.12.1=gpu_cuda113py39h19ae3d8_1 + - pyyaml=6.0=py39h5eee18b_1 + - readline=8.2=h5eee18b_0 + - requests=2.28.1=py39h06a4308_0 + - setuptools=65.6.3=py39h06a4308_0 + - six=1.16.0=pyhd3eb1b0_1 + - sqlite=3.40.1=h5082296_0 + - tk=8.6.12=h1ccaba5_0 + - torchvision=0.13.1=cpu_py39h164cc8f_0 + - typing-extensions=4.4.0=py39h06a4308_0 + - typing_extensions=4.4.0=py39h06a4308_0 + - tzdata=2022g=h04d1e81_0 + - urllib3=1.26.14=py39h06a4308_0 + - wheel=0.37.1=pyhd3eb1b0_0 + - xz=5.2.10=h5eee18b_1 + - yaml=0.2.5=h7b6447c_0 + - zlib=1.2.13=h5eee18b_0 + - zstd=1.5.2=ha4553b6_0 + - pip: + - contourpy==1.0.7 + - cycler==0.11.0 + - filelock==3.9.0 + - fonttools==4.38.0 + - ftfy==6.1.1 + - huggingface-hub==0.12.0 + - kiwisolver==1.4.4 + - matplotlib==3.6.3 + - packaging==23.0 + - psutil==5.9.4 + - pycocoevalcap==1.2 + - pycocotools==2.0.6 + - pyparsing==3.0.9 + - python-dateutil==2.8.2 + - python-pidfile==3.0.0 + - regex==2022.10.31 + - scipy==1.10.0 + - tqdm==4.64.1 + - wcwidth==0.2.6 diff --git a/pacscore/evaluation/__init__.py b/pacscore/evaluation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f28b923cfdf094c7fd62b0adf0143f1b946fd884 --- /dev/null +++ b/pacscore/evaluation/__init__.py @@ -0,0 +1,44 @@ +''' +Automatic generation evaluation metrics wrapper +The most useful function here is +get_all_metrics(refs, cands) +''' +from .pac_score import PACScore, RefPACScore +from .tokenizer import PTBTokenizer +from pycocoevalcap.meteor.meteor import Meteor +from pycocoevalcap.bleu.bleu import Bleu +from pycocoevalcap.cider.cider import Cider +from pycocoevalcap.rouge.rouge import Rouge +from pycocoevalcap.spice.spice import Spice + +def get_all_metrics(refs, cands, return_per_cap=False): + metrics = [] + names = [] + + pycoco_eval_cap_scorers = [(Bleu(4), 'BLEU'), + (Meteor(), 'METEOR'), + (Rouge(), 'ROUGE'), + (Cider(), 'CIDER'), + # (Spice(), 'SPICE') + ] + + for scorer, name in pycoco_eval_cap_scorers: + overall, per_cap = pycoco_eval(scorer, refs, cands) + if return_per_cap: + metrics.append(per_cap) + else: + metrics.append(overall) + names.append(name) + + metrics = dict(zip(names, metrics)) + return metrics + + +def pycoco_eval(scorer, refs, cands): + ''' + scorer is assumed to have a compute_score function. + refs is a list of lists of strings + cands is a list of predictions + ''' + average_score, scores = scorer.compute_score(refs, cands) + return average_score, scores diff --git a/pacscore/evaluation/pac_score/__init__.py b/pacscore/evaluation/pac_score/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bc4e8118813031033ac1ef319c5bc9e93bff09ed --- /dev/null +++ b/pacscore/evaluation/pac_score/__init__.py @@ -0,0 +1 @@ +from .pac_score import PACScore, RefPACScore \ No newline at end of file diff --git a/pacscore/evaluation/pac_score/pac_score.py b/pacscore/evaluation/pac_score/pac_score.py new file mode 100644 index 0000000000000000000000000000000000000000..d40c7a1d64324570a62419a2bc5dafb43ca17008 --- /dev/null +++ b/pacscore/evaluation/pac_score/pac_score.py @@ -0,0 +1,133 @@ +from PIL import Image +from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize +import torch +import tqdm +import numpy as np +import collections +from models import clip + + +class CapDataset(torch.utils.data.Dataset): + def __init__(self, data, prefix='A photo depicts'): + self.data = data + self.prefix = prefix + if self.prefix[-1] != ' ': + self.prefix += ' ' + + def __getitem__(self, idx): + c_data = self.data[idx] + c_data = clip.tokenize(self.prefix + c_data, truncate=True).squeeze() + return {'caption': c_data} + + def __len__(self): + return len(self.data) + + +class ImageDataset(torch.utils.data.Dataset): + def __init__(self, data, transform=None): + self.data = data + if transform: + self.preprocess = transform + else: + self.preprocess = self._transform_test(224) + + def _transform_test(self, n_px): + return Compose([ + Resize(n_px, interpolation=Image.BICUBIC), + CenterCrop(n_px), + lambda image: image.convert("RGB"), + ToTensor(), + Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) + + def __getitem__(self, idx): + c_data = self.data[idx] + image = Image.open(c_data) + image = self.preprocess(image) + return {'image': image} + + def __len__(self): + return len(self.data) + + +def extract_all_captions(captions, model, device, batch_size=256, num_workers=6): + data = torch.utils.data.DataLoader(CapDataset(captions), batch_size=batch_size, num_workers=num_workers, + shuffle=False) + all_text_features = [] + with torch.no_grad(): + for b in tqdm.tqdm(data): + b = b['caption'].to(device) + all_text_features.append(model.encode_text(b).detach().cpu().numpy()) + all_text_features = np.vstack(all_text_features) + return all_text_features + + +def extract_all_images(images, model, transform, device, batch_size=64, num_workers=6): + data = torch.utils.data.DataLoader(ImageDataset(images, transform), batch_size=batch_size, num_workers=num_workers, + shuffle=False) + all_image_features = [] + with torch.no_grad(): + for b in tqdm.tqdm(data): + b = b['image'].to(device) + all_image_features.append(model.encode_image(b).detach().cpu().numpy()) + all_image_features = np.vstack(all_image_features) + return all_image_features + + +def PACScore(model, transform, images, candidates, device, w=2.0): + ''' + compute the unreferenced PAC score. + ''' + len_candidates = [len(c.split()) for c in candidates] + if isinstance(images, list): + # extracting image features + images = extract_all_images(images, model, transform, device) + + candidates = extract_all_captions(candidates, model, device) + + images = images / np.sqrt(np.sum(images ** 2, axis=1, keepdims=True)) + candidates = candidates / np.sqrt(np.sum(candidates ** 2, axis=1, keepdims=True)) + + per = w * np.clip(np.sum(images * candidates, axis=1), 0, None) + return np.mean(per), per, candidates, len_candidates + + +def RefPACScore(model, references, candidates, device, len_candidates): + ''' + compute the RefPAC score, extracting only the reference captions. + ''' + if isinstance(candidates, list): + candidates = extract_all_captions(candidates, model, device) + + len_references = [] + flattened_refs = [] + flattened_refs_idxs = [] + for idx, refs in enumerate(references): + len_r = [len(r.split()) for r in refs] + len_references.append(len_r) + flattened_refs.extend(refs) + flattened_refs_idxs.extend([idx for _ in refs]) + + flattened_refs = extract_all_captions(flattened_refs, model, device) + + candidates = candidates / np.sqrt(np.sum(candidates ** 2, axis=1, keepdims=True)) + flattened_refs = flattened_refs / np.sqrt(np.sum(flattened_refs ** 2, axis=1, keepdims=True)) + + cand_idx2refs = collections.defaultdict(list) + for ref_feats, cand_idx in zip(flattened_refs, flattened_refs_idxs): + cand_idx2refs[cand_idx].append(ref_feats) + + assert len(cand_idx2refs) == len(candidates) + + cand_idx2refs = {k: np.vstack(v) for k, v in cand_idx2refs.items()} + + per = [] + for c_idx, (cand, l_ref, l_cand) in enumerate(zip(candidates, len_references, len_candidates)): + cur_refs = cand_idx2refs[c_idx] + all_sims = cand.dot(cur_refs.transpose()) + + per.append(np.max(all_sims)) + + return np.mean(per), per + + diff --git a/pacscore/evaluation/tokenizer.py b/pacscore/evaluation/tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..73fb49cb3fef0f9c773a498d8ae5e7ad994d7e8c --- /dev/null +++ b/pacscore/evaluation/tokenizer.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python +# +# File Name : ptbtokenizer.py +# +# Description : Do the PTB Tokenization and remove punctuations. +# +# Creation Date : 29-12-2014 +# Last Modified : Thu Mar 19 09:53:35 2015 +# Authors : Hao Fang and Tsung-Yi Lin + +import os +import subprocess +import tempfile + +class PTBTokenizer(object): + """Python wrapper of Stanford PTBTokenizer""" + + corenlp_jar = 'stanford-corenlp-3.4.1.jar' + punctuations = ["''", "'", "``", "`", "-LRB-", "-RRB-", "-LCB-", "-RCB-", \ + ".", "?", "!", ",", ":", "-", "--", "...", ";"] + + @classmethod + def tokenize(cls, corpus): + cmd = ['java', '-cp', cls.corenlp_jar, \ + 'edu.stanford.nlp.process.PTBTokenizer', \ + '-preserveLines', '-lowerCase'] + + if isinstance(corpus, list) or isinstance(corpus, tuple): + if isinstance(corpus[0], list) or isinstance(corpus[0], tuple): + corpus = {i:c for i, c in enumerate(corpus)} + else: + corpus = {i: [c, ] for i, c in enumerate(corpus)} + + # prepare data for PTB Tokenizer + tokenized_corpus = {} + image_id = [k for k, v in list(corpus.items()) for _ in range(len(v))] + sentences = '\n'.join([c.replace('\n', ' ') for k, v in corpus.items() for c in v]) + + # save sentences to temporary file + path_to_jar_dirname=os.path.dirname(os.path.abspath(__file__)) + tmp_file = tempfile.NamedTemporaryFile(delete=False, dir=path_to_jar_dirname) + tmp_file.write(sentences.encode()) + tmp_file.close() + + # tokenize sentence + cmd.append(os.path.basename(tmp_file.name)) + p_tokenizer = subprocess.Popen(cmd, cwd=path_to_jar_dirname, \ + stdout=subprocess.PIPE, stderr=open(os.devnull, 'w')) + token_lines = p_tokenizer.communicate(input=sentences.rstrip())[0] + token_lines = token_lines.decode() + lines = token_lines.split('\n') + # remove temp file + os.remove(tmp_file.name) + + # create dictionary for tokenized captions + for k, line in zip(image_id, lines): + if not k in tokenized_corpus: + tokenized_corpus[k] = [] + tokenized_caption = ' '.join([w for w in line.rstrip().split(' ') \ + if w not in cls.punctuations]) + tokenized_corpus[k].append(tokenized_caption) + + return tokenized_corpus \ No newline at end of file diff --git a/pacscore/example/bad_captions.json b/pacscore/example/bad_captions.json new file mode 100644 index 0000000000000000000000000000000000000000..49dc18c529f20f202fb35c89d4cd0e00f3f06d69 --- /dev/null +++ b/pacscore/example/bad_captions.json @@ -0,0 +1,5 @@ +{ + "image1": "A child is preparing to slide down a piece of playground equipment .", + "image2": "A black horse is jumping in the grass ." + +} \ No newline at end of file diff --git a/pacscore/example/good_captions.json b/pacscore/example/good_captions.json new file mode 100644 index 0000000000000000000000000000000000000000..b89b604a9d7411b24450af9bd79e6383d44ec8cc --- /dev/null +++ b/pacscore/example/good_captions.json @@ -0,0 +1,4 @@ +{ + "image1": "A white dog is laying on the ground with its head on its paws .", + "image2": "'Two beige dogs are playing in the grass near a doghouse .'" +} \ No newline at end of file diff --git a/pacscore/example/images/image1.jpg b/pacscore/example/images/image1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0e93fb44fcb226802110af58eda95346547160ac Binary files /dev/null and b/pacscore/example/images/image1.jpg differ diff --git a/pacscore/example/images/image2.jpg b/pacscore/example/images/image2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69aa5de5e6b493b756b9950d1a4ec98e36a75caf Binary files /dev/null and b/pacscore/example/images/image2.jpg differ diff --git a/pacscore/example/refs.json b/pacscore/example/refs.json new file mode 100644 index 0000000000000000000000000000000000000000..9684ce0d1dcc8672491a28dc10c6b402f5bc8575 --- /dev/null +++ b/pacscore/example/refs.json @@ -0,0 +1,18 @@ +{ + "image1": + [ + "A closeup of a white dog that is laying its head on its paws .", + "a large white dog lying on the floor .", + "A white dog has its head on the ground .", + "A white dog is resting its head on a tiled floor with its eyes open .", + "A white dog rests its head on the patio bricks ." + ], + "image2": + [ + "a black dog jumping to catch a rope toy .", + "A black dog playing fetch with a ball of rope .", + "A black dog pounces to get a rope toy .", + "A black dog running after his rope toy .", + "A large black dog is playing in a grassy yard ." + ] +} \ No newline at end of file diff --git a/pacscore/images/model.png b/pacscore/images/model.png new file mode 100644 index 0000000000000000000000000000000000000000..d987a07b06783d0aaa140c4ea114b7e90b1ed209 Binary files /dev/null and b/pacscore/images/model.png differ diff --git a/pacscore/models/__init__.py b/pacscore/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/pacscore/models/clip/__init__.py b/pacscore/models/clip/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dcc5619538c0f7c782508bdbd9587259d805e0d9 --- /dev/null +++ b/pacscore/models/clip/__init__.py @@ -0,0 +1 @@ +from .clip import * diff --git a/pacscore/models/clip/bpe_simple_vocab_16e6.txt.gz b/pacscore/models/clip/bpe_simple_vocab_16e6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..36a15856e00a06a9fbed8cdd34d2393fea4a3113 --- /dev/null +++ b/pacscore/models/clip/bpe_simple_vocab_16e6.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:924691ac288e54409236115652ad4aa250f48203de50a9e4722a6ecd48d6804a +size 1356917 diff --git a/pacscore/models/clip/clip.py b/pacscore/models/clip/clip.py new file mode 100644 index 0000000000000000000000000000000000000000..9c045ac24a53d60c1ad89956f4fd3f6d479c40f5 --- /dev/null +++ b/pacscore/models/clip/clip.py @@ -0,0 +1,237 @@ +import hashlib +import os +import urllib +import warnings +from typing import Any, Union, List +from pkg_resources import packaging + +import torch +from PIL import Image +from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize +from tqdm import tqdm + +from .model import build_model +from .simple_tokenizer import SimpleTokenizer as _Tokenizer + +try: + from torchvision.transforms import InterpolationMode + BICUBIC = InterpolationMode.BICUBIC +except ImportError: + BICUBIC = Image.BICUBIC + + +if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"): + warnings.warn("PyTorch version 1.7.1 or higher is recommended") + + +__all__ = ["available_models", "load", "tokenize"] +_tokenizer = _Tokenizer() + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", + "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt", + "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt", +} + + +def _download(url: str, root: str): + os.makedirs(root, exist_ok=True) + filename = os.path.basename(url) + + expected_sha256 = url.split("/")[-2] + download_target = os.path.join(root, filename) + + if os.path.exists(download_target) and not os.path.isfile(download_target): + raise RuntimeError(f"{download_target} exists and is not a regular file") + + if os.path.isfile(download_target): + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256: + return download_target + else: + warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file") + + with urllib.request.urlopen(url) as source, open(download_target, "wb") as output: + with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True, unit_divisor=1024) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256: + raise RuntimeError(f"Model has been downloaded but the SHA256 checksum does not not match") + + return download_target + + +def _convert_image_to_rgb(image): + return image.convert("RGB") + + +def _transform(n_px): + return Compose([ + Resize(n_px, interpolation=BICUBIC), + CenterCrop(n_px), + _convert_image_to_rgb, + ToTensor(), + Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) + + +def available_models() -> List[str]: + """Returns the names of available CLIP models""" + return list(_MODELS.keys()) + + +def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", jit: bool = False, download_root: str = None): + """Load a CLIP model + + Parameters + ---------- + name : str + A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict + + 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 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 + """ + if name in _MODELS: + model_path = _download(_MODELS[name], download_root or os.path.expanduser("~/.cache/clip")) + elif os.path.isfile(name): + model_path = name + else: + raise RuntimeError(f"Model {name} not found; available models = {available_models()}") + + with open(model_path, 'rb') as opened_file: + try: + # loading JIT archive + model = torch.jit.load(opened_file, map_location=device if jit else "cpu").eval() + state_dict = None + except RuntimeError: + # loading saved state dict + if jit: + warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead") + jit = False + state_dict = torch.load(opened_file, map_location="cpu") + + if not jit: + model = build_model(state_dict or model.state_dict()).to(device) + if str(device) == "cpu": + model.float() + return model, _transform(model.visual.input_resolution) + + # patch the device names + device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[]) + device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1] + + def patch_device(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("prim::Constant"): + if "value" in node.attributeNames() and str(node["value"]).startswith("cuda"): + node.copyAttributes(device_node) + + model.apply(patch_device) + patch_device(model.encode_image) + patch_device(model.encode_text) + + # patch dtype to float32 on CPU + if str(device) == "cpu": + float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[]) + float_input = list(float_holder.graph.findNode("aten::to").inputs())[1] + float_node = float_input.node() + + def patch_float(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("aten::to"): + inputs = list(node.inputs()) + for i in [1, 2]: # dtype can be the second or third argument to aten::to() + if inputs[i].node()["value"] == 5: + inputs[i].node().copyAttributes(float_node) + + model.apply(patch_float) + patch_float(model.encode_image) + patch_float(model.encode_text) + + model.float() + + return model, _transform(model.input_resolution.item()) + + +def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> Union[torch.IntTensor, torch.LongTensor]: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + + context_length : int + The context length to use; all CLIP models use 77 as the context length + + truncate: bool + Whether to truncate the text in case its encoding is longer than the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length]. + We return LongTensor when torch version is <1.8.0, since older index_select requires indices to be long. + """ + if isinstance(texts, str): + texts = [texts] + + sot_token = _tokenizer.encoder["<|startoftext|>"] + eot_token = _tokenizer.encoder["<|endoftext|>"] + all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts] + if packaging.version.parse(torch.__version__) < packaging.version.parse("1.8.0"): + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + else: + result = torch.zeros(len(all_tokens), context_length, dtype=torch.int) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + if truncate: + tokens = tokens[:context_length] + tokens[-1] = eot_token + else: + raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}") + result[i, :len(tokens)] = torch.tensor(tokens) + + return result diff --git a/pacscore/models/clip/model.py b/pacscore/models/clip/model.py new file mode 100644 index 0000000000000000000000000000000000000000..5e055de67f31125233ac097e84617be435739f7e --- /dev/null +++ b/pacscore/models/clip/model.py @@ -0,0 +1,480 @@ +from collections import OrderedDict +from typing import Tuple, Union +from torch import Tensor +import numpy as np +import torch +import torch.nn.functional as F +from torch import nn + +def one_hot_to_index(one_hot: Tensor) -> Tensor: + """ + Converts a one-hot tensor into a tensor with corresponding indexes + """ + device, dtype = one_hot.device, one_hot.dtype + vocab_size = one_hot.shape[-1] + oh2idx = torch.tensor(range(vocab_size), dtype=dtype, device=device) + return (one_hot @ oh2idx.unsqueeze(dim=1)).long().squeeze(dim=-1) + +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.reshape(x.shape[0], x.shape[1], x.shape[2] * x.shape[3]).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, 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[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 + + with torch.no_grad(): + 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)) + #ret = super().forward(x) + 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.attn_last = Attention(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 + self.d_model = d_model + self.n_head = n_head + + + + 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 attention_last(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 + att = self.attn(x, x, x, need_weights=True, attn_mask=self.attn_mask,average_attn_weights=False) + return att[0], att[1] + + + 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.embed_dim = width + 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 intermediate_features(self, x): + 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) + return x + + def last_step(self, x): + x_cls = x[:, 0, :] + + if self.proj is not None: + x_cls = x_cls @ self.proj + + return x_cls + + def forward(self, x: torch.Tensor): + with torch.no_grad(): + x = self.intermediate_features(x) + + x_cls = x[:, 0, :] + + if self.proj is not None: + x_cls = x_cls @ self.proj + return x_cls + + +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_image_modified(self, image): + return self.visual.last_step(image.type(self.dtype)) + + + def encode_text(self, text, local=False): + with torch.no_grad(): + if text.dtype in [torch.long, torch.int]: + text_idxs = text + x = self.token_embedding(text).type(self.dtype) # [batch_size, n_ctx, d_model] + else: + text_idxs = one_hot_to_index(text) + x = (text @ self.token_embedding.weight).type(self.dtype) + + 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) + + if local: + x = x @ self.text_projection + else: + x = x[torch.arange(x.shape[0]), text_idxs.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) + + # cosine similarity as logits + logit_scale = self.logit_scale.exp() + + return {'image_embed': image_features, + 'text_embed': text_features, + 'logit_scale': logit_scale} + + + +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(f"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, strict=False) + return model.eval() diff --git a/pacscore/models/clip/simple_tokenizer.py b/pacscore/models/clip/simple_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..0a66286b7d5019c6e221932a813768038f839c91 --- /dev/null +++ b/pacscore/models/clip/simple_tokenizer.py @@ -0,0 +1,132 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + vocab.extend(['<|startoftext|>', '<|endoftext|>']) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'} + self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '',) + pairs = get_pairs(word) + + if not pairs: + return token+'' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('', ' ') + return text diff --git a/pacscore/models/open_clip/__init__.py b/pacscore/models/open_clip/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..55b720f4043a2ebc3f07cd76b0edf2c363057f05 --- /dev/null +++ b/pacscore/models/open_clip/__init__.py @@ -0,0 +1,9 @@ +from .constants import OPENAI_DATASET_MEAN, OPENAI_DATASET_STD +from .factory import list_models, create_model, create_model_and_transforms, add_model_config +from .loss import ClipLoss +from .model import CLIP, CLIPTextCfg, CLIPVisionCfg, convert_weights_to_fp16, trace_model +from .openai import load_openai_model, list_openai_models +from .pretrained import list_pretrained, list_pretrained_tag_models, list_pretrained_model_tags,\ + get_pretrained_url, download_pretrained_from_url, is_pretrained_cfg, get_pretrained_cfg, download_pretrained +from .tokenizer import SimpleTokenizer, tokenize +from .transform import image_transform diff --git a/pacscore/models/open_clip/bpe_simple_vocab_16e6.txt.gz b/pacscore/models/open_clip/bpe_simple_vocab_16e6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..36a15856e00a06a9fbed8cdd34d2393fea4a3113 --- /dev/null +++ b/pacscore/models/open_clip/bpe_simple_vocab_16e6.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:924691ac288e54409236115652ad4aa250f48203de50a9e4722a6ecd48d6804a +size 1356917 diff --git a/pacscore/models/open_clip/constants.py b/pacscore/models/open_clip/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..a670bb3fab442baeb9af53b91c312e6982af57ee --- /dev/null +++ b/pacscore/models/open_clip/constants.py @@ -0,0 +1,2 @@ +OPENAI_DATASET_MEAN = (0.48145466, 0.4578275, 0.40821073) +OPENAI_DATASET_STD = (0.26862954, 0.26130258, 0.27577711) diff --git a/pacscore/models/open_clip/factory.py b/pacscore/models/open_clip/factory.py new file mode 100644 index 0000000000000000000000000000000000000000..029616c1efe957905b8882349504881e1ebc03d2 --- /dev/null +++ b/pacscore/models/open_clip/factory.py @@ -0,0 +1,175 @@ +import json +import logging +import os +import pathlib +import re +from copy import deepcopy +from pathlib import Path +from typing import Optional, Tuple + +import torch + +from .constants import OPENAI_DATASET_MEAN, OPENAI_DATASET_STD +from .model import CLIP, convert_weights_to_fp16, resize_pos_embed +from .openai import load_openai_model +from .pretrained import get_pretrained_cfg, download_pretrained +from .transform import image_transform + + +_MODEL_CONFIG_PATHS = [Path(__file__).parent / f"model_configs/"] +_MODEL_CONFIGS = {} # directory (model_name: config) of model architecture configs + + +def _natural_key(string_): + return [int(s) if s.isdigit() else s for s in re.split(r'(\d+)', string_.lower())] + + +def _rescan_model_configs(): + global _MODEL_CONFIGS + + config_ext = ('.json',) + config_files = [] + for config_path in _MODEL_CONFIG_PATHS: + if config_path.is_file() and config_path.suffix in config_ext: + config_files.append(config_path) + elif config_path.is_dir(): + for ext in config_ext: + config_files.extend(config_path.glob(f'*{ext}')) + + for cf in config_files: + with open(cf, 'r') as f: + model_cfg = json.load(f) + if all(a in model_cfg for a in ('embed_dim', 'vision_cfg', 'text_cfg')): + _MODEL_CONFIGS[cf.stem] = model_cfg + + _MODEL_CONFIGS = {k: v for k, v in sorted(_MODEL_CONFIGS.items(), key=lambda x: _natural_key(x[0]))} + + +_rescan_model_configs() # initial populate of model config registry + + +def load_state_dict(checkpoint_path: str, map_location='cpu'): + checkpoint = torch.load(checkpoint_path, map_location=map_location) + if isinstance(checkpoint, dict) and 'state_dict' in checkpoint: + state_dict = checkpoint['state_dict'] + else: + state_dict = checkpoint + if next(iter(state_dict.items()))[0].startswith('module'): + state_dict = {k[7:]: v for k, v in state_dict.items()} + return state_dict + + +def load_checkpoint(model, checkpoint_path, strict=True): + state_dict = load_state_dict(checkpoint_path) + resize_pos_embed(state_dict, model) + incompatible_keys = model.load_state_dict(state_dict, strict=strict) + return incompatible_keys + + +def create_model( + model_name: str, + pretrained: str = '', + precision: str = 'fp32', + device: torch.device = torch.device('cpu'), + jit: bool = False, + force_quick_gelu: bool = False, + pretrained_image: bool = False, + cache_dir: Optional[str] = None, +): + model_name = model_name.replace('/', '-') # for callers using old naming with / in ViT names + + if pretrained.lower() == 'openai': + logging.info(f'Loading pretrained {model_name} from OpenAI.') + model = load_openai_model(model_name, device=device, jit=jit, cache_dir=cache_dir) + # See https://discuss.pytorch.org/t/valueerror-attemting-to-unscale-fp16-gradients/81372 + if precision == "amp" or precision == "fp32": + model = model.float() + else: + if model_name in _MODEL_CONFIGS: + logging.info(f'Loading {model_name} model config.') + model_cfg = deepcopy(_MODEL_CONFIGS[model_name]) + else: + logging.error(f'Model config for {model_name} not found; available models {list_models()}.') + raise RuntimeError(f'Model config for {model_name} not found.') + + if force_quick_gelu: + # override for use of QuickGELU on non-OpenAI transformer models + model_cfg["quick_gelu"] = True + + if pretrained_image: + if 'timm_model_name' in model_cfg.get('vision_cfg', {}): + # pretrained weight loading for timm models set via vision_cfg + model_cfg['vision_cfg']['timm_model_pretrained'] = True + else: + assert False, 'pretrained image towers currently only supported for timm models' + + model = CLIP(**model_cfg) + + pretrained_cfg = {} + if pretrained: + checkpoint_path = '' + pretrained_cfg = get_pretrained_cfg(model_name, pretrained) + if pretrained_cfg: + checkpoint_path = download_pretrained(pretrained_cfg, cache_dir=cache_dir) + elif os.path.exists(pretrained): + checkpoint_path = pretrained + + if checkpoint_path: + logging.info(f'Loading pretrained {model_name} weights ({pretrained}).') + load_checkpoint(model, checkpoint_path) + else: + logging.warning(f'Pretrained weights ({pretrained}) not found for model {model_name}.') + raise RuntimeError(f'Pretrained weights ({pretrained}) not found for model {model_name}.') + + model.to(device=device) + if precision == "fp16": + assert device.type != 'cpu' + convert_weights_to_fp16(model) + + # set image / mean metadata from pretrained_cfg if available, or use default + model.visual.image_mean = pretrained_cfg.get('mean', None) or OPENAI_DATASET_MEAN + model.visual.image_std = pretrained_cfg.get('std', None) or OPENAI_DATASET_STD + + if jit: + model = torch.jit.script(model) + + return model + + +def create_model_and_transforms( + model_name: str, + pretrained: str = '', + precision: str = 'fp32', + device: torch.device = torch.device('cpu'), + jit: bool = False, + force_quick_gelu: bool = False, + pretrained_image: bool = False, + image_mean: Optional[Tuple[float, ...]] = None, + image_std: Optional[Tuple[float, ...]] = None, + cache_dir: Optional[str] = None, +): + model = create_model( + model_name, pretrained, precision, device, jit, + force_quick_gelu=force_quick_gelu, + pretrained_image=pretrained_image, + cache_dir=cache_dir) + + image_mean = image_mean or getattr(model.visual, 'image_mean', None) + image_std = image_std or getattr(model.visual, 'image_std', None) + preprocess_train = image_transform(model.visual.image_size, is_train=True, mean=image_mean, std=image_std) + preprocess_val = image_transform(model.visual.image_size, is_train=False, mean=image_mean, std=image_std) + + return model, preprocess_train, preprocess_val + + +def list_models(): + """ enumerate available model architectures based on config files """ + return list(_MODEL_CONFIGS.keys()) + + +def add_model_config(path): + """ add model config path or file and update registry """ + if not isinstance(path, Path): + path = Path(path) + _MODEL_CONFIG_PATHS.append(path) + _rescan_model_configs() diff --git a/pacscore/models/open_clip/loss.py b/pacscore/models/open_clip/loss.py new file mode 100644 index 0000000000000000000000000000000000000000..de31426dfa7ed40369b5461d6498008392d507e5 --- /dev/null +++ b/pacscore/models/open_clip/loss.py @@ -0,0 +1,121 @@ +import torch +import torch.nn as nn +from torch.nn import functional as F + +try: + import torch.distributed.nn + from torch import distributed as dist + has_distributed = True +except ImportError: + has_distributed = False + +try: + import horovod.torch as hvd +except ImportError: + hvd = None + + +def gather_features( + image_features, + text_features, + local_loss=False, + gather_with_grad=False, + rank=0, + world_size=1, + use_horovod=False +): + assert has_distributed, 'torch.distributed did not import correctly, please use a PyTorch version with support.' + if use_horovod: + assert hvd is not None, 'Please install horovod' + if gather_with_grad: + all_image_features = hvd.allgather(image_features) + all_text_features = hvd.allgather(text_features) + else: + with torch.no_grad(): + all_image_features = hvd.allgather(image_features) + all_text_features = hvd.allgather(text_features) + if not local_loss: + # ensure grads for local rank when all_* features don't have a gradient + gathered_image_features = list(all_image_features.chunk(world_size, dim=0)) + gathered_text_features = list(all_text_features.chunk(world_size, dim=0)) + gathered_image_features[rank] = image_features + gathered_text_features[rank] = text_features + all_image_features = torch.cat(gathered_image_features, dim=0) + all_text_features = torch.cat(gathered_text_features, dim=0) + else: + # We gather tensors from all gpus + if gather_with_grad: + all_image_features = torch.cat(torch.distributed.nn.all_gather(image_features), dim=0) + all_text_features = torch.cat(torch.distributed.nn.all_gather(text_features), dim=0) + else: + gathered_image_features = [torch.zeros_like(image_features) for _ in range(world_size)] + gathered_text_features = [torch.zeros_like(text_features) for _ in range(world_size)] + dist.all_gather(gathered_image_features, image_features) + dist.all_gather(gathered_text_features, text_features) + if not local_loss: + # ensure grads for local rank when all_* features don't have a gradient + gathered_image_features[rank] = image_features + gathered_text_features[rank] = text_features + all_image_features = torch.cat(gathered_image_features, dim=0) + all_text_features = torch.cat(gathered_text_features, dim=0) + + return all_image_features, all_text_features + + +class ClipLoss(nn.Module): + + def __init__( + self, + local_loss=False, + gather_with_grad=False, + cache_labels=False, + rank=0, + world_size=1, + use_horovod=False, + ): + super().__init__() + self.local_loss = local_loss + self.gather_with_grad = gather_with_grad + self.cache_labels = cache_labels + self.rank = rank + self.world_size = world_size + self.use_horovod = use_horovod + + # cache state + self.prev_num_logits = 0 + self.labels = {} + + def forward(self, image_features, text_features, logit_scale): + device = image_features.device + if self.world_size > 1: + all_image_features, all_text_features = gather_features( + image_features, text_features, + self.local_loss, self.gather_with_grad, self.rank, self.world_size, self.use_horovod) + + if self.local_loss: + logits_per_image = logit_scale * image_features @ all_text_features.T + logits_per_text = logit_scale * text_features @ all_image_features.T + else: + logits_per_image = logit_scale * all_image_features @ all_text_features.T + logits_per_text = logits_per_image.T + else: + logits_per_image = logit_scale * image_features @ text_features.T + logits_per_text = logit_scale * text_features @ image_features.T + + # calculated ground-truth and cache if enabled + num_logits = logits_per_image.shape[0] + if self.prev_num_logits != num_logits or device not in self.labels: + labels = torch.arange(num_logits, device=device, dtype=torch.long) + if self.world_size > 1 and self.local_loss: + labels = labels + num_logits * self.rank + if self.cache_labels: + self.labels[device] = labels + self.prev_num_logits = num_logits + else: + labels = self.labels[device] + + total_loss = ( + F.cross_entropy(logits_per_image, labels) + + F.cross_entropy(logits_per_text, labels) + ) / 2 + return total_loss diff --git a/pacscore/models/open_clip/model.py b/pacscore/models/open_clip/model.py new file mode 100644 index 0000000000000000000000000000000000000000..e896f204b3826c097ab6c5ece22b51d55a6be849 --- /dev/null +++ b/pacscore/models/open_clip/model.py @@ -0,0 +1,709 @@ +""" CLIP Model + +Adapted from https://github.com/openai/CLIP. Originally MIT License, Copyright (c) 2021 OpenAI. +""" +from collections import OrderedDict +from dataclasses import dataclass +import logging +import math +from typing import Tuple, Union, Callable, Optional + +import numpy as np +import torch +import torch.nn.functional as F +from torch import nn +from torch.utils.checkpoint import checkpoint + +from .timm_model import TimmModel +from .utils import freeze_batch_norm_2d, to_2tuple + + +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.act1 = nn.ReLU(inplace=True) + + self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + self.act2 = 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.act3 = 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.act1(self.bn1(self.conv1(x))) + out = self.act2(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.act3(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.reshape(x.shape[0], x.shape[1], x.shape[2] * x.shape[3]).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, 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[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, image_size=224, width=64): + super().__init__() + self.output_dim = output_dim + self.image_size = image_size + + # 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.act1 = 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.act2 = nn.ReLU(inplace=True) + self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False) + self.bn3 = nn.BatchNorm2d(width) + self.act3 = 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(image_size // 32, embed_dim, heads, output_dim) + + self.init_parameters() + + 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 init_parameters(self): + if self.attnpool is not None: + std = self.attnpool.c_proj.in_features ** -0.5 + nn.init.normal_(self.attnpool.q_proj.weight, std=std) + nn.init.normal_(self.attnpool.k_proj.weight, std=std) + nn.init.normal_(self.attnpool.v_proj.weight, std=std) + nn.init.normal_(self.attnpool.c_proj.weight, std=std) + + for resnet_block in [self.layer1, self.layer2, self.layer3, self.layer4]: + for name, param in resnet_block.named_parameters(): + if name.endswith("bn3.weight"): + nn.init.zeros_(param) + + def lock(self, unlocked_groups=0, freeze_bn_stats=False): + assert unlocked_groups == 0, 'partial locking not currently supported for this model' + for param in self.parameters(): + param.requires_grad = False + if freeze_bn_stats: + freeze_batch_norm_2d(self) + + @torch.jit.ignore + def set_grad_checkpointing(self, enable=True): + # FIXME support for non-transformer + pass + + def stem(self, x): + x = self.act1(self.bn1(self.conv1(x))) + x = self.act2(self.bn2(self.conv2(x))) + x = self.act3(self.bn3(self.conv3(x))) + x = self.avgpool(x) + return x + + def forward(self, x): + x = self.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 + x = F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps) + return x.to(orig_type) + + +class QuickGELU(nn.Module): + # NOTE This is slower than nn.GELU or nn.SiLU and uses more GPU memory + def forward(self, x: torch.Tensor): + return x * torch.sigmoid(1.702 * x) + + +class Attention(nn.Module): + def __init__( + self, + dim, + num_heads=8, + qkv_bias=True, + scaled_cosine=False, + scale_heads=False, + logit_scale_max=math.log(1. / 0.01), + attn_drop=0., + proj_drop=0. + ): + super().__init__() + self.scaled_cosine = scaled_cosine + self.scale_heads = scale_heads + assert dim % num_heads == 0, 'dim should be divisible by num_heads' + self.num_heads = num_heads + self.head_dim = dim // num_heads + self.scale = self.head_dim ** -0.5 + self.logit_scale_max = logit_scale_max + + # keeping in_proj in this form (instead of nn.Linear) to match weight scheme of original + self.in_proj_weight = nn.Parameter(torch.randn((dim * 3, dim)) * self.scale) + if qkv_bias: + self.in_proj_bias = nn.Parameter(torch.zeros(dim * 3)) + else: + self.in_proj_bias = None + + if self.scaled_cosine: + self.logit_scale = nn.Parameter(torch.log(10 * torch.ones((num_heads, 1, 1)))) + else: + self.logit_scale = None + self.attn_drop = nn.Dropout(attn_drop) + if self.scale_heads: + self.head_scale = nn.Parameter(torch.ones((num_heads, 1, 1))) + else: + self.head_scale = None + self.out_proj = nn.Linear(dim, dim) + self.out_drop = nn.Dropout(proj_drop) + + def forward(self, x, attn_mask: Optional[torch.Tensor] = None): + L, N, C = x.shape + q, k, v = F.linear(x, self.in_proj_weight, self.in_proj_bias).chunk(3, dim=-1) + q = q.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1) + k = k.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1) + v = v.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1) + + if self.logit_scale is not None: + attn = torch.bmm(F.normalize(q, dim=-1), F.normalize(k, dim=-1).transpose(-1, -2)) + logit_scale = torch.clamp(self.logit_scale, max=self.logit_scale_max).exp() + attn = attn.view(N, self.num_heads, L, L) * logit_scale + attn = attn.view(-1, L, L) + else: + q = q * self.scale + attn = torch.bmm(q, k.transpose(-1, -2)) + + if attn_mask is not None: + if attn_mask.dtype == torch.bool: + new_attn_mask = torch.zeros_like(attn_mask, dtype=q.dtype) + new_attn_mask.masked_fill_(attn_mask, float("-inf")) + attn_mask = new_attn_mask + attn += attn_mask + + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = torch.bmm(attn, v) + if self.head_scale is not None: + x = x.view(N, self.num_heads, L, C) * self.head_scale + x = x.view(-1, L, C) + x = x.transpose(0, 1).reshape(L, N, C) + x = self.out_proj(x) + x = self.out_drop(x) + return x + + +class ResidualAttentionBlock(nn.Module): + def __init__( + self, + d_model: int, + n_head: int, + mlp_ratio: float = 4.0, + act_layer: Callable = nn.GELU, + scale_cosine_attn: bool = False, + scale_heads: bool = False, + scale_attn: bool = False, + scale_fc: bool = False, + ): + super().__init__() + + self.ln_1 = LayerNorm(d_model) + # FIXME torchscript issues need to be resolved for custom attention + # if scale_cosine_attn or scale_heads: + # self.attn = Attention( + # d_model, n_head, + # scaled_cosine=scale_cosine_attn, + # scale_heads=scale_heads, + # ) + self.attn = nn.MultiheadAttention(d_model, n_head) + self.ln_attn = LayerNorm(d_model) if scale_attn else nn.Identity() + + self.ln_2 = LayerNorm(d_model) + mlp_width = int(d_model * mlp_ratio) + self.mlp = nn.Sequential(OrderedDict([ + ("c_fc", nn.Linear(d_model, mlp_width)), + ('ln', LayerNorm(mlp_width) if scale_fc else nn.Identity()), + ("gelu", act_layer()), + ("c_proj", nn.Linear(mlp_width, d_model)) + ])) + + def attention(self, x: torch.Tensor, attn_mask: Optional[torch.Tensor] = None): + return self.attn(x, x, x, need_weights=False, attn_mask=attn_mask)[0] + # FIXME torchscript issues need resolving for custom attention option to work + # if self.use_torch_attn: + # return self.attn(x, x, x, need_weights=False, attn_mask=attn_mask)[0] + # else: + # return self.attn(x, attn_mask=attn_mask) + + def forward(self, x: torch.Tensor, attn_mask: Optional[torch.Tensor] = None): + x = x + self.ln_attn(self.attention(self.ln_1(x), attn_mask=attn_mask)) + x = x + self.mlp(self.ln_2(x)) + return x + + +class Transformer(nn.Module): + def __init__(self, width: int, layers: int, heads: int, mlp_ratio: float = 4.0, act_layer: Callable = nn.GELU): + super().__init__() + self.width = width + self.layers = layers + self.grad_checkpointing = False + + self.resblocks = nn.ModuleList([ + ResidualAttentionBlock(width, heads, mlp_ratio, act_layer=act_layer) + for _ in range(layers) + ]) + + def forward(self, x: torch.Tensor, attn_mask: Optional[torch.Tensor] = None): + for r in self.resblocks: + if self.grad_checkpointing and not torch.jit.is_scripting(): + x = checkpoint(r, x, attn_mask) + else: + x = r(x, attn_mask=attn_mask) + return x + + +class VisualTransformer(nn.Module): + def __init__( + self, + image_size: int, + patch_size: int, + width: int, + layers: int, + heads: int, + mlp_ratio: float, + output_dim: int, + act_layer: Callable = nn.GELU + ): + super().__init__() + self.image_size = to_2tuple(image_size) + self.patch_size = to_2tuple(patch_size) + self.grid_size = (self.image_size[0] // self.patch_size[0], self.image_size[1] // self.patch_size[1]) + 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(self.grid_size[0] * self.grid_size[1] + 1, width)) + self.ln_pre = LayerNorm(width) + + self.transformer = Transformer(width, layers, heads, mlp_ratio, act_layer=act_layer) + + self.ln_post = LayerNorm(width) + self.proj = nn.Parameter(scale * torch.randn(width, output_dim)) + + def lock(self, unlocked_groups=0, freeze_bn_stats=False): + assert unlocked_groups == 0, 'partial locking not currently supported for this model' + for param in self.parameters(): + param.requires_grad = False + + @torch.jit.ignore + def set_grad_checkpointing(self, enable=True): + self.transformer.grad_checkpointing = enable + + def forward(self, x: torch.Tensor): + with torch.no_grad(): + 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 + + +@dataclass +class CLIPVisionCfg: + layers: Union[Tuple[int, int, int, int], int] = 12 + width: int = 768 + head_width: int = 64 + mlp_ratio: float = 4.0 + patch_size: int = 16 + image_size: Union[Tuple[int, int], int] = 224 + timm_model_name: str = None # a valid model name overrides layers, width, patch_size + timm_model_pretrained: bool = False # use (imagenet) pretrained weights for named model + timm_pool: str = 'avg' # feature pooling for timm model ('abs_attn', 'rot_attn', 'avg', '') + timm_proj: str = 'linear' # linear projection for timm model output ('linear', 'mlp', '') + + +@dataclass +class CLIPTextCfg: + context_length: int = 77 + vocab_size: int = 49408 + width: int = 512 + heads: int = 8 + layers: int = 12 + + +class CLIP(nn.Module): + def __init__( + self, + embed_dim: int, + vision_cfg: CLIPVisionCfg, + text_cfg: CLIPTextCfg, + quick_gelu: bool = False, + ): + super().__init__() + if isinstance(vision_cfg, dict): + vision_cfg = CLIPVisionCfg(**vision_cfg) + if isinstance(text_cfg, dict): + text_cfg = CLIPTextCfg(**text_cfg) + + self.context_length = text_cfg.context_length + + # OpenAI models are pretrained w/ QuickGELU but native nn.GELU is both faster and more + # memory efficient in recent PyTorch releases (>= 1.10). + # NOTE: timm models always use native GELU regardless of quick_gelu flag. + act_layer = QuickGELU if quick_gelu else nn.GELU + + if vision_cfg.timm_model_name: + self.visual = TimmModel( + vision_cfg.timm_model_name, + pretrained=vision_cfg.timm_model_pretrained, + pool=vision_cfg.timm_pool, + proj=vision_cfg.timm_proj, + embed_dim=embed_dim, + image_size=vision_cfg.image_size + ) + act_layer = nn.GELU # so that text transformer doesn't use QuickGELU w/ timm models + elif isinstance(vision_cfg.layers, (tuple, list)): + vision_heads = vision_cfg.width * 32 // vision_cfg.head_width + self.visual = ModifiedResNet( + layers=vision_cfg.layers, + output_dim=embed_dim, + heads=vision_heads, + image_size=vision_cfg.image_size, + width=vision_cfg.width + ) + else: + vision_heads = vision_cfg.width // vision_cfg.head_width + self.visual = VisualTransformer( + image_size=vision_cfg.image_size, + patch_size=vision_cfg.patch_size, + width=vision_cfg.width, + layers=vision_cfg.layers, + heads=vision_heads, + mlp_ratio=vision_cfg.mlp_ratio, + output_dim=embed_dim, + act_layer=act_layer, + ) + + self.transformer = Transformer( + width=text_cfg.width, + layers=text_cfg.layers, + heads=text_cfg.heads, + act_layer=act_layer, + ) + + self.vocab_size = text_cfg.vocab_size + self.token_embedding = nn.Embedding(text_cfg.vocab_size, text_cfg.width) + self.positional_embedding = nn.Parameter(torch.empty(self.context_length, text_cfg.width)) + self.ln_final = LayerNorm(text_cfg.width) + + self.text_projection = nn.Parameter(torch.empty(text_cfg.width, embed_dim)) + self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07)) + self.register_buffer('attn_mask', self.build_attention_mask(), persistent=False) + + self.init_parameters() + + def init_parameters(self): + nn.init.normal_(self.token_embedding.weight, std=0.02) + nn.init.normal_(self.positional_embedding, std=0.01) + nn.init.constant_(self.logit_scale, np.log(1 / 0.07)) + + if hasattr(self.visual, 'init_parameters'): + self.visual.init_parameters() + + 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 + + def lock_image_tower(self, unlocked_groups=0, freeze_bn_stats=False): + # lock image tower as per LiT - https://arxiv.org/abs/2111.07991 + self.visual.lock(unlocked_groups=unlocked_groups, freeze_bn_stats=freeze_bn_stats) + + @torch.jit.ignore + def set_grad_checkpointing(self, enable=True): + self.visual.set_grad_checkpointing(enable) + self.transformer.grad_checkpointing = enable + + def encode_image(self, image): + return self.visual(image) + + def encode_text(self, text, local=False): + with torch.no_grad(): + x = self.token_embedding(text) # [batch_size, n_ctx, d_model] + + x = x + self.positional_embedding + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x, attn_mask=self.attn_mask) + x = x.permute(1, 0, 2) # LND -> NLD + x = self.ln_final(x) + + # x.shape = [batch_size, n_ctx, transformer.width] + # take features from the eot embedding (eot_token is the highest number in each sequence) + if local: + x = x @ self.text_projection + else: + x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection + + return x + + def forward(self, image, text): + if image is None: + return self.encode_text(text) + elif text is None: + return self.encode_image(image) + image_features = self.encode_image(image) + + text_features = self.encode_text(text) + + return {'image_embed': image_features, + 'text_embed': text_features, + 'logit_scale': self.logit_scale.exp()} + + + +def convert_weights_to_fp16(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, Attention)): + 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_from_openai_state_dict(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_size = 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_size = 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(f"transformer.resblocks"))) + + vision_cfg = CLIPVisionCfg( + layers=vision_layers, + width=vision_width, + patch_size=vision_patch_size, + image_size=image_size, + ) + text_cfg = CLIPTextCfg( + context_length=context_length, + vocab_size=vocab_size, + width=transformer_width, + heads=transformer_heads, + layers=transformer_layers + ) + model = CLIP( + embed_dim, + vision_cfg=vision_cfg, + text_cfg=text_cfg, + quick_gelu=True, # OpenAI models were trained with QuickGELU + ) + + for key in ["input_resolution", "context_length", "vocab_size"]: + state_dict.pop(key, None) + + convert_weights_to_fp16(model) + model.load_state_dict(state_dict) + return model.eval() + + +def trace_model(model, batch_size=256, device=torch.device('cpu')): + model.eval() + image_size = model.visual.image_size + example_images = torch.ones((batch_size, 3, image_size, image_size), device=device) + example_text = torch.zeros((batch_size, model.context_length), dtype=torch.int, device=device) + model = torch.jit.trace_module( + model, + inputs=dict( + forward=(example_images, example_text), + encode_text=(example_text,), + encode_image=(example_images,) + )) + model.visual.image_size = image_size + return model + + +def resize_pos_embed(state_dict, model, interpolation: str = 'bicubic', seq_dim=1): + # Rescale the grid of position embeddings when loading from state_dict + old_pos_embed = state_dict.get('visual.positional_embedding', None) + if old_pos_embed is None or not hasattr(model.visual, 'grid_size'): + return + grid_size = to_2tuple(model.visual.grid_size) + extra_tokens = 1 # FIXME detect different token configs (ie no class token, or more) + new_seq_len = grid_size[0] * grid_size[1] + extra_tokens + if new_seq_len == old_pos_embed.shape[0]: + return + + if extra_tokens: + pos_emb_tok, pos_emb_img = old_pos_embed[:extra_tokens], old_pos_embed[extra_tokens:] + else: + pos_emb_tok, pos_emb_img = None, old_pos_embed + old_grid_size = to_2tuple(int(math.sqrt(len(pos_emb_img)))) + + logging.info('Resizing position embedding grid-size from %s to %s', old_grid_size, grid_size) + pos_emb_img = pos_emb_img.reshape(1, old_grid_size[0], old_grid_size[1], -1).permute(0, 3, 1, 2) + pos_emb_img = F.interpolate( + pos_emb_img, + size=grid_size, + mode=interpolation, + align_corners=True, + ) + pos_emb_img = pos_emb_img.permute(0, 2, 3, 1).reshape(1, grid_size[0] * grid_size[1], -1)[0] + if pos_emb_tok is not None: + new_pos_embed = torch.cat([pos_emb_tok, pos_emb_img], dim=0) + else: + new_pos_embed = pos_emb_img + state_dict['visual.positional_embedding'] = new_pos_embed diff --git a/pacscore/models/open_clip/model_configs/RN101-quickgelu.json b/pacscore/models/open_clip/model_configs/RN101-quickgelu.json new file mode 100644 index 0000000000000000000000000000000000000000..d0db2c161d13138788c4609d373b023b8454d624 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/RN101-quickgelu.json @@ -0,0 +1,22 @@ +{ + "embed_dim": 512, + "quick_gelu": true, + "vision_cfg": { + "image_size": 224, + "layers": [ + 3, + 4, + 23, + 3 + ], + "width": 64, + "patch_size": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/RN101.json b/pacscore/models/open_clip/model_configs/RN101.json new file mode 100644 index 0000000000000000000000000000000000000000..b88b4d3acbaa701c614ab0ea65fc88fcfe289c32 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/RN101.json @@ -0,0 +1,21 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": [ + 3, + 4, + 23, + 3 + ], + "width": 64, + "patch_size": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/RN50-quickgelu.json b/pacscore/models/open_clip/model_configs/RN50-quickgelu.json new file mode 100644 index 0000000000000000000000000000000000000000..8c2f91260cdeb043434dc1e893cce81d4ce7f0d1 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/RN50-quickgelu.json @@ -0,0 +1,22 @@ +{ + "embed_dim": 1024, + "quick_gelu": true, + "vision_cfg": { + "image_size": 224, + "layers": [ + 3, + 4, + 6, + 3 + ], + "width": 64, + "patch_size": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} diff --git a/pacscore/models/open_clip/model_configs/RN50.json b/pacscore/models/open_clip/model_configs/RN50.json new file mode 100644 index 0000000000000000000000000000000000000000..33aa884d54fee0076c33676831e49d5e1ffcb8f2 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/RN50.json @@ -0,0 +1,21 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": [ + 3, + 4, + 6, + 3 + ], + "width": 64, + "patch_size": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/RN50x16.json b/pacscore/models/open_clip/model_configs/RN50x16.json new file mode 100644 index 0000000000000000000000000000000000000000..3161e1a2c9a839161e652a4d729c2cdc971161db --- /dev/null +++ b/pacscore/models/open_clip/model_configs/RN50x16.json @@ -0,0 +1,21 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 384, + "layers": [ + 6, + 8, + 18, + 8 + ], + "width": 96, + "patch_size": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/RN50x4.json b/pacscore/models/open_clip/model_configs/RN50x4.json new file mode 100644 index 0000000000000000000000000000000000000000..e155237f8ce1026aaaeecc80751eabe6f329f0bb --- /dev/null +++ b/pacscore/models/open_clip/model_configs/RN50x4.json @@ -0,0 +1,21 @@ +{ + "embed_dim": 640, + "vision_cfg": { + "image_size": 288, + "layers": [ + 4, + 6, + 10, + 6 + ], + "width": 80, + "patch_size": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 640, + "heads": 10, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-B-16-plus-240.json b/pacscore/models/open_clip/model_configs/ViT-B-16-plus-240.json new file mode 100644 index 0000000000000000000000000000000000000000..5bbd12bcd01f64d6d0a0aa8316b129327a0d169a --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-B-16-plus-240.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 640, + "vision_cfg": { + "image_size": 240, + "layers": 12, + "width": 896, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 640, + "heads": 10, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-B-16-plus.json b/pacscore/models/open_clip/model_configs/ViT-B-16-plus.json new file mode 100644 index 0000000000000000000000000000000000000000..5dc1e09baccef2b15055c1bffeb9903e760101c6 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-B-16-plus.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 640, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 896, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 640, + "heads": 10, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-B-16.json b/pacscore/models/open_clip/model_configs/ViT-B-16.json new file mode 100644 index 0000000000000000000000000000000000000000..395eea77ec3907c0611531aba63459b193e67b9c --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-B-16.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-B-32-plus-256.json b/pacscore/models/open_clip/model_configs/ViT-B-32-plus-256.json new file mode 100644 index 0000000000000000000000000000000000000000..2f09c857de9a4c01ae51297a7e2451984879f9de --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-B-32-plus-256.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 640, + "vision_cfg": { + "image_size": 256, + "layers": 12, + "width": 896, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 640, + "heads": 10, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-B-32-quickgelu.json b/pacscore/models/open_clip/model_configs/ViT-B-32-quickgelu.json new file mode 100644 index 0000000000000000000000000000000000000000..ce6bd923593293ed50dfcfb28b73ca7403bcf3c5 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-B-32-quickgelu.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 512, + "quick_gelu": true, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-B-32.json b/pacscore/models/open_clip/model_configs/ViT-B-32.json new file mode 100644 index 0000000000000000000000000000000000000000..07c8e28eb06fa1813ba932fe4eec668262d1c47f --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-B-32.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-H-14.json b/pacscore/models/open_clip/model_configs/ViT-H-14.json new file mode 100644 index 0000000000000000000000000000000000000000..3e3a7e934e7f02e41f4829996c4950e05f015a74 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-H-14.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 32, + "width": 1280, + "head_width": 80, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1024, + "heads": 16, + "layers": 24 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-H-16.json b/pacscore/models/open_clip/model_configs/ViT-H-16.json new file mode 100644 index 0000000000000000000000000000000000000000..588485455fdf8193ec16474450b94e31c91ea93c --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-H-16.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 32, + "width": 1280, + "head_width": 80, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1024, + "heads": 16, + "layers": 24 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-L-14-280.json b/pacscore/models/open_clip/model_configs/ViT-L-14-280.json new file mode 100644 index 0000000000000000000000000000000000000000..2262deaefa82792d35d73c0d7c8e620525092581 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-L-14-280.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 280, + "layers": 24, + "width": 1024, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-L-14-336.json b/pacscore/models/open_clip/model_configs/ViT-L-14-336.json new file mode 100644 index 0000000000000000000000000000000000000000..8d1f74c2639c3a3705df9865b9c08215675ddc97 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-L-14-336.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 336, + "layers": 24, + "width": 1024, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-L-14.json b/pacscore/models/open_clip/model_configs/ViT-L-14.json new file mode 100644 index 0000000000000000000000000000000000000000..d4a4bbb1dd4ed4edb317d3ace4f3ad13b211c241 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-L-14.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 224, + "layers": 24, + "width": 1024, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-L-16-320.json b/pacscore/models/open_clip/model_configs/ViT-L-16-320.json new file mode 100644 index 0000000000000000000000000000000000000000..fc2d13ca9ec7f0b56a886ddaf66c4a7ba7a442ba --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-L-16-320.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 320, + "layers": 24, + "width": 1024, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-L-16.json b/pacscore/models/open_clip/model_configs/ViT-L-16.json new file mode 100644 index 0000000000000000000000000000000000000000..82a1cedfa290adacbbdc02bc5d589734c22d41d3 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-L-16.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 224, + "layers": 24, + "width": 1024, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/ViT-g-14.json b/pacscore/models/open_clip/model_configs/ViT-g-14.json new file mode 100644 index 0000000000000000000000000000000000000000..8c4b7325cc75b6112be7107d36ae2cb5762d9091 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/ViT-g-14.json @@ -0,0 +1,18 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 40, + "width": 1408, + "head_width": 88, + "mlp_ratio": 4.3637, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1024, + "heads": 16, + "layers": 24 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/timm-efficientnetv2_rw_s.json b/pacscore/models/open_clip/model_configs/timm-efficientnetv2_rw_s.json new file mode 100644 index 0000000000000000000000000000000000000000..e07e6beb3e026b4e22d418dd87cb2bdabd1922cc --- /dev/null +++ b/pacscore/models/open_clip/model_configs/timm-efficientnetv2_rw_s.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "timm_model_name": "efficientnetv2_rw_s", + "timm_model_pretrained": false, + "timm_pool": "abs_attn", + "timm_proj": "", + "image_size": 288 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/timm-resnet50d.json b/pacscore/models/open_clip/model_configs/timm-resnet50d.json new file mode 100644 index 0000000000000000000000000000000000000000..7bb0957cd23e3dd0fb461764c959a75e04cae743 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/timm-resnet50d.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "timm_model_name": "resnet50d", + "timm_model_pretrained": false, + "timm_pool": "abs_attn", + "timm_proj": "", + "image_size": 224 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} diff --git a/pacscore/models/open_clip/model_configs/timm-resnetaa50d.json b/pacscore/models/open_clip/model_configs/timm-resnetaa50d.json new file mode 100644 index 0000000000000000000000000000000000000000..c011e0c02b5d63b1ace51e4625d383adc6aedb50 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/timm-resnetaa50d.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "timm_model_name": "resnetaa50d", + "timm_model_pretrained": false, + "timm_pool": "abs_attn", + "timm_proj": "", + "image_size": 224 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} diff --git a/pacscore/models/open_clip/model_configs/timm-resnetblur50.json b/pacscore/models/open_clip/model_configs/timm-resnetblur50.json new file mode 100644 index 0000000000000000000000000000000000000000..05d0b209ac44198bd0b45c6931dee71eac9b1eab --- /dev/null +++ b/pacscore/models/open_clip/model_configs/timm-resnetblur50.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "timm_model_name": "resnetblur50", + "timm_model_pretrained": false, + "timm_pool": "abs_attn", + "timm_proj": "", + "image_size": 224 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} diff --git a/pacscore/models/open_clip/model_configs/timm-swin_base_patch4_window7_224.json b/pacscore/models/open_clip/model_configs/timm-swin_base_patch4_window7_224.json new file mode 100644 index 0000000000000000000000000000000000000000..29dd08f6fa23470fb2ef1c817c1f2b5a098ea8a3 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/timm-swin_base_patch4_window7_224.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "timm_model_name": "swin_base_patch4_window7_224", + "timm_model_pretrained": false, + "timm_pool": "", + "timm_proj": "linear", + "image_size": 224 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/timm-vit_base_patch16_224.json b/pacscore/models/open_clip/model_configs/timm-vit_base_patch16_224.json new file mode 100644 index 0000000000000000000000000000000000000000..39341ce1b0433f91e23755cd189cac4838251f9e --- /dev/null +++ b/pacscore/models/open_clip/model_configs/timm-vit_base_patch16_224.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "timm_model_name": "vit_base_patch16_224", + "timm_model_pretrained": false, + "timm_pool": "", + "timm_proj": "linear", + "image_size": 224 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/timm-vit_base_patch32_224.json b/pacscore/models/open_clip/model_configs/timm-vit_base_patch32_224.json new file mode 100644 index 0000000000000000000000000000000000000000..39b8452710f04751c58b048e94dbd96e779cb21a --- /dev/null +++ b/pacscore/models/open_clip/model_configs/timm-vit_base_patch32_224.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "timm_model_name": "vit_base_patch32_224", + "timm_model_pretrained": false, + "timm_pool": "", + "timm_proj": "linear", + "image_size": 224 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/model_configs/timm-vit_small_patch16_224.json b/pacscore/models/open_clip/model_configs/timm-vit_small_patch16_224.json new file mode 100644 index 0000000000000000000000000000000000000000..45863ab38346d7f31c6861565b3cc27bc003d723 --- /dev/null +++ b/pacscore/models/open_clip/model_configs/timm-vit_small_patch16_224.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "timm_model_name": "vit_small_patch16_224", + "timm_model_pretrained": false, + "timm_pool": "", + "timm_proj": "linear", + "image_size": 224 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/pacscore/models/open_clip/openai.py b/pacscore/models/open_clip/openai.py new file mode 100644 index 0000000000000000000000000000000000000000..156a4c0c5d7bddd56f3a2043d4eaf2df98429a8b --- /dev/null +++ b/pacscore/models/open_clip/openai.py @@ -0,0 +1,129 @@ +""" OpenAI pretrained model functions + +Adapted from https://github.com/openai/CLIP. Originally MIT License, Copyright (c) 2021 OpenAI. +""" + +import os +import warnings +from typing import Union, List + +import torch + +from .model import build_model_from_openai_state_dict +from .pretrained import get_pretrained_url, list_pretrained_tag_models, download_pretrained_from_url + +__all__ = ["list_openai_models", "load_openai_model"] + + +def list_openai_models() -> List[str]: + """Returns the names of available CLIP models""" + return list_pretrained_tag_models('openai') + + +def load_openai_model( + name: str, + device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", + jit=True, + cache_dir=None, +): + """Load a CLIP model + + Parameters + ---------- + name : str + A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict + device : Union[str, torch.device] + The device to put the loaded model + jit : bool + Whether to load the optimized JIT model (default) or more hackable non-JIT model. + cache_dir : Optional[str] + The directory to cache the downloaded model weights + + Returns + ------- + model : torch.nn.Module + The 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 + """ + if get_pretrained_url(name, 'openai'): + model_path = download_pretrained_from_url(get_pretrained_url(name, 'openai'), cache_dir=cache_dir) + elif os.path.isfile(name): + model_path = name + else: + raise RuntimeError(f"Model {name} not found; available models = {list_openai_models()}") + + try: + # loading JIT archive + model = torch.jit.load(model_path, map_location=device if jit else "cpu").eval() + state_dict = None + except RuntimeError: + # loading saved state dict + if jit: + warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead") + jit = False + state_dict = torch.load(model_path, map_location="cpu") + + if not jit: + try: + model = build_model_from_openai_state_dict(state_dict or model.state_dict()).to(device) + except KeyError: + sd = {k[7:]: v for k, v in state_dict["state_dict"].items()} + model = build_model_from_openai_state_dict(sd).to(device) + + if str(device) == "cpu": + model.float() + return model + + # patch the device names + device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[]) + device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1] + + def patch_device(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("prim::Constant"): + if "value" in node.attributeNames() and str(node["value"]).startswith("cuda"): + node.copyAttributes(device_node) + + model.apply(patch_device) + patch_device(model.encode_image) + patch_device(model.encode_text) + + # patch dtype to float32 on CPU + if str(device) == "cpu": + float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[]) + float_input = list(float_holder.graph.findNode("aten::to").inputs())[1] + float_node = float_input.node() + + def patch_float(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("aten::to"): + inputs = list(node.inputs()) + for i in [1, 2]: # dtype can be the second or third argument to aten::to() + if inputs[i].node()["value"] == 5: + inputs[i].node().copyAttributes(float_node) + + model.apply(patch_float) + patch_float(model.encode_image) + patch_float(model.encode_text) + model.float() + + # ensure image_size attr available at consistent location for both jit and non-jit + model.visual.image_size = model.input_resolution.item() + return model diff --git a/pacscore/models/open_clip/pretrained.py b/pacscore/models/open_clip/pretrained.py new file mode 100644 index 0000000000000000000000000000000000000000..d69d1bf87040e0a9be1a0fd5dc14b8a6ca346503 --- /dev/null +++ b/pacscore/models/open_clip/pretrained.py @@ -0,0 +1,297 @@ +import hashlib +import os +import urllib +import warnings +from functools import partial +from typing import Dict, Union + +from tqdm import tqdm + +from .version import __version__ + +try: + from huggingface_hub import hf_hub_download + hf_hub_download = partial(hf_hub_download, library_name="open_clip", library_version=__version__) + _has_hf_hub = True +except ImportError: + hf_hub_download = None + _has_hf_hub = False + + +def _pcfg(url='', hf_hub='', mean=None, std=None): + return dict( + url=url, + hf_hub=hf_hub, + mean=mean, + std=std, + ) + + +_RN50 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt"), + yfcc15m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn50-quickgelu-yfcc15m-455df137.pt"), + cc12m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn50-quickgelu-cc12m-f000538c.pt"), +) + +_RN50_quickgelu = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt"), + yfcc15m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn50-quickgelu-yfcc15m-455df137.pt"), + cc12m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn50-quickgelu-cc12m-f000538c.pt"), +) + +_RN101 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt"), + yfcc15m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn101-quickgelu-yfcc15m-3e04b30e.pt"), +) + +_RN101_quickgelu = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt"), + yfcc15m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn101-quickgelu-yfcc15m-3e04b30e.pt"), +) + +_RN50x4 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt"), +) + +_RN50x16 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt"), +) + +_RN50x64 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt"), +) + +_VITB32 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt"), + laion400m_e31=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_32-quickgelu-laion400m_e31-d867053b.pt"), + laion400m_e32=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_32-quickgelu-laion400m_e32-46683a32.pt"), + laion2b_e16=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_32-laion2b_e16-af8dbd0c.pth"), + laion2b_s34b_b79k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-laion2B-s34B-b79K/') +) + +_VITB32_quickgelu = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt"), + laion400m_e31=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_32-quickgelu-laion400m_e31-d867053b.pt"), + laion400m_e32=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_32-quickgelu-laion400m_e32-46683a32.pt"), +) + +_VITB16 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt"), + laion400m_e31=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_16-laion400m_e31-00efa78f.pt"), + laion400m_e32=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_16-laion400m_e32-55e67d44.pt"), + # laion400m_32k=_pcfg( + # url="", + # mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)), + # laion400m_64k=_pcfg( + # url="", + # mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)), +) + +_VITB16_PLUS_240 = dict( + laion400m_e31=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_16_plus_240-laion400m_e31-8fb26589.pt"), + laion400m_e32=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_16_plus_240-laion400m_e32-699c4b84.pt"), +) + +_VITL14 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt"), + laion400m_e31=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_l_14-laion400m_e31-69988bb6.pt"), + laion400m_e32=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_l_14-laion400m_e32-3d133497.pt"), + laion2b_s32b_b82k=_pcfg( + hf_hub='laion/CLIP-ViT-L-14-laion2B-s32B-b82K/', + mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)), +) + +_VITL14_336 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt"), +) + +_VITH14 = dict( + laion2b_s32b_b79k=_pcfg(hf_hub='laion/CLIP-ViT-H-14-laion2B-s32B-b79K/'), +) + +_VITg14 = dict( + laion2b_s12b_b42k=_pcfg(hf_hub='laion/CLIP-ViT-g-14-laion2B-s12B-b42K/'), +) + +_PRETRAINED = { + "RN50": _RN50, + "RN50-quickgelu": _RN50_quickgelu, + "RN101": _RN101, + "RN101-quickgelu": _RN101_quickgelu, + "RN50x4": _RN50x4, + "RN50x16": _RN50x16, + "RN50x64": _RN50x64, + "ViT-B-32": _VITB32, + "ViT-B-32-quickgelu": _VITB32_quickgelu, + "ViT-B-16": _VITB16, + "ViT-B-16-plus-240": _VITB16_PLUS_240, + "ViT-L-14": _VITL14, + "ViT-L-14-336": _VITL14_336, + "ViT-H-14": _VITH14, + "ViT-g-14": _VITg14, +} + + +def list_pretrained(as_str: bool = False): + """ returns list of pretrained models + Returns a tuple (model_name, pretrain_tag) by default or 'name:tag' if as_str == True + """ + return [':'.join([k, t]) if as_str else (k, t) for k in _PRETRAINED.keys() for t in _PRETRAINED[k].keys()] + + +def list_pretrained_tag_models(tag: str): + """ return all models having the specified pretrain tag """ + models = [] + for k in _PRETRAINED.keys(): + if tag in _PRETRAINED[k]: + models.append(k) + return models + + +def list_pretrained_model_tags(model: str): + """ return all pretrain tags for the specified model architecture """ + tags = [] + if model in _PRETRAINED: + tags.extend(_PRETRAINED[model].keys()) + return tags + + +def is_pretrained_cfg(model: str, tag: str): + if model not in _PRETRAINED: + return False + return tag.lower() in _PRETRAINED[model] + + +def get_pretrained_cfg(model: str, tag: str): + if model not in _PRETRAINED: + return {} + model_pretrained = _PRETRAINED[model] + return model_pretrained.get(tag.lower(), {}) + + +def get_pretrained_url(model: str, tag: str): + cfg = get_pretrained_cfg(model, tag) + return cfg.get('url', '') + + +def download_pretrained_from_url( + url: str, + cache_dir: Union[str, None] = None, +): + if not cache_dir: + cache_dir = os.path.expanduser("~/.cache/clip") + os.makedirs(cache_dir, exist_ok=True) + filename = os.path.basename(url) + + if 'openaipublic' in url: + expected_sha256 = url.split("/")[-2] + else: + expected_sha256 = '' + + download_target = os.path.join(cache_dir, filename) + + if os.path.exists(download_target) and not os.path.isfile(download_target): + raise RuntimeError(f"{download_target} exists and is not a regular file") + + if os.path.isfile(download_target): + if expected_sha256: + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256: + return download_target + else: + warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file") + else: + return download_target + + with urllib.request.urlopen(url) as source, open(download_target, "wb") as output: + with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + if expected_sha256 and hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256: + raise RuntimeError(f"Model has been downloaded but the SHA256 checksum does not not match") + + return download_target + + +def has_hf_hub(necessary=False): + if not _has_hf_hub and necessary: + # if no HF Hub module installed, and it is necessary to continue, raise error + raise RuntimeError( + 'Hugging Face hub model specified but package not installed. Run `pip install huggingface_hub`.') + return _has_hf_hub + + +def download_pretrained_from_hf( + model_id: str, + filename: str = 'open_clip_pytorch_model.bin', + revision=None, + cache_dir: Union[str, None] = None, +): + has_hf_hub(True) + cached_file = hf_hub_download(model_id, filename, revision=revision, cache_dir=cache_dir) + return cached_file + + +def download_pretrained( + cfg: Dict, + force_hf_hub: bool = False, + cache_dir: Union[str, None] = None, +): + target = '' + if not cfg: + return target + + download_url = cfg.get('url', '') + download_hf_hub = cfg.get('hf_hub', '') + if download_hf_hub and force_hf_hub: + # use HF hub even if url exists + download_url = '' + + if download_url: + target = download_pretrained_from_url(download_url, cache_dir=cache_dir) + elif download_hf_hub: + has_hf_hub(True) + # we assume the hf_hub entries in pretrained config combine model_id + filename in + # 'org/model_name/filename.pt' form. To specify just the model id w/o filename and + # use 'open_clip_pytorch_model.bin' default, there must be a trailing slash 'org/model_name/'. + model_id, filename = os.path.split(download_hf_hub) + if filename: + target = download_pretrained_from_hf(model_id, filename=filename, cache_dir=cache_dir) + else: + target = download_pretrained_from_hf(model_id, cache_dir=cache_dir) + + return target diff --git a/pacscore/models/open_clip/timm_model.py b/pacscore/models/open_clip/timm_model.py new file mode 100644 index 0000000000000000000000000000000000000000..071dd148c772f398e87ecbfc836dcfa4a3ae01af --- /dev/null +++ b/pacscore/models/open_clip/timm_model.py @@ -0,0 +1,106 @@ +""" timm model adapter + +Wraps timm (https://github.com/rwightman/pytorch-image-models) models for use as a vision tower in CLIP model. +""" +from collections import OrderedDict + +import torch.nn as nn + +try: + import timm + from timm.models.layers import Mlp, to_2tuple + from timm.models.layers.attention_pool2d import RotAttentionPool2d + from timm.models.layers.attention_pool2d import AttentionPool2d as AbsAttentionPool2d +except ImportError as e: + timm = None + +from .utils import freeze_batch_norm_2d + + +class TimmModel(nn.Module): + """ timm model adapter + # FIXME this adapter is a work in progress, may change in ways that break weight compat + """ + + def __init__( + self, + model_name, + embed_dim, + image_size=224, + pool='avg', + proj='linear', + drop=0., + pretrained=False): + super().__init__() + if timm is None: + raise RuntimeError("Please `pip install timm` to use timm models.") + + self.image_size = to_2tuple(image_size) + self.trunk = timm.create_model(model_name, pretrained=pretrained) + feat_size = self.trunk.default_cfg.get('pool_size', None) + feature_ndim = 1 if not feat_size else 2 + if pool in ('abs_attn', 'rot_attn'): + assert feature_ndim == 2 + # if attn pooling used, remove both classifier and default pool + self.trunk.reset_classifier(0, global_pool='') + else: + # reset global pool if pool config set, otherwise leave as network default + reset_kwargs = dict(global_pool=pool) if pool else {} + self.trunk.reset_classifier(0, **reset_kwargs) + prev_chs = self.trunk.num_features + + head_layers = OrderedDict() + if pool == 'abs_attn': + head_layers['pool'] = AbsAttentionPool2d(prev_chs, feat_size=feat_size, out_features=embed_dim) + prev_chs = embed_dim + elif pool == 'rot_attn': + head_layers['pool'] = RotAttentionPool2d(prev_chs, out_features=embed_dim) + prev_chs = embed_dim + else: + assert proj, 'projection layer needed if non-attention pooling is used.' + + # NOTE attention pool ends with a projection layer, so proj should usually be set to '' if such pooling is used + if proj == 'linear': + head_layers['drop'] = nn.Dropout(drop) + head_layers['proj'] = nn.Linear(prev_chs, embed_dim) + elif proj == 'mlp': + head_layers['mlp'] = Mlp(prev_chs, 2 * embed_dim, embed_dim, drop=drop) + + self.head = nn.Sequential(head_layers) + + def lock(self, unlocked_groups=0, freeze_bn_stats=False): + """ lock modules + Args: + unlocked_groups (int): leave last n layer groups unlocked (default: 0) + """ + if not unlocked_groups: + # lock full model + for param in self.trunk.parameters(): + param.requires_grad = False + if freeze_bn_stats: + freeze_batch_norm_2d(self.trunk) + else: + # NOTE: partial freeze requires latest timm (master) branch and is subject to change + try: + # FIXME import here until API stable and in an official release + from timm.models.helpers import group_parameters, group_modules + except ImportError: + raise RuntimeError( + 'Please install latest timm `pip install git+https://github.com/rwightman/pytorch-image-models`') + matcher = self.trunk.group_matcher() + gparams = group_parameters(self.trunk, matcher) + max_layer_id = max(gparams.keys()) + max_layer_id = max_layer_id - unlocked_groups + for group_idx in range(max_layer_id + 1): + group = gparams[group_idx] + for param in group: + self.trunk.get_parameter(param).requires_grad = False + if freeze_bn_stats: + gmodules = group_modules(self.trunk, matcher, reverse=True) + gmodules = {k for k, v in gmodules.items() if v <= max_layer_id} + freeze_batch_norm_2d(self.trunk, gmodules) + + def forward(self, x): + x = self.trunk(x) + x = self.head(x) + return x diff --git a/pacscore/models/open_clip/tokenizer.py b/pacscore/models/open_clip/tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..08e6d66388af2941b0df46b7fea13b535e49d587 --- /dev/null +++ b/pacscore/models/open_clip/tokenizer.py @@ -0,0 +1,181 @@ +""" CLIP tokenizer + +Copied from https://github.com/openai/CLIP. Originally MIT License, Copyright (c) 2021 OpenAI. +""" +import gzip +import html +import os +from functools import lru_cache +from typing import Union, List + +import ftfy +import regex as re +import torch + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe(), special_tokens=None): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + if not special_tokens: + special_tokens = ['', ''] + else: + special_tokens = ['', ''] + special_tokens + vocab.extend(special_tokens) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {t:t for t in special_tokens} + special = "|".join(special_tokens) + self.pat = re.compile(special + r"""|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + self.vocab_size = len(self.encoder) + self.all_special_ids = [self.encoder[t] for t in special_tokens] + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '',) + pairs = get_pairs(word) + + if not pairs: + return token+'' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('', ' ') + return text + + +_tokenizer = SimpleTokenizer() + + +def tokenize(texts: Union[str, List[str]], context_length: int = 77) -> torch.LongTensor: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + context_length : int + The context length to use; all CLIP models use 77 as the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length] + """ + if isinstance(texts, str): + texts = [texts] + + sot_token = _tokenizer.encoder[""] + eot_token = _tokenizer.encoder[""] + all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts] + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + tokens = tokens[:context_length] # Truncate + tokens[-1] = eot_token + result[i, :len(tokens)] = torch.tensor(tokens) + + return result diff --git a/pacscore/models/open_clip/transform.py b/pacscore/models/open_clip/transform.py new file mode 100644 index 0000000000000000000000000000000000000000..3aee70ff0059068330e81f2c9ee03eeb2ebabc76 --- /dev/null +++ b/pacscore/models/open_clip/transform.py @@ -0,0 +1,86 @@ +from typing import Optional, Sequence, Tuple + +import torch +import torch.nn as nn +import torchvision.transforms.functional as F + +from torchvision.transforms import Normalize, Compose, RandomResizedCrop, InterpolationMode, ToTensor, Resize, \ + CenterCrop + +from .constants import OPENAI_DATASET_MEAN, OPENAI_DATASET_STD + + +class ResizeMaxSize(nn.Module): + + def __init__(self, max_size, interpolation=InterpolationMode.BICUBIC, fn='max', fill=0): + super().__init__() + if not isinstance(max_size, int): + raise TypeError(f"Size should be int. Got {type(max_size)}") + self.max_size = max_size + self.interpolation = interpolation + self.fn = min if fn == 'min' else min + self.fill = fill + + def forward(self, img): + if isinstance(img, torch.Tensor): + height, width = img.shape[:2] + else: + width, height = img.size + scale = self.max_size / float(max(height, width)) + if scale != 1.0: + new_size = tuple(round(dim * scale) for dim in (height, width)) + img = F.resize(img, new_size, self.interpolation) + pad_h = self.max_size - new_size[0] + pad_w = self.max_size - new_size[1] + img = F.pad(img, padding=[pad_w//2, pad_h//2, pad_w - pad_w//2, pad_h - pad_h//2], fill=self.fill) + return img + + +def _convert_to_rgb(image): + return image.convert('RGB') + + +def image_transform( + image_size: int, + is_train: bool, + mean: Optional[Tuple[float, ...]] = None, + std: Optional[Tuple[float, ...]] = None, + resize_longest_max: bool = False, + fill_color: int = 0, +): + mean = mean or OPENAI_DATASET_MEAN + if not isinstance(mean, (list, tuple)): + mean = (mean,) * 3 + + std = std or OPENAI_DATASET_STD + if not isinstance(std, (list, tuple)): + std = (std,) * 3 + + if isinstance(image_size, (list, tuple)) and image_size[0] == image_size[1]: + # for square size, pass size as int so that Resize() uses aspect preserving shortest edge + image_size = image_size[0] + + normalize = Normalize(mean=mean, std=std) + if is_train: + return Compose([ + RandomResizedCrop(image_size, scale=(0.9, 1.0), interpolation=InterpolationMode.BICUBIC), + _convert_to_rgb, + ToTensor(), + normalize, + ]) + else: + if resize_longest_max: + transforms = [ + ResizeMaxSize(image_size, fill=fill_color) + ] + else: + transforms = [ + Resize(image_size, interpolation=InterpolationMode.BICUBIC), + CenterCrop(image_size), + ] + transforms.extend([ + _convert_to_rgb, + ToTensor(), + normalize, + ]) + return Compose(transforms) diff --git a/pacscore/models/open_clip/utils.py b/pacscore/models/open_clip/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..51e80c5e296b24cae130ab0459baf268e0db7673 --- /dev/null +++ b/pacscore/models/open_clip/utils.py @@ -0,0 +1,60 @@ +from itertools import repeat +import collections.abc + +from torch import nn as nn +from torchvision.ops.misc import FrozenBatchNorm2d + + +def freeze_batch_norm_2d(module, module_match={}, name=''): + """ + Converts all `BatchNorm2d` and `SyncBatchNorm` layers of provided module into `FrozenBatchNorm2d`. If `module` is + itself an instance of either `BatchNorm2d` or `SyncBatchNorm`, it is converted into `FrozenBatchNorm2d` and + returned. Otherwise, the module is walked recursively and submodules are converted in place. + + Args: + module (torch.nn.Module): Any PyTorch module. + module_match (dict): Dictionary of full module names to freeze (all if empty) + name (str): Full module name (prefix) + + Returns: + torch.nn.Module: Resulting module + + Inspired by https://github.com/pytorch/pytorch/blob/a5895f85be0f10212791145bfedc0261d364f103/torch/nn/modules/batchnorm.py#L762 + """ + res = module + is_match = True + if module_match: + is_match = name in module_match + if is_match and isinstance(module, (nn.modules.batchnorm.BatchNorm2d, nn.modules.batchnorm.SyncBatchNorm)): + res = FrozenBatchNorm2d(module.num_features) + res.num_features = module.num_features + res.affine = module.affine + if module.affine: + res.weight.data = module.weight.data.clone().detach() + res.bias.data = module.bias.data.clone().detach() + res.running_mean.data = module.running_mean.data + res.running_var.data = module.running_var.data + res.eps = module.eps + else: + for child_name, child in module.named_children(): + full_child_name = '.'.join([name, child_name]) if name else child_name + new_child = freeze_batch_norm_2d(child, module_match, full_child_name) + if new_child is not child: + res.add_module(child_name, new_child) + return res + + +# From PyTorch internals +def _ntuple(n): + def parse(x): + if isinstance(x, collections.abc.Iterable): + return x + return tuple(repeat(x, n)) + return parse + + +to_1tuple = _ntuple(1) +to_2tuple = _ntuple(2) +to_3tuple = _ntuple(3) +to_4tuple = _ntuple(4) +to_ntuple = lambda n, x: _ntuple(n)(x) diff --git a/pacscore/models/open_clip/version.py b/pacscore/models/open_clip/version.py new file mode 100644 index 0000000000000000000000000000000000000000..668c3446ee12c61dc54e5f9cacdd3b778505118c --- /dev/null +++ b/pacscore/models/open_clip/version.py @@ -0,0 +1 @@ +__version__ = '2.0.2' diff --git a/pacscore/models/utils.py b/pacscore/models/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..1e571dde534995a94bf2dae6a4c4c31d85bb7559 --- /dev/null +++ b/pacscore/models/utils.py @@ -0,0 +1,213 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +import numpy as np +import os +import random +import shutil +import torch +import torch.distributed as dist +import torch.autograd as autograd + +from PIL import ImageFilter + + +def get_model(model): + if isinstance(model, torch.nn.DataParallel) \ + or isinstance(model, torch.nn.parallel.DistributedDataParallel): + return model.module + else: + return model + + +def setup_for_distributed(is_master): + """ + This function disables printing when not in master process + """ + import builtins as __builtin__ + builtin_print = __builtin__.print + + def print(*args, **kwargs): + force = kwargs.pop('force', False) + if is_master or force: + builtin_print(*args, **kwargs) + + __builtin__.print = print + + +def is_dist_avail_and_initialized(): + if not dist.is_available(): + return False + if not dist.is_initialized(): + return False + return True + + +def get_world_size(): + if not is_dist_avail_and_initialized(): + return 1 + return dist.get_world_size() + + +def get_rank(): + if not is_dist_avail_and_initialized(): + return 0 + return dist.get_rank() + + +def is_main_process(): + return get_rank() == 0 + + +def save_on_master(state, is_best, output_dir): + if is_main_process(): + ckpt_path = f'{output_dir}/checkpoint.pt' + best_path = f'{output_dir}/checkpoint_best.pt' + torch.save(state, ckpt_path) + if is_best: + shutil.copyfile(ckpt_path, best_path) + + +def init_distributed_mode(args): + if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ: + args.rank = int(os.environ["RANK"]) + args.world_size = int(os.environ['WORLD_SIZE']) + args.gpu = int(os.environ['LOCAL_RANK']) + elif 'SLURM_PROCID' in os.environ: + args.rank = int(os.environ['SLURM_PROCID']) + args.gpu = args.rank % torch.cuda.device_count() + else: + print('Not using distributed mode') + args.distributed = False + return + + args.distributed = True + + torch.cuda.set_device(args.gpu) + args.dist_backend = 'nccl' + print('| distributed init (rank {}): {}'.format( + args.rank, args.dist_url), flush=True) + torch.distributed.init_process_group(backend=args.dist_backend, init_method=args.dist_url, + world_size=args.world_size, rank=args.rank) + torch.distributed.barrier() + setup_for_distributed(args.rank == 0) + + +def scaled_all_reduce(tensors, is_scale=True): + """Performs the scaled all_reduce operation on the provided tensors. + The input tensors are modified in-place. Currently supports only the sum + reduction operator. The reduced values are scaled by the inverse size of the + world size. + """ + world_size = get_world_size() + # There is no need for reduction in the single-proc case + if world_size == 1: + return tensors + # Queue the reductions + reductions = [] + for tensor in tensors: + reduction = dist.all_reduce(tensor, async_op=True) + reductions.append(reduction) + # Wait for reductions to finish + for reduction in reductions: + reduction.wait() + # Scale the results + if is_scale: + for tensor in tensors: + tensor.mul_(1.0 / world_size) + return tensors + + +def all_gather_batch(tensors): + """ + Performs all_gather operation on the provided tensors. + """ + # Queue the gathered tensors + world_size = get_world_size() + # There is no need for reduction in the single-proc case + if world_size == 1: + return tensors + tensor_list = [] + output_tensor = [] + for tensor in tensors: + tensor_all = [torch.ones_like(tensor) for _ in range(world_size)] + dist.all_gather( + tensor_all, + tensor, + async_op=False # performance opt + ) + + tensor_list.append(tensor_all) + + for tensor_all in tensor_list: + output_tensor.append(torch.cat(tensor_all, dim=0)) + return output_tensor + + +class GatherLayer(autograd.Function): + """ + Gather tensors from all workers with support for backward propagation: + This implementation does not cut the gradients as torch.distributed.all_gather does. + """ + + @staticmethod + def forward(ctx, x): + output = [torch.zeros_like(x) for _ in range(dist.get_world_size())] + dist.all_gather(output, x) + return tuple(output) + + @staticmethod + def backward(ctx, *grads): + all_gradients = torch.stack(grads) + dist.all_reduce(all_gradients) + return all_gradients[dist.get_rank()] + + +def all_gather_batch_with_grad(tensors): + """ + Performs all_gather operation on the provided tensors. + Graph remains connected for backward grad computation. + """ + # Queue the gathered tensors + world_size = get_world_size() + # There is no need for reduction in the single-proc case + if world_size == 1: + return tensors + tensor_list = [] + output_tensor = [] + + for tensor in tensors: + tensor_all = GatherLayer.apply(tensor) + tensor_list.append(tensor_all) + + for tensor_all in tensor_list: + output_tensor.append(torch.cat(tensor_all, dim=0)) + return output_tensor + + +def cosine_scheduler(base_value, final_value, epochs, niter_per_ep, warmup_epochs=0, start_warmup_value=0): + warmup_schedule = np.array([]) + warmup_iters = warmup_epochs * niter_per_ep + if warmup_epochs > 0: + warmup_schedule = np.linspace(start_warmup_value, base_value, warmup_iters) + + iters = np.arange(epochs * niter_per_ep - warmup_iters) + schedule = final_value + 0.5 * (base_value - final_value) * (1 + np.cos(np.pi * iters / len(iters))) + + schedule = np.concatenate((warmup_schedule, schedule)) + assert len(schedule) == epochs * niter_per_ep + return schedule + + +class GaussianBlur(object): + """Gaussian blur augmentation in SimCLR https://arxiv.org/abs/2002.05709""" + + def __init__(self, sigma=[.1, 2.]): + self.sigma = sigma + + def __call__(self, x): + sigma = random.uniform(self.sigma[0], self.sigma[1]) + x = x.filter(ImageFilter.GaussianBlur(radius=sigma)) + return x \ No newline at end of file diff --git a/pacscore/utils/__init__.py b/pacscore/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..16281fe0b66dbac563229823d656ef173736e306 --- /dev/null +++ b/pacscore/utils/__init__.py @@ -0,0 +1 @@ +from .utils import * diff --git a/pacscore/utils/utils.py b/pacscore/utils/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..01d8af887a197823be934a4af8bba6582cc184fb --- /dev/null +++ b/pacscore/utils/utils.py @@ -0,0 +1,9 @@ +import torch + +def collate_fn(batch): + if isinstance(batch, tuple) and isinstance(batch[0], list): + return batch + elif isinstance(batch, list): + transposed = list(zip(*batch)) + return [collate_fn(samples) for samples in transposed] + return torch.utils.data.default_collate(batch) diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 0000000000000000000000000000000000000000..0b6b76cf518a3bff45aed31e46ce7bec89ec2428 --- /dev/null +++ b/poetry.lock @@ -0,0 +1,4155 @@ +# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand. + +[[package]] +name = "absl-py" +version = "2.1.0" +description = "Abseil Python Common Libraries, see https://github.com/abseil/abseil-py." +optional = false +python-versions = ">=3.7" +files = [ + {file = "absl-py-2.1.0.tar.gz", hash = "sha256:7820790efbb316739cde8b4e19357243fc3608a152024288513dd968d7d959ff"}, + {file = "absl_py-2.1.0-py3-none-any.whl", hash = "sha256:526a04eadab8b4ee719ce68f204172ead1027549089702d99b9059f129ff1308"}, +] + +[[package]] +name = "aiohttp" +version = "3.9.5" +description = "Async http client/server framework (asyncio)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "aiohttp-3.9.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:fcde4c397f673fdec23e6b05ebf8d4751314fa7c24f93334bf1f1364c1c69ac7"}, + {file = "aiohttp-3.9.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5d6b3f1fabe465e819aed2c421a6743d8debbde79b6a8600739300630a01bf2c"}, + {file = "aiohttp-3.9.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ae79c1bc12c34082d92bf9422764f799aee4746fd7a392db46b7fd357d4a17a"}, + {file = "aiohttp-3.9.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d3ebb9e1316ec74277d19c5f482f98cc65a73ccd5430540d6d11682cd857430"}, + {file = "aiohttp-3.9.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:84dabd95154f43a2ea80deffec9cb44d2e301e38a0c9d331cc4aa0166fe28ae3"}, + {file = "aiohttp-3.9.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c8a02fbeca6f63cb1f0475c799679057fc9268b77075ab7cf3f1c600e81dd46b"}, + {file = "aiohttp-3.9.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c26959ca7b75ff768e2776d8055bf9582a6267e24556bb7f7bd29e677932be72"}, + {file = "aiohttp-3.9.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:714d4e5231fed4ba2762ed489b4aec07b2b9953cf4ee31e9871caac895a839c0"}, + {file = "aiohttp-3.9.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e7a6a8354f1b62e15d48e04350f13e726fa08b62c3d7b8401c0a1314f02e3558"}, + {file = "aiohttp-3.9.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:c413016880e03e69d166efb5a1a95d40f83d5a3a648d16486592c49ffb76d0db"}, + {file = "aiohttp-3.9.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:ff84aeb864e0fac81f676be9f4685f0527b660f1efdc40dcede3c251ef1e867f"}, + {file = "aiohttp-3.9.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:ad7f2919d7dac062f24d6f5fe95d401597fbb015a25771f85e692d043c9d7832"}, + {file = "aiohttp-3.9.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:702e2c7c187c1a498a4e2b03155d52658fdd6fda882d3d7fbb891a5cf108bb10"}, + {file = "aiohttp-3.9.5-cp310-cp310-win32.whl", hash = "sha256:67c3119f5ddc7261d47163ed86d760ddf0e625cd6246b4ed852e82159617b5fb"}, + {file = "aiohttp-3.9.5-cp310-cp310-win_amd64.whl", hash = "sha256:471f0ef53ccedec9995287f02caf0c068732f026455f07db3f01a46e49d76bbb"}, + {file = "aiohttp-3.9.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e0ae53e33ee7476dd3d1132f932eeb39bf6125083820049d06edcdca4381f342"}, + {file = "aiohttp-3.9.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c088c4d70d21f8ca5c0b8b5403fe84a7bc8e024161febdd4ef04575ef35d474d"}, + {file = "aiohttp-3.9.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:639d0042b7670222f33b0028de6b4e2fad6451462ce7df2af8aee37dcac55424"}, + {file = "aiohttp-3.9.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f26383adb94da5e7fb388d441bf09c61e5e35f455a3217bfd790c6b6bc64b2ee"}, + {file = "aiohttp-3.9.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66331d00fb28dc90aa606d9a54304af76b335ae204d1836f65797d6fe27f1ca2"}, + {file = "aiohttp-3.9.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4ff550491f5492ab5ed3533e76b8567f4b37bd2995e780a1f46bca2024223233"}, + {file = "aiohttp-3.9.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f22eb3a6c1080d862befa0a89c380b4dafce29dc6cd56083f630073d102eb595"}, + {file = "aiohttp-3.9.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a81b1143d42b66ffc40a441379387076243ef7b51019204fd3ec36b9f69e77d6"}, + {file = "aiohttp-3.9.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f64fd07515dad67f24b6ea4a66ae2876c01031de91c93075b8093f07c0a2d93d"}, + {file = "aiohttp-3.9.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:93e22add827447d2e26d67c9ac0161756007f152fdc5210277d00a85f6c92323"}, + {file = "aiohttp-3.9.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:55b39c8684a46e56ef8c8d24faf02de4a2b2ac60d26cee93bc595651ff545de9"}, + {file = "aiohttp-3.9.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4715a9b778f4293b9f8ae7a0a7cef9829f02ff8d6277a39d7f40565c737d3771"}, + {file = "aiohttp-3.9.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:afc52b8d969eff14e069a710057d15ab9ac17cd4b6753042c407dcea0e40bf75"}, + {file = "aiohttp-3.9.5-cp311-cp311-win32.whl", hash = "sha256:b3df71da99c98534be076196791adca8819761f0bf6e08e07fd7da25127150d6"}, + {file = "aiohttp-3.9.5-cp311-cp311-win_amd64.whl", hash = "sha256:88e311d98cc0bf45b62fc46c66753a83445f5ab20038bcc1b8a1cc05666f428a"}, + {file = "aiohttp-3.9.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:c7a4b7a6cf5b6eb11e109a9755fd4fda7d57395f8c575e166d363b9fc3ec4678"}, + {file = "aiohttp-3.9.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:0a158704edf0abcac8ac371fbb54044f3270bdbc93e254a82b6c82be1ef08f3c"}, + {file = "aiohttp-3.9.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d153f652a687a8e95ad367a86a61e8d53d528b0530ef382ec5aaf533140ed00f"}, + {file = "aiohttp-3.9.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:82a6a97d9771cb48ae16979c3a3a9a18b600a8505b1115cfe354dfb2054468b4"}, + {file = "aiohttp-3.9.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:60cdbd56f4cad9f69c35eaac0fbbdf1f77b0ff9456cebd4902f3dd1cf096464c"}, + {file = "aiohttp-3.9.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8676e8fd73141ded15ea586de0b7cda1542960a7b9ad89b2b06428e97125d4fa"}, + {file = "aiohttp-3.9.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da00da442a0e31f1c69d26d224e1efd3a1ca5bcbf210978a2ca7426dfcae9f58"}, + {file = "aiohttp-3.9.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:18f634d540dd099c262e9f887c8bbacc959847cfe5da7a0e2e1cf3f14dbf2daf"}, + {file = "aiohttp-3.9.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:320e8618eda64e19d11bdb3bd04ccc0a816c17eaecb7e4945d01deee2a22f95f"}, + {file = "aiohttp-3.9.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:2faa61a904b83142747fc6a6d7ad8fccff898c849123030f8e75d5d967fd4a81"}, + {file = "aiohttp-3.9.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:8c64a6dc3fe5db7b1b4d2b5cb84c4f677768bdc340611eca673afb7cf416ef5a"}, + {file = "aiohttp-3.9.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:393c7aba2b55559ef7ab791c94b44f7482a07bf7640d17b341b79081f5e5cd1a"}, + {file = "aiohttp-3.9.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:c671dc117c2c21a1ca10c116cfcd6e3e44da7fcde37bf83b2be485ab377b25da"}, + {file = "aiohttp-3.9.5-cp312-cp312-win32.whl", hash = "sha256:5a7ee16aab26e76add4afc45e8f8206c95d1d75540f1039b84a03c3b3800dd59"}, + {file = "aiohttp-3.9.5-cp312-cp312-win_amd64.whl", hash = "sha256:5ca51eadbd67045396bc92a4345d1790b7301c14d1848feaac1d6a6c9289e888"}, + {file = "aiohttp-3.9.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:694d828b5c41255e54bc2dddb51a9f5150b4eefa9886e38b52605a05d96566e8"}, + {file = "aiohttp-3.9.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0605cc2c0088fcaae79f01c913a38611ad09ba68ff482402d3410bf59039bfb8"}, + {file = "aiohttp-3.9.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4558e5012ee03d2638c681e156461d37b7a113fe13970d438d95d10173d25f78"}, + {file = "aiohttp-3.9.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9dbc053ac75ccc63dc3a3cc547b98c7258ec35a215a92bd9f983e0aac95d3d5b"}, + {file = "aiohttp-3.9.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4109adee842b90671f1b689901b948f347325045c15f46b39797ae1bf17019de"}, + {file = "aiohttp-3.9.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6ea1a5b409a85477fd8e5ee6ad8f0e40bf2844c270955e09360418cfd09abac"}, + {file = "aiohttp-3.9.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3c2890ca8c59ee683fd09adf32321a40fe1cf164e3387799efb2acebf090c11"}, + {file = "aiohttp-3.9.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3916c8692dbd9d55c523374a3b8213e628424d19116ac4308e434dbf6d95bbdd"}, + {file = "aiohttp-3.9.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:8d1964eb7617907c792ca00b341b5ec3e01ae8c280825deadbbd678447b127e1"}, + {file = "aiohttp-3.9.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:d5ab8e1f6bee051a4bf6195e38a5c13e5e161cb7bad83d8854524798bd9fcd6e"}, + {file = "aiohttp-3.9.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:52c27110f3862a1afbcb2af4281fc9fdc40327fa286c4625dfee247c3ba90156"}, + {file = "aiohttp-3.9.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:7f64cbd44443e80094309875d4f9c71d0401e966d191c3d469cde4642bc2e031"}, + {file = "aiohttp-3.9.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8b4f72fbb66279624bfe83fd5eb6aea0022dad8eec62b71e7bf63ee1caadeafe"}, + {file = "aiohttp-3.9.5-cp38-cp38-win32.whl", hash = "sha256:6380c039ec52866c06d69b5c7aad5478b24ed11696f0e72f6b807cfb261453da"}, + {file = "aiohttp-3.9.5-cp38-cp38-win_amd64.whl", hash = "sha256:da22dab31d7180f8c3ac7c7635f3bcd53808f374f6aa333fe0b0b9e14b01f91a"}, + {file = "aiohttp-3.9.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:1732102949ff6087589408d76cd6dea656b93c896b011ecafff418c9661dc4ed"}, + {file = "aiohttp-3.9.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c6021d296318cb6f9414b48e6a439a7f5d1f665464da507e8ff640848ee2a58a"}, + {file = "aiohttp-3.9.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:239f975589a944eeb1bad26b8b140a59a3a320067fb3cd10b75c3092405a1372"}, + {file = "aiohttp-3.9.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3b7b30258348082826d274504fbc7c849959f1989d86c29bc355107accec6cfb"}, + {file = "aiohttp-3.9.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd2adf5c87ff6d8b277814a28a535b59e20bfea40a101db6b3bdca7e9926bc24"}, + {file = "aiohttp-3.9.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e9a3d838441bebcf5cf442700e3963f58b5c33f015341f9ea86dcd7d503c07e2"}, + {file = "aiohttp-3.9.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e3a1ae66e3d0c17cf65c08968a5ee3180c5a95920ec2731f53343fac9bad106"}, + {file = "aiohttp-3.9.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9c69e77370cce2d6df5d12b4e12bdcca60c47ba13d1cbbc8645dd005a20b738b"}, + {file = "aiohttp-3.9.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0cbf56238f4bbf49dab8c2dc2e6b1b68502b1e88d335bea59b3f5b9f4c001475"}, + {file = "aiohttp-3.9.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:d1469f228cd9ffddd396d9948b8c9cd8022b6d1bf1e40c6f25b0fb90b4f893ed"}, + {file = "aiohttp-3.9.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:45731330e754f5811c314901cebdf19dd776a44b31927fa4b4dbecab9e457b0c"}, + {file = "aiohttp-3.9.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:3fcb4046d2904378e3aeea1df51f697b0467f2aac55d232c87ba162709478c46"}, + {file = "aiohttp-3.9.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8cf142aa6c1a751fcb364158fd710b8a9be874b81889c2bd13aa8893197455e2"}, + {file = "aiohttp-3.9.5-cp39-cp39-win32.whl", hash = "sha256:7b179eea70833c8dee51ec42f3b4097bd6370892fa93f510f76762105568cf09"}, + {file = "aiohttp-3.9.5-cp39-cp39-win_amd64.whl", hash = "sha256:38d80498e2e169bc61418ff36170e0aad0cd268da8b38a17c4cf29d254a8b3f1"}, + {file = "aiohttp-3.9.5.tar.gz", hash = "sha256:edea7d15772ceeb29db4aff55e482d4bcfb6ae160ce144f2682de02f6d693551"}, +] + +[package.dependencies] +aiosignal = ">=1.1.2" +async-timeout = {version = ">=4.0,<5.0", markers = "python_version < \"3.11\""} +attrs = ">=17.3.0" +frozenlist = ">=1.1.1" +multidict = ">=4.5,<7.0" +yarl = ">=1.0,<2.0" + +[package.extras] +speedups = ["Brotli", "aiodns", "brotlicffi"] + +[[package]] +name = "aiosignal" +version = "1.3.1" +description = "aiosignal: a list of registered asynchronous callbacks" +optional = false +python-versions = ">=3.7" +files = [ + {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, + {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, +] + +[package.dependencies] +frozenlist = ">=1.1.0" + +[[package]] +name = "altair" +version = "5.3.0" +description = "Vega-Altair: A declarative statistical visualization library for Python." +optional = false +python-versions = ">=3.8" +files = [ + {file = "altair-5.3.0-py3-none-any.whl", hash = "sha256:7084a1dab4d83c5e7e5246b92dc1b4451a6c68fd057f3716ee9d315c8980e59a"}, + {file = "altair-5.3.0.tar.gz", hash = "sha256:5a268b1a0983b23d8f9129f819f956174aa7aea2719ed55a52eba9979b9f6675"}, +] + +[package.dependencies] +jinja2 = "*" +jsonschema = ">=3.0" +numpy = "*" +packaging = "*" +pandas = ">=0.25" +toolz = "*" +typing-extensions = {version = ">=4.0.1", markers = "python_version < \"3.11\""} + +[package.extras] +all = ["altair-tiles (>=0.3.0)", "anywidget (>=0.9.0)", "pyarrow (>=11)", "vega-datasets (>=0.9.0)", "vegafusion[embed] (>=1.6.6)", "vl-convert-python (>=1.3.0)"] +dev = ["geopandas", "hatch", "ipython", "m2r", "mypy", "pandas-stubs", "pytest", "pytest-cov", "ruff (>=0.3.0)", "types-jsonschema", "types-setuptools"] +doc = ["docutils", "jinja2", "myst-parser", "numpydoc", "pillow (>=9,<10)", "pydata-sphinx-theme (>=0.14.1)", "scipy", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinxext-altair"] + +[[package]] +name = "antlr4-python3-runtime" +version = "4.8" +description = "ANTLR 4.8 runtime for Python 3.7" +optional = false +python-versions = "*" +files = [ + {file = "antlr4-python3-runtime-4.8.tar.gz", hash = "sha256:15793f5d0512a372b4e7d2284058ad32ce7dd27126b105fb0b2245130445db33"}, +] + +[[package]] +name = "appdirs" +version = "1.4.4" +description = "A small Python module for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." +optional = false +python-versions = "*" +files = [ + {file = "appdirs-1.4.4-py2.py3-none-any.whl", hash = "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128"}, + {file = "appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41"}, +] + +[[package]] +name = "async-timeout" +version = "4.0.3" +description = "Timeout context manager for asyncio programs" +optional = false +python-versions = ">=3.7" +files = [ + {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"}, + {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"}, +] + +[[package]] +name = "attrs" +version = "23.2.0" +description = "Classes Without Boilerplate" +optional = false +python-versions = ">=3.7" +files = [ + {file = "attrs-23.2.0-py3-none-any.whl", hash = "sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1"}, + {file = "attrs-23.2.0.tar.gz", hash = "sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30"}, +] + +[package.extras] +cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] +dev = ["attrs[tests]", "pre-commit"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] +tests = ["attrs[tests-no-zope]", "zope-interface"] +tests-mypy = ["mypy (>=1.6)", "pytest-mypy-plugins"] +tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist[psutil]"] + +[[package]] +name = "bitarray" +version = "2.9.2" +description = "efficient arrays of booleans -- C extension" +optional = false +python-versions = "*" +files = [ + {file = "bitarray-2.9.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:917905de565d9576eb20f53c797c15ba88b9f4f19728acabec8d01eee1d3756a"}, + {file = "bitarray-2.9.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b35bfcb08b7693ab4bf9059111a6e9f14e07d57ac93cd967c420db58ab9b71e1"}, + {file = "bitarray-2.9.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ea1923d2e7880f9e1959e035da661767b5a2e16a45dfd57d6aa831e8b65ee1bf"}, + {file = "bitarray-2.9.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e0b63a565e8a311cc8348ff1262d5784df0f79d64031d546411afd5dd7ef67d"}, + {file = "bitarray-2.9.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cf0620da2b81946d28c0b16f3e3704d38e9837d85ee4f0652816e2609aaa4fed"}, + {file = "bitarray-2.9.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:79a9b8b05f2876c7195a2b698c47528e86a73c61ea203394ff8e7a4434bda5c8"}, + {file = "bitarray-2.9.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:345c76b349ff145549652436235c5532e5bfe9db690db6f0a6ad301c62b9ef21"}, + {file = "bitarray-2.9.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4e2936f090bf3f4d1771f44f9077ebccdbc0415d2b598d51a969afcb519df505"}, + {file = "bitarray-2.9.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:f9346e98fc2abcef90b942973087e2462af6d3e3710e82938078d3493f7fef52"}, + {file = "bitarray-2.9.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e6ec283d4741befb86e8c3ea2e9ac1d17416c956d392107e45263e736954b1f7"}, + {file = "bitarray-2.9.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:962892646599529917ef26266091e4cb3077c88b93c3833a909d68dcc971c4e3"}, + {file = "bitarray-2.9.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:e8da5355d7d75a52df5b84750989e34e39919ec7e59fafc4c104cc1607ab2d31"}, + {file = "bitarray-2.9.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:603e7d640e54ad764d2b4da6b61e126259af84f253a20f512dd10689566e5478"}, + {file = "bitarray-2.9.2-cp310-cp310-win32.whl", hash = "sha256:f00079f8e69d75c2a417de7961a77612bb77ef46c09bc74607d86de4740771ef"}, + {file = "bitarray-2.9.2-cp310-cp310-win_amd64.whl", hash = "sha256:1bb33673e7f7190a65f0a940c1ef63266abdb391f4a3e544a47542d40a81f536"}, + {file = "bitarray-2.9.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:fe71fd4b76380c2772f96f1e53a524da7063645d647a4fcd3b651bdd80ca0f2e"}, + {file = "bitarray-2.9.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d527172919cdea1e13994a66d9708a80c3d33dedcf2f0548e4925e600fef3a3a"}, + {file = "bitarray-2.9.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:052c5073bdcaa9dd10628d99d37a2f33ec09364b86dd1f6281e2d9f8d3db3060"}, + {file = "bitarray-2.9.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e064caa55a6ed493aca1eda06f8b3f689778bc780a75e6ad7724642ba5dc62f7"}, + {file = "bitarray-2.9.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:508069a04f658210fdeee85a7a0ca84db4bcc110cbb1d21f692caa13210f24a7"}, + {file = "bitarray-2.9.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4da73ebd537d75fa7bccfc2228fcaedea0803f21dd9d0bf0d3b67fef3c4af294"}, + {file = "bitarray-2.9.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5cb378eaa65cd43098f11ff5d27e48ee3b956d2c00d2d6b5bfc2a09fe183be47"}, + {file = "bitarray-2.9.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d14c790b91f6cbcd9b718f88ed737c78939980c69ac8c7f03dd7e60040c12951"}, + {file = "bitarray-2.9.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:7eea9318293bc0ea6447e9ebfba600a62f3428bea7e9c6d42170ae4f481dbab3"}, + {file = "bitarray-2.9.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:b76ffec27c7450b8a334f967366a9ebadaea66ee43f5b530c12861b1a991f503"}, + {file = "bitarray-2.9.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:76b76a07d4ee611405045c6950a1e24c4362b6b44808d4ad6eea75e0dbc59af4"}, + {file = "bitarray-2.9.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:c7d16beeaaab15b075990cd26963d6b5b22e8c5becd131781514a00b8bdd04bd"}, + {file = "bitarray-2.9.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60df43e868a615c7e15117a1e1c2e5e11f48f6457280eba6ddf8fbefbec7da99"}, + {file = "bitarray-2.9.2-cp311-cp311-win32.whl", hash = "sha256:e788608ed7767b7b3bbde6d49058bccdf94df0de9ca75d13aa99020cc7e68095"}, + {file = "bitarray-2.9.2-cp311-cp311-win_amd64.whl", hash = "sha256:a23397da092ef0a8cfe729571da64c2fc30ac18243caa82ac7c4f965087506ff"}, + {file = "bitarray-2.9.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:90e3a281ffe3897991091b7c46fca38c2675bfd4399ffe79dfeded6c52715436"}, + {file = "bitarray-2.9.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:bed637b674db5e6c8a97a4a321e3e4d73e72d50b5c6b29950008a93069cc64cd"}, + {file = "bitarray-2.9.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e49066d251dbbe4e6e3a5c3937d85b589e40e2669ad0eef41a00f82ec17d844b"}, + {file = "bitarray-2.9.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c4344e96642e2211fb3a50558feff682c31563a4c64529a931769d40832ca79"}, + {file = "bitarray-2.9.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aeb60962ec4813c539a59fbd4f383509c7222b62c3fb1faa76b54943a613e33a"}, + {file = "bitarray-2.9.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ed0f7982f10581bb16553719e5e8f933e003f5b22f7d25a68bdb30fac630a6ff"}, + {file = "bitarray-2.9.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c71d1cabdeee0cdda4669168618f0e46b7dace207b29da7b63aaa1adc2b54081"}, + {file = "bitarray-2.9.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b0ef2d0a6f1502d38d911d25609b44c6cc27bee0a4363dd295df78b075041b60"}, + {file = "bitarray-2.9.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:6f71d92f533770fb027388b35b6e11988ab89242b883f48a6fe7202d238c61f8"}, + {file = "bitarray-2.9.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:ba0734aa300757c924f3faf8148e1b8c247176a0ac8e16aefdf9c1eb19e868f7"}, + {file = "bitarray-2.9.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:d91406f413ccbf4af6ab5ae7bc78f772a95609f9ddd14123db36ef8c37116d95"}, + {file = "bitarray-2.9.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:87abb7f80c0a042f3fe8e5264da1a2756267450bb602110d5327b8eaff7682e7"}, + {file = "bitarray-2.9.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b558ce85579b51a2e38703877d1e93b7728a7af664dd45a34e833534f0b755d"}, + {file = "bitarray-2.9.2-cp312-cp312-win32.whl", hash = "sha256:dac2399ee2889fbdd3472bfc2ede74c34cceb1ccf29a339964281a16eb1d3188"}, + {file = "bitarray-2.9.2-cp312-cp312-win_amd64.whl", hash = "sha256:48a30d718d1a6dfc22a49547450107abe8f4afdf2abdcbe76eb9ed88edc49498"}, + {file = "bitarray-2.9.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:2c6be1b651fad8f3adb7a5aa12c65b612cd9b89530969af941844ae680f7d981"}, + {file = "bitarray-2.9.2-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5b399ae6ab975257ec359f03b48fc00b1c1cd109471e41903548469b8feae5c"}, + {file = "bitarray-2.9.2-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0b3543c8a1cb286ad105f11c25d8d0f712f41c5c55f90be39f0e5a1376c7d0b0"}, + {file = "bitarray-2.9.2-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:03adaacb79e2fb8f483ab3a67665eec53bb3fd0cd5dbd7358741aef124688db3"}, + {file = "bitarray-2.9.2-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ae5b0657380d2581e13e46864d147a52c1e2bbac9f59b59c576e42fa7d10cf0"}, + {file = "bitarray-2.9.2-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7c1f4bf6ea8eb9d7f30808c2e9894237a96650adfecbf5f3643862dc5982f89e"}, + {file = "bitarray-2.9.2-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:a8873089be2aa15494c0f81af1209f6e1237d762c5065bc4766c1b84321e1b50"}, + {file = "bitarray-2.9.2-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:677e67f50e2559efc677a4366707070933ad5418b8347a603a49a070890b19bc"}, + {file = "bitarray-2.9.2-cp36-cp36m-musllinux_1_1_ppc64le.whl", hash = "sha256:a620d8ce4ea2f1c73c6b6b1399e14cb68c6915e2be3fad5808c2998ed55b4acf"}, + {file = "bitarray-2.9.2-cp36-cp36m-musllinux_1_1_s390x.whl", hash = "sha256:64115ccabbdbe279c24c367b629c6b1d3da9ed36c7420129e27c338a3971bfee"}, + {file = "bitarray-2.9.2-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:5d6fb422772e75385b76ad1c52f45a68bd4efafd8be8d0061c11877be74c4d43"}, + {file = "bitarray-2.9.2-cp36-cp36m-win32.whl", hash = "sha256:852e202875dd6dfd6139ce7ec4e98dac2b17d8d25934dc99900831e81c3adaef"}, + {file = "bitarray-2.9.2-cp36-cp36m-win_amd64.whl", hash = "sha256:7dfefdcb0dc6a3ba9936063cec65a74595571b375beabe18742b3d91d087eefd"}, + {file = "bitarray-2.9.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b306c4cf66912511422060f7f5e1149c8bdb404f8e00e600561b0749fdd45659"}, + {file = "bitarray-2.9.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a09c4f81635408e3387348f415521d4b94198c562c23330f560596a6aaa26eaf"}, + {file = "bitarray-2.9.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5361413fd2ecfdf44dc8f065177dc6aba97fa80a91b815586cb388763acf7f8d"}, + {file = "bitarray-2.9.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e8a9475d415ef1eaae7942df6f780fa4dcd48fce32825eda591a17abba869299"}, + {file = "bitarray-2.9.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9b87baa7bfff9a5878fcc1bffe49ecde6e647a72a64b39a69cd8a2992a43a34"}, + {file = "bitarray-2.9.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bb6b86cfdfc503e92cb71c68766a24565359136961642504a7cc9faf936d9c88"}, + {file = "bitarray-2.9.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:cd56b8ae87ebc71bcacbd73615098e8a8de952ecbb5785b6b4e2b07da8a06e1f"}, + {file = "bitarray-2.9.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:3fa909cfd675004aed8b4cc9df352415933656e0155a6209d878b7cb615c787e"}, + {file = "bitarray-2.9.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b069ca9bf728e0c5c5b60e00a89df9af34cc170c695c3bfa3b372d8f40288efb"}, + {file = "bitarray-2.9.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:6067f2f07a7121749858c7daa93c8774325c91590b3e81a299621e347740c2ae"}, + {file = "bitarray-2.9.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:321841cdad1dd0f58fe62e80e9c9c7531f8ebf8be93f047401e930dc47425b1e"}, + {file = "bitarray-2.9.2-cp37-cp37m-win32.whl", hash = "sha256:54e16e32e60973bb83c315de9975bc1bcfc9bd50bb13001c31da159bc49b0ca1"}, + {file = "bitarray-2.9.2-cp37-cp37m-win_amd64.whl", hash = "sha256:f4dcadb7b8034aa3491ee8f5a69b3d9ba9d7d1e55c3cc1fc45be313e708277f8"}, + {file = "bitarray-2.9.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:c8919fdbd3bb596b104388b56ae4b266eb28da1f2f7dff2e1f9334a21840fe96"}, + {file = "bitarray-2.9.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:eb7a9d8a2e400a1026de341ad48e21670a6261a75b06df162c5c39b0d0e7c8f4"}, + {file = "bitarray-2.9.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:6ec84668dd7b937874a2b2c293cd14ba84f37be0d196dead852e0ada9815d807"}, + {file = "bitarray-2.9.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2de9a31c34e543ae089fd2a5ced01292f725190e379921384f695e2d7184bd3"}, + {file = "bitarray-2.9.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9521f49ae121a17c0a41e5112249e6fa7f6a571245b1118de81fb86e7c1bc1ce"}, + {file = "bitarray-2.9.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6cc6545d6d76542aee3d18c1c9485fb7b9812b8df4ebe52c4535ec42081b48f"}, + {file = "bitarray-2.9.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:856bbe1616425f71c0df5ef2e8755e878d9504d5a531acba58ab4273c52c117a"}, + {file = "bitarray-2.9.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d4bba8042ea6ab331ade91bc435d81ad72fddb098e49108610b0ce7780c14e68"}, + {file = "bitarray-2.9.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a035da89c959d98afc813e3c62f052690d67cfd55a36592f25d734b70de7d4b0"}, + {file = "bitarray-2.9.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:6d70b1579da7fb71be5a841a1f965d19aca0ef27f629cfc07d06b09aafd0a333"}, + {file = "bitarray-2.9.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:405b83bed28efaae6d86b6ab287c75712ead0adbfab2a1075a1b7ab47dad4d62"}, + {file = "bitarray-2.9.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:7eb8be687c50da0b397d5e0ab7ca200b5ebb639e79a9f5e285851d1944c94be9"}, + {file = "bitarray-2.9.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:eceb551dfeaf19c609003a69a0cf8264b0efd7abc3791a11dfabf4788daf0d19"}, + {file = "bitarray-2.9.2-cp38-cp38-win32.whl", hash = "sha256:bb198c6ed1edbcdaf3d1fa3c9c9d1cdb7e179a5134ef5ee660b53cdec43b34e7"}, + {file = "bitarray-2.9.2-cp38-cp38-win_amd64.whl", hash = "sha256:648d2f2685590b0103c67a937c2fb9e09bcc8dfb166f0c7c77bd341902a6f5b3"}, + {file = "bitarray-2.9.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:ea816dc8f8e65841a8bbdd30e921edffeeb6f76efe6a1eb0da147b60d539d1cf"}, + {file = "bitarray-2.9.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4d0e32530f941c41eddfc77600ec89b65184cb909c549336463a738fab3ed285"}, + {file = "bitarray-2.9.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4a22266fb416a3b6c258bf7f83c9fe531ba0b755a56986a81ad69dc0f3bcc070"}, + {file = "bitarray-2.9.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc6d3e80dd8239850f2604833ff3168b28909c8a9357abfed95632cccd17e3e7"}, + {file = "bitarray-2.9.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f135e804986b12bf14f2cd1eb86674c47dea86c4c5f0fa13c88978876b97ebe6"}, + {file = "bitarray-2.9.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:87580c7f7d14f7ec401eda7adac1e2a25e95153e9c339872c8ae61b3208819a1"}, + {file = "bitarray-2.9.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64b433e26993127732ac7b66a7821b2537c3044355798de7c5fcb0af34b8296f"}, + {file = "bitarray-2.9.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e497c535f2a9b68c69d36631bf2dba243e05eb343b00b9c7bbdc8c601c6802d"}, + {file = "bitarray-2.9.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:e40b3cb9fa1edb4e0175d7c06345c49c7925fe93e39ef55ecb0bc40c906b0c09"}, + {file = "bitarray-2.9.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f2f8692f95c9e377eb19ca519d30d1f884b02feb7e115f798de47570a359e43f"}, + {file = "bitarray-2.9.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f0b84fc50b6dbeced4fa390688c07c10a73222810fb0e08392bd1a1b8259de36"}, + {file = "bitarray-2.9.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:d656ad38c942e38a470ddbce26b5020e08e1a7ea86b8fd413bb9024b5189993a"}, + {file = "bitarray-2.9.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6ab0f1dbfe5070db98771a56aa14797595acd45a1af9eadfb193851a270e7996"}, + {file = "bitarray-2.9.2-cp39-cp39-win32.whl", hash = "sha256:0a99b23ac845a9ea3157782c97465e6ae026fe0c7c4c1ed1d88f759fd6ea52d9"}, + {file = "bitarray-2.9.2-cp39-cp39-win_amd64.whl", hash = "sha256:9bbcfc7c279e8d74b076e514e669b683f77b4a2a328585b3f16d4c5259c91222"}, + {file = "bitarray-2.9.2-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:43847799461d8ba71deb4d97b47250c2c2fb66d82cd3cb8b4caf52bb97c03034"}, + {file = "bitarray-2.9.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4f44381b0a4bdf64416082f4f0e7140377ae962c0ced6f983c6d7bbfc034040"}, + {file = "bitarray-2.9.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a484061616fb4b158b80789bd3cb511f399d2116525a8b29b6334c68abc2310f"}, + {file = "bitarray-2.9.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1ff9e38356cc803e06134cf8ae9758e836ccd1b793135ef3db53c7c5d71e93bc"}, + {file = "bitarray-2.9.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b44105792fbdcfbda3e26ee88786790fda409da4c71f6c2b73888108cf8f062f"}, + {file = "bitarray-2.9.2-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7e913098de169c7fc890638ce5e171387363eb812579e637c44261460ac00aa2"}, + {file = "bitarray-2.9.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6fe315355cdfe3ed22ef355b8bdc81a805ca4d0949d921576560e5b227a1112"}, + {file = "bitarray-2.9.2-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f708e91fdbe443f3bec2df394ed42328fb9b0446dff5cb4199023ac6499e09fd"}, + {file = "bitarray-2.9.2-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5b7b09489b71f9f1f64c0fa0977e250ec24500767dab7383ba9912495849cadf"}, + {file = "bitarray-2.9.2-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:128cc3488176145b9b137fdcf54c1c201809bbb8dd30b260ee40afe915843b43"}, + {file = "bitarray-2.9.2-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:21f21e7f56206be346bdbda2a6bdb2165a5e6a11821f88fd4911c5a6bbbdc7e2"}, + {file = "bitarray-2.9.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f4dd3af86dd8a617eb6464622fb64ca86e61ce99b59b5c35d8cd33f9c30603d"}, + {file = "bitarray-2.9.2-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6465de861aff7a2559f226b37982007417eab8c3557543879987f58b453519bd"}, + {file = "bitarray-2.9.2-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dbaf2bb71d6027152d603f1d5f31e0dfd5e50173d06f877bec484e5396d4594b"}, + {file = "bitarray-2.9.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:2f32948c86e0d230a296686db28191b67ed229756f84728847daa0c7ab7406e3"}, + {file = "bitarray-2.9.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:be94e5a685e60f9d24532af8fe5c268002e9016fa80272a94727f435de3d1003"}, + {file = "bitarray-2.9.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5cc9381fd54f3c23ae1039f977bfd6d041a5c3c1518104f616643c3a5a73b15"}, + {file = "bitarray-2.9.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cd926e8ae4d1ed1ac4a8f37212a62886292f692bc1739fde98013bf210c2d175"}, + {file = "bitarray-2.9.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:461a3dafb9d5fda0bb3385dc507d78b1984b49da3fe4c6d56c869a54373b7008"}, + {file = "bitarray-2.9.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:393cb27fd859af5fd9c16eb26b1c59b17b390ff66b3ae5d0dd258270191baf13"}, + {file = "bitarray-2.9.2.tar.gz", hash = "sha256:a8f286a51a32323715d77755ed959f94bef13972e9a2fe71b609e40e6d27957e"}, +] + +[[package]] +name = "blinker" +version = "1.8.2" +description = "Fast, simple object-to-object and broadcast signaling" +optional = false +python-versions = ">=3.8" +files = [ + {file = "blinker-1.8.2-py3-none-any.whl", hash = "sha256:1779309f71bf239144b9399d06ae925637cf6634cf6bd131104184531bf67c01"}, + {file = "blinker-1.8.2.tar.gz", hash = "sha256:8f77b09d3bf7c795e969e9486f39c2c5e9c39d4ee07424be2bc594ece9642d83"}, +] + +[[package]] +name = "cachetools" +version = "5.3.3" +description = "Extensible memoizing collections and decorators" +optional = false +python-versions = ">=3.7" +files = [ + {file = "cachetools-5.3.3-py3-none-any.whl", hash = "sha256:0abad1021d3f8325b2fc1d2e9c8b9c9d57b04c3932657a72465447332c24d945"}, + {file = "cachetools-5.3.3.tar.gz", hash = "sha256:ba29e2dfa0b8b556606f097407ed1aa62080ee108ab0dc5ec9d6a723a007d105"}, +] + +[[package]] +name = "certifi" +version = "2024.6.2" +description = "Python package for providing Mozilla's CA Bundle." +optional = false +python-versions = ">=3.6" +files = [ + {file = "certifi-2024.6.2-py3-none-any.whl", hash = "sha256:ddc6c8ce995e6987e7faf5e3f1b02b302836a0e5d98ece18392cb1a36c72ad56"}, + {file = "certifi-2024.6.2.tar.gz", hash = "sha256:3cd43f1c6fa7dedc5899d69d3ad0398fd018ad1a17fba83ddaf78aa46c747516"}, +] + +[[package]] +name = "cffi" +version = "1.16.0" +description = "Foreign Function Interface for Python calling C code." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"}, + {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"}, + {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"}, + {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"}, + {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"}, + {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"}, + {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"}, + {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"}, + {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"}, + {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"}, + {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"}, + {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"}, + {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"}, + {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"}, + {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"}, +] + +[package.dependencies] +pycparser = "*" + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[package]] +name = "click" +version = "8.1.7" +description = "Composable command line interface toolkit" +optional = false +python-versions = ">=3.7" +files = [ + {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, + {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "contourpy" +version = "1.2.1" +description = "Python library for calculating contours of 2D quadrilateral grids" +optional = false +python-versions = ">=3.9" +files = [ + {file = "contourpy-1.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bd7c23df857d488f418439686d3b10ae2fbf9bc256cd045b37a8c16575ea1040"}, + {file = "contourpy-1.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5b9eb0ca724a241683c9685a484da9d35c872fd42756574a7cfbf58af26677fd"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c75507d0a55378240f781599c30e7776674dbaf883a46d1c90f37e563453480"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11959f0ce4a6f7b76ec578576a0b61a28bdc0696194b6347ba3f1c53827178b9"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb3315a8a236ee19b6df481fc5f997436e8ade24a9f03dfdc6bd490fea20c6da"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39f3ecaf76cd98e802f094e0d4fbc6dc9c45a8d0c4d185f0f6c2234e14e5f75b"}, + {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:94b34f32646ca0414237168d68a9157cb3889f06b096612afdd296003fdd32fd"}, + {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:457499c79fa84593f22454bbd27670227874cd2ff5d6c84e60575c8b50a69619"}, + {file = "contourpy-1.2.1-cp310-cp310-win32.whl", hash = "sha256:ac58bdee53cbeba2ecad824fa8159493f0bf3b8ea4e93feb06c9a465d6c87da8"}, + {file = "contourpy-1.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:9cffe0f850e89d7c0012a1fb8730f75edd4320a0a731ed0c183904fe6ecfc3a9"}, + {file = "contourpy-1.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6022cecf8f44e36af10bd9118ca71f371078b4c168b6e0fab43d4a889985dbb5"}, + {file = "contourpy-1.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ef5adb9a3b1d0c645ff694f9bca7702ec2c70f4d734f9922ea34de02294fdf72"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6150ffa5c767bc6332df27157d95442c379b7dce3a38dff89c0f39b63275696f"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c863140fafc615c14a4bf4efd0f4425c02230eb8ef02784c9a156461e62c965"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:00e5388f71c1a0610e6fe56b5c44ab7ba14165cdd6d695429c5cd94021e390b2"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4492d82b3bc7fbb7e3610747b159869468079fe149ec5c4d771fa1f614a14df"}, + {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:49e70d111fee47284d9dd867c9bb9a7058a3c617274900780c43e38d90fe1205"}, + {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b59c0ffceff8d4d3996a45f2bb6f4c207f94684a96bf3d9728dbb77428dd8cb8"}, + {file = "contourpy-1.2.1-cp311-cp311-win32.whl", hash = "sha256:7b4182299f251060996af5249c286bae9361fa8c6a9cda5efc29fe8bfd6062ec"}, + {file = "contourpy-1.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2855c8b0b55958265e8b5888d6a615ba02883b225f2227461aa9127c578a4922"}, + {file = "contourpy-1.2.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:62828cada4a2b850dbef89c81f5a33741898b305db244904de418cc957ff05dc"}, + {file = "contourpy-1.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:309be79c0a354afff9ff7da4aaed7c3257e77edf6c1b448a779329431ee79d7e"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e785e0f2ef0d567099b9ff92cbfb958d71c2d5b9259981cd9bee81bd194c9a4"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1cac0a8f71a041aa587410424ad46dfa6a11f6149ceb219ce7dd48f6b02b87a7"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af3f4485884750dddd9c25cb7e3915d83c2db92488b38ccb77dd594eac84c4a0"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ce6889abac9a42afd07a562c2d6d4b2b7134f83f18571d859b25624a331c90b"}, + {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a1eea9aecf761c661d096d39ed9026574de8adb2ae1c5bd7b33558af884fb2ce"}, + {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:187fa1d4c6acc06adb0fae5544c59898ad781409e61a926ac7e84b8f276dcef4"}, + {file = "contourpy-1.2.1-cp312-cp312-win32.whl", hash = "sha256:c2528d60e398c7c4c799d56f907664673a807635b857df18f7ae64d3e6ce2d9f"}, + {file = "contourpy-1.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:1a07fc092a4088ee952ddae19a2b2a85757b923217b7eed584fdf25f53a6e7ce"}, + {file = "contourpy-1.2.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bb6834cbd983b19f06908b45bfc2dad6ac9479ae04abe923a275b5f48f1a186b"}, + {file = "contourpy-1.2.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1d59e739ab0e3520e62a26c60707cc3ab0365d2f8fecea74bfe4de72dc56388f"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd3db01f59fdcbce5b22afad19e390260d6d0222f35a1023d9adc5690a889364"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a12a813949e5066148712a0626895c26b2578874e4cc63160bb007e6df3436fe"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe0ccca550bb8e5abc22f530ec0466136379c01321fd94f30a22231e8a48d985"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1d59258c3c67c865435d8fbeb35f8c59b8bef3d6f46c1f29f6123556af28445"}, + {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f32c38afb74bd98ce26de7cc74a67b40afb7b05aae7b42924ea990d51e4dac02"}, + {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d31a63bc6e6d87f77d71e1abbd7387ab817a66733734883d1fc0021ed9bfa083"}, + {file = "contourpy-1.2.1-cp39-cp39-win32.whl", hash = "sha256:ddcb8581510311e13421b1f544403c16e901c4e8f09083c881fab2be80ee31ba"}, + {file = "contourpy-1.2.1-cp39-cp39-win_amd64.whl", hash = "sha256:10a37ae557aabf2509c79715cd20b62e4c7c28b8cd62dd7d99e5ed3ce28c3fd9"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a31f94983fecbac95e58388210427d68cd30fe8a36927980fab9c20062645609"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef2b055471c0eb466033760a521efb9d8a32b99ab907fc8358481a1dd29e3bd3"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:b33d2bc4f69caedcd0a275329eb2198f560b325605810895627be5d4b876bf7f"}, + {file = "contourpy-1.2.1.tar.gz", hash = "sha256:4d8908b3bee1c889e547867ca4cdc54e5ab6be6d3e078556814a22457f49423c"}, +] + +[package.dependencies] +numpy = ">=1.20" + +[package.extras] +bokeh = ["bokeh", "selenium"] +docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"] +mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.8.0)", "types-Pillow"] +test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] +test-no-images = ["pytest", "pytest-cov", "pytest-xdist", "wurlitzer"] + +[[package]] +name = "coverage" +version = "5.5" +description = "Code coverage measurement for Python" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4" +files = [ + {file = "coverage-5.5-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:b6d534e4b2ab35c9f93f46229363e17f63c53ad01330df9f2d6bd1187e5eaacf"}, + {file = "coverage-5.5-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:b7895207b4c843c76a25ab8c1e866261bcfe27bfaa20c192de5190121770672b"}, + {file = "coverage-5.5-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:c2723d347ab06e7ddad1a58b2a821218239249a9e4365eaff6649d31180c1669"}, + {file = "coverage-5.5-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:900fbf7759501bc7807fd6638c947d7a831fc9fdf742dc10f02956ff7220fa90"}, + {file = "coverage-5.5-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:004d1880bed2d97151facef49f08e255a20ceb6f9432df75f4eef018fdd5a78c"}, + {file = "coverage-5.5-cp27-cp27m-win32.whl", hash = "sha256:06191eb60f8d8a5bc046f3799f8a07a2d7aefb9504b0209aff0b47298333302a"}, + {file = "coverage-5.5-cp27-cp27m-win_amd64.whl", hash = "sha256:7501140f755b725495941b43347ba8a2777407fc7f250d4f5a7d2a1050ba8e82"}, + {file = "coverage-5.5-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:372da284cfd642d8e08ef606917846fa2ee350f64994bebfbd3afb0040436905"}, + {file = "coverage-5.5-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:8963a499849a1fc54b35b1c9f162f4108017b2e6db2c46c1bed93a72262ed083"}, + {file = "coverage-5.5-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:869a64f53488f40fa5b5b9dcb9e9b2962a66a87dab37790f3fcfb5144b996ef5"}, + {file = "coverage-5.5-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:4a7697d8cb0f27399b0e393c0b90f0f1e40c82023ea4d45d22bce7032a5d7b81"}, + {file = "coverage-5.5-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:8d0a0725ad7c1a0bcd8d1b437e191107d457e2ec1084b9f190630a4fb1af78e6"}, + {file = "coverage-5.5-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:51cb9476a3987c8967ebab3f0fe144819781fca264f57f89760037a2ea191cb0"}, + {file = "coverage-5.5-cp310-cp310-win_amd64.whl", hash = "sha256:c0891a6a97b09c1f3e073a890514d5012eb256845c451bd48f7968ef939bf4ae"}, + {file = "coverage-5.5-cp35-cp35m-macosx_10_9_x86_64.whl", hash = "sha256:3487286bc29a5aa4b93a072e9592f22254291ce96a9fbc5251f566b6b7343cdb"}, + {file = "coverage-5.5-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:deee1077aae10d8fa88cb02c845cfba9b62c55e1183f52f6ae6a2df6a2187160"}, + {file = "coverage-5.5-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:f11642dddbb0253cc8853254301b51390ba0081750a8ac03f20ea8103f0c56b6"}, + {file = "coverage-5.5-cp35-cp35m-manylinux2010_i686.whl", hash = "sha256:6c90e11318f0d3c436a42409f2749ee1a115cd8b067d7f14c148f1ce5574d701"}, + {file = "coverage-5.5-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:30c77c1dc9f253283e34c27935fded5015f7d1abe83bc7821680ac444eaf7793"}, + {file = "coverage-5.5-cp35-cp35m-win32.whl", hash = "sha256:9a1ef3b66e38ef8618ce5fdc7bea3d9f45f3624e2a66295eea5e57966c85909e"}, + {file = "coverage-5.5-cp35-cp35m-win_amd64.whl", hash = "sha256:972c85d205b51e30e59525694670de6a8a89691186012535f9d7dbaa230e42c3"}, + {file = "coverage-5.5-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:af0e781009aaf59e25c5a678122391cb0f345ac0ec272c7961dc5455e1c40066"}, + {file = "coverage-5.5-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:74d881fc777ebb11c63736622b60cb9e4aee5cace591ce274fb69e582a12a61a"}, + {file = "coverage-5.5-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:92b017ce34b68a7d67bd6d117e6d443a9bf63a2ecf8567bb3d8c6c7bc5014465"}, + {file = "coverage-5.5-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:d636598c8305e1f90b439dbf4f66437de4a5e3c31fdf47ad29542478c8508bbb"}, + {file = "coverage-5.5-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:41179b8a845742d1eb60449bdb2992196e211341818565abded11cfa90efb821"}, + {file = "coverage-5.5-cp36-cp36m-win32.whl", hash = "sha256:040af6c32813fa3eae5305d53f18875bedd079960822ef8ec067a66dd8afcd45"}, + {file = "coverage-5.5-cp36-cp36m-win_amd64.whl", hash = "sha256:5fec2d43a2cc6965edc0bb9e83e1e4b557f76f843a77a2496cbe719583ce8184"}, + {file = "coverage-5.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:18ba8bbede96a2c3dde7b868de9dcbd55670690af0988713f0603f037848418a"}, + {file = "coverage-5.5-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:2910f4d36a6a9b4214bb7038d537f015346f413a975d57ca6b43bf23d6563b53"}, + {file = "coverage-5.5-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:f0b278ce10936db1a37e6954e15a3730bea96a0997c26d7fee88e6c396c2086d"}, + {file = "coverage-5.5-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:796c9c3c79747146ebd278dbe1e5c5c05dd6b10cc3bcb8389dfdf844f3ead638"}, + {file = "coverage-5.5-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:53194af30d5bad77fcba80e23a1441c71abfb3e01192034f8246e0d8f99528f3"}, + {file = "coverage-5.5-cp37-cp37m-win32.whl", hash = "sha256:184a47bbe0aa6400ed2d41d8e9ed868b8205046518c52464fde713ea06e3a74a"}, + {file = "coverage-5.5-cp37-cp37m-win_amd64.whl", hash = "sha256:2949cad1c5208b8298d5686d5a85b66aae46d73eec2c3e08c817dd3513e5848a"}, + {file = "coverage-5.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:217658ec7187497e3f3ebd901afdca1af062b42cfe3e0dafea4cced3983739f6"}, + {file = "coverage-5.5-cp38-cp38-manylinux1_i686.whl", hash = "sha256:1aa846f56c3d49205c952d8318e76ccc2ae23303351d9270ab220004c580cfe2"}, + {file = "coverage-5.5-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:24d4a7de75446be83244eabbff746d66b9240ae020ced65d060815fac3423759"}, + {file = "coverage-5.5-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:d1f8bf7b90ba55699b3a5e44930e93ff0189aa27186e96071fac7dd0d06a1873"}, + {file = "coverage-5.5-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:970284a88b99673ccb2e4e334cfb38a10aab7cd44f7457564d11898a74b62d0a"}, + {file = "coverage-5.5-cp38-cp38-win32.whl", hash = "sha256:01d84219b5cdbfc8122223b39a954820929497a1cb1422824bb86b07b74594b6"}, + {file = "coverage-5.5-cp38-cp38-win_amd64.whl", hash = "sha256:2e0d881ad471768bf6e6c2bf905d183543f10098e3b3640fc029509530091502"}, + {file = "coverage-5.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d1f9ce122f83b2305592c11d64f181b87153fc2c2bbd3bb4a3dde8303cfb1a6b"}, + {file = "coverage-5.5-cp39-cp39-manylinux1_i686.whl", hash = "sha256:13c4ee887eca0f4c5a247b75398d4114c37882658300e153113dafb1d76de529"}, + {file = "coverage-5.5-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:52596d3d0e8bdf3af43db3e9ba8dcdaac724ba7b5ca3f6358529d56f7a166f8b"}, + {file = "coverage-5.5-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:2cafbbb3af0733db200c9b5f798d18953b1a304d3f86a938367de1567f4b5bff"}, + {file = "coverage-5.5-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:44d654437b8ddd9eee7d1eaee28b7219bec228520ff809af170488fd2fed3e2b"}, + {file = "coverage-5.5-cp39-cp39-win32.whl", hash = "sha256:d314ed732c25d29775e84a960c3c60808b682c08d86602ec2c3008e1202e3bb6"}, + {file = "coverage-5.5-cp39-cp39-win_amd64.whl", hash = "sha256:13034c4409db851670bc9acd836243aeee299949bd5673e11844befcb0149f03"}, + {file = "coverage-5.5-pp36-none-any.whl", hash = "sha256:f030f8873312a16414c0d8e1a1ddff2d3235655a2174e3648b4fa66b3f2f1079"}, + {file = "coverage-5.5-pp37-none-any.whl", hash = "sha256:2a3859cb82dcbda1cfd3e6f71c27081d18aa251d20a17d87d26d4cd216fb0af4"}, + {file = "coverage-5.5.tar.gz", hash = "sha256:ebe78fe9a0e874362175b02371bdfbee64d8edc42a044253ddf4ee7d3c15212c"}, +] + +[package.extras] +toml = ["toml"] + +[[package]] +name = "cycler" +version = "0.12.1" +description = "Composable style cycles" +optional = false +python-versions = ">=3.8" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[package.extras] +docs = ["ipython", "matplotlib", "numpydoc", "sphinx"] +tests = ["pytest", "pytest-cov", "pytest-xdist"] + +[[package]] +name = "cython" +version = "3.0.10" +description = "The Cython compiler for writing C extensions in the Python language." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,>=2.7" +files = [ + {file = "Cython-3.0.10-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e876272548d73583e90babda94c1299537006cad7a34e515a06c51b41f8657aa"}, + {file = "Cython-3.0.10-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:adc377aa33c3309191e617bf675fdbb51ca727acb9dc1aa23fc698d8121f7e23"}, + {file = "Cython-3.0.10-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:401aba1869a57aba2922ccb656a6320447e55ace42709b504c2f8e8b166f46e1"}, + {file = "Cython-3.0.10-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:541fbe725d6534a90b93f8c577eb70924d664b227a4631b90a6e0506d1469591"}, + {file = "Cython-3.0.10-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:86998b01f6a6d48398df8467292c7637e57f7e3a2ca68655367f13f66fed7734"}, + {file = "Cython-3.0.10-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d092c0ddba7e9e530a5c5be4ac06db8360258acc27675d1fc86294a5dc8994c5"}, + {file = "Cython-3.0.10-cp310-cp310-win32.whl", hash = "sha256:3cffb666e649dba23810732497442fb339ee67ba4e0be1f0579991e83fcc2436"}, + {file = "Cython-3.0.10-cp310-cp310-win_amd64.whl", hash = "sha256:9ea31184c7b3a728ef1f81fccb161d8948c05aa86c79f63b74fb6f3ddec860ec"}, + {file = "Cython-3.0.10-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:051069638abfb076900b0c2bcb6facf545655b3f429e80dd14365192074af5a4"}, + {file = "Cython-3.0.10-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:712760879600907189c7d0d346851525545484e13cd8b787e94bfd293da8ccf0"}, + {file = "Cython-3.0.10-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38d40fa1324ac47c04483d151f5e092406a147eac88a18aec789cf01c089c3f2"}, + {file = "Cython-3.0.10-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5bd49a3a9fdff65446a3e1c2bfc0ec85c6ce4c3cad27cd4ad7ba150a62b7fb59"}, + {file = "Cython-3.0.10-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e8df79b596633b8295eaa48b1157d796775c2bb078f32267d32f3001b687f2fd"}, + {file = "Cython-3.0.10-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:bcc9795990e525c192bc5c0775e441d7d56d7a7d02210451e9e13c0448dba51b"}, + {file = "Cython-3.0.10-cp311-cp311-win32.whl", hash = "sha256:09f2000041db482cad3bfce94e1fa3a4c82b0e57390a164c02566cbbda8c4f12"}, + {file = "Cython-3.0.10-cp311-cp311-win_amd64.whl", hash = "sha256:3919a55ec9b6c7db6f68a004c21c05ed540c40dbe459ced5d801d5a1f326a053"}, + {file = "Cython-3.0.10-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:8f2864ab5fcd27a346f0b50f901ebeb8f60b25a60a575ccfd982e7f3e9674914"}, + {file = "Cython-3.0.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:407840c56385b9c085826fe300213e0e76ba15d1d47daf4b58569078ecb94446"}, + {file = "Cython-3.0.10-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5a036d00caa73550a3a976432ef21c1e3fa12637e1616aab32caded35331ae96"}, + {file = "Cython-3.0.10-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9cc6a0e7e23a96dec3f3c9d39690d4281beabd5297855140d0d30855f950275e"}, + {file = "Cython-3.0.10-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a5e14a8c6a8157d2b0cdc2e8e3444905d20a0e78e19d2a097e89fb8b04b51f6b"}, + {file = "Cython-3.0.10-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:f8a2b8fa0fd8358bccb5f3304be563c4750aae175100463d212d5ea0ec74cbe0"}, + {file = "Cython-3.0.10-cp312-cp312-win32.whl", hash = "sha256:2d29e617fd23cf4b83afe8f93f2966566c9f565918ad1e86a4502fe825cc0a79"}, + {file = "Cython-3.0.10-cp312-cp312-win_amd64.whl", hash = "sha256:6c5af936940a38c300977b81598d9c0901158f220a58c177820e17e1774f1cf1"}, + {file = "Cython-3.0.10-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:5f465443917d5c0f69825fca3b52b64c74ac3de0143b1fff6db8ba5b48c9fb4a"}, + {file = "Cython-3.0.10-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fadb84193c25641973666e583df8df4e27c52cdc05ddce7c6f6510d690ba34a"}, + {file = "Cython-3.0.10-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fa9e7786083b6aa61594c16979d621b62e61fcd9c2edd4761641b95c7fb34b2"}, + {file = "Cython-3.0.10-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f4780d0f98ce28191c4d841c4358b5d5e79d96520650910cd59904123821c52d"}, + {file = "Cython-3.0.10-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:32fbad02d1189be75eb96456d9c73f5548078e5338d8fa153ecb0115b6ee279f"}, + {file = "Cython-3.0.10-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:90e2f514fc753b55245351305a399463103ec18666150bb1c36779b9862388e9"}, + {file = "Cython-3.0.10-cp36-cp36m-win32.whl", hash = "sha256:a9c976e9ec429539a4367cb4b24d15a1e46b925976f4341143f49f5f161171f5"}, + {file = "Cython-3.0.10-cp36-cp36m-win_amd64.whl", hash = "sha256:a9bb402674788a7f4061aeef8057632ec440123e74ed0fb425308a59afdfa10e"}, + {file = "Cython-3.0.10-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:206e803598010ecc3813db8748ed685f7beeca6c413f982df9f8a505fce56563"}, + {file = "Cython-3.0.10-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:15b6d397f4ee5ad54e373589522af37935a32863f1b23fa8c6922adf833e28e2"}, + {file = "Cython-3.0.10-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a181144c2f893ed8e6a994d43d0b96300bc99873f21e3b7334ca26c61c37b680"}, + {file = "Cython-3.0.10-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b74b700d6a793113d03fb54b63bdbadba6365379424bac7c0470605672769260"}, + {file = "Cython-3.0.10-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:076e9fd4e0ca33c5fa00a7479180dbfb62f17fe928e2909f82da814536e96d2b"}, + {file = "Cython-3.0.10-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:269f06e6961e8591d56e30b46e1a51b6ccb42cab04c29fa3b30d3e8723485fb4"}, + {file = "Cython-3.0.10-cp37-cp37m-win32.whl", hash = "sha256:d4e83a8ceff7af60064da4ccfce0ac82372544dd5392f1b350c34f1b04d0fae6"}, + {file = "Cython-3.0.10-cp37-cp37m-win_amd64.whl", hash = "sha256:40fac59c3a7fbcd9c25aea64c342c890a5e2270ce64a1525e840807800167799"}, + {file = "Cython-3.0.10-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f43a58bf2434870d2fc42ac2e9ff8138c9e00c6251468de279d93fa279e9ba3b"}, + {file = "Cython-3.0.10-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e9a885ec63d3955a08cefc4eec39fefa9fe14989c6e5e2382bd4aeb6bdb9bc3"}, + {file = "Cython-3.0.10-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acfbe0fff364d54906058fc61f2393f38cd7fa07d344d80923937b87e339adcf"}, + {file = "Cython-3.0.10-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8adcde00a8a88fab27509b558cd8c2959ab0c70c65d3814cfea8c68b83fa6dcd"}, + {file = "Cython-3.0.10-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2c9c1e3e78909488f3b16fabae02308423fa6369ed96ab1e250807d344cfffd7"}, + {file = "Cython-3.0.10-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:fc6e0faf5b57523b073f0cdefadcaef3a51235d519a0594865925cadb3aeadf0"}, + {file = "Cython-3.0.10-cp38-cp38-win32.whl", hash = "sha256:35f6ede7c74024ed1982832ae61c9fad7cf60cc3f5b8c6a63bb34e38bc291936"}, + {file = "Cython-3.0.10-cp38-cp38-win_amd64.whl", hash = "sha256:950c0c7b770d2a7cec74fb6f5ccc321d0b51d151f48c075c0d0db635a60ba1b5"}, + {file = "Cython-3.0.10-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:077b61ee789e48700e25d4a16daa4258b8e65167136e457174df400cf9b4feab"}, + {file = "Cython-3.0.10-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:64f1f8bba9d8f37c0cffc934792b4ac7c42d0891077127c11deebe9fa0a0f7e4"}, + {file = "Cython-3.0.10-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:651a15a8534ebfb9b58cb0b87c269c70984b6f9c88bfe65e4f635f0e3f07dfcd"}, + {file = "Cython-3.0.10-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d10fc9aa82e5e53a0b7fd118f9771199cddac8feb4a6d8350b7d4109085aa775"}, + {file = "Cython-3.0.10-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:4f610964ab252a83e573a427e28b103e2f1dd3c23bee54f32319f9e73c3c5499"}, + {file = "Cython-3.0.10-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8c9c4c4f3ab8f8c02817b0e16e8fa7b8cc880f76e9b63fe9c010e60c1a6c2b13"}, + {file = "Cython-3.0.10-cp39-cp39-win32.whl", hash = "sha256:0bac3ccdd4e03924028220c62ae3529e17efa8ca7e9df9330de95de02f582b26"}, + {file = "Cython-3.0.10-cp39-cp39-win_amd64.whl", hash = "sha256:81f356c1c8c0885b8435bfc468025f545c5d764aa9c75ab662616dd1193c331e"}, + {file = "Cython-3.0.10-py2.py3-none-any.whl", hash = "sha256:fcbb679c0b43514d591577fd0d20021c55c240ca9ccafbdb82d3fb95e5edfee2"}, + {file = "Cython-3.0.10.tar.gz", hash = "sha256:dcc96739331fb854dcf503f94607576cfe8488066c61ca50dfd55836f132de99"}, +] + +[[package]] +name = "docker-pycreds" +version = "0.4.0" +description = "Python bindings for the docker credentials store API" +optional = false +python-versions = "*" +files = [ + {file = "docker-pycreds-0.4.0.tar.gz", hash = "sha256:6ce3270bcaf404cc4c3e27e4b6c70d3521deae82fb508767870fdbf772d584d4"}, + {file = "docker_pycreds-0.4.0-py2.py3-none-any.whl", hash = "sha256:7266112468627868005106ec19cd0d722702d2b7d5912a28e19b826c3d37af49"}, +] + +[package.dependencies] +six = ">=1.4.0" + +[[package]] +name = "fairseq" +version = "0.12.2" +description = "Facebook AI Research Sequence-to-Sequence Toolkit" +optional = false +python-versions = "*" +files = [ + {file = "fairseq-0.12.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:fe65b07c5121b7cda0c7a17166994a6b0059259ce37881b6daa117b8c209b662"}, + {file = "fairseq-0.12.2-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:0543905012e39f00bd8c3f3781d9f49e76ab309801eb2eb7de250f5984df0de3"}, + {file = "fairseq-0.12.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c4877d65346797fc580a3a7e6e2364d2331a0026ef099c22eb8311441e49c2c6"}, + {file = "fairseq-0.12.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:26454f334ca705c67f898846dff34e14c148fcdaf53b4f52d64209773b509347"}, + {file = "fairseq-0.12.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:3b8c8b6dc368d2fd23a06ff613a2af05959eee275fe90846d7cffef4a43c522a"}, + {file = "fairseq-0.12.2-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:08fa308c760f995cdc13d9c385e2b9d923a78b48275d8b4d78f3a854c71a8f29"}, + {file = "fairseq-0.12.2.tar.gz", hash = "sha256:34f1b18426bf3844714534162f065ab733e049597476daa35fffb4d06a92b524"}, +] + +[package.dependencies] +bitarray = "*" +cffi = "*" +cython = "*" +hydra-core = ">=1.0.7,<1.1" +numpy = {version = "*", markers = "python_version >= \"3.7\""} +omegaconf = "<2.1" +regex = "*" +sacrebleu = ">=1.4.12" +torch = "*" +torchaudio = ">=0.8.0" +tqdm = "*" + +[[package]] +name = "filelock" +version = "3.14.0" +description = "A platform independent file lock." +optional = false +python-versions = ">=3.8" +files = [ + {file = "filelock-3.14.0-py3-none-any.whl", hash = "sha256:43339835842f110ca7ae60f1e1c160714c5a6afd15a2873419ab185334975c0f"}, + {file = "filelock-3.14.0.tar.gz", hash = "sha256:6ea72da3be9b8c82afd3edcf99f2fffbb5076335a5ae4d03248bb5b6c3eae78a"}, +] + +[package.extras] +docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8.0.1)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)"] +typing = ["typing-extensions (>=4.8)"] + +[[package]] +name = "fonttools" +version = "4.53.0" +description = "Tools to manipulate font files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "fonttools-4.53.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:52a6e0a7a0bf611c19bc8ec8f7592bdae79c8296c70eb05917fd831354699b20"}, + {file = "fonttools-4.53.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:099634631b9dd271d4a835d2b2a9e042ccc94ecdf7e2dd9f7f34f7daf333358d"}, + {file = "fonttools-4.53.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e40013572bfb843d6794a3ce076c29ef4efd15937ab833f520117f8eccc84fd6"}, + {file = "fonttools-4.53.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:715b41c3e231f7334cbe79dfc698213dcb7211520ec7a3bc2ba20c8515e8a3b5"}, + {file = "fonttools-4.53.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74ae2441731a05b44d5988d3ac2cf784d3ee0a535dbed257cbfff4be8bb49eb9"}, + {file = "fonttools-4.53.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:95db0c6581a54b47c30860d013977b8a14febc206c8b5ff562f9fe32738a8aca"}, + {file = "fonttools-4.53.0-cp310-cp310-win32.whl", hash = "sha256:9cd7a6beec6495d1dffb1033d50a3f82dfece23e9eb3c20cd3c2444d27514068"}, + {file = "fonttools-4.53.0-cp310-cp310-win_amd64.whl", hash = "sha256:daaef7390e632283051e3cf3e16aff2b68b247e99aea916f64e578c0449c9c68"}, + {file = "fonttools-4.53.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a209d2e624ba492df4f3bfad5996d1f76f03069c6133c60cd04f9a9e715595ec"}, + {file = "fonttools-4.53.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4f520d9ac5b938e6494f58a25c77564beca7d0199ecf726e1bd3d56872c59749"}, + {file = "fonttools-4.53.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eceef49f457253000e6a2d0f7bd08ff4e9fe96ec4ffce2dbcb32e34d9c1b8161"}, + {file = "fonttools-4.53.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa1f3e34373aa16045484b4d9d352d4c6b5f9f77ac77a178252ccbc851e8b2ee"}, + {file = "fonttools-4.53.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:28d072169fe8275fb1a0d35e3233f6df36a7e8474e56cb790a7258ad822b6fd6"}, + {file = "fonttools-4.53.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4a2a6ba400d386e904fd05db81f73bee0008af37799a7586deaa4aef8cd5971e"}, + {file = "fonttools-4.53.0-cp311-cp311-win32.whl", hash = "sha256:bb7273789f69b565d88e97e9e1da602b4ee7ba733caf35a6c2affd4334d4f005"}, + {file = "fonttools-4.53.0-cp311-cp311-win_amd64.whl", hash = "sha256:9fe9096a60113e1d755e9e6bda15ef7e03391ee0554d22829aa506cdf946f796"}, + {file = "fonttools-4.53.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d8f191a17369bd53a5557a5ee4bab91d5330ca3aefcdf17fab9a497b0e7cff7a"}, + {file = "fonttools-4.53.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:93156dd7f90ae0a1b0e8871032a07ef3178f553f0c70c386025a808f3a63b1f4"}, + {file = "fonttools-4.53.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bff98816cb144fb7b85e4b5ba3888a33b56ecef075b0e95b95bcd0a5fbf20f06"}, + {file = "fonttools-4.53.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:973d030180eca8255b1bce6ffc09ef38a05dcec0e8320cc9b7bcaa65346f341d"}, + {file = "fonttools-4.53.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c4ee5a24e281fbd8261c6ab29faa7fd9a87a12e8c0eed485b705236c65999109"}, + {file = "fonttools-4.53.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bd5bc124fae781a4422f61b98d1d7faa47985f663a64770b78f13d2c072410c2"}, + {file = "fonttools-4.53.0-cp312-cp312-win32.whl", hash = "sha256:a239afa1126b6a619130909c8404070e2b473dd2b7fc4aacacd2e763f8597fea"}, + {file = "fonttools-4.53.0-cp312-cp312-win_amd64.whl", hash = "sha256:45b4afb069039f0366a43a5d454bc54eea942bfb66b3fc3e9a2c07ef4d617380"}, + {file = "fonttools-4.53.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:93bc9e5aaa06ff928d751dc6be889ff3e7d2aa393ab873bc7f6396a99f6fbb12"}, + {file = "fonttools-4.53.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:2367d47816cc9783a28645bc1dac07f8ffc93e0f015e8c9fc674a5b76a6da6e4"}, + {file = "fonttools-4.53.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:907fa0b662dd8fc1d7c661b90782ce81afb510fc4b7aa6ae7304d6c094b27bce"}, + {file = "fonttools-4.53.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e0ad3c6ea4bd6a289d958a1eb922767233f00982cf0fe42b177657c86c80a8f"}, + {file = "fonttools-4.53.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:73121a9b7ff93ada888aaee3985a88495489cc027894458cb1a736660bdfb206"}, + {file = "fonttools-4.53.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:ee595d7ba9bba130b2bec555a40aafa60c26ce68ed0cf509983e0f12d88674fd"}, + {file = "fonttools-4.53.0-cp38-cp38-win32.whl", hash = "sha256:fca66d9ff2ac89b03f5aa17e0b21a97c21f3491c46b583bb131eb32c7bab33af"}, + {file = "fonttools-4.53.0-cp38-cp38-win_amd64.whl", hash = "sha256:31f0e3147375002aae30696dd1dc596636abbd22fca09d2e730ecde0baad1d6b"}, + {file = "fonttools-4.53.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7d6166192dcd925c78a91d599b48960e0a46fe565391c79fe6de481ac44d20ac"}, + {file = "fonttools-4.53.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ef50ec31649fbc3acf6afd261ed89d09eb909b97cc289d80476166df8438524d"}, + {file = "fonttools-4.53.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f193f060391a455920d61684a70017ef5284ccbe6023bb056e15e5ac3de11d1"}, + {file = "fonttools-4.53.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba9f09ff17f947392a855e3455a846f9855f6cf6bec33e9a427d3c1d254c712f"}, + {file = "fonttools-4.53.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:0c555e039d268445172b909b1b6bdcba42ada1cf4a60e367d68702e3f87e5f64"}, + {file = "fonttools-4.53.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5a4788036201c908079e89ae3f5399b33bf45b9ea4514913f4dbbe4fac08efe0"}, + {file = "fonttools-4.53.0-cp39-cp39-win32.whl", hash = "sha256:d1a24f51a3305362b94681120c508758a88f207fa0a681c16b5a4172e9e6c7a9"}, + {file = "fonttools-4.53.0-cp39-cp39-win_amd64.whl", hash = "sha256:1e677bfb2b4bd0e5e99e0f7283e65e47a9814b0486cb64a41adf9ef110e078f2"}, + {file = "fonttools-4.53.0-py3-none-any.whl", hash = "sha256:6b4f04b1fbc01a3569d63359f2227c89ab294550de277fd09d8fca6185669fa4"}, + {file = "fonttools-4.53.0.tar.gz", hash = "sha256:c93ed66d32de1559b6fc348838c7572d5c0ac1e4a258e76763a5caddd8944002"}, +] + +[package.extras] +all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "pycairo", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.1.0)", "xattr", "zopfli (>=0.1.4)"] +graphite = ["lz4 (>=1.7.4.2)"] +interpolatable = ["munkres", "pycairo", "scipy"] +lxml = ["lxml (>=4.0)"] +pathops = ["skia-pathops (>=0.5.0)"] +plot = ["matplotlib"] +repacker = ["uharfbuzz (>=0.23.0)"] +symfont = ["sympy"] +type1 = ["xattr"] +ufo = ["fs (>=2.2.0,<3)"] +unicode = ["unicodedata2 (>=15.1.0)"] +woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] + +[[package]] +name = "frozenlist" +version = "1.4.1" +description = "A list-like structure which implements collections.abc.MutableSequence" +optional = false +python-versions = ">=3.8" +files = [ + {file = "frozenlist-1.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f9aa1878d1083b276b0196f2dfbe00c9b7e752475ed3b682025ff20c1c1f51ac"}, + {file = "frozenlist-1.4.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:29acab3f66f0f24674b7dc4736477bcd4bc3ad4b896f5f45379a67bce8b96868"}, + {file = "frozenlist-1.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:74fb4bee6880b529a0c6560885fce4dc95936920f9f20f53d99a213f7bf66776"}, + {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:590344787a90ae57d62511dd7c736ed56b428f04cd8c161fcc5e7232c130c69a"}, + {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:068b63f23b17df8569b7fdca5517edef76171cf3897eb68beb01341131fbd2ad"}, + {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c849d495bf5154cd8da18a9eb15db127d4dba2968d88831aff6f0331ea9bd4c"}, + {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9750cc7fe1ae3b1611bb8cfc3f9ec11d532244235d75901fb6b8e42ce9229dfe"}, + {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9b2de4cf0cdd5bd2dee4c4f63a653c61d2408055ab77b151c1957f221cabf2a"}, + {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0633c8d5337cb5c77acbccc6357ac49a1770b8c487e5b3505c57b949b4b82e98"}, + {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:27657df69e8801be6c3638054e202a135c7f299267f1a55ed3a598934f6c0d75"}, + {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:f9a3ea26252bd92f570600098783d1371354d89d5f6b7dfd87359d669f2109b5"}, + {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:4f57dab5fe3407b6c0c1cc907ac98e8a189f9e418f3b6e54d65a718aaafe3950"}, + {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e02a0e11cf6597299b9f3bbd3f93d79217cb90cfd1411aec33848b13f5c656cc"}, + {file = "frozenlist-1.4.1-cp310-cp310-win32.whl", hash = "sha256:a828c57f00f729620a442881cc60e57cfcec6842ba38e1b19fd3e47ac0ff8dc1"}, + {file = "frozenlist-1.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:f56e2333dda1fe0f909e7cc59f021eba0d2307bc6f012a1ccf2beca6ba362439"}, + {file = "frozenlist-1.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a0cb6f11204443f27a1628b0e460f37fb30f624be6051d490fa7d7e26d4af3d0"}, + {file = "frozenlist-1.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b46c8ae3a8f1f41a0d2ef350c0b6e65822d80772fe46b653ab6b6274f61d4a49"}, + {file = "frozenlist-1.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fde5bd59ab5357e3853313127f4d3565fc7dad314a74d7b5d43c22c6a5ed2ced"}, + {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:722e1124aec435320ae01ee3ac7bec11a5d47f25d0ed6328f2273d287bc3abb0"}, + {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2471c201b70d58a0f0c1f91261542a03d9a5e088ed3dc6c160d614c01649c106"}, + {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c757a9dd70d72b076d6f68efdbb9bc943665ae954dad2801b874c8c69e185068"}, + {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f146e0911cb2f1da549fc58fc7bcd2b836a44b79ef871980d605ec392ff6b0d2"}, + {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f9c515e7914626b2a2e1e311794b4c35720a0be87af52b79ff8e1429fc25f19"}, + {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c302220494f5c1ebeb0912ea782bcd5e2f8308037b3c7553fad0e48ebad6ad82"}, + {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:442acde1e068288a4ba7acfe05f5f343e19fac87bfc96d89eb886b0363e977ec"}, + {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:1b280e6507ea8a4fa0c0a7150b4e526a8d113989e28eaaef946cc77ffd7efc0a"}, + {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:fe1a06da377e3a1062ae5fe0926e12b84eceb8a50b350ddca72dc85015873f74"}, + {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:db9e724bebd621d9beca794f2a4ff1d26eed5965b004a97f1f1685a173b869c2"}, + {file = "frozenlist-1.4.1-cp311-cp311-win32.whl", hash = "sha256:e774d53b1a477a67838a904131c4b0eef6b3d8a651f8b138b04f748fccfefe17"}, + {file = "frozenlist-1.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:fb3c2db03683b5767dedb5769b8a40ebb47d6f7f45b1b3e3b4b51ec8ad9d9825"}, + {file = "frozenlist-1.4.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:1979bc0aeb89b33b588c51c54ab0161791149f2461ea7c7c946d95d5f93b56ae"}, + {file = "frozenlist-1.4.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cc7b01b3754ea68a62bd77ce6020afaffb44a590c2289089289363472d13aedb"}, + {file = "frozenlist-1.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c9c92be9fd329ac801cc420e08452b70e7aeab94ea4233a4804f0915c14eba9b"}, + {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c3894db91f5a489fc8fa6a9991820f368f0b3cbdb9cd8849547ccfab3392d86"}, + {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ba60bb19387e13597fb059f32cd4d59445d7b18b69a745b8f8e5db0346f33480"}, + {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8aefbba5f69d42246543407ed2461db31006b0f76c4e32dfd6f42215a2c41d09"}, + {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:780d3a35680ced9ce682fbcf4cb9c2bad3136eeff760ab33707b71db84664e3a"}, + {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9acbb16f06fe7f52f441bb6f413ebae6c37baa6ef9edd49cdd567216da8600cd"}, + {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:23b701e65c7b36e4bf15546a89279bd4d8675faabc287d06bbcfac7d3c33e1e6"}, + {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:3e0153a805a98f5ada7e09826255ba99fb4f7524bb81bf6b47fb702666484ae1"}, + {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:dd9b1baec094d91bf36ec729445f7769d0d0cf6b64d04d86e45baf89e2b9059b"}, + {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:1a4471094e146b6790f61b98616ab8e44f72661879cc63fa1049d13ef711e71e"}, + {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5667ed53d68d91920defdf4035d1cdaa3c3121dc0b113255124bcfada1cfa1b8"}, + {file = "frozenlist-1.4.1-cp312-cp312-win32.whl", hash = "sha256:beee944ae828747fd7cb216a70f120767fc9f4f00bacae8543c14a6831673f89"}, + {file = "frozenlist-1.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:64536573d0a2cb6e625cf309984e2d873979709f2cf22839bf2d61790b448ad5"}, + {file = "frozenlist-1.4.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:20b51fa3f588ff2fe658663db52a41a4f7aa6c04f6201449c6c7c476bd255c0d"}, + {file = "frozenlist-1.4.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:410478a0c562d1a5bcc2f7ea448359fcb050ed48b3c6f6f4f18c313a9bdb1826"}, + {file = "frozenlist-1.4.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c6321c9efe29975232da3bd0af0ad216800a47e93d763ce64f291917a381b8eb"}, + {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48f6a4533887e189dae092f1cf981f2e3885175f7a0f33c91fb5b7b682b6bab6"}, + {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6eb73fa5426ea69ee0e012fb59cdc76a15b1283d6e32e4f8dc4482ec67d1194d"}, + {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fbeb989b5cc29e8daf7f976b421c220f1b8c731cbf22b9130d8815418ea45887"}, + {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:32453c1de775c889eb4e22f1197fe3bdfe457d16476ea407472b9442e6295f7a"}, + {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693945278a31f2086d9bf3df0fe8254bbeaef1fe71e1351c3bd730aa7d31c41b"}, + {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:1d0ce09d36d53bbbe566fe296965b23b961764c0bcf3ce2fa45f463745c04701"}, + {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3a670dc61eb0d0eb7080890c13de3066790f9049b47b0de04007090807c776b0"}, + {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:dca69045298ce5c11fd539682cff879cc1e664c245d1c64da929813e54241d11"}, + {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:a06339f38e9ed3a64e4c4e43aec7f59084033647f908e4259d279a52d3757d09"}, + {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b7f2f9f912dca3934c1baec2e4585a674ef16fe00218d833856408c48d5beee7"}, + {file = "frozenlist-1.4.1-cp38-cp38-win32.whl", hash = "sha256:e7004be74cbb7d9f34553a5ce5fb08be14fb33bc86f332fb71cbe5216362a497"}, + {file = "frozenlist-1.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:5a7d70357e7cee13f470c7883a063aae5fe209a493c57d86eb7f5a6f910fae09"}, + {file = "frozenlist-1.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:bfa4a17e17ce9abf47a74ae02f32d014c5e9404b6d9ac7f729e01562bbee601e"}, + {file = "frozenlist-1.4.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b7e3ed87d4138356775346e6845cccbe66cd9e207f3cd11d2f0b9fd13681359d"}, + {file = "frozenlist-1.4.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c99169d4ff810155ca50b4da3b075cbde79752443117d89429595c2e8e37fed8"}, + {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edb678da49d9f72c9f6c609fbe41a5dfb9a9282f9e6a2253d5a91e0fc382d7c0"}, + {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6db4667b187a6742b33afbbaf05a7bc551ffcf1ced0000a571aedbb4aa42fc7b"}, + {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55fdc093b5a3cb41d420884cdaf37a1e74c3c37a31f46e66286d9145d2063bd0"}, + {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82e8211d69a4f4bc360ea22cd6555f8e61a1bd211d1d5d39d3d228b48c83a897"}, + {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89aa2c2eeb20957be2d950b85974b30a01a762f3308cd02bb15e1ad632e22dc7"}, + {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9d3e0c25a2350080e9319724dede4f31f43a6c9779be48021a7f4ebde8b2d742"}, + {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7268252af60904bf52c26173cbadc3a071cece75f873705419c8681f24d3edea"}, + {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:0c250a29735d4f15321007fb02865f0e6b6a41a6b88f1f523ca1596ab5f50bd5"}, + {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:96ec70beabbd3b10e8bfe52616a13561e58fe84c0101dd031dc78f250d5128b9"}, + {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:23b2d7679b73fe0e5a4560b672a39f98dfc6f60df63823b0a9970525325b95f6"}, + {file = "frozenlist-1.4.1-cp39-cp39-win32.whl", hash = "sha256:a7496bfe1da7fb1a4e1cc23bb67c58fab69311cc7d32b5a99c2007b4b2a0e932"}, + {file = "frozenlist-1.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:e6a20a581f9ce92d389a8c7d7c3dd47c81fd5d6e655c8dddf341e14aa48659d0"}, + {file = "frozenlist-1.4.1-py3-none-any.whl", hash = "sha256:04ced3e6a46b4cfffe20f9ae482818e34eba9b5fb0ce4056e4cc9b6e212d09b7"}, + {file = "frozenlist-1.4.1.tar.gz", hash = "sha256:c037a86e8513059a2613aaba4d817bb90b9d9b6b69aace3ce9c877e8c8ed402b"}, +] + +[[package]] +name = "fsspec" +version = "0.8.7" +description = "File-system specification" +optional = false +python-versions = ">3.6" +files = [ + {file = "fsspec-0.8.7-py3-none-any.whl", hash = "sha256:65dbf8244a3a3d23342109925f9f588c7551b2b01a5f47e555043b17e2b32d62"}, + {file = "fsspec-0.8.7.tar.gz", hash = "sha256:4b11557a90ac637089b10afa4c77adf42080c0696f6f2771c41ce92d73c41432"}, +] + +[package.dependencies] +aiohttp = {version = "*", optional = true, markers = "extra == \"http\""} +requests = {version = "*", optional = true, markers = "extra == \"http\""} + +[package.extras] +abfs = ["adlfs"] +adl = ["adlfs"] +dask = ["dask", "distributed"] +dropbox = ["dropbox", "dropboxdrivefs", "requests"] +gcs = ["gcsfs"] +git = ["pygit2"] +github = ["requests"] +gs = ["gcsfs"] +hdfs = ["pyarrow"] +http = ["aiohttp", "requests"] +s3 = ["s3fs"] +sftp = ["paramiko"] +smb = ["smbprotocol"] +ssh = ["paramiko"] + +[[package]] +name = "ftfy" +version = "6.2.0" +description = "Fixes mojibake and other problems with Unicode, after the fact" +optional = false +python-versions = ">=3.8,<4" +files = [ + {file = "ftfy-6.2.0-py3-none-any.whl", hash = "sha256:f94a2c34b76e07475720e3096f5ca80911d152406fbde66fdb45c4d0c9150026"}, + {file = "ftfy-6.2.0.tar.gz", hash = "sha256:5e42143c7025ef97944ca2619d6b61b0619fc6654f98771d39e862c1424c75c0"}, +] + +[package.dependencies] +wcwidth = ">=0.2.12,<0.3.0" + +[[package]] +name = "future" +version = "1.0.0" +description = "Clean single-source support for Python 3 and 2" +optional = false +python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "future-1.0.0-py3-none-any.whl", hash = "sha256:929292d34f5872e70396626ef385ec22355a1fae8ad29e1a734c3e43f9fbc216"}, + {file = "future-1.0.0.tar.gz", hash = "sha256:bd2968309307861edae1458a4f8a4f3598c03be43b97521076aebf5d94c07b05"}, +] + +[[package]] +name = "gitdb" +version = "4.0.11" +description = "Git Object Database" +optional = false +python-versions = ">=3.7" +files = [ + {file = "gitdb-4.0.11-py3-none-any.whl", hash = "sha256:81a3407ddd2ee8df444cbacea00e2d038e40150acfa3001696fe0dcf1d3adfa4"}, + {file = "gitdb-4.0.11.tar.gz", hash = "sha256:bf5421126136d6d0af55bc1e7c1af1c397a34f5b7bd79e776cd3e89785c2b04b"}, +] + +[package.dependencies] +smmap = ">=3.0.1,<6" + +[[package]] +name = "gitpython" +version = "3.1.43" +description = "GitPython is a Python library used to interact with Git repositories" +optional = false +python-versions = ">=3.7" +files = [ + {file = "GitPython-3.1.43-py3-none-any.whl", hash = "sha256:eec7ec56b92aad751f9912a73404bc02ba212a23adb2c7098ee668417051a1ff"}, + {file = "GitPython-3.1.43.tar.gz", hash = "sha256:35f314a9f878467f5453cc1fee295c3e18e52f1b99f10f6cf5b1682e968a9e7c"}, +] + +[package.dependencies] +gitdb = ">=4.0.1,<5" + +[package.extras] +doc = ["sphinx (==4.3.2)", "sphinx-autodoc-typehints", "sphinx-rtd-theme", "sphinxcontrib-applehelp (>=1.0.2,<=1.0.4)", "sphinxcontrib-devhelp (==1.0.2)", "sphinxcontrib-htmlhelp (>=2.0.0,<=2.0.1)", "sphinxcontrib-qthelp (==1.0.3)", "sphinxcontrib-serializinghtml (==1.1.5)"] +test = ["coverage[toml]", "ddt (>=1.1.1,!=1.4.3)", "mock", "mypy", "pre-commit", "pytest (>=7.3.1)", "pytest-cov", "pytest-instafail", "pytest-mock", "pytest-sugar", "typing-extensions"] + +[[package]] +name = "grpcio" +version = "1.64.1" +description = "HTTP/2-based RPC framework" +optional = false +python-versions = ">=3.8" +files = [ + {file = "grpcio-1.64.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:55697ecec192bc3f2f3cc13a295ab670f51de29884ca9ae6cd6247df55df2502"}, + {file = "grpcio-1.64.1-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:3b64ae304c175671efdaa7ec9ae2cc36996b681eb63ca39c464958396697daff"}, + {file = "grpcio-1.64.1-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:bac71b4b28bc9af61efcdc7630b166440bbfbaa80940c9a697271b5e1dabbc61"}, + {file = "grpcio-1.64.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6c024ffc22d6dc59000faf8ad781696d81e8e38f4078cb0f2630b4a3cf231a90"}, + {file = "grpcio-1.64.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7cd5c1325f6808b8ae31657d281aadb2a51ac11ab081ae335f4f7fc44c1721d"}, + {file = "grpcio-1.64.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:0a2813093ddb27418a4c99f9b1c223fab0b053157176a64cc9db0f4557b69bd9"}, + {file = "grpcio-1.64.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:2981c7365a9353f9b5c864595c510c983251b1ab403e05b1ccc70a3d9541a73b"}, + {file = "grpcio-1.64.1-cp310-cp310-win32.whl", hash = "sha256:1262402af5a511c245c3ae918167eca57342c72320dffae5d9b51840c4b2f86d"}, + {file = "grpcio-1.64.1-cp310-cp310-win_amd64.whl", hash = "sha256:19264fc964576ddb065368cae953f8d0514ecc6cb3da8903766d9fb9d4554c33"}, + {file = "grpcio-1.64.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:58b1041e7c870bb30ee41d3090cbd6f0851f30ae4eb68228955d973d3efa2e61"}, + {file = "grpcio-1.64.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:bbc5b1d78a7822b0a84c6f8917faa986c1a744e65d762ef6d8be9d75677af2ca"}, + {file = "grpcio-1.64.1-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:5841dd1f284bd1b3d8a6eca3a7f062b06f1eec09b184397e1d1d43447e89a7ae"}, + {file = "grpcio-1.64.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8caee47e970b92b3dd948371230fcceb80d3f2277b3bf7fbd7c0564e7d39068e"}, + {file = "grpcio-1.64.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:73819689c169417a4f978e562d24f2def2be75739c4bed1992435d007819da1b"}, + {file = "grpcio-1.64.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:6503b64c8b2dfad299749cad1b595c650c91e5b2c8a1b775380fcf8d2cbba1e9"}, + {file = "grpcio-1.64.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1de403fc1305fd96cfa75e83be3dee8538f2413a6b1685b8452301c7ba33c294"}, + {file = "grpcio-1.64.1-cp311-cp311-win32.whl", hash = "sha256:d4d29cc612e1332237877dfa7fe687157973aab1d63bd0f84cf06692f04c0367"}, + {file = "grpcio-1.64.1-cp311-cp311-win_amd64.whl", hash = "sha256:5e56462b05a6f860b72f0fa50dca06d5b26543a4e88d0396259a07dc30f4e5aa"}, + {file = "grpcio-1.64.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:4657d24c8063e6095f850b68f2d1ba3b39f2b287a38242dcabc166453e950c59"}, + {file = "grpcio-1.64.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:62b4e6eb7bf901719fce0ca83e3ed474ae5022bb3827b0a501e056458c51c0a1"}, + {file = "grpcio-1.64.1-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:ee73a2f5ca4ba44fa33b4d7d2c71e2c8a9e9f78d53f6507ad68e7d2ad5f64a22"}, + {file = "grpcio-1.64.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:198908f9b22e2672a998870355e226a725aeab327ac4e6ff3a1399792ece4762"}, + {file = "grpcio-1.64.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39b9d0acaa8d835a6566c640f48b50054f422d03e77e49716d4c4e8e279665a1"}, + {file = "grpcio-1.64.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:5e42634a989c3aa6049f132266faf6b949ec2a6f7d302dbb5c15395b77d757eb"}, + {file = "grpcio-1.64.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b1a82e0b9b3022799c336e1fc0f6210adc019ae84efb7321d668129d28ee1efb"}, + {file = "grpcio-1.64.1-cp312-cp312-win32.whl", hash = "sha256:55260032b95c49bee69a423c2f5365baa9369d2f7d233e933564d8a47b893027"}, + {file = "grpcio-1.64.1-cp312-cp312-win_amd64.whl", hash = "sha256:c1a786ac592b47573a5bb7e35665c08064a5d77ab88a076eec11f8ae86b3e3f6"}, + {file = "grpcio-1.64.1-cp38-cp38-linux_armv7l.whl", hash = "sha256:a011ac6c03cfe162ff2b727bcb530567826cec85eb8d4ad2bfb4bd023287a52d"}, + {file = "grpcio-1.64.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:4d6dab6124225496010bd22690f2d9bd35c7cbb267b3f14e7a3eb05c911325d4"}, + {file = "grpcio-1.64.1-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:a5e771d0252e871ce194d0fdcafd13971f1aae0ddacc5f25615030d5df55c3a2"}, + {file = "grpcio-1.64.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2c3c1b90ab93fed424e454e93c0ed0b9d552bdf1b0929712b094f5ecfe7a23ad"}, + {file = "grpcio-1.64.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20405cb8b13fd779135df23fabadc53b86522d0f1cba8cca0e87968587f50650"}, + {file = "grpcio-1.64.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:0cc79c982ccb2feec8aad0e8fb0d168bcbca85bc77b080d0d3c5f2f15c24ea8f"}, + {file = "grpcio-1.64.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:a3a035c37ce7565b8f4f35ff683a4db34d24e53dc487e47438e434eb3f701b2a"}, + {file = "grpcio-1.64.1-cp38-cp38-win32.whl", hash = "sha256:1257b76748612aca0f89beec7fa0615727fd6f2a1ad580a9638816a4b2eb18fd"}, + {file = "grpcio-1.64.1-cp38-cp38-win_amd64.whl", hash = "sha256:0a12ddb1678ebc6a84ec6b0487feac020ee2b1659cbe69b80f06dbffdb249122"}, + {file = "grpcio-1.64.1-cp39-cp39-linux_armv7l.whl", hash = "sha256:75dbbf415026d2862192fe1b28d71f209e2fd87079d98470db90bebe57b33179"}, + {file = "grpcio-1.64.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e3d9f8d1221baa0ced7ec7322a981e28deb23749c76eeeb3d33e18b72935ab62"}, + {file = "grpcio-1.64.1-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:5f8b75f64d5d324c565b263c67dbe4f0af595635bbdd93bb1a88189fc62ed2e5"}, + {file = "grpcio-1.64.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c84ad903d0d94311a2b7eea608da163dace97c5fe9412ea311e72c3684925602"}, + {file = "grpcio-1.64.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:940e3ec884520155f68a3b712d045e077d61c520a195d1a5932c531f11883489"}, + {file = "grpcio-1.64.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f10193c69fc9d3d726e83bbf0f3d316f1847c3071c8c93d8090cf5f326b14309"}, + {file = "grpcio-1.64.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ac15b6c2c80a4d1338b04d42a02d376a53395ddf0ec9ab157cbaf44191f3ffdd"}, + {file = "grpcio-1.64.1-cp39-cp39-win32.whl", hash = "sha256:03b43d0ccf99c557ec671c7dede64f023c7da9bb632ac65dbc57f166e4970040"}, + {file = "grpcio-1.64.1-cp39-cp39-win_amd64.whl", hash = "sha256:ed6091fa0adcc7e4ff944090cf203a52da35c37a130efa564ded02b7aff63bcd"}, + {file = "grpcio-1.64.1.tar.gz", hash = "sha256:8d51dd1c59d5fa0f34266b80a3805ec29a1f26425c2a54736133f6d87fc4968a"}, +] + +[package.extras] +protobuf = ["grpcio-tools (>=1.64.1)"] + +[[package]] +name = "huggingface-hub" +version = "0.17.3" +description = "Client library to download and publish models, datasets and other repos on the huggingface.co hub" +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "huggingface_hub-0.17.3-py3-none-any.whl", hash = "sha256:545eb3665f6ac587add946e73984148f2ea5c7877eac2e845549730570c1933a"}, + {file = "huggingface_hub-0.17.3.tar.gz", hash = "sha256:40439632b211311f788964602bf8b0d9d6b7a2314fba4e8d67b2ce3ecea0e3fd"}, +] + +[package.dependencies] +filelock = "*" +fsspec = "*" +packaging = ">=20.9" +pyyaml = ">=5.1" +requests = "*" +tqdm = ">=4.42.1" +typing-extensions = ">=3.7.4.3" + +[package.extras] +all = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "black (==23.7)", "gradio", "jedi", "mypy (==1.5.1)", "numpy", "pydantic (<2.0)", "pytest", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-vcr", "pytest-xdist", "ruff (>=0.0.241)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "urllib3 (<2.0)"] +cli = ["InquirerPy (==0.3.4)"] +dev = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "black (==23.7)", "gradio", "jedi", "mypy (==1.5.1)", "numpy", "pydantic (<2.0)", "pytest", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-vcr", "pytest-xdist", "ruff (>=0.0.241)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "urllib3 (<2.0)"] +docs = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "black (==23.7)", "gradio", "hf-doc-builder", "jedi", "mypy (==1.5.1)", "numpy", "pydantic (<2.0)", "pytest", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-vcr", "pytest-xdist", "ruff (>=0.0.241)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "urllib3 (<2.0)", "watchdog"] +fastai = ["fastai (>=2.4)", "fastcore (>=1.3.27)", "toml"] +inference = ["aiohttp", "pydantic (<2.0)"] +quality = ["black (==23.7)", "mypy (==1.5.1)", "ruff (>=0.0.241)"] +tensorflow = ["graphviz", "pydot", "tensorflow"] +testing = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "gradio", "jedi", "numpy", "pydantic (<2.0)", "pytest", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-vcr", "pytest-xdist", "soundfile", "urllib3 (<2.0)"] +torch = ["torch"] +typing = ["pydantic (<2.0)", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3"] + +[[package]] +name = "hydra-core" +version = "1.0.7" +description = "A framework for elegantly configuring complex applications" +optional = false +python-versions = "*" +files = [ + {file = "hydra-core-1.0.7.tar.gz", hash = "sha256:58cc3f7531995b6d8de162ca21f936e17bdaebd4d1e8614d63c32e17c2e41e45"}, + {file = "hydra_core-1.0.7-py3-none-any.whl", hash = "sha256:e800c6deb8309395508094851fa93bc13408f2285261eb97e626d37193b58a9f"}, +] + +[package.dependencies] +antlr4-python3-runtime = "4.8" +omegaconf = ">=2.0.5,<2.1" + +[[package]] +name = "idna" +version = "3.7" +description = "Internationalized Domain Names in Applications (IDNA)" +optional = false +python-versions = ">=3.5" +files = [ + {file = "idna-3.7-py3-none-any.whl", hash = "sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"}, + {file = "idna-3.7.tar.gz", hash = "sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc"}, +] + +[[package]] +name = "importlib-metadata" +version = "7.1.0" +description = "Read metadata from Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "importlib_metadata-7.1.0-py3-none-any.whl", hash = "sha256:30962b96c0c223483ed6cc7280e7f0199feb01a0e40cfae4d4450fc6fab1f570"}, + {file = "importlib_metadata-7.1.0.tar.gz", hash = "sha256:b78938b926ee8d5f020fc4772d487045805a55ddbad2ecf21c6d60938dc7fcd2"}, +] + +[package.dependencies] +zipp = ">=0.5" + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +perf = ["ipython"] +testing = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-perf (>=0.9.2)", "pytest-ruff (>=0.2.1)"] + +[[package]] +name = "importlib-resources" +version = "6.4.0" +description = "Read resources from Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "importlib_resources-6.4.0-py3-none-any.whl", hash = "sha256:50d10f043df931902d4194ea07ec57960f66a80449ff867bfe782b4c486ba78c"}, + {file = "importlib_resources-6.4.0.tar.gz", hash = "sha256:cdb2b453b8046ca4e3798eb1d84f3cce1446a0e8e7b5ef4efb600f19fc398145"}, +] + +[package.dependencies] +zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""} + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["jaraco.test (>=5.4)", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)", "zipp (>=3.17)"] + +[[package]] +name = "jinja2" +version = "3.1.4" +description = "A very fast and expressive template engine." +optional = false +python-versions = ">=3.7" +files = [ + {file = "jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d"}, + {file = "jinja2-3.1.4.tar.gz", hash = "sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369"}, +] + +[package.dependencies] +MarkupSafe = ">=2.0" + +[package.extras] +i18n = ["Babel (>=2.7)"] + +[[package]] +name = "joblib" +version = "1.4.2" +description = "Lightweight pipelining with Python functions" +optional = false +python-versions = ">=3.8" +files = [ + {file = "joblib-1.4.2-py3-none-any.whl", hash = "sha256:06d478d5674cbc267e7496a410ee875abd68e4340feff4490bcb7afb88060ae6"}, + {file = "joblib-1.4.2.tar.gz", hash = "sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e"}, +] + +[[package]] +name = "jsonschema" +version = "4.22.0" +description = "An implementation of JSON Schema validation for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema-4.22.0-py3-none-any.whl", hash = "sha256:ff4cfd6b1367a40e7bc6411caec72effadd3db0bbe5017de188f2d6108335802"}, + {file = "jsonschema-4.22.0.tar.gz", hash = "sha256:5b22d434a45935119af990552c862e5d6d564e8f6601206b305a61fdf661a2b7"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +jsonschema-specifications = ">=2023.03.6" +referencing = ">=0.28.4" +rpds-py = ">=0.7.1" + +[package.extras] +format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] +format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[package.dependencies] +referencing = ">=0.31.0" + +[[package]] +name = "kiwisolver" +version = "1.4.5" +description = "A fast implementation of the Cassowary constraint solver" +optional = false +python-versions = ">=3.7" +files = [ + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win32.whl", hash = "sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win32.whl", hash = "sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win32.whl", hash = "sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win32.whl", hash = "sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win_amd64.whl", hash = "sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win32.whl", hash = "sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win32.whl", hash = "sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee"}, + {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"}, +] + +[[package]] +name = "lxml" +version = "5.2.2" +description = "Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API." +optional = false +python-versions = ">=3.6" +files = [ + {file = "lxml-5.2.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:364d03207f3e603922d0d3932ef363d55bbf48e3647395765f9bfcbdf6d23632"}, + {file = "lxml-5.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:50127c186f191b8917ea2fb8b206fbebe87fd414a6084d15568c27d0a21d60db"}, + {file = "lxml-5.2.2-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:74e4f025ef3db1c6da4460dd27c118d8cd136d0391da4e387a15e48e5c975147"}, + {file = "lxml-5.2.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:981a06a3076997adf7c743dcd0d7a0415582661e2517c7d961493572e909aa1d"}, + {file = "lxml-5.2.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aef5474d913d3b05e613906ba4090433c515e13ea49c837aca18bde190853dff"}, + {file = "lxml-5.2.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1e275ea572389e41e8b039ac076a46cb87ee6b8542df3fff26f5baab43713bca"}, + {file = "lxml-5.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5b65529bb2f21ac7861a0e94fdbf5dc0daab41497d18223b46ee8515e5ad297"}, + {file = "lxml-5.2.2-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:bcc98f911f10278d1daf14b87d65325851a1d29153caaf146877ec37031d5f36"}, + {file = "lxml-5.2.2-cp310-cp310-manylinux_2_28_ppc64le.whl", hash = "sha256:b47633251727c8fe279f34025844b3b3a3e40cd1b198356d003aa146258d13a2"}, + {file = "lxml-5.2.2-cp310-cp310-manylinux_2_28_s390x.whl", hash = "sha256:fbc9d316552f9ef7bba39f4edfad4a734d3d6f93341232a9dddadec4f15d425f"}, + {file = "lxml-5.2.2-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:13e69be35391ce72712184f69000cda04fc89689429179bc4c0ae5f0b7a8c21b"}, + {file = "lxml-5.2.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:3b6a30a9ab040b3f545b697cb3adbf3696c05a3a68aad172e3fd7ca73ab3c835"}, + {file = "lxml-5.2.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:a233bb68625a85126ac9f1fc66d24337d6e8a0f9207b688eec2e7c880f012ec0"}, + {file = "lxml-5.2.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:dfa7c241073d8f2b8e8dbc7803c434f57dbb83ae2a3d7892dd068d99e96efe2c"}, + {file = "lxml-5.2.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1a7aca7964ac4bb07680d5c9d63b9d7028cace3e2d43175cb50bba8c5ad33316"}, + {file = "lxml-5.2.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ae4073a60ab98529ab8a72ebf429f2a8cc612619a8c04e08bed27450d52103c0"}, + {file = "lxml-5.2.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ffb2be176fed4457e445fe540617f0252a72a8bc56208fd65a690fdb1f57660b"}, + {file = "lxml-5.2.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e290d79a4107d7d794634ce3e985b9ae4f920380a813717adf61804904dc4393"}, + {file = "lxml-5.2.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:96e85aa09274955bb6bd483eaf5b12abadade01010478154b0ec70284c1b1526"}, + {file = "lxml-5.2.2-cp310-cp310-win32.whl", hash = "sha256:f956196ef61369f1685d14dad80611488d8dc1ef00be57c0c5a03064005b0f30"}, + {file = "lxml-5.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:875a3f90d7eb5c5d77e529080d95140eacb3c6d13ad5b616ee8095447b1d22e7"}, + {file = "lxml-5.2.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:45f9494613160d0405682f9eee781c7e6d1bf45f819654eb249f8f46a2c22545"}, + {file = "lxml-5.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b0b3f2df149efb242cee2ffdeb6674b7f30d23c9a7af26595099afaf46ef4e88"}, + {file = "lxml-5.2.2-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d28cb356f119a437cc58a13f8135ab8a4c8ece18159eb9194b0d269ec4e28083"}, + {file = "lxml-5.2.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:657a972f46bbefdbba2d4f14413c0d079f9ae243bd68193cb5061b9732fa54c1"}, + {file = "lxml-5.2.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b74b9ea10063efb77a965a8d5f4182806fbf59ed068b3c3fd6f30d2ac7bee734"}, + {file = "lxml-5.2.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:07542787f86112d46d07d4f3c4e7c760282011b354d012dc4141cc12a68cef5f"}, + {file = "lxml-5.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:303f540ad2dddd35b92415b74b900c749ec2010e703ab3bfd6660979d01fd4ed"}, + {file = "lxml-5.2.2-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:2eb2227ce1ff998faf0cd7fe85bbf086aa41dfc5af3b1d80867ecfe75fb68df3"}, + {file = "lxml-5.2.2-cp311-cp311-manylinux_2_28_ppc64le.whl", hash = "sha256:1d8a701774dfc42a2f0b8ccdfe7dbc140500d1049e0632a611985d943fcf12df"}, + {file = "lxml-5.2.2-cp311-cp311-manylinux_2_28_s390x.whl", hash = "sha256:56793b7a1a091a7c286b5f4aa1fe4ae5d1446fe742d00cdf2ffb1077865db10d"}, + {file = "lxml-5.2.2-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:eb00b549b13bd6d884c863554566095bf6fa9c3cecb2e7b399c4bc7904cb33b5"}, + {file = "lxml-5.2.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1a2569a1f15ae6c8c64108a2cd2b4a858fc1e13d25846be0666fc144715e32ab"}, + {file = "lxml-5.2.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:8cf85a6e40ff1f37fe0f25719aadf443686b1ac7652593dc53c7ef9b8492b115"}, + {file = "lxml-5.2.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:d237ba6664b8e60fd90b8549a149a74fcc675272e0e95539a00522e4ca688b04"}, + {file = "lxml-5.2.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0b3f5016e00ae7630a4b83d0868fca1e3d494c78a75b1c7252606a3a1c5fc2ad"}, + {file = "lxml-5.2.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:23441e2b5339bc54dc949e9e675fa35efe858108404ef9aa92f0456929ef6fe8"}, + {file = "lxml-5.2.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:2fb0ba3e8566548d6c8e7dd82a8229ff47bd8fb8c2da237607ac8e5a1b8312e5"}, + {file = "lxml-5.2.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:79d1fb9252e7e2cfe4de6e9a6610c7cbb99b9708e2c3e29057f487de5a9eaefa"}, + {file = "lxml-5.2.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6dcc3d17eac1df7859ae01202e9bb11ffa8c98949dcbeb1069c8b9a75917e01b"}, + {file = "lxml-5.2.2-cp311-cp311-win32.whl", hash = "sha256:4c30a2f83677876465f44c018830f608fa3c6a8a466eb223535035fbc16f3438"}, + {file = "lxml-5.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:49095a38eb333aaf44c06052fd2ec3b8f23e19747ca7ec6f6c954ffea6dbf7be"}, + {file = "lxml-5.2.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:7429e7faa1a60cad26ae4227f4dd0459efde239e494c7312624ce228e04f6391"}, + {file = "lxml-5.2.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:50ccb5d355961c0f12f6cf24b7187dbabd5433f29e15147a67995474f27d1776"}, + {file = "lxml-5.2.2-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc911208b18842a3a57266d8e51fc3cfaccee90a5351b92079beed912a7914c2"}, + {file = "lxml-5.2.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:33ce9e786753743159799fdf8e92a5da351158c4bfb6f2db0bf31e7892a1feb5"}, + {file = "lxml-5.2.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ec87c44f619380878bd49ca109669c9f221d9ae6883a5bcb3616785fa8f94c97"}, + {file = "lxml-5.2.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08ea0f606808354eb8f2dfaac095963cb25d9d28e27edcc375d7b30ab01abbf6"}, + {file = "lxml-5.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75a9632f1d4f698b2e6e2e1ada40e71f369b15d69baddb8968dcc8e683839b18"}, + {file = "lxml-5.2.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:74da9f97daec6928567b48c90ea2c82a106b2d500f397eeb8941e47d30b1ca85"}, + {file = "lxml-5.2.2-cp312-cp312-manylinux_2_28_ppc64le.whl", hash = "sha256:0969e92af09c5687d769731e3f39ed62427cc72176cebb54b7a9d52cc4fa3b73"}, + {file = "lxml-5.2.2-cp312-cp312-manylinux_2_28_s390x.whl", hash = "sha256:9164361769b6ca7769079f4d426a41df6164879f7f3568be9086e15baca61466"}, + {file = "lxml-5.2.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:d26a618ae1766279f2660aca0081b2220aca6bd1aa06b2cf73f07383faf48927"}, + {file = "lxml-5.2.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab67ed772c584b7ef2379797bf14b82df9aa5f7438c5b9a09624dd834c1c1aaf"}, + {file = "lxml-5.2.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:3d1e35572a56941b32c239774d7e9ad724074d37f90c7a7d499ab98761bd80cf"}, + {file = "lxml-5.2.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:8268cbcd48c5375f46e000adb1390572c98879eb4f77910c6053d25cc3ac2c67"}, + {file = "lxml-5.2.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e282aedd63c639c07c3857097fc0e236f984ceb4089a8b284da1c526491e3f3d"}, + {file = "lxml-5.2.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfdc2bfe69e9adf0df4915949c22a25b39d175d599bf98e7ddf620a13678585"}, + {file = "lxml-5.2.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4aefd911793b5d2d7a921233a54c90329bf3d4a6817dc465f12ffdfe4fc7b8fe"}, + {file = "lxml-5.2.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:8b8df03a9e995b6211dafa63b32f9d405881518ff1ddd775db4e7b98fb545e1c"}, + {file = "lxml-5.2.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f11ae142f3a322d44513de1018b50f474f8f736bc3cd91d969f464b5bfef8836"}, + {file = "lxml-5.2.2-cp312-cp312-win32.whl", hash = "sha256:16a8326e51fcdffc886294c1e70b11ddccec836516a343f9ed0f82aac043c24a"}, + {file = "lxml-5.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:bbc4b80af581e18568ff07f6395c02114d05f4865c2812a1f02f2eaecf0bfd48"}, + {file = "lxml-5.2.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:e3d9d13603410b72787579769469af730c38f2f25505573a5888a94b62b920f8"}, + {file = "lxml-5.2.2-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:38b67afb0a06b8575948641c1d6d68e41b83a3abeae2ca9eed2ac59892b36706"}, + {file = "lxml-5.2.2-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c689d0d5381f56de7bd6966a4541bff6e08bf8d3871bbd89a0c6ab18aa699573"}, + {file = "lxml-5.2.2-cp36-cp36m-manylinux_2_28_x86_64.whl", hash = "sha256:cf2a978c795b54c539f47964ec05e35c05bd045db5ca1e8366988c7f2fe6b3ce"}, + {file = "lxml-5.2.2-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:739e36ef7412b2bd940f75b278749106e6d025e40027c0b94a17ef7968d55d56"}, + {file = "lxml-5.2.2-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:d8bbcd21769594dbba9c37d3c819e2d5847656ca99c747ddb31ac1701d0c0ed9"}, + {file = "lxml-5.2.2-cp36-cp36m-musllinux_1_2_x86_64.whl", hash = "sha256:2304d3c93f2258ccf2cf7a6ba8c761d76ef84948d87bf9664e14d203da2cd264"}, + {file = "lxml-5.2.2-cp36-cp36m-win32.whl", hash = "sha256:02437fb7308386867c8b7b0e5bc4cd4b04548b1c5d089ffb8e7b31009b961dc3"}, + {file = "lxml-5.2.2-cp36-cp36m-win_amd64.whl", hash = "sha256:edcfa83e03370032a489430215c1e7783128808fd3e2e0a3225deee278585196"}, + {file = "lxml-5.2.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:28bf95177400066596cdbcfc933312493799382879da504633d16cf60bba735b"}, + {file = "lxml-5.2.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3a745cc98d504d5bd2c19b10c79c61c7c3df9222629f1b6210c0368177589fb8"}, + {file = "lxml-5.2.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b590b39ef90c6b22ec0be925b211298e810b4856909c8ca60d27ffbca6c12e6"}, + {file = "lxml-5.2.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b336b0416828022bfd5a2e3083e7f5ba54b96242159f83c7e3eebaec752f1716"}, + {file = "lxml-5.2.2-cp37-cp37m-manylinux_2_28_aarch64.whl", hash = "sha256:c2faf60c583af0d135e853c86ac2735ce178f0e338a3c7f9ae8f622fd2eb788c"}, + {file = "lxml-5.2.2-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:4bc6cb140a7a0ad1f7bc37e018d0ed690b7b6520ade518285dc3171f7a117905"}, + {file = "lxml-5.2.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7ff762670cada8e05b32bf1e4dc50b140790909caa8303cfddc4d702b71ea184"}, + {file = "lxml-5.2.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:57f0a0bbc9868e10ebe874e9f129d2917750adf008fe7b9c1598c0fbbfdde6a6"}, + {file = "lxml-5.2.2-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:a6d2092797b388342c1bc932077ad232f914351932353e2e8706851c870bca1f"}, + {file = "lxml-5.2.2-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:60499fe961b21264e17a471ec296dcbf4365fbea611bf9e303ab69db7159ce61"}, + {file = "lxml-5.2.2-cp37-cp37m-win32.whl", hash = "sha256:d9b342c76003c6b9336a80efcc766748a333573abf9350f4094ee46b006ec18f"}, + {file = "lxml-5.2.2-cp37-cp37m-win_amd64.whl", hash = "sha256:b16db2770517b8799c79aa80f4053cd6f8b716f21f8aca962725a9565ce3ee40"}, + {file = "lxml-5.2.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7ed07b3062b055d7a7f9d6557a251cc655eed0b3152b76de619516621c56f5d3"}, + {file = "lxml-5.2.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f60fdd125d85bf9c279ffb8e94c78c51b3b6a37711464e1f5f31078b45002421"}, + {file = "lxml-5.2.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8a7e24cb69ee5f32e003f50e016d5fde438010c1022c96738b04fc2423e61706"}, + {file = "lxml-5.2.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23cfafd56887eaed93d07bc4547abd5e09d837a002b791e9767765492a75883f"}, + {file = "lxml-5.2.2-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:19b4e485cd07b7d83e3fe3b72132e7df70bfac22b14fe4bf7a23822c3a35bff5"}, + {file = "lxml-5.2.2-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:7ce7ad8abebe737ad6143d9d3bf94b88b93365ea30a5b81f6877ec9c0dee0a48"}, + {file = "lxml-5.2.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:e49b052b768bb74f58c7dda4e0bdf7b79d43a9204ca584ffe1fb48a6f3c84c66"}, + {file = "lxml-5.2.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d14a0d029a4e176795cef99c056d58067c06195e0c7e2dbb293bf95c08f772a3"}, + {file = "lxml-5.2.2-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:be49ad33819d7dcc28a309b86d4ed98e1a65f3075c6acd3cd4fe32103235222b"}, + {file = "lxml-5.2.2-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:a6d17e0370d2516d5bb9062c7b4cb731cff921fc875644c3d751ad857ba9c5b1"}, + {file = "lxml-5.2.2-cp38-cp38-win32.whl", hash = "sha256:5b8c041b6265e08eac8a724b74b655404070b636a8dd6d7a13c3adc07882ef30"}, + {file = "lxml-5.2.2-cp38-cp38-win_amd64.whl", hash = "sha256:f61efaf4bed1cc0860e567d2ecb2363974d414f7f1f124b1df368bbf183453a6"}, + {file = "lxml-5.2.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:fb91819461b1b56d06fa4bcf86617fac795f6a99d12239fb0c68dbeba41a0a30"}, + {file = "lxml-5.2.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d4ed0c7cbecde7194cd3228c044e86bf73e30a23505af852857c09c24e77ec5d"}, + {file = "lxml-5.2.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:54401c77a63cc7d6dc4b4e173bb484f28a5607f3df71484709fe037c92d4f0ed"}, + {file = "lxml-5.2.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:625e3ef310e7fa3a761d48ca7ea1f9d8718a32b1542e727d584d82f4453d5eeb"}, + {file = "lxml-5.2.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:519895c99c815a1a24a926d5b60627ce5ea48e9f639a5cd328bda0515ea0f10c"}, + {file = "lxml-5.2.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c7079d5eb1c1315a858bbf180000757db8ad904a89476653232db835c3114001"}, + {file = "lxml-5.2.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:343ab62e9ca78094f2306aefed67dcfad61c4683f87eee48ff2fd74902447726"}, + {file = "lxml-5.2.2-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:cd9e78285da6c9ba2d5c769628f43ef66d96ac3085e59b10ad4f3707980710d3"}, + {file = "lxml-5.2.2-cp39-cp39-manylinux_2_28_ppc64le.whl", hash = "sha256:546cf886f6242dff9ec206331209db9c8e1643ae642dea5fdbecae2453cb50fd"}, + {file = "lxml-5.2.2-cp39-cp39-manylinux_2_28_s390x.whl", hash = "sha256:02f6a8eb6512fdc2fd4ca10a49c341c4e109aa6e9448cc4859af5b949622715a"}, + {file = "lxml-5.2.2-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:339ee4a4704bc724757cd5dd9dc8cf4d00980f5d3e6e06d5847c1b594ace68ab"}, + {file = "lxml-5.2.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0a028b61a2e357ace98b1615fc03f76eb517cc028993964fe08ad514b1e8892d"}, + {file = "lxml-5.2.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f90e552ecbad426eab352e7b2933091f2be77115bb16f09f78404861c8322981"}, + {file = "lxml-5.2.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:d83e2d94b69bf31ead2fa45f0acdef0757fa0458a129734f59f67f3d2eb7ef32"}, + {file = "lxml-5.2.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a02d3c48f9bb1e10c7788d92c0c7db6f2002d024ab6e74d6f45ae33e3d0288a3"}, + {file = "lxml-5.2.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:6d68ce8e7b2075390e8ac1e1d3a99e8b6372c694bbe612632606d1d546794207"}, + {file = "lxml-5.2.2-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:453d037e09a5176d92ec0fd282e934ed26d806331a8b70ab431a81e2fbabf56d"}, + {file = "lxml-5.2.2-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:3b019d4ee84b683342af793b56bb35034bd749e4cbdd3d33f7d1107790f8c472"}, + {file = "lxml-5.2.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:cb3942960f0beb9f46e2a71a3aca220d1ca32feb5a398656be934320804c0df9"}, + {file = "lxml-5.2.2-cp39-cp39-win32.whl", hash = "sha256:ac6540c9fff6e3813d29d0403ee7a81897f1d8ecc09a8ff84d2eea70ede1cdbf"}, + {file = "lxml-5.2.2-cp39-cp39-win_amd64.whl", hash = "sha256:610b5c77428a50269f38a534057444c249976433f40f53e3b47e68349cca1425"}, + {file = "lxml-5.2.2-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:b537bd04d7ccd7c6350cdaaaad911f6312cbd61e6e6045542f781c7f8b2e99d2"}, + {file = "lxml-5.2.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4820c02195d6dfb7b8508ff276752f6b2ff8b64ae5d13ebe02e7667e035000b9"}, + {file = "lxml-5.2.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2a09f6184f17a80897172863a655467da2b11151ec98ba8d7af89f17bf63dae"}, + {file = "lxml-5.2.2-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:76acba4c66c47d27c8365e7c10b3d8016a7da83d3191d053a58382311a8bf4e1"}, + {file = "lxml-5.2.2-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:b128092c927eaf485928cec0c28f6b8bead277e28acf56800e972aa2c2abd7a2"}, + {file = "lxml-5.2.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ae791f6bd43305aade8c0e22f816b34f3b72b6c820477aab4d18473a37e8090b"}, + {file = "lxml-5.2.2-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a2f6a1bc2460e643785a2cde17293bd7a8f990884b822f7bca47bee0a82fc66b"}, + {file = "lxml-5.2.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e8d351ff44c1638cb6e980623d517abd9f580d2e53bfcd18d8941c052a5a009"}, + {file = "lxml-5.2.2-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bec4bd9133420c5c52d562469c754f27c5c9e36ee06abc169612c959bd7dbb07"}, + {file = "lxml-5.2.2-pp37-pypy37_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:55ce6b6d803890bd3cc89975fca9de1dff39729b43b73cb15ddd933b8bc20484"}, + {file = "lxml-5.2.2-pp37-pypy37_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:8ab6a358d1286498d80fe67bd3d69fcbc7d1359b45b41e74c4a26964ca99c3f8"}, + {file = "lxml-5.2.2-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:06668e39e1f3c065349c51ac27ae430719d7806c026fec462e5693b08b95696b"}, + {file = "lxml-5.2.2-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:9cd5323344d8ebb9fb5e96da5de5ad4ebab993bbf51674259dbe9d7a18049525"}, + {file = "lxml-5.2.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89feb82ca055af0fe797a2323ec9043b26bc371365847dbe83c7fd2e2f181c34"}, + {file = "lxml-5.2.2-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e481bba1e11ba585fb06db666bfc23dbe181dbafc7b25776156120bf12e0d5a6"}, + {file = "lxml-5.2.2-pp38-pypy38_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:9d6c6ea6a11ca0ff9cd0390b885984ed31157c168565702959c25e2191674a14"}, + {file = "lxml-5.2.2-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:3d98de734abee23e61f6b8c2e08a88453ada7d6486dc7cdc82922a03968928db"}, + {file = "lxml-5.2.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:69ab77a1373f1e7563e0fb5a29a8440367dec051da6c7405333699d07444f511"}, + {file = "lxml-5.2.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:34e17913c431f5ae01d8658dbf792fdc457073dcdfbb31dc0cc6ab256e664a8d"}, + {file = "lxml-5.2.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05f8757b03208c3f50097761be2dea0aba02e94f0dc7023ed73a7bb14ff11eb0"}, + {file = "lxml-5.2.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a520b4f9974b0a0a6ed73c2154de57cdfd0c8800f4f15ab2b73238ffed0b36e"}, + {file = "lxml-5.2.2-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:5e097646944b66207023bc3c634827de858aebc226d5d4d6d16f0b77566ea182"}, + {file = "lxml-5.2.2-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:b5e4ef22ff25bfd4ede5f8fb30f7b24446345f3e79d9b7455aef2836437bc38a"}, + {file = "lxml-5.2.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ff69a9a0b4b17d78170c73abe2ab12084bdf1691550c5629ad1fe7849433f324"}, + {file = "lxml-5.2.2.tar.gz", hash = "sha256:bb2dc4898180bea79863d5487e5f9c7c34297414bad54bcd0f0852aee9cfdb87"}, +] + +[package.extras] +cssselect = ["cssselect (>=0.7)"] +html-clean = ["lxml-html-clean"] +html5 = ["html5lib"] +htmlsoup = ["BeautifulSoup4"] +source = ["Cython (>=3.0.10)"] + +[[package]] +name = "markdown" +version = "3.6" +description = "Python implementation of John Gruber's Markdown." +optional = false +python-versions = ">=3.8" +files = [ + {file = "Markdown-3.6-py3-none-any.whl", hash = "sha256:48f276f4d8cfb8ce6527c8f79e2ee29708508bf4d40aa410fbc3b4ee832c850f"}, + {file = "Markdown-3.6.tar.gz", hash = "sha256:ed4f41f6daecbeeb96e576ce414c41d2d876daa9a16cb35fa8ed8c2ddfad0224"}, +] + +[package.dependencies] +importlib-metadata = {version = ">=4.4", markers = "python_version < \"3.10\""} + +[package.extras] +docs = ["mdx-gh-links (>=0.2)", "mkdocs (>=1.5)", "mkdocs-gen-files", "mkdocs-literate-nav", "mkdocs-nature (>=0.6)", "mkdocs-section-index", "mkdocstrings[python]"] +testing = ["coverage", "pyyaml"] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +description = "Python port of markdown-it. Markdown parsing, done right!" +optional = false +python-versions = ">=3.8" +files = [ + {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, + {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, +] + +[package.dependencies] +mdurl = ">=0.1,<1.0" + +[package.extras] +benchmarking = ["psutil", "pytest", "pytest-benchmark"] +code-style = ["pre-commit (>=3.0,<4.0)"] +compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "mistletoe (>=1.0,<2.0)", "mistune (>=2.0,<3.0)", "panflute (>=2.3,<3.0)"] +linkify = ["linkify-it-py (>=1,<3)"] +plugins = ["mdit-py-plugins"] +profiling = ["gprof2dot"] +rtd = ["jupyter_sphinx", "mdit-py-plugins", "myst-parser", "pyyaml", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinx_book_theme"] +testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] + +[[package]] +name = "markupsafe" +version = "2.1.5" +description = "Safely add untrusted strings to HTML/XML markup." +optional = false +python-versions = ">=3.7" +files = [ + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + +[[package]] +name = "matplotlib" +version = "3.9.0" +description = "Python plotting package" +optional = false +python-versions = ">=3.9" +files = [ + {file = "matplotlib-3.9.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2bcee1dffaf60fe7656183ac2190bd630842ff87b3153afb3e384d966b57fe56"}, + {file = "matplotlib-3.9.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3f988bafb0fa39d1074ddd5bacd958c853e11def40800c5824556eb630f94d3b"}, + {file = "matplotlib-3.9.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe428e191ea016bb278758c8ee82a8129c51d81d8c4bc0846c09e7e8e9057241"}, + {file = "matplotlib-3.9.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaf3978060a106fab40c328778b148f590e27f6fa3cd15a19d6892575bce387d"}, + {file = "matplotlib-3.9.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:2e7f03e5cbbfacdd48c8ea394d365d91ee8f3cae7e6ec611409927b5ed997ee4"}, + {file = "matplotlib-3.9.0-cp310-cp310-win_amd64.whl", hash = "sha256:13beb4840317d45ffd4183a778685e215939be7b08616f431c7795276e067463"}, + {file = "matplotlib-3.9.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:063af8587fceeac13b0936c42a2b6c732c2ab1c98d38abc3337e430e1ff75e38"}, + {file = "matplotlib-3.9.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9a2fa6d899e17ddca6d6526cf6e7ba677738bf2a6a9590d702c277204a7c6152"}, + {file = "matplotlib-3.9.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:550cdda3adbd596078cca7d13ed50b77879104e2e46392dcd7c75259d8f00e85"}, + {file = "matplotlib-3.9.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76cce0f31b351e3551d1f3779420cf8f6ec0d4a8cf9c0237a3b549fd28eb4abb"}, + {file = "matplotlib-3.9.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c53aeb514ccbbcbab55a27f912d79ea30ab21ee0531ee2c09f13800efb272674"}, + {file = "matplotlib-3.9.0-cp311-cp311-win_amd64.whl", hash = "sha256:a5be985db2596d761cdf0c2eaf52396f26e6a64ab46bd8cd810c48972349d1be"}, + {file = "matplotlib-3.9.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:c79f3a585f1368da6049318bdf1f85568d8d04b2e89fc24b7e02cc9b62017382"}, + {file = "matplotlib-3.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bdd1ecbe268eb3e7653e04f451635f0fb0f77f07fd070242b44c076c9106da84"}, + {file = "matplotlib-3.9.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d38e85a1a6d732f645f1403ce5e6727fd9418cd4574521d5803d3d94911038e5"}, + {file = "matplotlib-3.9.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a490715b3b9984fa609116481b22178348c1a220a4499cda79132000a79b4db"}, + {file = "matplotlib-3.9.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8146ce83cbc5dc71c223a74a1996d446cd35cfb6a04b683e1446b7e6c73603b7"}, + {file = "matplotlib-3.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:d91a4ffc587bacf5c4ce4ecfe4bcd23a4b675e76315f2866e588686cc97fccdf"}, + {file = "matplotlib-3.9.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:616fabf4981a3b3c5a15cd95eba359c8489c4e20e03717aea42866d8d0465956"}, + {file = "matplotlib-3.9.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cd53c79fd02f1c1808d2cfc87dd3cf4dbc63c5244a58ee7944497107469c8d8a"}, + {file = "matplotlib-3.9.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:06a478f0d67636554fa78558cfbcd7b9dba85b51f5c3b5a0c9be49010cf5f321"}, + {file = "matplotlib-3.9.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:81c40af649d19c85f8073e25e5806926986806fa6d54be506fbf02aef47d5a89"}, + {file = "matplotlib-3.9.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:52146fc3bd7813cc784562cb93a15788be0b2875c4655e2cc6ea646bfa30344b"}, + {file = "matplotlib-3.9.0-cp39-cp39-win_amd64.whl", hash = "sha256:0fc51eaa5262553868461c083d9adadb11a6017315f3a757fc45ec6ec5f02888"}, + {file = "matplotlib-3.9.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:bd4f2831168afac55b881db82a7730992aa41c4f007f1913465fb182d6fb20c0"}, + {file = "matplotlib-3.9.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:290d304e59be2b33ef5c2d768d0237f5bd132986bdcc66f80bc9bcc300066a03"}, + {file = "matplotlib-3.9.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ff2e239c26be4f24bfa45860c20ffccd118d270c5b5d081fa4ea409b5469fcd"}, + {file = "matplotlib-3.9.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:af4001b7cae70f7eaacfb063db605280058246de590fa7874f00f62259f2df7e"}, + {file = "matplotlib-3.9.0.tar.gz", hash = "sha256:e6d29ea6c19e34b30fb7d88b7081f869a03014f66fe06d62cc77d5a6ea88ed7a"}, +] + +[package.dependencies] +contourpy = ">=1.0.1" +cycler = ">=0.10" +fonttools = ">=4.22.0" +importlib-resources = {version = ">=3.2.0", markers = "python_version < \"3.10\""} +kiwisolver = ">=1.3.1" +numpy = ">=1.23" +packaging = ">=20.0" +pillow = ">=8" +pyparsing = ">=2.3.1" +python-dateutil = ">=2.7" + +[package.extras] +dev = ["meson-python (>=0.13.1)", "numpy (>=1.25)", "pybind11 (>=2.6)", "setuptools (>=64)", "setuptools_scm (>=7)"] + +[[package]] +name = "mdurl" +version = "0.1.2" +description = "Markdown URL utilities" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, + {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +description = "Python library for arbitrary-precision floating-point arithmetic" +optional = false +python-versions = "*" +files = [ + {file = "mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"}, + {file = "mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f"}, +] + +[package.extras] +develop = ["codecov", "pycodestyle", "pytest (>=4.6)", "pytest-cov", "wheel"] +docs = ["sphinx"] +gmpy = ["gmpy2 (>=2.1.0a4)"] +tests = ["pytest (>=4.6)"] + +[[package]] +name = "multidict" +version = "6.0.5" +description = "multidict implementation" +optional = false +python-versions = ">=3.7" +files = [ + {file = "multidict-6.0.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:228b644ae063c10e7f324ab1ab6b548bdf6f8b47f3ec234fef1093bc2735e5f9"}, + {file = "multidict-6.0.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:896ebdcf62683551312c30e20614305f53125750803b614e9e6ce74a96232604"}, + {file = "multidict-6.0.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:411bf8515f3be9813d06004cac41ccf7d1cd46dfe233705933dd163b60e37600"}, + {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d147090048129ce3c453f0292e7697d333db95e52616b3793922945804a433c"}, + {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:215ed703caf15f578dca76ee6f6b21b7603791ae090fbf1ef9d865571039ade5"}, + {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c6390cf87ff6234643428991b7359b5f59cc15155695deb4eda5c777d2b880f"}, + {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21fd81c4ebdb4f214161be351eb5bcf385426bf023041da2fd9e60681f3cebae"}, + {file = "multidict-6.0.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3cc2ad10255f903656017363cd59436f2111443a76f996584d1077e43ee51182"}, + {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:6939c95381e003f54cd4c5516740faba40cf5ad3eeff460c3ad1d3e0ea2549bf"}, + {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:220dd781e3f7af2c2c1053da9fa96d9cf3072ca58f057f4c5adaaa1cab8fc442"}, + {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:766c8f7511df26d9f11cd3a8be623e59cca73d44643abab3f8c8c07620524e4a"}, + {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:fe5d7785250541f7f5019ab9cba2c71169dc7d74d0f45253f8313f436458a4ef"}, + {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c1c1496e73051918fcd4f58ff2e0f2f3066d1c76a0c6aeffd9b45d53243702cc"}, + {file = "multidict-6.0.5-cp310-cp310-win32.whl", hash = "sha256:7afcdd1fc07befad18ec4523a782cde4e93e0a2bf71239894b8d61ee578c1319"}, + {file = "multidict-6.0.5-cp310-cp310-win_amd64.whl", hash = "sha256:99f60d34c048c5c2fabc766108c103612344c46e35d4ed9ae0673d33c8fb26e8"}, + {file = "multidict-6.0.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f285e862d2f153a70586579c15c44656f888806ed0e5b56b64489afe4a2dbfba"}, + {file = "multidict-6.0.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:53689bb4e102200a4fafa9de9c7c3c212ab40a7ab2c8e474491914d2305f187e"}, + {file = "multidict-6.0.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:612d1156111ae11d14afaf3a0669ebf6c170dbb735e510a7438ffe2369a847fd"}, + {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7be7047bd08accdb7487737631d25735c9a04327911de89ff1b26b81745bd4e3"}, + {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de170c7b4fe6859beb8926e84f7d7d6c693dfe8e27372ce3b76f01c46e489fcf"}, + {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04bde7a7b3de05732a4eb39c94574db1ec99abb56162d6c520ad26f83267de29"}, + {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85f67aed7bb647f93e7520633d8f51d3cbc6ab96957c71272b286b2f30dc70ed"}, + {file = "multidict-6.0.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:425bf820055005bfc8aa9a0b99ccb52cc2f4070153e34b701acc98d201693733"}, + {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d3eb1ceec286eba8220c26f3b0096cf189aea7057b6e7b7a2e60ed36b373b77f"}, + {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:7901c05ead4b3fb75113fb1dd33eb1253c6d3ee37ce93305acd9d38e0b5f21a4"}, + {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:e0e79d91e71b9867c73323a3444724d496c037e578a0e1755ae159ba14f4f3d1"}, + {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:29bfeb0dff5cb5fdab2023a7a9947b3b4af63e9c47cae2a10ad58394b517fddc"}, + {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e030047e85cbcedbfc073f71836d62dd5dadfbe7531cae27789ff66bc551bd5e"}, + {file = "multidict-6.0.5-cp311-cp311-win32.whl", hash = "sha256:2f4848aa3baa109e6ab81fe2006c77ed4d3cd1e0ac2c1fbddb7b1277c168788c"}, + {file = "multidict-6.0.5-cp311-cp311-win_amd64.whl", hash = "sha256:2faa5ae9376faba05f630d7e5e6be05be22913782b927b19d12b8145968a85ea"}, + {file = "multidict-6.0.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:51d035609b86722963404f711db441cf7134f1889107fb171a970c9701f92e1e"}, + {file = "multidict-6.0.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cbebcd5bcaf1eaf302617c114aa67569dd3f090dd0ce8ba9e35e9985b41ac35b"}, + {file = "multidict-6.0.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2ffc42c922dbfddb4a4c3b438eb056828719f07608af27d163191cb3e3aa6cc5"}, + {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ceb3b7e6a0135e092de86110c5a74e46bda4bd4fbfeeb3a3bcec79c0f861e450"}, + {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:79660376075cfd4b2c80f295528aa6beb2058fd289f4c9252f986751a4cd0496"}, + {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e4428b29611e989719874670fd152b6625500ad6c686d464e99f5aaeeaca175a"}, + {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d84a5c3a5f7ce6db1f999fb9438f686bc2e09d38143f2d93d8406ed2dd6b9226"}, + {file = "multidict-6.0.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:76c0de87358b192de7ea9649beb392f107dcad9ad27276324c24c91774ca5271"}, + {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:79a6d2ba910adb2cbafc95dad936f8b9386e77c84c35bc0add315b856d7c3abb"}, + {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:92d16a3e275e38293623ebf639c471d3e03bb20b8ebb845237e0d3664914caef"}, + {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:fb616be3538599e797a2017cccca78e354c767165e8858ab5116813146041a24"}, + {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:14c2976aa9038c2629efa2c148022ed5eb4cb939e15ec7aace7ca932f48f9ba6"}, + {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:435a0984199d81ca178b9ae2c26ec3d49692d20ee29bc4c11a2a8d4514c67eda"}, + {file = "multidict-6.0.5-cp312-cp312-win32.whl", hash = "sha256:9fe7b0653ba3d9d65cbe7698cca585bf0f8c83dbbcc710db9c90f478e175f2d5"}, + {file = "multidict-6.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:01265f5e40f5a17f8241d52656ed27192be03bfa8764d88e8220141d1e4b3556"}, + {file = "multidict-6.0.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:19fe01cea168585ba0f678cad6f58133db2aa14eccaf22f88e4a6dccadfad8b3"}, + {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bf7a982604375a8d49b6cc1b781c1747f243d91b81035a9b43a2126c04766f5"}, + {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:107c0cdefe028703fb5dafe640a409cb146d44a6ae201e55b35a4af8e95457dd"}, + {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:403c0911cd5d5791605808b942c88a8155c2592e05332d2bf78f18697a5fa15e"}, + {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aeaf541ddbad8311a87dd695ed9642401131ea39ad7bc8cf3ef3967fd093b626"}, + {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e4972624066095e52b569e02b5ca97dbd7a7ddd4294bf4e7247d52635630dd83"}, + {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:d946b0a9eb8aaa590df1fe082cee553ceab173e6cb5b03239716338629c50c7a"}, + {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:b55358304d7a73d7bdf5de62494aaf70bd33015831ffd98bc498b433dfe5b10c"}, + {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:a3145cb08d8625b2d3fee1b2d596a8766352979c9bffe5d7833e0503d0f0b5e5"}, + {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:d65f25da8e248202bd47445cec78e0025c0fe7582b23ec69c3b27a640dd7a8e3"}, + {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:c9bf56195c6bbd293340ea82eafd0071cb3d450c703d2c93afb89f93b8386ccc"}, + {file = "multidict-6.0.5-cp37-cp37m-win32.whl", hash = "sha256:69db76c09796b313331bb7048229e3bee7928eb62bab5e071e9f7fcc4879caee"}, + {file = "multidict-6.0.5-cp37-cp37m-win_amd64.whl", hash = "sha256:fce28b3c8a81b6b36dfac9feb1de115bab619b3c13905b419ec71d03a3fc1423"}, + {file = "multidict-6.0.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:76f067f5121dcecf0d63a67f29080b26c43c71a98b10c701b0677e4a065fbd54"}, + {file = "multidict-6.0.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b82cc8ace10ab5bd93235dfaab2021c70637005e1ac787031f4d1da63d493c1d"}, + {file = "multidict-6.0.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5cb241881eefd96b46f89b1a056187ea8e9ba14ab88ba632e68d7a2ecb7aadf7"}, + {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8e94e6912639a02ce173341ff62cc1201232ab86b8a8fcc05572741a5dc7d93"}, + {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:09a892e4a9fb47331da06948690ae38eaa2426de97b4ccbfafbdcbe5c8f37ff8"}, + {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55205d03e8a598cfc688c71ca8ea5f66447164efff8869517f175ea632c7cb7b"}, + {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:37b15024f864916b4951adb95d3a80c9431299080341ab9544ed148091b53f50"}, + {file = "multidict-6.0.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2a1dee728b52b33eebff5072817176c172050d44d67befd681609b4746e1c2e"}, + {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:edd08e6f2f1a390bf137080507e44ccc086353c8e98c657e666c017718561b89"}, + {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:60d698e8179a42ec85172d12f50b1668254628425a6bd611aba022257cac1386"}, + {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:3d25f19500588cbc47dc19081d78131c32637c25804df8414463ec908631e453"}, + {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:4cc0ef8b962ac7a5e62b9e826bd0cd5040e7d401bc45a6835910ed699037a461"}, + {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:eca2e9d0cc5a889850e9bbd68e98314ada174ff6ccd1129500103df7a94a7a44"}, + {file = "multidict-6.0.5-cp38-cp38-win32.whl", hash = "sha256:4a6a4f196f08c58c59e0b8ef8ec441d12aee4125a7d4f4fef000ccb22f8d7241"}, + {file = "multidict-6.0.5-cp38-cp38-win_amd64.whl", hash = "sha256:0275e35209c27a3f7951e1ce7aaf93ce0d163b28948444bec61dd7badc6d3f8c"}, + {file = "multidict-6.0.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e7be68734bd8c9a513f2b0cfd508802d6609da068f40dc57d4e3494cefc92929"}, + {file = "multidict-6.0.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1d9ea7a7e779d7a3561aade7d596649fbecfa5c08a7674b11b423783217933f9"}, + {file = "multidict-6.0.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ea1456df2a27c73ce51120fa2f519f1bea2f4a03a917f4a43c8707cf4cbbae1a"}, + {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf590b134eb70629e350691ecca88eac3e3b8b3c86992042fb82e3cb1830d5e1"}, + {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5c0631926c4f58e9a5ccce555ad7747d9a9f8b10619621f22f9635f069f6233e"}, + {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dce1c6912ab9ff5f179eaf6efe7365c1f425ed690b03341911bf4939ef2f3046"}, + {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0868d64af83169e4d4152ec612637a543f7a336e4a307b119e98042e852ad9c"}, + {file = "multidict-6.0.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:141b43360bfd3bdd75f15ed811850763555a251e38b2405967f8e25fb43f7d40"}, + {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:7df704ca8cf4a073334e0427ae2345323613e4df18cc224f647f251e5e75a527"}, + {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:6214c5a5571802c33f80e6c84713b2c79e024995b9c5897f794b43e714daeec9"}, + {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:cd6c8fca38178e12c00418de737aef1261576bd1b6e8c6134d3e729a4e858b38"}, + {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:e02021f87a5b6932fa6ce916ca004c4d441509d33bbdbeca70d05dff5e9d2479"}, + {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ebd8d160f91a764652d3e51ce0d2956b38efe37c9231cd82cfc0bed2e40b581c"}, + {file = "multidict-6.0.5-cp39-cp39-win32.whl", hash = "sha256:04da1bb8c8dbadf2a18a452639771951c662c5ad03aefe4884775454be322c9b"}, + {file = "multidict-6.0.5-cp39-cp39-win_amd64.whl", hash = "sha256:d6f6d4f185481c9669b9447bf9d9cf3b95a0e9df9d169bbc17e363b7d5487755"}, + {file = "multidict-6.0.5-py3-none-any.whl", hash = "sha256:0d63c74e3d7ab26de115c49bffc92cc77ed23395303d496eae515d4204a625e7"}, + {file = "multidict-6.0.5.tar.gz", hash = "sha256:f7e301075edaf50500f0b341543c41194d8df3ae5caf4702f2095f3ca73dd8da"}, +] + +[[package]] +name = "networkx" +version = "3.2.1" +description = "Python package for creating and manipulating graphs and networks" +optional = false +python-versions = ">=3.9" +files = [ + {file = "networkx-3.2.1-py3-none-any.whl", hash = "sha256:f18c69adc97877c42332c170849c96cefa91881c99a7cb3e95b7c659ebdc1ec2"}, + {file = "networkx-3.2.1.tar.gz", hash = "sha256:9f1bb5cf3409bf324e0a722c20bdb4c20ee39bf1c30ce8ae499c8502b0b5e0c6"}, +] + +[package.extras] +default = ["matplotlib (>=3.5)", "numpy (>=1.22)", "pandas (>=1.4)", "scipy (>=1.9,!=1.11.0,!=1.11.1)"] +developer = ["changelist (==0.4)", "mypy (>=1.1)", "pre-commit (>=3.2)", "rtoml"] +doc = ["nb2plots (>=0.7)", "nbconvert (<7.9)", "numpydoc (>=1.6)", "pillow (>=9.4)", "pydata-sphinx-theme (>=0.14)", "sphinx (>=7)", "sphinx-gallery (>=0.14)", "texext (>=0.6.7)"] +extra = ["lxml (>=4.6)", "pydot (>=1.4.2)", "pygraphviz (>=1.11)", "sympy (>=1.10)"] +test = ["pytest (>=7.2)", "pytest-cov (>=4.0)"] + +[[package]] +name = "numpy" +version = "1.26.4" +description = "Fundamental package for array computing in Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0"}, + {file = "numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2"}, + {file = "numpy-1.26.4-cp310-cp310-win32.whl", hash = "sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07"}, + {file = "numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a"}, + {file = "numpy-1.26.4-cp311-cp311-win32.whl", hash = "sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20"}, + {file = "numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0"}, + {file = "numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110"}, + {file = "numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7349ab0fa0c429c82442a27a9673fc802ffdb7c7775fad780226cb234965e53c"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:52b8b60467cd7dd1e9ed082188b4e6bb35aa5cdd01777621a1658910745b90be"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5241e0a80d808d70546c697135da2c613f30e28251ff8307eb72ba696945764"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f870204a840a60da0b12273ef34f7051e98c3b5961b61b0c2c1be6dfd64fbcd3"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:679b0076f67ecc0138fd2ede3a8fd196dddc2ad3254069bcb9faf9a79b1cebcd"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:47711010ad8555514b434df65f7d7b076bb8261df1ca9bb78f53d3b2db02e95c"}, + {file = "numpy-1.26.4-cp39-cp39-win32.whl", hash = "sha256:a354325ee03388678242a4d7ebcd08b5c727033fcff3b2f536aea978e15ee9e6"}, + {file = "numpy-1.26.4-cp39-cp39-win_amd64.whl", hash = "sha256:3373d5d70a5fe74a2c1bb6d2cfd9609ecf686d47a2d7b1d37a8f3b6bf6003aea"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:afedb719a9dcfc7eaf2287b839d8198e06dcd4cb5d276a3df279231138e83d30"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95a7476c59002f2f6c590b9b7b998306fba6a5aa646b1e22ddfeaf8f78c3a29c"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7e50d0a0cc3189f9cb0aeb3a6a6af18c16f59f004b866cd2be1c14b36134a4a0"}, + {file = "numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010"}, +] + +[[package]] +name = "nvidia-cublas-cu12" +version = "12.1.3.1" +description = "CUBLAS native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cublas_cu12-12.1.3.1-py3-none-manylinux1_x86_64.whl", hash = "sha256:ee53ccca76a6fc08fb9701aa95b6ceb242cdaab118c3bb152af4e579af792728"}, + {file = "nvidia_cublas_cu12-12.1.3.1-py3-none-win_amd64.whl", hash = "sha256:2b964d60e8cf11b5e1073d179d85fa340c120e99b3067558f3cf98dd69d02906"}, +] + +[[package]] +name = "nvidia-cuda-cupti-cu12" +version = "12.1.105" +description = "CUDA profiling tools runtime libs." +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cuda_cupti_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:e54fde3983165c624cb79254ae9818a456eb6e87a7fd4d56a2352c24ee542d7e"}, + {file = "nvidia_cuda_cupti_cu12-12.1.105-py3-none-win_amd64.whl", hash = "sha256:bea8236d13a0ac7190bd2919c3e8e6ce1e402104276e6f9694479e48bb0eb2a4"}, +] + +[[package]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.1.105" +description = "NVRTC native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cuda_nvrtc_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:339b385f50c309763ca65456ec75e17bbefcbbf2893f462cb8b90584cd27a1c2"}, + {file = "nvidia_cuda_nvrtc_cu12-12.1.105-py3-none-win_amd64.whl", hash = "sha256:0a98a522d9ff138b96c010a65e145dc1b4850e9ecb75a0172371793752fd46ed"}, +] + +[[package]] +name = "nvidia-cuda-runtime-cu12" +version = "12.1.105" +description = "CUDA Runtime native Libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cuda_runtime_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:6e258468ddf5796e25f1dc591a31029fa317d97a0a94ed93468fc86301d61e40"}, + {file = "nvidia_cuda_runtime_cu12-12.1.105-py3-none-win_amd64.whl", hash = "sha256:dfb46ef84d73fababab44cf03e3b83f80700d27ca300e537f85f636fac474344"}, +] + +[[package]] +name = "nvidia-cudnn-cu12" +version = "8.9.2.26" +description = "cuDNN runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cudnn_cu12-8.9.2.26-py3-none-manylinux1_x86_64.whl", hash = "sha256:5ccb288774fdfb07a7e7025ffec286971c06d8d7b4fb162525334616d7629ff9"}, +] + +[package.dependencies] +nvidia-cublas-cu12 = "*" + +[[package]] +name = "nvidia-cufft-cu12" +version = "11.0.2.54" +description = "CUFFT native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cufft_cu12-11.0.2.54-py3-none-manylinux1_x86_64.whl", hash = "sha256:794e3948a1aa71fd817c3775866943936774d1c14e7628c74f6f7417224cdf56"}, + {file = "nvidia_cufft_cu12-11.0.2.54-py3-none-win_amd64.whl", hash = "sha256:d9ac353f78ff89951da4af698f80870b1534ed69993f10a4cf1d96f21357e253"}, +] + +[[package]] +name = "nvidia-curand-cu12" +version = "10.3.2.106" +description = "CURAND native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_curand_cu12-10.3.2.106-py3-none-manylinux1_x86_64.whl", hash = "sha256:9d264c5036dde4e64f1de8c50ae753237c12e0b1348738169cd0f8a536c0e1e0"}, + {file = "nvidia_curand_cu12-10.3.2.106-py3-none-win_amd64.whl", hash = "sha256:75b6b0c574c0037839121317e17fd01f8a69fd2ef8e25853d826fec30bdba74a"}, +] + +[[package]] +name = "nvidia-cusolver-cu12" +version = "11.4.5.107" +description = "CUDA solver native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cusolver_cu12-11.4.5.107-py3-none-manylinux1_x86_64.whl", hash = "sha256:8a7ec542f0412294b15072fa7dab71d31334014a69f953004ea7a118206fe0dd"}, + {file = "nvidia_cusolver_cu12-11.4.5.107-py3-none-win_amd64.whl", hash = "sha256:74e0c3a24c78612192a74fcd90dd117f1cf21dea4822e66d89e8ea80e3cd2da5"}, +] + +[package.dependencies] +nvidia-cublas-cu12 = "*" +nvidia-cusparse-cu12 = "*" +nvidia-nvjitlink-cu12 = "*" + +[[package]] +name = "nvidia-cusparse-cu12" +version = "12.1.0.106" +description = "CUSPARSE native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl", hash = "sha256:f3b50f42cf363f86ab21f720998517a659a48131e8d538dc02f8768237bd884c"}, + {file = "nvidia_cusparse_cu12-12.1.0.106-py3-none-win_amd64.whl", hash = "sha256:b798237e81b9719373e8fae8d4f091b70a0cf09d9d85c95a557e11df2d8e9a5a"}, +] + +[package.dependencies] +nvidia-nvjitlink-cu12 = "*" + +[[package]] +name = "nvidia-nccl-cu12" +version = "2.18.1" +description = "NVIDIA Collective Communication Library (NCCL) Runtime" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_nccl_cu12-2.18.1-py3-none-manylinux1_x86_64.whl", hash = "sha256:1a6c4acefcbebfa6de320f412bf7866de856e786e0462326ba1bac40de0b5e71"}, +] + +[[package]] +name = "nvidia-nvjitlink-cu12" +version = "12.5.40" +description = "Nvidia JIT LTO Library" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_nvjitlink_cu12-12.5.40-py3-none-manylinux2014_x86_64.whl", hash = "sha256:d9714f27c1d0f0895cd8915c07a87a1d0029a0aa36acaf9156952ec2a8a12189"}, + {file = "nvidia_nvjitlink_cu12-12.5.40-py3-none-win_amd64.whl", hash = "sha256:c3401dc8543b52d3a8158007a0c1ab4e9c768fcbd24153a48c86972102197ddd"}, +] + +[[package]] +name = "nvidia-nvtx-cu12" +version = "12.1.105" +description = "NVIDIA Tools Extension" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_nvtx_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:dc21cf308ca5691e7c04d962e213f8a4aa9bbfa23d95412f452254c2caeb09e5"}, + {file = "nvidia_nvtx_cu12-12.1.105-py3-none-win_amd64.whl", hash = "sha256:65f4d98982b31b60026e0e6de73fbdfc09d08a96f4656dd3665ca616a11e1e82"}, +] + +[[package]] +name = "omegaconf" +version = "2.0.6" +description = "A flexible configuration library" +optional = false +python-versions = ">=3.6" +files = [ + {file = "omegaconf-2.0.6-py3-none-any.whl", hash = "sha256:9e349fd76819b95b47aa628edea1ff83fed5b25108608abdd6c7fdca188e302a"}, + {file = "omegaconf-2.0.6.tar.gz", hash = "sha256:92ca535a788d21651bf4c2eaf5c1ca4c7a8003b2dab4a87cbb09109784268806"}, +] + +[package.dependencies] +PyYAML = ">=5.1" +typing-extensions = "*" + +[[package]] +name = "packaging" +version = "24.1" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"}, + {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"}, +] + +[[package]] +name = "pandas" +version = "1.5.3" +description = "Powerful data structures for data analysis, time series, and statistics" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pandas-1.5.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3749077d86e3a2f0ed51367f30bf5b82e131cc0f14260c4d3e499186fccc4406"}, + {file = "pandas-1.5.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:972d8a45395f2a2d26733eb8d0f629b2f90bebe8e8eddbb8829b180c09639572"}, + {file = "pandas-1.5.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:50869a35cbb0f2e0cd5ec04b191e7b12ed688874bd05dd777c19b28cbea90996"}, + {file = "pandas-1.5.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3ac844a0fe00bfaeb2c9b51ab1424e5c8744f89860b138434a363b1f620f354"}, + {file = "pandas-1.5.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a0a56cef15fd1586726dace5616db75ebcfec9179a3a55e78f72c5639fa2a23"}, + {file = "pandas-1.5.3-cp310-cp310-win_amd64.whl", hash = "sha256:478ff646ca42b20376e4ed3fa2e8d7341e8a63105586efe54fa2508ee087f328"}, + {file = "pandas-1.5.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6973549c01ca91ec96199e940495219c887ea815b2083722821f1d7abfa2b4dc"}, + {file = "pandas-1.5.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c39a8da13cede5adcd3be1182883aea1c925476f4e84b2807a46e2775306305d"}, + {file = "pandas-1.5.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f76d097d12c82a535fda9dfe5e8dd4127952b45fea9b0276cb30cca5ea313fbc"}, + {file = "pandas-1.5.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e474390e60ed609cec869b0da796ad94f420bb057d86784191eefc62b65819ae"}, + {file = "pandas-1.5.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f2b952406a1588ad4cad5b3f55f520e82e902388a6d5a4a91baa8d38d23c7f6"}, + {file = "pandas-1.5.3-cp311-cp311-win_amd64.whl", hash = "sha256:bc4c368f42b551bf72fac35c5128963a171b40dce866fb066540eeaf46faa003"}, + {file = "pandas-1.5.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:14e45300521902689a81f3f41386dc86f19b8ba8dd5ac5a3c7010ef8d2932813"}, + {file = "pandas-1.5.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9842b6f4b8479e41968eced654487258ed81df7d1c9b7b870ceea24ed9459b31"}, + {file = "pandas-1.5.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:26d9c71772c7afb9d5046e6e9cf42d83dd147b5cf5bcb9d97252077118543792"}, + {file = "pandas-1.5.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5fbcb19d6fceb9e946b3e23258757c7b225ba450990d9ed63ccceeb8cae609f7"}, + {file = "pandas-1.5.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:565fa34a5434d38e9d250af3c12ff931abaf88050551d9fbcdfafca50d62babf"}, + {file = "pandas-1.5.3-cp38-cp38-win32.whl", hash = "sha256:87bd9c03da1ac870a6d2c8902a0e1fd4267ca00f13bc494c9e5a9020920e1d51"}, + {file = "pandas-1.5.3-cp38-cp38-win_amd64.whl", hash = "sha256:41179ce559943d83a9b4bbacb736b04c928b095b5f25dd2b7389eda08f46f373"}, + {file = "pandas-1.5.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c74a62747864ed568f5a82a49a23a8d7fe171d0c69038b38cedf0976831296fa"}, + {file = "pandas-1.5.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c4c00e0b0597c8e4f59e8d461f797e5d70b4d025880516a8261b2817c47759ee"}, + {file = "pandas-1.5.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a50d9a4336a9621cab7b8eb3fb11adb82de58f9b91d84c2cd526576b881a0c5a"}, + {file = "pandas-1.5.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd05f7783b3274aa206a1af06f0ceed3f9b412cf665b7247eacd83be41cf7bf0"}, + {file = "pandas-1.5.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f69c4029613de47816b1bb30ff5ac778686688751a5e9c99ad8c7031f6508e5"}, + {file = "pandas-1.5.3-cp39-cp39-win32.whl", hash = "sha256:7cec0bee9f294e5de5bbfc14d0573f65526071029d036b753ee6507d2a21480a"}, + {file = "pandas-1.5.3-cp39-cp39-win_amd64.whl", hash = "sha256:dfd681c5dc216037e0b0a2c821f5ed99ba9f03ebcf119c7dac0e9a7b960b9ec9"}, + {file = "pandas-1.5.3.tar.gz", hash = "sha256:74a3fd7e5a7ec052f183273dc7b0acd3a863edf7520f5d3a1765c04ffdb3b0b1"}, +] + +[package.dependencies] +numpy = {version = ">=1.20.3", markers = "python_version < \"3.10\""} +python-dateutil = ">=2.8.1" +pytz = ">=2020.1" + +[package.extras] +test = ["hypothesis (>=5.5.3)", "pytest (>=6.0)", "pytest-xdist (>=1.31)"] + +[[package]] +name = "pathtools" +version = "0.1.2" +description = "File system general utilities" +optional = false +python-versions = "*" +files = [ + {file = "pathtools-0.1.2.tar.gz", hash = "sha256:7c35c5421a39bb82e58018febd90e3b6e5db34c5443aaaf742b3f33d4655f1c0"}, +] + +[[package]] +name = "pillow" +version = "10.3.0" +description = "Python Imaging Library (Fork)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pillow-10.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:90b9e29824800e90c84e4022dd5cc16eb2d9605ee13f05d47641eb183cd73d45"}, + {file = "pillow-10.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2c405445c79c3f5a124573a051062300936b0281fee57637e706453e452746c"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78618cdbccaa74d3f88d0ad6cb8ac3007f1a6fa5c6f19af64b55ca170bfa1edf"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:261ddb7ca91fcf71757979534fb4c128448b5b4c55cb6152d280312062f69599"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:ce49c67f4ea0609933d01c0731b34b8695a7a748d6c8d186f95e7d085d2fe475"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:b14f16f94cbc61215115b9b1236f9c18403c15dd3c52cf629072afa9d54c1cbf"}, + {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d33891be6df59d93df4d846640f0e46f1a807339f09e79a8040bc887bdcd7ed3"}, + {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b50811d664d392f02f7761621303eba9d1b056fb1868c8cdf4231279645c25f5"}, + {file = "pillow-10.3.0-cp310-cp310-win32.whl", hash = "sha256:ca2870d5d10d8726a27396d3ca4cf7976cec0f3cb706debe88e3a5bd4610f7d2"}, + {file = "pillow-10.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:f0d0591a0aeaefdaf9a5e545e7485f89910c977087e7de2b6c388aec32011e9f"}, + {file = "pillow-10.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:ccce24b7ad89adb5a1e34a6ba96ac2530046763912806ad4c247356a8f33a67b"}, + {file = "pillow-10.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:5f77cf66e96ae734717d341c145c5949c63180842a545c47a0ce7ae52ca83795"}, + {file = "pillow-10.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e4b878386c4bf293578b48fc570b84ecfe477d3b77ba39a6e87150af77f40c57"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdcbb4068117dfd9ce0138d068ac512843c52295ed996ae6dd1faf537b6dbc27"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9797a6c8fe16f25749b371c02e2ade0efb51155e767a971c61734b1bf6293994"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9e91179a242bbc99be65e139e30690e081fe6cb91a8e77faf4c409653de39451"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1b87bd9d81d179bd8ab871603bd80d8645729939f90b71e62914e816a76fc6bd"}, + {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:81d09caa7b27ef4e61cb7d8fbf1714f5aec1c6b6c5270ee53504981e6e9121ad"}, + {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:048ad577748b9fa4a99a0548c64f2cb8d672d5bf2e643a739ac8faff1164238c"}, + {file = "pillow-10.3.0-cp311-cp311-win32.whl", hash = "sha256:7161ec49ef0800947dc5570f86568a7bb36fa97dd09e9827dc02b718c5643f09"}, + {file = "pillow-10.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8eb0908e954d093b02a543dc963984d6e99ad2b5e36503d8a0aaf040505f747d"}, + {file = "pillow-10.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:4e6f7d1c414191c1199f8996d3f2282b9ebea0945693fb67392c75a3a320941f"}, + {file = "pillow-10.3.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:e46f38133e5a060d46bd630faa4d9fa0202377495df1f068a8299fd78c84de84"}, + {file = "pillow-10.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:50b8eae8f7334ec826d6eeffaeeb00e36b5e24aa0b9df322c247539714c6df19"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d3bea1c75f8c53ee4d505c3e67d8c158ad4df0d83170605b50b64025917f338"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19aeb96d43902f0a783946a0a87dbdad5c84c936025b8419da0a0cd7724356b1"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:74d28c17412d9caa1066f7a31df8403ec23d5268ba46cd0ad2c50fb82ae40462"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ff61bfd9253c3915e6d41c651d5f962da23eda633cf02262990094a18a55371a"}, + {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d886f5d353333b4771d21267c7ecc75b710f1a73d72d03ca06df49b09015a9ef"}, + {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b5ec25d8b17217d635f8935dbc1b9aa5907962fae29dff220f2659487891cd3"}, + {file = "pillow-10.3.0-cp312-cp312-win32.whl", hash = "sha256:51243f1ed5161b9945011a7360e997729776f6e5d7005ba0c6879267d4c5139d"}, + {file = "pillow-10.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:412444afb8c4c7a6cc11a47dade32982439925537e483be7c0ae0cf96c4f6a0b"}, + {file = "pillow-10.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:798232c92e7665fe82ac085f9d8e8ca98826f8e27859d9a96b41d519ecd2e49a"}, + {file = "pillow-10.3.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:4eaa22f0d22b1a7e93ff0a596d57fdede2e550aecffb5a1ef1106aaece48e96b"}, + {file = "pillow-10.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cd5e14fbf22a87321b24c88669aad3a51ec052eb145315b3da3b7e3cc105b9a2"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1530e8f3a4b965eb6a7785cf17a426c779333eb62c9a7d1bbcf3ffd5bf77a4aa"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d512aafa1d32efa014fa041d38868fda85028e3f930a96f85d49c7d8ddc0383"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:339894035d0ede518b16073bdc2feef4c991ee991a29774b33e515f1d308e08d"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:aa7e402ce11f0885305bfb6afb3434b3cd8f53b563ac065452d9d5654c7b86fd"}, + {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0ea2a783a2bdf2a561808fe4a7a12e9aa3799b701ba305de596bc48b8bdfce9d"}, + {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c78e1b00a87ce43bb37642c0812315b411e856a905d58d597750eb79802aaaa3"}, + {file = "pillow-10.3.0-cp38-cp38-win32.whl", hash = "sha256:72d622d262e463dfb7595202d229f5f3ab4b852289a1cd09650362db23b9eb0b"}, + {file = "pillow-10.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:2034f6759a722da3a3dbd91a81148cf884e91d1b747992ca288ab88c1de15999"}, + {file = "pillow-10.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2ed854e716a89b1afcedea551cd85f2eb2a807613752ab997b9974aaa0d56936"}, + {file = "pillow-10.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dc1a390a82755a8c26c9964d457d4c9cbec5405896cba94cf51f36ea0d855002"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4203efca580f0dd6f882ca211f923168548f7ba334c189e9eab1178ab840bf60"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3102045a10945173d38336f6e71a8dc71bcaeed55c3123ad4af82c52807b9375"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:6fb1b30043271ec92dc65f6d9f0b7a830c210b8a96423074b15c7bc999975f57"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:1dfc94946bc60ea375cc39cff0b8da6c7e5f8fcdc1d946beb8da5c216156ddd8"}, + {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b09b86b27a064c9624d0a6c54da01c1beaf5b6cadfa609cf63789b1d08a797b9"}, + {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d3b2348a78bc939b4fed6552abfd2e7988e0f81443ef3911a4b8498ca084f6eb"}, + {file = "pillow-10.3.0-cp39-cp39-win32.whl", hash = "sha256:45ebc7b45406febf07fef35d856f0293a92e7417ae7933207e90bf9090b70572"}, + {file = "pillow-10.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:0ba26351b137ca4e0db0342d5d00d2e355eb29372c05afd544ebf47c0956ffeb"}, + {file = "pillow-10.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:50fd3f6b26e3441ae07b7c979309638b72abc1a25da31a81a7fbd9495713ef4f"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:6b02471b72526ab8a18c39cb7967b72d194ec53c1fd0a70b050565a0f366d355"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8ab74c06ffdab957d7670c2a5a6e1a70181cd10b727cd788c4dd9005b6a8acd9"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:048eeade4c33fdf7e08da40ef402e748df113fd0b4584e32c4af74fe78baaeb2"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2ec1e921fd07c7cda7962bad283acc2f2a9ccc1b971ee4b216b75fad6f0463"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:4c8e73e99da7db1b4cad7f8d682cf6abad7844da39834c288fbfa394a47bbced"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:16563993329b79513f59142a6b02055e10514c1a8e86dca8b48a893e33cf91e3"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dd78700f5788ae180b5ee8902c6aea5a5726bac7c364b202b4b3e3ba2d293170"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:aff76a55a8aa8364d25400a210a65ff59d0168e0b4285ba6bf2bd83cf675ba32"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:b7bc2176354defba3edc2b9a777744462da2f8e921fbaf61e52acb95bafa9828"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:793b4e24db2e8742ca6423d3fde8396db336698c55cd34b660663ee9e45ed37f"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d93480005693d247f8346bc8ee28c72a2191bdf1f6b5db469c096c0c867ac015"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c83341b89884e2b2e55886e8fbbf37c3fa5efd6c8907124aeb72f285ae5696e5"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1a1d1915db1a4fdb2754b9de292642a39a7fb28f1736699527bb649484fb966a"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a0eaa93d054751ee9964afa21c06247779b90440ca41d184aeb5d410f20ff591"}, + {file = "pillow-10.3.0.tar.gz", hash = "sha256:9d2455fbf44c914840c793e89aa82d0e1763a14253a000743719ae5946814b2d"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] +fpx = ["olefile"] +mic = ["olefile"] +tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] +typing = ["typing-extensions"] +xmp = ["defusedxml"] + +[[package]] +name = "portalocker" +version = "2.8.2" +description = "Wraps the portalocker recipe for easy usage" +optional = false +python-versions = ">=3.8" +files = [ + {file = "portalocker-2.8.2-py3-none-any.whl", hash = "sha256:cfb86acc09b9aa7c3b43594e19be1345b9d16af3feb08bf92f23d4dce513a28e"}, + {file = "portalocker-2.8.2.tar.gz", hash = "sha256:2b035aa7828e46c58e9b31390ee1f169b98e1066ab10b9a6a861fe7e25ee4f33"}, +] + +[package.dependencies] +pywin32 = {version = ">=226", markers = "platform_system == \"Windows\""} + +[package.extras] +docs = ["sphinx (>=1.7.1)"] +redis = ["redis"] +tests = ["pytest (>=5.4.1)", "pytest-cov (>=2.8.1)", "pytest-mypy (>=0.8.0)", "pytest-timeout (>=2.1.0)", "redis", "sphinx (>=6.0.0)", "types-redis"] + +[[package]] +name = "protobuf" +version = "3.20.0" +description = "Protocol Buffers" +optional = false +python-versions = ">=3.7" +files = [ + {file = "protobuf-3.20.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:9d0f3aca8ca51c8b5e204ab92bd8afdb2a8e3df46bd0ce0bd39065d79aabcaa4"}, + {file = "protobuf-3.20.0-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:001c2160c03b6349c04de39cf1a58e342750da3632f6978a1634a3dcca1ec10e"}, + {file = "protobuf-3.20.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5b5860b790498f233cdc8d635a17fc08de62e59d4dcd8cdb6c6c0d38a31edf2b"}, + {file = "protobuf-3.20.0-cp310-cp310-win32.whl", hash = "sha256:0b250c60256c8824219352dc2a228a6b49987e5bf94d3ffcf4c46585efcbd499"}, + {file = "protobuf-3.20.0-cp310-cp310-win_amd64.whl", hash = "sha256:a1eebb6eb0653e594cb86cd8e536b9b083373fca9aba761ade6cd412d46fb2ab"}, + {file = "protobuf-3.20.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:bc14037281db66aa60856cd4ce4541a942040686d290e3f3224dd3978f88f554"}, + {file = "protobuf-3.20.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:47257d932de14a7b6c4ae1b7dbf592388153ee35ec7cae216b87ae6490ed39a3"}, + {file = "protobuf-3.20.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:fbcbb068ebe67c4ff6483d2e2aa87079c325f8470b24b098d6bf7d4d21d57a69"}, + {file = "protobuf-3.20.0-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:542f25a4adf3691a306dcc00bf9a73176554938ec9b98f20f929a044f80acf1b"}, + {file = "protobuf-3.20.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:fd7133b885e356fa4920ead8289bb45dc6f185a164e99e10279f33732ed5ce15"}, + {file = "protobuf-3.20.0-cp37-cp37m-win32.whl", hash = "sha256:8d84453422312f8275455d1cb52d850d6a4d7d714b784e41b573c6f5bfc2a029"}, + {file = "protobuf-3.20.0-cp37-cp37m-win_amd64.whl", hash = "sha256:52bae32a147c375522ce09bd6af4d2949aca32a0415bc62df1456b3ad17c6001"}, + {file = "protobuf-3.20.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:25d2fcd6eef340082718ec9ad2c58d734429f2b1f7335d989523852f2bba220b"}, + {file = "protobuf-3.20.0-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:88c8be0558bdfc35e68c42ae5bf785eb9390d25915d4863bbc7583d23da77074"}, + {file = "protobuf-3.20.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:38fd9eb74b852e4ee14b16e9670cd401d147ee3f3ec0d4f7652e0c921d6227f8"}, + {file = "protobuf-3.20.0-cp38-cp38-win32.whl", hash = "sha256:7dcd84dc31ebb35ade755e06d1561d1bd3b85e85dbdbf6278011fc97b22810db"}, + {file = "protobuf-3.20.0-cp38-cp38-win_amd64.whl", hash = "sha256:1eb13f5a5a59ca4973bcfa2fc8fff644bd39f2109c3f7a60bd5860cb6a49b679"}, + {file = "protobuf-3.20.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1d24c81c2310f0063b8fc1c20c8ed01f3331be9374b4b5c2de846f69e11e21fb"}, + {file = "protobuf-3.20.0-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:8be43a91ab66fe995e85ccdbdd1046d9f0443d59e060c0840319290de25b7d33"}, + {file = "protobuf-3.20.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:7a53d4035427b9dbfbb397f46642754d294f131e93c661d056366f2a31438263"}, + {file = "protobuf-3.20.0-cp39-cp39-win32.whl", hash = "sha256:32bf4a90c207a0b4e70ca6dd09d43de3cb9898f7d5b69c2e9e3b966a7f342820"}, + {file = "protobuf-3.20.0-cp39-cp39-win_amd64.whl", hash = "sha256:6efe066a7135233f97ce51a1aa007d4fb0be28ef093b4f88dac4ad1b3a2b7b6f"}, + {file = "protobuf-3.20.0-py2.py3-none-any.whl", hash = "sha256:4eda68bd9e2a4879385e6b1ea528c976f59cd9728382005cc54c28bcce8db983"}, + {file = "protobuf-3.20.0.tar.gz", hash = "sha256:71b2c3d1cd26ed1ec7c8196834143258b2ad7f444efff26fdc366c6f5e752702"}, +] + +[[package]] +name = "psutil" +version = "5.9.8" +description = "Cross-platform lib for process and system monitoring in Python." +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*" +files = [ + {file = "psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:26bd09967ae00920df88e0352a91cff1a78f8d69b3ecabbfe733610c0af486c8"}, + {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:05806de88103b25903dff19bb6692bd2e714ccf9e668d050d144012055cbca73"}, + {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:611052c4bc70432ec770d5d54f64206aa7203a101ec273a0cd82418c86503bb7"}, + {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:50187900d73c1381ba1454cf40308c2bf6f34268518b3f36a9b663ca87e65e36"}, + {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:02615ed8c5ea222323408ceba16c60e99c3f91639b07da6373fb7e6539abc56d"}, + {file = "psutil-5.9.8-cp27-none-win32.whl", hash = "sha256:36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e"}, + {file = "psutil-5.9.8-cp27-none-win_amd64.whl", hash = "sha256:bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631"}, + {file = "psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81"}, + {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421"}, + {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4"}, + {file = "psutil-5.9.8-cp36-cp36m-win32.whl", hash = "sha256:7d79560ad97af658a0f6adfef8b834b53f64746d45b403f225b85c5c2c140eee"}, + {file = "psutil-5.9.8-cp36-cp36m-win_amd64.whl", hash = "sha256:27cc40c3493bb10de1be4b3f07cae4c010ce715290a5be22b98493509c6299e2"}, + {file = "psutil-5.9.8-cp37-abi3-win32.whl", hash = "sha256:bc56c2a1b0d15aa3eaa5a60c9f3f8e3e565303b465dbf57a1b730e7a2b9844e0"}, + {file = "psutil-5.9.8-cp37-abi3-win_amd64.whl", hash = "sha256:8db4c1b57507eef143a15a6884ca10f7c73876cdf5d51e713151c1236a0e68cf"}, + {file = "psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:d16bbddf0693323b8c6123dd804100241da461e41d6e332fb0ba6058f630f8c8"}, + {file = "psutil-5.9.8.tar.gz", hash = "sha256:6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c"}, +] + +[package.extras] +test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"] + +[[package]] +name = "psycopg2-binary" +version = "2.9.9" +description = "psycopg2 - Python-PostgreSQL Database Adapter" +optional = false +python-versions = ">=3.7" +files = [ + {file = "psycopg2-binary-2.9.9.tar.gz", hash = "sha256:7f01846810177d829c7692f1f5ada8096762d9172af1b1a28d4ab5b77c923c1c"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c2470da5418b76232f02a2fcd2229537bb2d5a7096674ce61859c3229f2eb202"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c6af2a6d4b7ee9615cbb162b0738f6e1fd1f5c3eda7e5da17861eacf4c717ea7"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:75723c3c0fbbf34350b46a3199eb50638ab22a0228f93fb472ef4d9becc2382b"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:83791a65b51ad6ee6cf0845634859d69a038ea9b03d7b26e703f94c7e93dbcf9"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0ef4854e82c09e84cc63084a9e4ccd6d9b154f1dbdd283efb92ecd0b5e2b8c84"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed1184ab8f113e8d660ce49a56390ca181f2981066acc27cf637d5c1e10ce46e"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d2997c458c690ec2bc6b0b7ecbafd02b029b7b4283078d3b32a852a7ce3ddd98"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:b58b4710c7f4161b5e9dcbe73bb7c62d65670a87df7bcce9e1faaad43e715245"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:0c009475ee389757e6e34611d75f6e4f05f0cf5ebb76c6037508318e1a1e0d7e"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8dbf6d1bc73f1d04ec1734bae3b4fb0ee3cb2a493d35ede9badbeb901fb40f6f"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-win32.whl", hash = "sha256:3f78fd71c4f43a13d342be74ebbc0666fe1f555b8837eb113cb7416856c79682"}, + {file = "psycopg2_binary-2.9.9-cp310-cp310-win_amd64.whl", hash = "sha256:876801744b0dee379e4e3c38b76fc89f88834bb15bf92ee07d94acd06ec890a0"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ee825e70b1a209475622f7f7b776785bd68f34af6e7a46e2e42f27b659b5bc26"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1ea665f8ce695bcc37a90ee52de7a7980be5161375d42a0b6c6abedbf0d81f0f"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:143072318f793f53819048fdfe30c321890af0c3ec7cb1dfc9cc87aa88241de2"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c332c8d69fb64979ebf76613c66b985414927a40f8defa16cf1bc028b7b0a7b0"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7fc5a5acafb7d6ccca13bfa8c90f8c51f13d8fb87d95656d3950f0158d3ce53"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:977646e05232579d2e7b9c59e21dbe5261f403a88417f6a6512e70d3f8a046be"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:b6356793b84728d9d50ead16ab43c187673831e9d4019013f1402c41b1db9b27"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:bc7bb56d04601d443f24094e9e31ae6deec9ccb23581f75343feebaf30423359"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:77853062a2c45be16fd6b8d6de2a99278ee1d985a7bd8b103e97e41c034006d2"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:78151aa3ec21dccd5cdef6c74c3e73386dcdfaf19bced944169697d7ac7482fc"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-win32.whl", hash = "sha256:dc4926288b2a3e9fd7b50dc6a1909a13bbdadfc67d93f3374d984e56f885579d"}, + {file = "psycopg2_binary-2.9.9-cp311-cp311-win_amd64.whl", hash = "sha256:b76bedd166805480ab069612119ea636f5ab8f8771e640ae103e05a4aae3e417"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:8532fd6e6e2dc57bcb3bc90b079c60de896d2128c5d9d6f24a63875a95a088cf"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0605eaed3eb239e87df0d5e3c6489daae3f7388d455d0c0b4df899519c6a38d"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f8544b092a29a6ddd72f3556a9fcf249ec412e10ad28be6a0c0d948924f2212"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2d423c8d8a3c82d08fe8af900ad5b613ce3632a1249fd6a223941d0735fce493"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2e5afae772c00980525f6d6ecf7cbca55676296b580c0e6abb407f15f3706996"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e6f98446430fdf41bd36d4faa6cb409f5140c1c2cf58ce0bbdaf16af7d3f119"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c77e3d1862452565875eb31bdb45ac62502feabbd53429fdc39a1cc341d681ba"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:cb16c65dcb648d0a43a2521f2f0a2300f40639f6f8c1ecbc662141e4e3e1ee07"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:911dda9c487075abd54e644ccdf5e5c16773470a6a5d3826fda76699410066fb"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:57fede879f08d23c85140a360c6a77709113efd1c993923c59fde17aa27599fe"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-win32.whl", hash = "sha256:64cf30263844fa208851ebb13b0732ce674d8ec6a0c86a4e160495d299ba3c93"}, + {file = "psycopg2_binary-2.9.9-cp312-cp312-win_amd64.whl", hash = "sha256:81ff62668af011f9a48787564ab7eded4e9fb17a4a6a74af5ffa6a457400d2ab"}, + {file = "psycopg2_binary-2.9.9-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:2293b001e319ab0d869d660a704942c9e2cce19745262a8aba2115ef41a0a42a"}, + {file = "psycopg2_binary-2.9.9-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:03ef7df18daf2c4c07e2695e8cfd5ee7f748a1d54d802330985a78d2a5a6dca9"}, + {file = "psycopg2_binary-2.9.9-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a602ea5aff39bb9fac6308e9c9d82b9a35c2bf288e184a816002c9fae930b77"}, + {file = "psycopg2_binary-2.9.9-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8359bf4791968c5a78c56103702000105501adb557f3cf772b2c207284273984"}, + {file = "psycopg2_binary-2.9.9-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:275ff571376626195ab95a746e6a04c7df8ea34638b99fc11160de91f2fef503"}, + {file = "psycopg2_binary-2.9.9-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:f9b5571d33660d5009a8b3c25dc1db560206e2d2f89d3df1cb32d72c0d117d52"}, + {file = "psycopg2_binary-2.9.9-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:420f9bbf47a02616e8554e825208cb947969451978dceb77f95ad09c37791dae"}, + {file = "psycopg2_binary-2.9.9-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:4154ad09dac630a0f13f37b583eae260c6aa885d67dfbccb5b02c33f31a6d420"}, + {file = "psycopg2_binary-2.9.9-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:a148c5d507bb9b4f2030a2025c545fccb0e1ef317393eaba42e7eabd28eb6041"}, + {file = "psycopg2_binary-2.9.9-cp37-cp37m-win32.whl", hash = "sha256:68fc1f1ba168724771e38bee37d940d2865cb0f562380a1fb1ffb428b75cb692"}, + {file = "psycopg2_binary-2.9.9-cp37-cp37m-win_amd64.whl", hash = "sha256:281309265596e388ef483250db3640e5f414168c5a67e9c665cafce9492eda2f"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:60989127da422b74a04345096c10d416c2b41bd7bf2a380eb541059e4e999980"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:246b123cc54bb5361588acc54218c8c9fb73068bf227a4a531d8ed56fa3ca7d6"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:34eccd14566f8fe14b2b95bb13b11572f7c7d5c36da61caf414d23b91fcc5d94"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:18d0ef97766055fec15b5de2c06dd8e7654705ce3e5e5eed3b6651a1d2a9a152"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d3f82c171b4ccd83bbaf35aa05e44e690113bd4f3b7b6cc54d2219b132f3ae55"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ead20f7913a9c1e894aebe47cccf9dc834e1618b7aa96155d2091a626e59c972"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:ca49a8119c6cbd77375ae303b0cfd8c11f011abbbd64601167ecca18a87e7cdd"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:323ba25b92454adb36fa425dc5cf6f8f19f78948cbad2e7bc6cdf7b0d7982e59"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:1236ed0952fbd919c100bc839eaa4a39ebc397ed1c08a97fc45fee2a595aa1b3"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:729177eaf0aefca0994ce4cffe96ad3c75e377c7b6f4efa59ebf003b6d398716"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-win32.whl", hash = "sha256:804d99b24ad523a1fe18cc707bf741670332f7c7412e9d49cb5eab67e886b9b5"}, + {file = "psycopg2_binary-2.9.9-cp38-cp38-win_amd64.whl", hash = "sha256:a6cdcc3ede532f4a4b96000b6362099591ab4a3e913d70bcbac2b56c872446f7"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:72dffbd8b4194858d0941062a9766f8297e8868e1dd07a7b36212aaa90f49472"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:30dcc86377618a4c8f3b72418df92e77be4254d8f89f14b8e8f57d6d43603c0f"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:31a34c508c003a4347d389a9e6fcc2307cc2150eb516462a7a17512130de109e"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:15208be1c50b99203fe88d15695f22a5bed95ab3f84354c494bcb1d08557df67"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1873aade94b74715be2246321c8650cabf5a0d098a95bab81145ffffa4c13876"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a58c98a7e9c021f357348867f537017057c2ed7f77337fd914d0bedb35dace7"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:4686818798f9194d03c9129a4d9a702d9e113a89cb03bffe08c6cf799e053291"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:ebdc36bea43063116f0486869652cb2ed7032dbc59fbcb4445c4862b5c1ecf7f"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:ca08decd2697fdea0aea364b370b1249d47336aec935f87b8bbfd7da5b2ee9c1"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ac05fb791acf5e1a3e39402641827780fe44d27e72567a000412c648a85ba860"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-win32.whl", hash = "sha256:9dba73be7305b399924709b91682299794887cbbd88e38226ed9f6712eabee90"}, + {file = "psycopg2_binary-2.9.9-cp39-cp39-win_amd64.whl", hash = "sha256:f7ae5d65ccfbebdfa761585228eb4d0df3a8b15cfb53bd953e713e09fbb12957"}, +] + +[[package]] +name = "pyarrow" +version = "16.1.0" +description = "Python library for Apache Arrow" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pyarrow-16.1.0-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:17e23b9a65a70cc733d8b738baa6ad3722298fa0c81d88f63ff94bf25eaa77b9"}, + {file = "pyarrow-16.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4740cc41e2ba5d641071d0ab5e9ef9b5e6e8c7611351a5cb7c1d175eaf43674a"}, + {file = "pyarrow-16.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:98100e0268d04e0eec47b73f20b39c45b4006f3c4233719c3848aa27a03c1aef"}, + {file = "pyarrow-16.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f68f409e7b283c085f2da014f9ef81e885d90dcd733bd648cfba3ef265961848"}, + {file = "pyarrow-16.1.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:a8914cd176f448e09746037b0c6b3a9d7688cef451ec5735094055116857580c"}, + {file = "pyarrow-16.1.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:48be160782c0556156d91adbdd5a4a7e719f8d407cb46ae3bb4eaee09b3111bd"}, + {file = "pyarrow-16.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:9cf389d444b0f41d9fe1444b70650fea31e9d52cfcb5f818b7888b91b586efff"}, + {file = "pyarrow-16.1.0-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:d0ebea336b535b37eee9eee31761813086d33ed06de9ab6fc6aaa0bace7b250c"}, + {file = "pyarrow-16.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2e73cfc4a99e796727919c5541c65bb88b973377501e39b9842ea71401ca6c1c"}, + {file = "pyarrow-16.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf9251264247ecfe93e5f5a0cd43b8ae834f1e61d1abca22da55b20c788417f6"}, + {file = "pyarrow-16.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ddf5aace92d520d3d2a20031d8b0ec27b4395cab9f74e07cc95edf42a5cc0147"}, + {file = "pyarrow-16.1.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:25233642583bf658f629eb230b9bb79d9af4d9f9229890b3c878699c82f7d11e"}, + {file = "pyarrow-16.1.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:a33a64576fddfbec0a44112eaf844c20853647ca833e9a647bfae0582b2ff94b"}, + {file = "pyarrow-16.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:185d121b50836379fe012753cf15c4ba9638bda9645183ab36246923875f8d1b"}, + {file = "pyarrow-16.1.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:2e51ca1d6ed7f2e9d5c3c83decf27b0d17bb207a7dea986e8dc3e24f80ff7d6f"}, + {file = "pyarrow-16.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:06ebccb6f8cb7357de85f60d5da50e83507954af617d7b05f48af1621d331c9a"}, + {file = "pyarrow-16.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b04707f1979815f5e49824ce52d1dceb46e2f12909a48a6a753fe7cafbc44a0c"}, + {file = "pyarrow-16.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d32000693deff8dc5df444b032b5985a48592c0697cb6e3071a5d59888714e2"}, + {file = "pyarrow-16.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:8785bb10d5d6fd5e15d718ee1d1f914fe768bf8b4d1e5e9bf253de8a26cb1628"}, + {file = "pyarrow-16.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:e1369af39587b794873b8a307cc6623a3b1194e69399af0efd05bb202195a5a7"}, + {file = "pyarrow-16.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:febde33305f1498f6df85e8020bca496d0e9ebf2093bab9e0f65e2b4ae2b3444"}, + {file = "pyarrow-16.1.0-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:b5f5705ab977947a43ac83b52ade3b881eb6e95fcc02d76f501d549a210ba77f"}, + {file = "pyarrow-16.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:0d27bf89dfc2576f6206e9cd6cf7a107c9c06dc13d53bbc25b0bd4556f19cf5f"}, + {file = "pyarrow-16.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d07de3ee730647a600037bc1d7b7994067ed64d0eba797ac74b2bc77384f4c2"}, + {file = "pyarrow-16.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fbef391b63f708e103df99fbaa3acf9f671d77a183a07546ba2f2c297b361e83"}, + {file = "pyarrow-16.1.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:19741c4dbbbc986d38856ee7ddfdd6a00fc3b0fc2d928795b95410d38bb97d15"}, + {file = "pyarrow-16.1.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:f2c5fb249caa17b94e2b9278b36a05ce03d3180e6da0c4c3b3ce5b2788f30eed"}, + {file = "pyarrow-16.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:e6b6d3cd35fbb93b70ade1336022cc1147b95ec6af7d36906ca7fe432eb09710"}, + {file = "pyarrow-16.1.0-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:18da9b76a36a954665ccca8aa6bd9f46c1145f79c0bb8f4f244f5f8e799bca55"}, + {file = "pyarrow-16.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:99f7549779b6e434467d2aa43ab2b7224dd9e41bdde486020bae198978c9e05e"}, + {file = "pyarrow-16.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f07fdffe4fd5b15f5ec15c8b64584868d063bc22b86b46c9695624ca3505b7b4"}, + {file = "pyarrow-16.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ddfe389a08ea374972bd4065d5f25d14e36b43ebc22fc75f7b951f24378bf0b5"}, + {file = "pyarrow-16.1.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:3b20bd67c94b3a2ea0a749d2a5712fc845a69cb5d52e78e6449bbd295611f3aa"}, + {file = "pyarrow-16.1.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:ba8ac20693c0bb0bf4b238751d4409e62852004a8cf031c73b0e0962b03e45e3"}, + {file = "pyarrow-16.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:31a1851751433d89a986616015841977e0a188662fcffd1a5677453f1df2de0a"}, + {file = "pyarrow-16.1.0.tar.gz", hash = "sha256:15fbb22ea96d11f0b5768504a3f961edab25eaf4197c341720c4a387f6c60315"}, +] + +[package.dependencies] +numpy = ">=1.16.6" + +[[package]] +name = "pycocoevalcap" +version = "1.2" +description = "MS-COCO Caption Evaluation for Python 3" +optional = false +python-versions = ">=3" +files = [ + {file = "pycocoevalcap-1.2-py3-none-any.whl", hash = "sha256:083ed7910f1aec000b0a237ef6665f74edf19954204d0b1cbdb8399ed132228d"}, + {file = "pycocoevalcap-1.2.tar.gz", hash = "sha256:7857f4d596ca2fa0b1a9a3c2067588a4257556077b7ad614d00b2b7b8f57cdde"}, +] + +[package.dependencies] +pycocotools = ">=2.0.2" + +[[package]] +name = "pycocotools" +version = "2.0.7" +description = "Official APIs for the MS-COCO dataset" +optional = false +python-versions = ">=3.5" +files = [ + {file = "pycocotools-2.0.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a6683a002fcb4500edbcec94bdf48be69f578a9aa5c638db38614df1f45cc935"}, + {file = "pycocotools-2.0.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d517ec315e53ef8df9f6b0899ebc4c79bd61fd715383861949bb1c3fca2c6d5"}, + {file = "pycocotools-2.0.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eb5d46900375adaba88eedb5cbc29d8cbcf43e82505d67378df1c3b720a8c5f"}, + {file = "pycocotools-2.0.7-cp310-cp310-win_amd64.whl", hash = "sha256:363a6be808125306ace1a163c0b9ba479ee08eceec1fbd3889a88bd8245f73dc"}, + {file = "pycocotools-2.0.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:623b941bbafecbfee574aedbf3cb257f7a879f4fdb79394e6d3fb9c76e7ad6cf"}, + {file = "pycocotools-2.0.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ac4f30bac1503c780072053e6922971392fa3628b2e6967192bfca1f14736e2"}, + {file = "pycocotools-2.0.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:121017ca87e2eec4e9081636d1a79519b50f473959defc5671c2d1ce0eec482e"}, + {file = "pycocotools-2.0.7-cp311-cp311-win_amd64.whl", hash = "sha256:4a8ec6f439638120e11f49120e1ddb6c66e0b1f293d7884207d02703a73d25a1"}, + {file = "pycocotools-2.0.7-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1a675728e459d72be6e3bb3546672bb37c7daffdc2e5335aa7b834aece2b560"}, + {file = "pycocotools-2.0.7-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6541340f26bae32e044eedc5d8ccdac5bd0cb64eb2b0a342dac859b696edd0aa"}, + {file = "pycocotools-2.0.7-cp37-cp37m-win_amd64.whl", hash = "sha256:8def3c46349e919999d6d5a1d6b7e587e6891524cc28f8b4a11e463bf0914621"}, + {file = "pycocotools-2.0.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6469089b9b36a1f645dc9ee830f29d261e99b4b3be73cb260688fd8b6d02760c"}, + {file = "pycocotools-2.0.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1dbc429018149dc34e206ea32ee6297ff30b55a8615a3f7f4c6e3842f9df73db"}, + {file = "pycocotools-2.0.7-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66864bec8b30d47faa946bb55c8e8d6b7acb9fba0c17ff6aaa37abd78cda962a"}, + {file = "pycocotools-2.0.7-cp38-cp38-win_amd64.whl", hash = "sha256:625388f52e543f6f798f75f1ec125fe519580f22e72ccbd75eee0355ce336e18"}, + {file = "pycocotools-2.0.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:73dc251ae4a06b7c10747ca7e2d29faabb4f13e5fc43760945966845581e79ae"}, + {file = "pycocotools-2.0.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e6f7bfa1c5fb206a614bf2382c923d56092219a12dfd0fec3b5f83c13e29e00"}, + {file = "pycocotools-2.0.7-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b29086b6ce7b73e4ddaf3045006f5c059f344a2720605cd4474814017ff2af53"}, + {file = "pycocotools-2.0.7-cp39-cp39-win_amd64.whl", hash = "sha256:254506c0eecabb3abbde17640f82103c0c04d53148ae920657664cab9cd649fc"}, + {file = "pycocotools-2.0.7.tar.gz", hash = "sha256:da8b7815196eebf0adabf67fcc459126cbc6498bbc6ab1fd144c371465d86879"}, +] + +[package.dependencies] +matplotlib = ">=2.1.0" +numpy = "*" + +[[package]] +name = "pycparser" +version = "2.22" +description = "C parser in Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + +[[package]] +name = "pydeck" +version = "0.9.1" +description = "Widget for deck.gl maps" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pydeck-0.9.1-py2.py3-none-any.whl", hash = "sha256:b3f75ba0d273fc917094fa61224f3f6076ca8752b93d46faf3bcfd9f9d59b038"}, + {file = "pydeck-0.9.1.tar.gz", hash = "sha256:f74475ae637951d63f2ee58326757f8d4f9cd9f2a457cf42950715003e2cb605"}, +] + +[package.dependencies] +jinja2 = ">=2.10.1" +numpy = ">=1.16.4" + +[package.extras] +carto = ["pydeck-carto"] +jupyter = ["ipykernel (>=5.1.2)", "ipython (>=5.8.0)", "ipywidgets (>=7,<8)", "traitlets (>=4.3.2)"] + +[[package]] +name = "pygments" +version = "2.18.0" +description = "Pygments is a syntax highlighting package written in Python." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"}, + {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"}, +] + +[package.extras] +windows-terminal = ["colorama (>=0.4.6)"] + +[[package]] +name = "pyparsing" +version = "3.1.2" +description = "pyparsing module - Classes and methods to define and execute parsing grammars" +optional = false +python-versions = ">=3.6.8" +files = [ + {file = "pyparsing-3.1.2-py3-none-any.whl", hash = "sha256:f9db75911801ed778fe61bb643079ff86601aca99fcae6345aa67292038fb742"}, + {file = "pyparsing-3.1.2.tar.gz", hash = "sha256:a1bac0ce561155ecc3ed78ca94d3c9378656ad4c94c1270de543f621420f94ad"}, +] + +[package.extras] +diagrams = ["jinja2", "railroad-diagrams"] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +description = "Extensions to the standard Python datetime module" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[package.dependencies] +six = ">=1.5" + +[[package]] +name = "pytorch-lightning" +version = "1.2.10" +description = "PyTorch Lightning is the lightweight PyTorch wrapper for ML researchers. Scale your models. Write less boilerplate." +optional = false +python-versions = ">=3.6" +files = [ + {file = "pytorch-lightning-1.2.10.tar.gz", hash = "sha256:2d8365e30ded0c20e73ce6e5b6028478ae460b8fd33727df2275666df005a301"}, + {file = "pytorch_lightning-1.2.10-py3-none-any.whl", hash = "sha256:52d05dda39e6ddd7ab6775c4ca8943e7881000acd9c9218c7e3c9feae43489b2"}, +] + +[package.dependencies] +fsspec = {version = ">=0.8.1", extras = ["http"]} +future = ">=0.17.1" +numpy = ">=1.16.6" +packaging = "*" +PyYAML = ">=5.1,<5.4.dev0 || >=5.5.dev0" +tensorboard = ">=2.2.0,<2.5.0 || >2.5.0" +torch = ">=1.4" +torchmetrics = "0.2.0" +tqdm = ">=4.41.0" + +[package.extras] +all = ["check-manifest", "cloudpickle (>=1.3)", "codecov (>=2.1)", "comet-ml (>=3.1.12)", "coverage (>=5.2)", "flake8 (>=3.6)", "gym (>=0.17.0)", "horovod (>=0.21.2)", "hydra-core (>=1.0)", "ipython[all]", "isort (>=5.6.4)", "matplotlib (>3.1)", "mlflow (>=1.0.0)", "mypy (>=0.720,<0.800)", "neptune-client (>=0.4.109)", "nltk (<3.6)", "omegaconf (>=2.0.1)", "onnxruntime (>=1.3.0)", "pandas", "pre-commit (>=1.0)", "pytest (>=6.0)", "scikit-image (>=0.17.2)", "scikit-learn (>=0.22.2)", "test-tube (>=0.7.5)", "torchtext (>=0.5)", "torchvision (>=0.5)", "twine (==3.2)", "wandb (>=0.8.21)"] +cpu = ["check-manifest", "cloudpickle (>=1.3)", "codecov (>=2.1)", "comet-ml (>=3.1.12)", "coverage (>=5.2)", "flake8 (>=3.6)", "gym (>=0.17.0)", "hydra-core (>=1.0)", "ipython[all]", "isort (>=5.6.4)", "matplotlib (>3.1)", "mlflow (>=1.0.0)", "mypy (>=0.720,<0.800)", "neptune-client (>=0.4.109)", "nltk (<3.6)", "omegaconf (>=2.0.1)", "onnxruntime (>=1.3.0)", "pandas", "pre-commit (>=1.0)", "pytest (>=6.0)", "scikit-image (>=0.17.2)", "scikit-learn (>=0.22.2)", "test-tube (>=0.7.5)", "torchtext (>=0.5)", "torchvision (>=0.5)", "twine (==3.2)", "wandb (>=0.8.21)"] +cpu-extra = ["hydra-core (>=1.0)", "matplotlib (>3.1)", "omegaconf (>=2.0.1)", "onnxruntime (>=1.3.0)", "torchtext (>=0.5)"] +dev = ["check-manifest", "cloudpickle (>=1.3)", "codecov (>=2.1)", "comet-ml (>=3.1.12)", "coverage (>=5.2)", "flake8 (>=3.6)", "horovod (>=0.21.2)", "hydra-core (>=1.0)", "isort (>=5.6.4)", "matplotlib (>3.1)", "mlflow (>=1.0.0)", "mypy (>=0.720,<0.800)", "neptune-client (>=0.4.109)", "nltk (<3.6)", "omegaconf (>=2.0.1)", "onnxruntime (>=1.3.0)", "pandas", "pre-commit (>=1.0)", "pytest (>=6.0)", "scikit-image (>=0.17.2)", "scikit-learn (>=0.22.2)", "test-tube (>=0.7.5)", "torchtext (>=0.5)", "twine (==3.2)", "wandb (>=0.8.21)"] +examples = ["gym (>=0.17.0)", "ipython[all]", "torchvision (>=0.5)"] +extra = ["horovod (>=0.21.2)", "hydra-core (>=1.0)", "matplotlib (>3.1)", "omegaconf (>=2.0.1)", "onnxruntime (>=1.3.0)", "torchtext (>=0.5)"] +loggers = ["comet-ml (>=3.1.12)", "mlflow (>=1.0.0)", "neptune-client (>=0.4.109)", "test-tube (>=0.7.5)", "wandb (>=0.8.21)"] +test = ["check-manifest", "cloudpickle (>=1.3)", "codecov (>=2.1)", "coverage (>=5.2)", "flake8 (>=3.6)", "isort (>=5.6.4)", "mypy (>=0.720,<0.800)", "nltk (<3.6)", "pandas", "pre-commit (>=1.0)", "pytest (>=6.0)", "scikit-image (>=0.17.2)", "scikit-learn (>=0.22.2)", "twine (==3.2)"] + +[[package]] +name = "pytorch-nlp" +version = "0.5.0" +description = "Text utilities and datasets for PyTorch" +optional = false +python-versions = ">=3.5" +files = [ + {file = "pytorch-nlp-0.5.0.tar.gz", hash = "sha256:aba7aecbc6f0952edde8bc067394c8d43b74a35c5949d6106666d01a64d9cfab"}, + {file = "pytorch_nlp-0.5.0-py3-none-any.whl", hash = "sha256:ddce6448819d1518d2694622573caff268a20c19832f55f7f5b672e2a64a400f"}, +] + +[package.dependencies] +numpy = "*" +tqdm = "*" + +[[package]] +name = "pytz" +version = "2024.1" +description = "World timezone definitions, modern and historical" +optional = false +python-versions = "*" +files = [ + {file = "pytz-2024.1-py2.py3-none-any.whl", hash = "sha256:328171f4e3623139da4983451950b28e95ac706e13f3f2630a879749e7a8b319"}, + {file = "pytz-2024.1.tar.gz", hash = "sha256:2a29735ea9c18baf14b448846bde5a48030ed267578472d8955cd0e7443a9812"}, +] + +[[package]] +name = "pywin32" +version = "306" +description = "Python for Window Extensions" +optional = false +python-versions = "*" +files = [ + {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"}, + {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"}, + {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"}, + {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"}, + {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"}, + {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"}, + {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"}, + {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"}, + {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"}, + {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"}, + {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"}, + {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"}, + {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"}, + {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"}, +] + +[[package]] +name = "pyyaml" +version = "5.3.1" +description = "YAML parser and emitter for Python" +optional = false +python-versions = "*" +files = [ + {file = "PyYAML-5.3.1-cp27-cp27m-win32.whl", hash = "sha256:74809a57b329d6cc0fdccee6318f44b9b8649961fa73144a98735b0aaf029f1f"}, + {file = "PyYAML-5.3.1-cp27-cp27m-win_amd64.whl", hash = "sha256:240097ff019d7c70a4922b6869d8a86407758333f02203e0fc6ff79c5dcede76"}, + {file = "PyYAML-5.3.1-cp35-cp35m-win32.whl", hash = "sha256:4f4b913ca1a7319b33cfb1369e91e50354d6f07a135f3b901aca02aa95940bd2"}, + {file = "PyYAML-5.3.1-cp35-cp35m-win_amd64.whl", hash = "sha256:cc8955cfbfc7a115fa81d85284ee61147059a753344bc51098f3ccd69b0d7e0c"}, + {file = "PyYAML-5.3.1-cp36-cp36m-win32.whl", hash = "sha256:7739fc0fa8205b3ee8808aea45e968bc90082c10aef6ea95e855e10abf4a37b2"}, + {file = "PyYAML-5.3.1-cp36-cp36m-win_amd64.whl", hash = "sha256:69f00dca373f240f842b2931fb2c7e14ddbacd1397d57157a9b005a6a9942648"}, + {file = "PyYAML-5.3.1-cp37-cp37m-win32.whl", hash = "sha256:d13155f591e6fcc1ec3b30685d50bf0711574e2c0dfffd7644babf8b5102ca1a"}, + {file = "PyYAML-5.3.1-cp37-cp37m-win_amd64.whl", hash = "sha256:73f099454b799e05e5ab51423c7bcf361c58d3206fa7b0d555426b1f4d9a3eaf"}, + {file = "PyYAML-5.3.1-cp38-cp38-win32.whl", hash = "sha256:06a0d7ba600ce0b2d2fe2e78453a470b5a6e000a985dd4a4e54e436cc36b0e97"}, + {file = "PyYAML-5.3.1-cp38-cp38-win_amd64.whl", hash = "sha256:95f71d2af0ff4227885f7a6605c37fd53d3a106fcab511b8860ecca9fcf400ee"}, + {file = "PyYAML-5.3.1-cp39-cp39-win32.whl", hash = "sha256:ad9c67312c84def58f3c04504727ca879cb0013b2517c85a9a253f0cb6380c0a"}, + {file = "PyYAML-5.3.1-cp39-cp39-win_amd64.whl", hash = "sha256:6034f55dab5fea9e53f436aa68fa3ace2634918e8b5994d82f3621c04ff5ed2e"}, + {file = "PyYAML-5.3.1.tar.gz", hash = "sha256:b8eac752c5e14d3eca0e6dd9199cd627518cb5ec06add0de9d32baeee6fe645d"}, +] + +[[package]] +name = "referencing" +version = "0.35.1" +description = "JSON Referencing + Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de"}, + {file = "referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +rpds-py = ">=0.7.0" + +[[package]] +name = "regex" +version = "2023.12.25" +description = "Alternative regular expression module, to replace re." +optional = false +python-versions = ">=3.7" +files = [ + {file = "regex-2023.12.25-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0694219a1d54336fd0445ea382d49d36882415c0134ee1e8332afd1529f0baa5"}, + {file = "regex-2023.12.25-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b014333bd0217ad3d54c143de9d4b9a3ca1c5a29a6d0d554952ea071cff0f1f8"}, + {file = "regex-2023.12.25-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d865984b3f71f6d0af64d0d88f5733521698f6c16f445bb09ce746c92c97c586"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e0eabac536b4cc7f57a5f3d095bfa557860ab912f25965e08fe1545e2ed8b4c"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c25a8ad70e716f96e13a637802813f65d8a6760ef48672aa3502f4c24ea8b400"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a9b6d73353f777630626f403b0652055ebfe8ff142a44ec2cf18ae470395766e"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9cc99d6946d750eb75827cb53c4371b8b0fe89c733a94b1573c9dd16ea6c9e4"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88d1f7bef20c721359d8675f7d9f8e414ec5003d8f642fdfd8087777ff7f94b5"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:cb3fe77aec8f1995611f966d0c656fdce398317f850d0e6e7aebdfe61f40e1cd"}, + {file = "regex-2023.12.25-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7aa47c2e9ea33a4a2a05f40fcd3ea36d73853a2aae7b4feab6fc85f8bf2c9704"}, + {file = "regex-2023.12.25-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:df26481f0c7a3f8739fecb3e81bc9da3fcfae34d6c094563b9d4670b047312e1"}, + {file = "regex-2023.12.25-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:c40281f7d70baf6e0db0c2f7472b31609f5bc2748fe7275ea65a0b4601d9b392"}, + {file = "regex-2023.12.25-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:d94a1db462d5690ebf6ae86d11c5e420042b9898af5dcf278bd97d6bda065423"}, + {file = "regex-2023.12.25-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ba1b30765a55acf15dce3f364e4928b80858fa8f979ad41f862358939bdd1f2f"}, + {file = "regex-2023.12.25-cp310-cp310-win32.whl", hash = "sha256:150c39f5b964e4d7dba46a7962a088fbc91f06e606f023ce57bb347a3b2d4630"}, + {file = "regex-2023.12.25-cp310-cp310-win_amd64.whl", hash = "sha256:09da66917262d9481c719599116c7dc0c321ffcec4b1f510c4f8a066f8768105"}, + {file = "regex-2023.12.25-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1b9d811f72210fa9306aeb88385b8f8bcef0dfbf3873410413c00aa94c56c2b6"}, + {file = "regex-2023.12.25-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d902a43085a308cef32c0d3aea962524b725403fd9373dea18110904003bac97"}, + {file = "regex-2023.12.25-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d166eafc19f4718df38887b2bbe1467a4f74a9830e8605089ea7a30dd4da8887"}, + {file = "regex-2023.12.25-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c7ad32824b7f02bb3c9f80306d405a1d9b7bb89362d68b3c5a9be53836caebdb"}, + {file = "regex-2023.12.25-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:636ba0a77de609d6510235b7f0e77ec494d2657108f777e8765efc060094c98c"}, + {file = "regex-2023.12.25-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fda75704357805eb953a3ee15a2b240694a9a514548cd49b3c5124b4e2ad01b"}, + {file = "regex-2023.12.25-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f72cbae7f6b01591f90814250e636065850c5926751af02bb48da94dfced7baa"}, + {file = "regex-2023.12.25-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:db2a0b1857f18b11e3b0e54ddfefc96af46b0896fb678c85f63fb8c37518b3e7"}, + {file = "regex-2023.12.25-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:7502534e55c7c36c0978c91ba6f61703faf7ce733715ca48f499d3dbbd7657e0"}, + {file = "regex-2023.12.25-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:e8c7e08bb566de4faaf11984af13f6bcf6a08f327b13631d41d62592681d24fe"}, + {file = "regex-2023.12.25-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:283fc8eed679758de38fe493b7d7d84a198b558942b03f017b1f94dda8efae80"}, + {file = "regex-2023.12.25-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:f44dd4d68697559d007462b0a3a1d9acd61d97072b71f6d1968daef26bc744bd"}, + {file = "regex-2023.12.25-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:67d3ccfc590e5e7197750fcb3a2915b416a53e2de847a728cfa60141054123d4"}, + {file = "regex-2023.12.25-cp311-cp311-win32.whl", hash = "sha256:68191f80a9bad283432385961d9efe09d783bcd36ed35a60fb1ff3f1ec2efe87"}, + {file = "regex-2023.12.25-cp311-cp311-win_amd64.whl", hash = "sha256:7d2af3f6b8419661a0c421584cfe8aaec1c0e435ce7e47ee2a97e344b98f794f"}, + {file = "regex-2023.12.25-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8a0ccf52bb37d1a700375a6b395bff5dd15c50acb745f7db30415bae3c2b0715"}, + {file = "regex-2023.12.25-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c3c4a78615b7762740531c27cf46e2f388d8d727d0c0c739e72048beb26c8a9d"}, + {file = "regex-2023.12.25-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ad83e7545b4ab69216cef4cc47e344d19622e28aabec61574b20257c65466d6a"}, + {file = "regex-2023.12.25-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b7a635871143661feccce3979e1727c4e094f2bdfd3ec4b90dfd4f16f571a87a"}, + {file = "regex-2023.12.25-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d498eea3f581fbe1b34b59c697512a8baef88212f92e4c7830fcc1499f5b45a5"}, + {file = "regex-2023.12.25-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:43f7cd5754d02a56ae4ebb91b33461dc67be8e3e0153f593c509e21d219c5060"}, + {file = "regex-2023.12.25-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51f4b32f793812714fd5307222a7f77e739b9bc566dc94a18126aba3b92b98a3"}, + {file = "regex-2023.12.25-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ba99d8077424501b9616b43a2d208095746fb1284fc5ba490139651f971d39d9"}, + {file = "regex-2023.12.25-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:4bfc2b16e3ba8850e0e262467275dd4d62f0d045e0e9eda2bc65078c0110a11f"}, + {file = "regex-2023.12.25-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8c2c19dae8a3eb0ea45a8448356ed561be843b13cbc34b840922ddf565498c1c"}, + {file = "regex-2023.12.25-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:60080bb3d8617d96f0fb7e19796384cc2467447ef1c491694850ebd3670bc457"}, + {file = "regex-2023.12.25-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b77e27b79448e34c2c51c09836033056a0547aa360c45eeeb67803da7b0eedaf"}, + {file = "regex-2023.12.25-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:518440c991f514331f4850a63560321f833979d145d7d81186dbe2f19e27ae3d"}, + {file = "regex-2023.12.25-cp312-cp312-win32.whl", hash = "sha256:e2610e9406d3b0073636a3a2e80db05a02f0c3169b5632022b4e81c0364bcda5"}, + {file = "regex-2023.12.25-cp312-cp312-win_amd64.whl", hash = "sha256:cc37b9aeebab425f11f27e5e9e6cf580be7206c6582a64467a14dda211abc232"}, + {file = "regex-2023.12.25-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:da695d75ac97cb1cd725adac136d25ca687da4536154cdc2815f576e4da11c69"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d126361607b33c4eb7b36debc173bf25d7805847346dd4d99b5499e1fef52bc7"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4719bb05094d7d8563a450cf8738d2e1061420f79cfcc1fa7f0a44744c4d8f73"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5dd58946bce44b53b06d94aa95560d0b243eb2fe64227cba50017a8d8b3cd3e2"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22a86d9fff2009302c440b9d799ef2fe322416d2d58fc124b926aa89365ec482"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2aae8101919e8aa05ecfe6322b278f41ce2994c4a430303c4cd163fef746e04f"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e692296c4cc2873967771345a876bcfc1c547e8dd695c6b89342488b0ea55cd8"}, + {file = "regex-2023.12.25-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:263ef5cc10979837f243950637fffb06e8daed7f1ac1e39d5910fd29929e489a"}, + {file = "regex-2023.12.25-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:d6f7e255e5fa94642a0724e35406e6cb7001c09d476ab5fce002f652b36d0c39"}, + {file = "regex-2023.12.25-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:88ad44e220e22b63b0f8f81f007e8abbb92874d8ced66f32571ef8beb0643b2b"}, + {file = "regex-2023.12.25-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:3a17d3ede18f9cedcbe23d2daa8a2cd6f59fe2bf082c567e43083bba3fb00347"}, + {file = "regex-2023.12.25-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:d15b274f9e15b1a0b7a45d2ac86d1f634d983ca40d6b886721626c47a400bf39"}, + {file = "regex-2023.12.25-cp37-cp37m-win32.whl", hash = "sha256:ed19b3a05ae0c97dd8f75a5d8f21f7723a8c33bbc555da6bbe1f96c470139d3c"}, + {file = "regex-2023.12.25-cp37-cp37m-win_amd64.whl", hash = "sha256:a6d1047952c0b8104a1d371f88f4ab62e6275567d4458c1e26e9627ad489b445"}, + {file = "regex-2023.12.25-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:b43523d7bc2abd757119dbfb38af91b5735eea45537ec6ec3a5ec3f9562a1c53"}, + {file = "regex-2023.12.25-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:efb2d82f33b2212898f1659fb1c2e9ac30493ac41e4d53123da374c3b5541e64"}, + {file = "regex-2023.12.25-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b7fca9205b59c1a3d5031f7e64ed627a1074730a51c2a80e97653e3e9fa0d415"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:086dd15e9435b393ae06f96ab69ab2d333f5d65cbe65ca5a3ef0ec9564dfe770"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e81469f7d01efed9b53740aedd26085f20d49da65f9c1f41e822a33992cb1590"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:34e4af5b27232f68042aa40a91c3b9bb4da0eeb31b7632e0091afc4310afe6cb"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9852b76ab558e45b20bf1893b59af64a28bd3820b0c2efc80e0a70a4a3ea51c1"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ff100b203092af77d1a5a7abe085b3506b7eaaf9abf65b73b7d6905b6cb76988"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:cc038b2d8b1470364b1888a98fd22d616fba2b6309c5b5f181ad4483e0017861"}, + {file = "regex-2023.12.25-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:094ba386bb5c01e54e14434d4caabf6583334090865b23ef58e0424a6286d3dc"}, + {file = "regex-2023.12.25-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:5cd05d0f57846d8ba4b71d9c00f6f37d6b97d5e5ef8b3c3840426a475c8f70f4"}, + {file = "regex-2023.12.25-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:9aa1a67bbf0f957bbe096375887b2505f5d8ae16bf04488e8b0f334c36e31360"}, + {file = "regex-2023.12.25-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:98a2636994f943b871786c9e82bfe7883ecdaba2ef5df54e1450fa9869d1f756"}, + {file = "regex-2023.12.25-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:37f8e93a81fc5e5bd8db7e10e62dc64261bcd88f8d7e6640aaebe9bc180d9ce2"}, + {file = "regex-2023.12.25-cp38-cp38-win32.whl", hash = "sha256:d78bd484930c1da2b9679290a41cdb25cc127d783768a0369d6b449e72f88beb"}, + {file = "regex-2023.12.25-cp38-cp38-win_amd64.whl", hash = "sha256:b521dcecebc5b978b447f0f69b5b7f3840eac454862270406a39837ffae4e697"}, + {file = "regex-2023.12.25-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:f7bc09bc9c29ebead055bcba136a67378f03d66bf359e87d0f7c759d6d4ffa31"}, + {file = "regex-2023.12.25-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e14b73607d6231f3cc4622809c196b540a6a44e903bcfad940779c80dffa7be7"}, + {file = "regex-2023.12.25-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9eda5f7a50141291beda3edd00abc2d4a5b16c29c92daf8d5bd76934150f3edc"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc6bb9aa69aacf0f6032c307da718f61a40cf970849e471254e0e91c56ffca95"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:298dc6354d414bc921581be85695d18912bea163a8b23cac9a2562bbcd5088b1"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2f4e475a80ecbd15896a976aa0b386c5525d0ed34d5c600b6d3ebac0a67c7ddf"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:531ac6cf22b53e0696f8e1d56ce2396311254eb806111ddd3922c9d937151dae"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:22f3470f7524b6da61e2020672df2f3063676aff444db1daa283c2ea4ed259d6"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:89723d2112697feaa320c9d351e5f5e7b841e83f8b143dba8e2d2b5f04e10923"}, + {file = "regex-2023.12.25-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0ecf44ddf9171cd7566ef1768047f6e66975788258b1c6c6ca78098b95cf9a3d"}, + {file = "regex-2023.12.25-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:905466ad1702ed4acfd67a902af50b8db1feeb9781436372261808df7a2a7bca"}, + {file = "regex-2023.12.25-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:4558410b7a5607a645e9804a3e9dd509af12fb72b9825b13791a37cd417d73a5"}, + {file = "regex-2023.12.25-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:7e316026cc1095f2a3e8cc012822c99f413b702eaa2ca5408a513609488cb62f"}, + {file = "regex-2023.12.25-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3b1de218d5375cd6ac4b5493e0b9f3df2be331e86520f23382f216c137913d20"}, + {file = "regex-2023.12.25-cp39-cp39-win32.whl", hash = "sha256:11a963f8e25ab5c61348d090bf1b07f1953929c13bd2309a0662e9ff680763c9"}, + {file = "regex-2023.12.25-cp39-cp39-win_amd64.whl", hash = "sha256:e693e233ac92ba83a87024e1d32b5f9ab15ca55ddd916d878146f4e3406b5c91"}, + {file = "regex-2023.12.25.tar.gz", hash = "sha256:29171aa128da69afdf4bde412d5bedc335f2ca8fcfe4489038577d05f16181e5"}, +] + +[[package]] +name = "requests" +version = "2.32.3" +description = "Python HTTP for Humans." +optional = false +python-versions = ">=3.8" +files = [ + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, +] + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + +[[package]] +name = "rich" +version = "13.7.1" +description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "rich-13.7.1-py3-none-any.whl", hash = "sha256:4edbae314f59eb482f54e9e30bf00d33350aaa94f4bfcd4e9e3110e64d0d7222"}, + {file = "rich-13.7.1.tar.gz", hash = "sha256:9be308cb1fe2f1f57d67ce99e95af38a1e2bc71ad9813b0e247cf7ffbcc3a432"}, +] + +[package.dependencies] +markdown-it-py = ">=2.2.0" +pygments = ">=2.13.0,<3.0.0" + +[package.extras] +jupyter = ["ipywidgets (>=7.5.1,<9)"] + +[[package]] +name = "rpds-py" +version = "0.18.1" +description = "Python bindings to Rust's persistent data structures (rpds)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "rpds_py-0.18.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:d31dea506d718693b6b2cffc0648a8929bdc51c70a311b2770f09611caa10d53"}, + {file = "rpds_py-0.18.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:732672fbc449bab754e0b15356c077cc31566df874964d4801ab14f71951ea80"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a98a1f0552b5f227a3d6422dbd61bc6f30db170939bd87ed14f3c339aa6c7c9"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7f1944ce16401aad1e3f7d312247b3d5de7981f634dc9dfe90da72b87d37887d"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:38e14fb4e370885c4ecd734f093a2225ee52dc384b86fa55fe3f74638b2cfb09"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08d74b184f9ab6289b87b19fe6a6d1a97fbfea84b8a3e745e87a5de3029bf944"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d70129cef4a8d979caa37e7fe957202e7eee8ea02c5e16455bc9808a59c6b2f0"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ce0bb20e3a11bd04461324a6a798af34d503f8d6f1aa3d2aa8901ceaf039176d"}, + {file = "rpds_py-0.18.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:81c5196a790032e0fc2464c0b4ab95f8610f96f1f2fa3d4deacce6a79852da60"}, + {file = "rpds_py-0.18.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:f3027be483868c99b4985fda802a57a67fdf30c5d9a50338d9db646d590198da"}, + {file = "rpds_py-0.18.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d44607f98caa2961bab4fa3c4309724b185b464cdc3ba6f3d7340bac3ec97cc1"}, + {file = "rpds_py-0.18.1-cp310-none-win32.whl", hash = "sha256:c273e795e7a0f1fddd46e1e3cb8be15634c29ae8ff31c196debb620e1edb9333"}, + {file = "rpds_py-0.18.1-cp310-none-win_amd64.whl", hash = "sha256:8352f48d511de5f973e4f2f9412736d7dea76c69faa6d36bcf885b50c758ab9a"}, + {file = "rpds_py-0.18.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6b5ff7e1d63a8281654b5e2896d7f08799378e594f09cf3674e832ecaf396ce8"}, + {file = "rpds_py-0.18.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8927638a4d4137a289e41d0fd631551e89fa346d6dbcfc31ad627557d03ceb6d"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:154bf5c93d79558b44e5b50cc354aa0459e518e83677791e6adb0b039b7aa6a7"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07f2139741e5deb2c5154a7b9629bc5aa48c766b643c1a6750d16f865a82c5fc"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8c7672e9fba7425f79019db9945b16e308ed8bc89348c23d955c8c0540da0a07"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:489bdfe1abd0406eba6b3bb4fdc87c7fa40f1031de073d0cfb744634cc8fa261"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c20f05e8e3d4fc76875fc9cb8cf24b90a63f5a1b4c5b9273f0e8225e169b100"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:967342e045564cef76dfcf1edb700b1e20838d83b1aa02ab313e6a497cf923b8"}, + {file = "rpds_py-0.18.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2cc7c1a47f3a63282ab0f422d90ddac4aa3034e39fc66a559ab93041e6505da7"}, + {file = "rpds_py-0.18.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f7afbfee1157e0f9376c00bb232e80a60e59ed716e3211a80cb8506550671e6e"}, + {file = "rpds_py-0.18.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9e6934d70dc50f9f8ea47081ceafdec09245fd9f6032669c3b45705dea096b88"}, + {file = "rpds_py-0.18.1-cp311-none-win32.whl", hash = "sha256:c69882964516dc143083d3795cb508e806b09fc3800fd0d4cddc1df6c36e76bb"}, + {file = "rpds_py-0.18.1-cp311-none-win_amd64.whl", hash = "sha256:70a838f7754483bcdc830444952fd89645569e7452e3226de4a613a4c1793fb2"}, + {file = "rpds_py-0.18.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3dd3cd86e1db5aadd334e011eba4e29d37a104b403e8ca24dcd6703c68ca55b3"}, + {file = "rpds_py-0.18.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:05f3d615099bd9b13ecf2fc9cf2d839ad3f20239c678f461c753e93755d629ee"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35b2b771b13eee8729a5049c976197ff58a27a3829c018a04341bcf1ae409b2b"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ee17cd26b97d537af8f33635ef38be873073d516fd425e80559f4585a7b90c43"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b646bf655b135ccf4522ed43d6902af37d3f5dbcf0da66c769a2b3938b9d8184"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:19ba472b9606c36716062c023afa2484d1e4220548751bda14f725a7de17b4f6"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e30ac5e329098903262dc5bdd7e2086e0256aa762cc8b744f9e7bf2a427d3f8"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d58ad6317d188c43750cb76e9deacf6051d0f884d87dc6518e0280438648a9ac"}, + {file = "rpds_py-0.18.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e1735502458621921cee039c47318cb90b51d532c2766593be6207eec53e5c4c"}, + {file = "rpds_py-0.18.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:f5bab211605d91db0e2995a17b5c6ee5edec1270e46223e513eaa20da20076ac"}, + {file = "rpds_py-0.18.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2fc24a329a717f9e2448f8cd1f960f9dac4e45b6224d60734edeb67499bab03a"}, + {file = "rpds_py-0.18.1-cp312-none-win32.whl", hash = "sha256:1805d5901779662d599d0e2e4159d8a82c0b05faa86ef9222bf974572286b2b6"}, + {file = "rpds_py-0.18.1-cp312-none-win_amd64.whl", hash = "sha256:720edcb916df872d80f80a1cc5ea9058300b97721efda8651efcd938a9c70a72"}, + {file = "rpds_py-0.18.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:c827576e2fa017a081346dce87d532a5310241648eb3700af9a571a6e9fc7e74"}, + {file = "rpds_py-0.18.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:aa3679e751408d75a0b4d8d26d6647b6d9326f5e35c00a7ccd82b78ef64f65f8"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0abeee75434e2ee2d142d650d1e54ac1f8b01e6e6abdde8ffd6eeac6e9c38e20"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed402d6153c5d519a0faf1bb69898e97fb31613b49da27a84a13935ea9164dfc"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:338dee44b0cef8b70fd2ef54b4e09bb1b97fc6c3a58fea5db6cc083fd9fc2724"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7750569d9526199c5b97e5a9f8d96a13300950d910cf04a861d96f4273d5b104"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:607345bd5912aacc0c5a63d45a1f73fef29e697884f7e861094e443187c02be5"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:207c82978115baa1fd8d706d720b4a4d2b0913df1c78c85ba73fe6c5804505f0"}, + {file = "rpds_py-0.18.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:6d1e42d2735d437e7e80bab4d78eb2e459af48c0a46e686ea35f690b93db792d"}, + {file = "rpds_py-0.18.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:5463c47c08630007dc0fe99fb480ea4f34a89712410592380425a9b4e1611d8e"}, + {file = "rpds_py-0.18.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:06d218939e1bf2ca50e6b0ec700ffe755e5216a8230ab3e87c059ebb4ea06afc"}, + {file = "rpds_py-0.18.1-cp38-none-win32.whl", hash = "sha256:312fe69b4fe1ffbe76520a7676b1e5ac06ddf7826d764cc10265c3b53f96dbe9"}, + {file = "rpds_py-0.18.1-cp38-none-win_amd64.whl", hash = "sha256:9437ca26784120a279f3137ee080b0e717012c42921eb07861b412340f85bae2"}, + {file = "rpds_py-0.18.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:19e515b78c3fc1039dd7da0a33c28c3154458f947f4dc198d3c72db2b6b5dc93"}, + {file = "rpds_py-0.18.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a7b28c5b066bca9a4eb4e2f2663012debe680f097979d880657f00e1c30875a0"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:673fdbbf668dd958eff750e500495ef3f611e2ecc209464f661bc82e9838991e"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d960de62227635d2e61068f42a6cb6aae91a7fe00fca0e3aeed17667c8a34611"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:352a88dc7892f1da66b6027af06a2e7e5d53fe05924cc2cfc56495b586a10b72"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e0ee01ad8260184db21468a6e1c37afa0529acc12c3a697ee498d3c2c4dcaf3"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4c39ad2f512b4041343ea3c7894339e4ca7839ac38ca83d68a832fc8b3748ab"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:aaa71ee43a703c321906813bb252f69524f02aa05bf4eec85f0c41d5d62d0f4c"}, + {file = "rpds_py-0.18.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:6cd8098517c64a85e790657e7b1e509b9fe07487fd358e19431cb120f7d96338"}, + {file = "rpds_py-0.18.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:4adec039b8e2928983f885c53b7cc4cda8965b62b6596501a0308d2703f8af1b"}, + {file = "rpds_py-0.18.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:32b7daaa3e9389db3695964ce8e566e3413b0c43e3394c05e4b243a4cd7bef26"}, + {file = "rpds_py-0.18.1-cp39-none-win32.whl", hash = "sha256:2625f03b105328729f9450c8badda34d5243231eef6535f80064d57035738360"}, + {file = "rpds_py-0.18.1-cp39-none-win_amd64.whl", hash = "sha256:bf18932d0003c8c4d51a39f244231986ab23ee057d235a12b2684ea26a353590"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:cbfbea39ba64f5e53ae2915de36f130588bba71245b418060ec3330ebf85678e"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:a3d456ff2a6a4d2adcdf3c1c960a36f4fd2fec6e3b4902a42a384d17cf4e7a65"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7700936ef9d006b7ef605dc53aa364da2de5a3aa65516a1f3ce73bf82ecfc7ae"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:51584acc5916212e1bf45edd17f3a6b05fe0cbb40482d25e619f824dccb679de"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:942695a206a58d2575033ff1e42b12b2aece98d6003c6bc739fbf33d1773b12f"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b906b5f58892813e5ba5c6056d6a5ad08f358ba49f046d910ad992196ea61397"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6f8e3fecca256fefc91bb6765a693d96692459d7d4c644660a9fff32e517843"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7732770412bab81c5a9f6d20aeb60ae943a9b36dcd990d876a773526468e7163"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:bd1105b50ede37461c1d51b9698c4f4be6e13e69a908ab7751e3807985fc0346"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:618916f5535784960f3ecf8111581f4ad31d347c3de66d02e728de460a46303c"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:17c6d2155e2423f7e79e3bb18151c686d40db42d8645e7977442170c360194d4"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:6c4c4c3f878df21faf5fac86eda32671c27889e13570645a9eea0a1abdd50922"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:fab6ce90574645a0d6c58890e9bcaac8d94dff54fb51c69e5522a7358b80ab64"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:531796fb842b53f2695e94dc338929e9f9dbf473b64710c28af5a160b2a8927d"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:740884bc62a5e2bbb31e584f5d23b32320fd75d79f916f15a788d527a5e83644"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:998125738de0158f088aef3cb264a34251908dd2e5d9966774fdab7402edfab7"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e2be6e9dd4111d5b31ba3b74d17da54a8319d8168890fbaea4b9e5c3de630ae5"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0cee71bc618cd93716f3c1bf56653740d2d13ddbd47673efa8bf41435a60daa"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2c3caec4ec5cd1d18e5dd6ae5194d24ed12785212a90b37f5f7f06b8bedd7139"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:27bba383e8c5231cd559affe169ca0b96ec78d39909ffd817f28b166d7ddd4d8"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:a888e8bdb45916234b99da2d859566f1e8a1d2275a801bb8e4a9644e3c7e7909"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:6031b25fb1b06327b43d841f33842b383beba399884f8228a6bb3df3088485ff"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:48c2faaa8adfacefcbfdb5f2e2e7bdad081e5ace8d182e5f4ade971f128e6bb3"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:d85164315bd68c0806768dc6bb0429c6f95c354f87485ee3593c4f6b14def2bd"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6afd80f6c79893cfc0574956f78a0add8c76e3696f2d6a15bca2c66c415cf2d4"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa242ac1ff583e4ec7771141606aafc92b361cd90a05c30d93e343a0c2d82a89"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d21be4770ff4e08698e1e8e0bce06edb6ea0626e7c8f560bc08222880aca6a6f"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c45a639e93a0c5d4b788b2613bd637468edd62f8f95ebc6fcc303d58ab3f0a8"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:910e71711d1055b2768181efa0a17537b2622afeb0424116619817007f8a2b10"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b9bb1f182a97880f6078283b3505a707057c42bf55d8fca604f70dedfdc0772a"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:1d54f74f40b1f7aaa595a02ff42ef38ca654b1469bef7d52867da474243cc633"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:8d2e182c9ee01135e11e9676e9a62dfad791a7a467738f06726872374a83db49"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:636a15acc588f70fda1661234761f9ed9ad79ebed3f2125d44be0862708b666e"}, + {file = "rpds_py-0.18.1.tar.gz", hash = "sha256:dc48b479d540770c811fbd1eb9ba2bb66951863e448efec2e2c102625328e92f"}, +] + +[[package]] +name = "sacrebleu" +version = "2.4.2" +description = "Hassle-free computation of shareable, comparable, and reproducible BLEU, chrF, and TER scores" +optional = false +python-versions = ">=3.6" +files = [ + {file = "sacrebleu-2.4.2-py3-none-any.whl", hash = "sha256:611a581d205828912f0b05f806b110180087184d3be2dc650fda7a729d6ecb89"}, +] + +[package.dependencies] +colorama = "*" +lxml = "*" +numpy = ">=1.17" +portalocker = "*" +regex = "*" +tabulate = ">=0.8.9" + +[package.extras] +dev = ["lxml-stubs", "mypy", "pytest", "types-tabulate", "wheel"] +ja = ["ipadic (>=1.0,<2.0)", "mecab-python3 (>=1.0.5,<=1.0.6)"] +ko = ["mecab-ko (>=1.0.0,<=1.0.1)", "mecab-ko-dic (>=1.0,<2.0)"] + +[[package]] +name = "safetensors" +version = "0.4.3" +description = "" +optional = false +python-versions = ">=3.7" +files = [ + {file = "safetensors-0.4.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:dcf5705cab159ce0130cd56057f5f3425023c407e170bca60b4868048bae64fd"}, + {file = "safetensors-0.4.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:bb4f8c5d0358a31e9a08daeebb68f5e161cdd4018855426d3f0c23bb51087055"}, + {file = "safetensors-0.4.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:70a5319ef409e7f88686a46607cbc3c428271069d8b770076feaf913664a07ac"}, + {file = "safetensors-0.4.3-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fb9c65bd82f9ef3ce4970dc19ee86be5f6f93d032159acf35e663c6bea02b237"}, + {file = "safetensors-0.4.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:edb5698a7bc282089f64c96c477846950358a46ede85a1c040e0230344fdde10"}, + {file = "safetensors-0.4.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:efcc860be094b8d19ac61b452ec635c7acb9afa77beb218b1d7784c6d41fe8ad"}, + {file = "safetensors-0.4.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d88b33980222085dd6001ae2cad87c6068e0991d4f5ccf44975d216db3b57376"}, + {file = "safetensors-0.4.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5fc6775529fb9f0ce2266edd3e5d3f10aab068e49f765e11f6f2a63b5367021d"}, + {file = "safetensors-0.4.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9c6ad011c1b4e3acff058d6b090f1da8e55a332fbf84695cf3100c649cc452d1"}, + {file = "safetensors-0.4.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8c496c5401c1b9c46d41a7688e8ff5b0310a3b9bae31ce0f0ae870e1ea2b8caf"}, + {file = "safetensors-0.4.3-cp310-none-win32.whl", hash = "sha256:38e2a8666178224a51cca61d3cb4c88704f696eac8f72a49a598a93bbd8a4af9"}, + {file = "safetensors-0.4.3-cp310-none-win_amd64.whl", hash = "sha256:393e6e391467d1b2b829c77e47d726f3b9b93630e6a045b1d1fca67dc78bf632"}, + {file = "safetensors-0.4.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:22f3b5d65e440cec0de8edaa672efa888030802e11c09b3d6203bff60ebff05a"}, + {file = "safetensors-0.4.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c4fa560ebd4522adddb71dcd25d09bf211b5634003f015a4b815b7647d62ebe"}, + {file = "safetensors-0.4.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e9afd5358719f1b2cf425fad638fc3c887997d6782da317096877e5b15b2ce93"}, + {file = "safetensors-0.4.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d8c5093206ef4b198600ae484230402af6713dab1bd5b8e231905d754022bec7"}, + {file = "safetensors-0.4.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e0b2104df1579d6ba9052c0ae0e3137c9698b2d85b0645507e6fd1813b70931a"}, + {file = "safetensors-0.4.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8cf18888606dad030455d18f6c381720e57fc6a4170ee1966adb7ebc98d4d6a3"}, + {file = "safetensors-0.4.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0bf4f9d6323d9f86eef5567eabd88f070691cf031d4c0df27a40d3b4aaee755b"}, + {file = "safetensors-0.4.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:585c9ae13a205807b63bef8a37994f30c917ff800ab8a1ca9c9b5d73024f97ee"}, + {file = "safetensors-0.4.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:faefeb3b81bdfb4e5a55b9bbdf3d8d8753f65506e1d67d03f5c851a6c87150e9"}, + {file = "safetensors-0.4.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:befdf0167ad626f22f6aac6163477fcefa342224a22f11fdd05abb3995c1783c"}, + {file = "safetensors-0.4.3-cp311-none-win32.whl", hash = "sha256:a7cef55929dcbef24af3eb40bedec35d82c3c2fa46338bb13ecf3c5720af8a61"}, + {file = "safetensors-0.4.3-cp311-none-win_amd64.whl", hash = "sha256:840b7ac0eff5633e1d053cc9db12fdf56b566e9403b4950b2dc85393d9b88d67"}, + {file = "safetensors-0.4.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:22d21760dc6ebae42e9c058d75aa9907d9f35e38f896e3c69ba0e7b213033856"}, + {file = "safetensors-0.4.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d22c1a10dff3f64d0d68abb8298a3fd88ccff79f408a3e15b3e7f637ef5c980"}, + {file = "safetensors-0.4.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1648568667f820b8c48317c7006221dc40aced1869908c187f493838a1362bc"}, + {file = "safetensors-0.4.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:446e9fe52c051aeab12aac63d1017e0f68a02a92a027b901c4f8e931b24e5397"}, + {file = "safetensors-0.4.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fef5d70683643618244a4f5221053567ca3e77c2531e42ad48ae05fae909f542"}, + {file = "safetensors-0.4.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a1f4430cc0c9d6afa01214a4b3919d0a029637df8e09675ceef1ca3f0dfa0df"}, + {file = "safetensors-0.4.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2d603846a8585b9432a0fd415db1d4c57c0f860eb4aea21f92559ff9902bae4d"}, + {file = "safetensors-0.4.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a844cdb5d7cbc22f5f16c7e2a0271170750763c4db08381b7f696dbd2c78a361"}, + {file = "safetensors-0.4.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:88887f69f7a00cf02b954cdc3034ffb383b2303bc0ab481d4716e2da51ddc10e"}, + {file = "safetensors-0.4.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ee463219d9ec6c2be1d331ab13a8e0cd50d2f32240a81d498266d77d07b7e71e"}, + {file = "safetensors-0.4.3-cp312-none-win32.whl", hash = "sha256:d0dd4a1db09db2dba0f94d15addc7e7cd3a7b0d393aa4c7518c39ae7374623c3"}, + {file = "safetensors-0.4.3-cp312-none-win_amd64.whl", hash = "sha256:d14d30c25897b2bf19b6fb5ff7e26cc40006ad53fd4a88244fdf26517d852dd7"}, + {file = "safetensors-0.4.3-cp37-cp37m-macosx_10_12_x86_64.whl", hash = "sha256:d1456f814655b224d4bf6e7915c51ce74e389b413be791203092b7ff78c936dd"}, + {file = "safetensors-0.4.3-cp37-cp37m-macosx_11_0_arm64.whl", hash = "sha256:455d538aa1aae4a8b279344a08136d3f16334247907b18a5c3c7fa88ef0d3c46"}, + {file = "safetensors-0.4.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf476bca34e1340ee3294ef13e2c625833f83d096cfdf69a5342475602004f95"}, + {file = "safetensors-0.4.3-cp37-cp37m-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:02ef3a24face643456020536591fbd3c717c5abaa2737ec428ccbbc86dffa7a4"}, + {file = "safetensors-0.4.3-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7de32d0d34b6623bb56ca278f90db081f85fb9c5d327e3c18fd23ac64f465768"}, + {file = "safetensors-0.4.3-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a0deb16a1d3ea90c244ceb42d2c6c276059616be21a19ac7101aa97da448faf"}, + {file = "safetensors-0.4.3-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c59d51f182c729f47e841510b70b967b0752039f79f1de23bcdd86462a9b09ee"}, + {file = "safetensors-0.4.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1f598b713cc1a4eb31d3b3203557ac308acf21c8f41104cdd74bf640c6e538e3"}, + {file = "safetensors-0.4.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:5757e4688f20df083e233b47de43845d1adb7e17b6cf7da5f8444416fc53828d"}, + {file = "safetensors-0.4.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:fe746d03ed8d193674a26105e4f0fe6c726f5bb602ffc695b409eaf02f04763d"}, + {file = "safetensors-0.4.3-cp37-none-win32.whl", hash = "sha256:0d5ffc6a80f715c30af253e0e288ad1cd97a3d0086c9c87995e5093ebc075e50"}, + {file = "safetensors-0.4.3-cp37-none-win_amd64.whl", hash = "sha256:a11c374eb63a9c16c5ed146457241182f310902bd2a9c18255781bb832b6748b"}, + {file = "safetensors-0.4.3-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:b1e31be7945f66be23f4ec1682bb47faa3df34cb89fc68527de6554d3c4258a4"}, + {file = "safetensors-0.4.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:03a4447c784917c9bf01d8f2ac5080bc15c41692202cd5f406afba16629e84d6"}, + {file = "safetensors-0.4.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d244bcafeb1bc06d47cfee71727e775bca88a8efda77a13e7306aae3813fa7e4"}, + {file = "safetensors-0.4.3-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:53c4879b9c6bd7cd25d114ee0ef95420e2812e676314300624594940a8d6a91f"}, + {file = "safetensors-0.4.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:74707624b81f1b7f2b93f5619d4a9f00934d5948005a03f2c1845ffbfff42212"}, + {file = "safetensors-0.4.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0d52c958dc210265157573f81d34adf54e255bc2b59ded6218500c9b15a750eb"}, + {file = "safetensors-0.4.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f9568f380f513a60139971169c4a358b8731509cc19112369902eddb33faa4d"}, + {file = "safetensors-0.4.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0d9cd8e1560dfc514b6d7859247dc6a86ad2f83151a62c577428d5102d872721"}, + {file = "safetensors-0.4.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:89f9f17b0dacb913ed87d57afbc8aad85ea42c1085bd5de2f20d83d13e9fc4b2"}, + {file = "safetensors-0.4.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:1139eb436fd201c133d03c81209d39ac57e129f5e74e34bb9ab60f8d9b726270"}, + {file = "safetensors-0.4.3-cp38-none-win32.whl", hash = "sha256:d9c289f140a9ae4853fc2236a2ffc9a9f2d5eae0cb673167e0f1b8c18c0961ac"}, + {file = "safetensors-0.4.3-cp38-none-win_amd64.whl", hash = "sha256:622afd28968ef3e9786562d352659a37de4481a4070f4ebac883f98c5836563e"}, + {file = "safetensors-0.4.3-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:8651c7299cbd8b4161a36cd6a322fa07d39cd23535b144d02f1c1972d0c62f3c"}, + {file = "safetensors-0.4.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e375d975159ac534c7161269de24ddcd490df2157b55c1a6eeace6cbb56903f0"}, + {file = "safetensors-0.4.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:084fc436e317f83f7071fc6a62ca1c513b2103db325cd09952914b50f51cf78f"}, + {file = "safetensors-0.4.3-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:41a727a7f5e6ad9f1db6951adee21bbdadc632363d79dc434876369a17de6ad6"}, + {file = "safetensors-0.4.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e7dbbde64b6c534548696808a0e01276d28ea5773bc9a2dfb97a88cd3dffe3df"}, + {file = "safetensors-0.4.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bbae3b4b9d997971431c346edbfe6e41e98424a097860ee872721e176040a893"}, + {file = "safetensors-0.4.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01e4b22e3284cd866edeabe4f4d896229495da457229408d2e1e4810c5187121"}, + {file = "safetensors-0.4.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0dd37306546b58d3043eb044c8103a02792cc024b51d1dd16bd3dd1f334cb3ed"}, + {file = "safetensors-0.4.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d8815b5e1dac85fc534a97fd339e12404db557878c090f90442247e87c8aeaea"}, + {file = "safetensors-0.4.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:e011cc162503c19f4b1fd63dfcddf73739c7a243a17dac09b78e57a00983ab35"}, + {file = "safetensors-0.4.3-cp39-none-win32.whl", hash = "sha256:01feb3089e5932d7e662eda77c3ecc389f97c0883c4a12b5cfdc32b589a811c3"}, + {file = "safetensors-0.4.3-cp39-none-win_amd64.whl", hash = "sha256:3f9cdca09052f585e62328c1c2923c70f46814715c795be65f0b93f57ec98a02"}, + {file = "safetensors-0.4.3-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:1b89381517891a7bb7d1405d828b2bf5d75528299f8231e9346b8eba092227f9"}, + {file = "safetensors-0.4.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:cd6fff9e56df398abc5866b19a32124815b656613c1c5ec0f9350906fd798aac"}, + {file = "safetensors-0.4.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:840caf38d86aa7014fe37ade5d0d84e23dcfbc798b8078015831996ecbc206a3"}, + {file = "safetensors-0.4.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f9650713b2cfa9537a2baf7dd9fee458b24a0aaaa6cafcea8bdd5fb2b8efdc34"}, + {file = "safetensors-0.4.3-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e4119532cd10dba04b423e0f86aecb96cfa5a602238c0aa012f70c3a40c44b50"}, + {file = "safetensors-0.4.3-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:e066e8861eef6387b7c772344d1fe1f9a72800e04ee9a54239d460c400c72aab"}, + {file = "safetensors-0.4.3-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:90964917f5b0fa0fa07e9a051fbef100250c04d150b7026ccbf87a34a54012e0"}, + {file = "safetensors-0.4.3-pp37-pypy37_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c41e1893d1206aa7054029681778d9a58b3529d4c807002c156d58426c225173"}, + {file = "safetensors-0.4.3-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ae7613a119a71a497d012ccc83775c308b9c1dab454806291427f84397d852fd"}, + {file = "safetensors-0.4.3-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f9bac020faba7f5dc481e881b14b6425265feabb5bfc552551d21189c0eddc3"}, + {file = "safetensors-0.4.3-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:420a98f593ff9930f5822560d14c395ccbc57342ddff3b463bc0b3d6b1951550"}, + {file = "safetensors-0.4.3-pp37-pypy37_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:f5e6883af9a68c0028f70a4c19d5a6ab6238a379be36ad300a22318316c00cb0"}, + {file = "safetensors-0.4.3-pp37-pypy37_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:cdd0a3b5da66e7f377474599814dbf5cbf135ff059cc73694de129b58a5e8a2c"}, + {file = "safetensors-0.4.3-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:9bfb92f82574d9e58401d79c70c716985dc049b635fef6eecbb024c79b2c46ad"}, + {file = "safetensors-0.4.3-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:3615a96dd2dcc30eb66d82bc76cda2565f4f7bfa89fcb0e31ba3cea8a1a9ecbb"}, + {file = "safetensors-0.4.3-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:868ad1b6fc41209ab6bd12f63923e8baeb1a086814cb2e81a65ed3d497e0cf8f"}, + {file = "safetensors-0.4.3-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b7ffba80aa49bd09195145a7fd233a7781173b422eeb995096f2b30591639517"}, + {file = "safetensors-0.4.3-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c0acbe31340ab150423347e5b9cc595867d814244ac14218932a5cf1dd38eb39"}, + {file = "safetensors-0.4.3-pp38-pypy38_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:19bbdf95de2cf64f25cd614c5236c8b06eb2cfa47cbf64311f4b5d80224623a3"}, + {file = "safetensors-0.4.3-pp38-pypy38_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:b852e47eb08475c2c1bd8131207b405793bfc20d6f45aff893d3baaad449ed14"}, + {file = "safetensors-0.4.3-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5d07cbca5b99babb692d76d8151bec46f461f8ad8daafbfd96b2fca40cadae65"}, + {file = "safetensors-0.4.3-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1ab6527a20586d94291c96e00a668fa03f86189b8a9defa2cdd34a1a01acc7d5"}, + {file = "safetensors-0.4.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:02318f01e332cc23ffb4f6716e05a492c5f18b1d13e343c49265149396284a44"}, + {file = "safetensors-0.4.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec4b52ce9a396260eb9731eb6aea41a7320de22ed73a1042c2230af0212758ce"}, + {file = "safetensors-0.4.3-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:018b691383026a2436a22b648873ed11444a364324e7088b99cd2503dd828400"}, + {file = "safetensors-0.4.3-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:309b10dbcab63269ecbf0e2ca10ce59223bb756ca5d431ce9c9eeabd446569da"}, + {file = "safetensors-0.4.3-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:b277482120df46e27a58082df06a15aebda4481e30a1c21eefd0921ae7e03f65"}, + {file = "safetensors-0.4.3.tar.gz", hash = "sha256:2f85fc50c4e07a21e95c24e07460fe6f7e2859d0ce88092838352b798ce711c2"}, +] + +[package.extras] +all = ["safetensors[jax]", "safetensors[numpy]", "safetensors[paddlepaddle]", "safetensors[pinned-tf]", "safetensors[quality]", "safetensors[testing]", "safetensors[torch]"] +dev = ["safetensors[all]"] +jax = ["flax (>=0.6.3)", "jax (>=0.3.25)", "jaxlib (>=0.3.25)", "safetensors[numpy]"] +mlx = ["mlx (>=0.0.9)"] +numpy = ["numpy (>=1.21.6)"] +paddlepaddle = ["paddlepaddle (>=2.4.1)", "safetensors[numpy]"] +pinned-tf = ["safetensors[numpy]", "tensorflow (==2.11.0)"] +quality = ["black (==22.3)", "click (==8.0.4)", "flake8 (>=3.8.3)", "isort (>=5.5.4)"] +tensorflow = ["safetensors[numpy]", "tensorflow (>=2.11.0)"] +testing = ["h5py (>=3.7.0)", "huggingface-hub (>=0.12.1)", "hypothesis (>=6.70.2)", "pytest (>=7.2.0)", "pytest-benchmark (>=4.0.0)", "safetensors[numpy]", "setuptools-rust (>=1.5.2)"] +torch = ["safetensors[numpy]", "torch (>=1.10)"] + +[[package]] +name = "scikit-learn" +version = "1.5.0" +description = "A set of python modules for machine learning and data mining" +optional = false +python-versions = ">=3.9" +files = [ + {file = "scikit_learn-1.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:12e40ac48555e6b551f0a0a5743cc94cc5a765c9513fe708e01f0aa001da2801"}, + {file = "scikit_learn-1.5.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:f405c4dae288f5f6553b10c4ac9ea7754d5180ec11e296464adb5d6ac68b6ef5"}, + {file = "scikit_learn-1.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df8ccabbf583315f13160a4bb06037bde99ea7d8211a69787a6b7c5d4ebb6fc3"}, + {file = "scikit_learn-1.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c75ea812cd83b1385bbfa94ae971f0d80adb338a9523f6bbcb5e0b0381151d4"}, + {file = "scikit_learn-1.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:a90c5da84829a0b9b4bf00daf62754b2be741e66b5946911f5bdfaa869fcedd6"}, + {file = "scikit_learn-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2a65af2d8a6cce4e163a7951a4cfbfa7fceb2d5c013a4b593686c7f16445cf9d"}, + {file = "scikit_learn-1.5.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:4c0c56c3005f2ec1db3787aeaabefa96256580678cec783986836fc64f8ff622"}, + {file = "scikit_learn-1.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f77547165c00625551e5c250cefa3f03f2fc92c5e18668abd90bfc4be2e0bff"}, + {file = "scikit_learn-1.5.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:118a8d229a41158c9f90093e46b3737120a165181a1b58c03461447aa4657415"}, + {file = "scikit_learn-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:a03b09f9f7f09ffe8c5efffe2e9de1196c696d811be6798ad5eddf323c6f4d40"}, + {file = "scikit_learn-1.5.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:460806030c666addee1f074788b3978329a5bfdc9b7d63e7aad3f6d45c67a210"}, + {file = "scikit_learn-1.5.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:1b94d6440603752b27842eda97f6395f570941857456c606eb1d638efdb38184"}, + {file = "scikit_learn-1.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d82c2e573f0f2f2f0be897e7a31fcf4e73869247738ab8c3ce7245549af58ab8"}, + {file = "scikit_learn-1.5.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3a10e1d9e834e84d05e468ec501a356226338778769317ee0b84043c0d8fb06"}, + {file = "scikit_learn-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:855fc5fa8ed9e4f08291203af3d3e5fbdc4737bd617a371559aaa2088166046e"}, + {file = "scikit_learn-1.5.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:40fb7d4a9a2db07e6e0cae4dc7bdbb8fada17043bac24104d8165e10e4cff1a2"}, + {file = "scikit_learn-1.5.0-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:47132440050b1c5beb95f8ba0b2402bbd9057ce96ec0ba86f2f445dd4f34df67"}, + {file = "scikit_learn-1.5.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:174beb56e3e881c90424e21f576fa69c4ffcf5174632a79ab4461c4c960315ac"}, + {file = "scikit_learn-1.5.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:261fe334ca48f09ed64b8fae13f9b46cc43ac5f580c4a605cbb0a517456c8f71"}, + {file = "scikit_learn-1.5.0-cp39-cp39-win_amd64.whl", hash = "sha256:057b991ac64b3e75c9c04b5f9395eaf19a6179244c089afdebaad98264bff37c"}, + {file = "scikit_learn-1.5.0.tar.gz", hash = "sha256:789e3db01c750ed6d496fa2db7d50637857b451e57bcae863bff707c1247bef7"}, +] + +[package.dependencies] +joblib = ">=1.2.0" +numpy = ">=1.19.5" +scipy = ">=1.6.0" +threadpoolctl = ">=3.1.0" + +[package.extras] +benchmark = ["matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "pandas (>=1.1.5)"] +build = ["cython (>=3.0.10)", "meson-python (>=0.15.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)"] +docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "polars (>=0.20.23)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)", "sphinx (>=6.0.0)", "sphinx-copybutton (>=0.5.2)", "sphinx-gallery (>=0.15.0)", "sphinx-prompt (>=1.3.0)", "sphinxext-opengraph (>=0.4.2)"] +examples = ["matplotlib (>=3.3.4)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)"] +install = ["joblib (>=1.2.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)", "threadpoolctl (>=3.1.0)"] +maintenance = ["conda-lock (==2.5.6)"] +tests = ["black (>=24.3.0)", "matplotlib (>=3.3.4)", "mypy (>=1.9)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "polars (>=0.20.23)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.2.1)", "scikit-image (>=0.17.2)"] + +[[package]] +name = "scipy" +version = "1.13.1" +description = "Fundamental algorithms for scientific computing in Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "scipy-1.13.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:20335853b85e9a49ff7572ab453794298bcf0354d8068c5f6775a0eabf350aca"}, + {file = "scipy-1.13.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d605e9c23906d1994f55ace80e0125c587f96c020037ea6aa98d01b4bd2e222f"}, + {file = "scipy-1.13.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cfa31f1def5c819b19ecc3a8b52d28ffdcc7ed52bb20c9a7589669dd3c250989"}, + {file = "scipy-1.13.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26264b282b9da0952a024ae34710c2aff7d27480ee91a2e82b7b7073c24722f"}, + {file = "scipy-1.13.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:eccfa1906eacc02de42d70ef4aecea45415f5be17e72b61bafcfd329bdc52e94"}, + {file = "scipy-1.13.1-cp310-cp310-win_amd64.whl", hash = "sha256:2831f0dc9c5ea9edd6e51e6e769b655f08ec6db6e2e10f86ef39bd32eb11da54"}, + {file = "scipy-1.13.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:27e52b09c0d3a1d5b63e1105f24177e544a222b43611aaf5bc44d4a0979e32f9"}, + {file = "scipy-1.13.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:54f430b00f0133e2224c3ba42b805bfd0086fe488835effa33fa291561932326"}, + {file = "scipy-1.13.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e89369d27f9e7b0884ae559a3a956e77c02114cc60a6058b4e5011572eea9299"}, + {file = "scipy-1.13.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a78b4b3345f1b6f68a763c6e25c0c9a23a9fd0f39f5f3d200efe8feda560a5fa"}, + {file = "scipy-1.13.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:45484bee6d65633752c490404513b9ef02475b4284c4cfab0ef946def50b3f59"}, + {file = "scipy-1.13.1-cp311-cp311-win_amd64.whl", hash = "sha256:5713f62f781eebd8d597eb3f88b8bf9274e79eeabf63afb4a737abc6c84ad37b"}, + {file = "scipy-1.13.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5d72782f39716b2b3509cd7c33cdc08c96f2f4d2b06d51e52fb45a19ca0c86a1"}, + {file = "scipy-1.13.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:017367484ce5498445aade74b1d5ab377acdc65e27095155e448c88497755a5d"}, + {file = "scipy-1.13.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:949ae67db5fa78a86e8fa644b9a6b07252f449dcf74247108c50e1d20d2b4627"}, + {file = "scipy-1.13.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de3ade0e53bc1f21358aa74ff4830235d716211d7d077e340c7349bc3542e884"}, + {file = "scipy-1.13.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2ac65fb503dad64218c228e2dc2d0a0193f7904747db43014645ae139c8fad16"}, + {file = "scipy-1.13.1-cp312-cp312-win_amd64.whl", hash = "sha256:cdd7dacfb95fea358916410ec61bbc20440f7860333aee6d882bb8046264e949"}, + {file = "scipy-1.13.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:436bbb42a94a8aeef855d755ce5a465479c721e9d684de76bf61a62e7c2b81d5"}, + {file = "scipy-1.13.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:8335549ebbca860c52bf3d02f80784e91a004b71b059e3eea9678ba994796a24"}, + {file = "scipy-1.13.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d533654b7d221a6a97304ab63c41c96473ff04459e404b83275b60aa8f4b7004"}, + {file = "scipy-1.13.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637e98dcf185ba7f8e663e122ebf908c4702420477ae52a04f9908707456ba4d"}, + {file = "scipy-1.13.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a014c2b3697bde71724244f63de2476925596c24285c7a637364761f8710891c"}, + {file = "scipy-1.13.1-cp39-cp39-win_amd64.whl", hash = "sha256:392e4ec766654852c25ebad4f64e4e584cf19820b980bc04960bca0b0cd6eaa2"}, + {file = "scipy-1.13.1.tar.gz", hash = "sha256:095a87a0312b08dfd6a6155cbbd310a8c51800fc931b8c0b84003014b874ed3c"}, +] + +[package.dependencies] +numpy = ">=1.22.4,<2.3" + +[package.extras] +dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"] +doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.12.0)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0)", "sphinx-design (>=0.4.0)"] +test = ["array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] + +[[package]] +name = "sentry-sdk" +version = "2.5.1" +description = "Python client for Sentry (https://sentry.io)" +optional = false +python-versions = ">=3.6" +files = [ + {file = "sentry_sdk-2.5.1-py2.py3-none-any.whl", hash = "sha256:1f87acdce4a43a523ae5aa21a3fc37522d73ebd9ec04b1dbf01aa3d173852def"}, + {file = "sentry_sdk-2.5.1.tar.gz", hash = "sha256:fbc40a78a8a9c6675133031116144f0d0940376fa6e4e1acd5624c90b0aaf58b"}, +] + +[package.dependencies] +certifi = "*" +urllib3 = ">=1.26.11" + +[package.extras] +aiohttp = ["aiohttp (>=3.5)"] +anthropic = ["anthropic (>=0.16)"] +arq = ["arq (>=0.23)"] +asyncpg = ["asyncpg (>=0.23)"] +beam = ["apache-beam (>=2.12)"] +bottle = ["bottle (>=0.12.13)"] +celery = ["celery (>=3)"] +celery-redbeat = ["celery-redbeat (>=2)"] +chalice = ["chalice (>=1.16.0)"] +clickhouse-driver = ["clickhouse-driver (>=0.2.0)"] +django = ["django (>=1.8)"] +falcon = ["falcon (>=1.4)"] +fastapi = ["fastapi (>=0.79.0)"] +flask = ["blinker (>=1.1)", "flask (>=0.11)", "markupsafe"] +grpcio = ["grpcio (>=1.21.1)", "protobuf (>=3.8.0)"] +httpx = ["httpx (>=0.16.0)"] +huey = ["huey (>=2)"] +huggingface-hub = ["huggingface-hub (>=0.22)"] +langchain = ["langchain (>=0.0.210)"] +loguru = ["loguru (>=0.5)"] +openai = ["openai (>=1.0.0)", "tiktoken (>=0.3.0)"] +opentelemetry = ["opentelemetry-distro (>=0.35b0)"] +opentelemetry-experimental = ["opentelemetry-distro (>=0.40b0,<1.0)", "opentelemetry-instrumentation-aiohttp-client (>=0.40b0,<1.0)", "opentelemetry-instrumentation-django (>=0.40b0,<1.0)", "opentelemetry-instrumentation-fastapi (>=0.40b0,<1.0)", "opentelemetry-instrumentation-flask (>=0.40b0,<1.0)", "opentelemetry-instrumentation-requests (>=0.40b0,<1.0)", "opentelemetry-instrumentation-sqlite3 (>=0.40b0,<1.0)", "opentelemetry-instrumentation-urllib (>=0.40b0,<1.0)"] +pure-eval = ["asttokens", "executing", "pure-eval"] +pymongo = ["pymongo (>=3.1)"] +pyspark = ["pyspark (>=2.4.4)"] +quart = ["blinker (>=1.1)", "quart (>=0.16.1)"] +rq = ["rq (>=0.6)"] +sanic = ["sanic (>=0.8)"] +sqlalchemy = ["sqlalchemy (>=1.2)"] +starlette = ["starlette (>=0.19.1)"] +starlite = ["starlite (>=1.48)"] +tornado = ["tornado (>=5)"] + +[[package]] +name = "setproctitle" +version = "1.3.3" +description = "A Python module to customize the process title" +optional = false +python-versions = ">=3.7" +files = [ + {file = "setproctitle-1.3.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:897a73208da48db41e687225f355ce993167079eda1260ba5e13c4e53be7f754"}, + {file = "setproctitle-1.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8c331e91a14ba4076f88c29c777ad6b58639530ed5b24b5564b5ed2fd7a95452"}, + {file = "setproctitle-1.3.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bbbd6c7de0771c84b4aa30e70b409565eb1fc13627a723ca6be774ed6b9d9fa3"}, + {file = "setproctitle-1.3.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c05ac48ef16ee013b8a326c63e4610e2430dbec037ec5c5b58fcced550382b74"}, + {file = "setproctitle-1.3.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1342f4fdb37f89d3e3c1c0a59d6ddbedbde838fff5c51178a7982993d238fe4f"}, + {file = "setproctitle-1.3.3-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc74e84fdfa96821580fb5e9c0b0777c1c4779434ce16d3d62a9c4d8c710df39"}, + {file = "setproctitle-1.3.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9617b676b95adb412bb69645d5b077d664b6882bb0d37bfdafbbb1b999568d85"}, + {file = "setproctitle-1.3.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6a249415f5bb88b5e9e8c4db47f609e0bf0e20a75e8d744ea787f3092ba1f2d0"}, + {file = "setproctitle-1.3.3-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:38da436a0aaace9add67b999eb6abe4b84397edf4a78ec28f264e5b4c9d53cd5"}, + {file = "setproctitle-1.3.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:da0d57edd4c95bf221b2ebbaa061e65b1788f1544977288bdf95831b6e44e44d"}, + {file = "setproctitle-1.3.3-cp310-cp310-win32.whl", hash = "sha256:a1fcac43918b836ace25f69b1dca8c9395253ad8152b625064415b1d2f9be4fb"}, + {file = "setproctitle-1.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:200620c3b15388d7f3f97e0ae26599c0c378fdf07ae9ac5a13616e933cbd2086"}, + {file = "setproctitle-1.3.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:334f7ed39895d692f753a443102dd5fed180c571eb6a48b2a5b7f5b3564908c8"}, + {file = "setproctitle-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:950f6476d56ff7817a8fed4ab207727fc5260af83481b2a4b125f32844df513a"}, + {file = "setproctitle-1.3.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:195c961f54a09eb2acabbfc90c413955cf16c6e2f8caa2adbf2237d1019c7dd8"}, + {file = "setproctitle-1.3.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f05e66746bf9fe6a3397ec246fe481096664a9c97eb3fea6004735a4daf867fd"}, + {file = "setproctitle-1.3.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b5901a31012a40ec913265b64e48c2a4059278d9f4e6be628441482dd13fb8b5"}, + {file = "setproctitle-1.3.3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64286f8a995f2cd934082b398fc63fca7d5ffe31f0e27e75b3ca6b4efda4e353"}, + {file = "setproctitle-1.3.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:184239903bbc6b813b1a8fc86394dc6ca7d20e2ebe6f69f716bec301e4b0199d"}, + {file = "setproctitle-1.3.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:664698ae0013f986118064b6676d7dcd28fefd0d7d5a5ae9497cbc10cba48fa5"}, + {file = "setproctitle-1.3.3-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:e5119a211c2e98ff18b9908ba62a3bd0e3fabb02a29277a7232a6fb4b2560aa0"}, + {file = "setproctitle-1.3.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:417de6b2e214e837827067048f61841f5d7fc27926f2e43954567094051aff18"}, + {file = "setproctitle-1.3.3-cp311-cp311-win32.whl", hash = "sha256:6a143b31d758296dc2f440175f6c8e0b5301ced3b0f477b84ca43cdcf7f2f476"}, + {file = "setproctitle-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:a680d62c399fa4b44899094027ec9a1bdaf6f31c650e44183b50d4c4d0ccc085"}, + {file = "setproctitle-1.3.3-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d4460795a8a7a391e3567b902ec5bdf6c60a47d791c3b1d27080fc203d11c9dc"}, + {file = "setproctitle-1.3.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:bdfd7254745bb737ca1384dee57e6523651892f0ea2a7344490e9caefcc35e64"}, + {file = "setproctitle-1.3.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:477d3da48e216d7fc04bddab67b0dcde633e19f484a146fd2a34bb0e9dbb4a1e"}, + {file = "setproctitle-1.3.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ab2900d111e93aff5df9fddc64cf51ca4ef2c9f98702ce26524f1acc5a786ae7"}, + {file = "setproctitle-1.3.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:088b9efc62d5aa5d6edf6cba1cf0c81f4488b5ce1c0342a8b67ae39d64001120"}, + {file = "setproctitle-1.3.3-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6d50252377db62d6a0bb82cc898089916457f2db2041e1d03ce7fadd4a07381"}, + {file = "setproctitle-1.3.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:87e668f9561fd3a457ba189edfc9e37709261287b52293c115ae3487a24b92f6"}, + {file = "setproctitle-1.3.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:287490eb90e7a0ddd22e74c89a92cc922389daa95babc833c08cf80c84c4df0a"}, + {file = "setproctitle-1.3.3-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:4fe1c49486109f72d502f8be569972e27f385fe632bd8895f4730df3c87d5ac8"}, + {file = "setproctitle-1.3.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4a6ba2494a6449b1f477bd3e67935c2b7b0274f2f6dcd0f7c6aceae10c6c6ba3"}, + {file = "setproctitle-1.3.3-cp312-cp312-win32.whl", hash = "sha256:2df2b67e4b1d7498632e18c56722851ba4db5d6a0c91aaf0fd395111e51cdcf4"}, + {file = "setproctitle-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:f38d48abc121263f3b62943f84cbaede05749047e428409c2c199664feb6abc7"}, + {file = "setproctitle-1.3.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:816330675e3504ae4d9a2185c46b573105d2310c20b19ea2b4596a9460a4f674"}, + {file = "setproctitle-1.3.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68f960bc22d8d8e4ac886d1e2e21ccbd283adcf3c43136161c1ba0fa509088e0"}, + {file = "setproctitle-1.3.3-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00e6e7adff74796ef12753ff399491b8827f84f6c77659d71bd0b35870a17d8f"}, + {file = "setproctitle-1.3.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:53bc0d2358507596c22b02db079618451f3bd720755d88e3cccd840bafb4c41c"}, + {file = "setproctitle-1.3.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad6d20f9541f5f6ac63df553b6d7a04f313947f550eab6a61aa758b45f0d5657"}, + {file = "setproctitle-1.3.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c1c84beab776b0becaa368254801e57692ed749d935469ac10e2b9b825dbdd8e"}, + {file = "setproctitle-1.3.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:507e8dc2891021350eaea40a44ddd887c9f006e6b599af8d64a505c0f718f170"}, + {file = "setproctitle-1.3.3-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b1067647ac7aba0b44b591936118a22847bda3c507b0a42d74272256a7a798e9"}, + {file = "setproctitle-1.3.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:2e71f6365744bf53714e8bd2522b3c9c1d83f52ffa6324bd7cbb4da707312cd8"}, + {file = "setproctitle-1.3.3-cp37-cp37m-win32.whl", hash = "sha256:7f1d36a1e15a46e8ede4e953abb104fdbc0845a266ec0e99cc0492a4364f8c44"}, + {file = "setproctitle-1.3.3-cp37-cp37m-win_amd64.whl", hash = "sha256:c9a402881ec269d0cc9c354b149fc29f9ec1a1939a777f1c858cdb09c7a261df"}, + {file = "setproctitle-1.3.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ff814dea1e5c492a4980e3e7d094286077054e7ea116cbeda138819db194b2cd"}, + {file = "setproctitle-1.3.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:accb66d7b3ccb00d5cd11d8c6e07055a4568a24c95cf86109894dcc0c134cc89"}, + {file = "setproctitle-1.3.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:554eae5a5b28f02705b83a230e9d163d645c9a08914c0ad921df363a07cf39b1"}, + {file = "setproctitle-1.3.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a911b26264dbe9e8066c7531c0591cfab27b464459c74385b276fe487ca91c12"}, + {file = "setproctitle-1.3.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2982efe7640c4835f7355fdb4da313ad37fb3b40f5c69069912f8048f77b28c8"}, + {file = "setproctitle-1.3.3-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:df3f4274b80709d8bcab2f9a862973d453b308b97a0b423a501bcd93582852e3"}, + {file = "setproctitle-1.3.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:af2c67ae4c795d1674a8d3ac1988676fa306bcfa1e23fddb5e0bd5f5635309ca"}, + {file = "setproctitle-1.3.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:af4061f67fd7ec01624c5e3c21f6b7af2ef0e6bab7fbb43f209e6506c9ce0092"}, + {file = "setproctitle-1.3.3-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:37a62cbe16d4c6294e84670b59cf7adcc73faafe6af07f8cb9adaf1f0e775b19"}, + {file = "setproctitle-1.3.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:a83ca086fbb017f0d87f240a8f9bbcf0809f3b754ee01cec928fff926542c450"}, + {file = "setproctitle-1.3.3-cp38-cp38-win32.whl", hash = "sha256:059f4ce86f8cc92e5860abfc43a1dceb21137b26a02373618d88f6b4b86ba9b2"}, + {file = "setproctitle-1.3.3-cp38-cp38-win_amd64.whl", hash = "sha256:ab92e51cd4a218208efee4c6d37db7368fdf182f6e7ff148fb295ecddf264287"}, + {file = "setproctitle-1.3.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c7951820b77abe03d88b114b998867c0f99da03859e5ab2623d94690848d3e45"}, + {file = "setproctitle-1.3.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5bc94cf128676e8fac6503b37763adb378e2b6be1249d207630f83fc325d9b11"}, + {file = "setproctitle-1.3.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f5d9027eeda64d353cf21a3ceb74bb1760bd534526c9214e19f052424b37e42"}, + {file = "setproctitle-1.3.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2e4a8104db15d3462e29d9946f26bed817a5b1d7a47eabca2d9dc2b995991503"}, + {file = "setproctitle-1.3.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c32c41ace41f344d317399efff4cffb133e709cec2ef09c99e7a13e9f3b9483c"}, + {file = "setproctitle-1.3.3-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cbf16381c7bf7f963b58fb4daaa65684e10966ee14d26f5cc90f07049bfd8c1e"}, + {file = "setproctitle-1.3.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:e18b7bd0898398cc97ce2dfc83bb192a13a087ef6b2d5a8a36460311cb09e775"}, + {file = "setproctitle-1.3.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:69d565d20efe527bd8a9b92e7f299ae5e73b6c0470f3719bd66f3cd821e0d5bd"}, + {file = "setproctitle-1.3.3-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:ddedd300cd690a3b06e7eac90ed4452348b1348635777ce23d460d913b5b63c3"}, + {file = "setproctitle-1.3.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:415bfcfd01d1fbf5cbd75004599ef167a533395955305f42220a585f64036081"}, + {file = "setproctitle-1.3.3-cp39-cp39-win32.whl", hash = "sha256:21112fcd2195d48f25760f0eafa7a76510871bbb3b750219310cf88b04456ae3"}, + {file = "setproctitle-1.3.3-cp39-cp39-win_amd64.whl", hash = "sha256:5a740f05d0968a5a17da3d676ce6afefebeeeb5ce137510901bf6306ba8ee002"}, + {file = "setproctitle-1.3.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:6b9e62ddb3db4b5205c0321dd69a406d8af9ee1693529d144e86bd43bcb4b6c0"}, + {file = "setproctitle-1.3.3-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9e3b99b338598de0bd6b2643bf8c343cf5ff70db3627af3ca427a5e1a1a90dd9"}, + {file = "setproctitle-1.3.3-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38ae9a02766dad331deb06855fb7a6ca15daea333b3967e214de12cfae8f0ef5"}, + {file = "setproctitle-1.3.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:200ede6fd11233085ba9b764eb055a2a191fb4ffb950c68675ac53c874c22e20"}, + {file = "setproctitle-1.3.3-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0d3a953c50776751e80fe755a380a64cb14d61e8762bd43041ab3f8cc436092f"}, + {file = "setproctitle-1.3.3-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5e08e232b78ba3ac6bc0d23ce9e2bee8fad2be391b7e2da834fc9a45129eb87"}, + {file = "setproctitle-1.3.3-pp37-pypy37_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f1da82c3e11284da4fcbf54957dafbf0655d2389cd3d54e4eaba636faf6d117a"}, + {file = "setproctitle-1.3.3-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:aeaa71fb9568ebe9b911ddb490c644fbd2006e8c940f21cb9a1e9425bd709574"}, + {file = "setproctitle-1.3.3-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:59335d000c6250c35989394661eb6287187854e94ac79ea22315469ee4f4c244"}, + {file = "setproctitle-1.3.3-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c3ba57029c9c50ecaf0c92bb127224cc2ea9fda057b5d99d3f348c9ec2855ad3"}, + {file = "setproctitle-1.3.3-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d876d355c53d975c2ef9c4f2487c8f83dad6aeaaee1b6571453cb0ee992f55f6"}, + {file = "setproctitle-1.3.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:224602f0939e6fb9d5dd881be1229d485f3257b540f8a900d4271a2c2aa4e5f4"}, + {file = "setproctitle-1.3.3-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d7f27e0268af2d7503386e0e6be87fb9b6657afd96f5726b733837121146750d"}, + {file = "setproctitle-1.3.3-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f5e7266498cd31a4572378c61920af9f6b4676a73c299fce8ba93afd694f8ae7"}, + {file = "setproctitle-1.3.3-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33c5609ad51cd99d388e55651b19148ea99727516132fb44680e1f28dd0d1de9"}, + {file = "setproctitle-1.3.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:eae8988e78192fd1a3245a6f4f382390b61bce6cfcc93f3809726e4c885fa68d"}, + {file = "setproctitle-1.3.3.tar.gz", hash = "sha256:c913e151e7ea01567837ff037a23ca8740192880198b7fbb90b16d181607caae"}, +] + +[package.extras] +test = ["pytest"] + +[[package]] +name = "setuptools" +version = "69.5.1" +description = "Easily download, build, install, upgrade, and uninstall Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "setuptools-69.5.1-py3-none-any.whl", hash = "sha256:c636ac361bc47580504644275c9ad802c50415c7522212252c033bd15f301f32"}, + {file = "setuptools-69.5.1.tar.gz", hash = "sha256:6c1fccdac05a97e598fb0ae3bbed5904ccb317337a51139dcd51453611bbb987"}, +] + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"] +testing = ["build[virtualenv]", "filelock (>=3.4.0)", "importlib-metadata", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "mypy (==1.9)", "packaging (>=23.2)", "pip (>=19.1)", "pytest (>=6,!=8.1.1)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy", "pytest-perf", "pytest-ruff (>=0.2.1)", "pytest-timeout", "pytest-xdist (>=3)", "tomli", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] +testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.2)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"] + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "smmap" +version = "5.0.1" +description = "A pure Python implementation of a sliding window memory map manager" +optional = false +python-versions = ">=3.7" +files = [ + {file = "smmap-5.0.1-py3-none-any.whl", hash = "sha256:e6d8668fa5f93e706934a62d7b4db19c8d9eb8cf2adbb75ef1b675aa332b69da"}, + {file = "smmap-5.0.1.tar.gz", hash = "sha256:dceeb6c0028fdb6734471eb07c0cd2aae706ccaecab45965ee83f11c8d3b1f62"}, +] + +[[package]] +name = "sphinx-markdown-tables" +version = "0.0.15" +description = "A Sphinx extension for rendering tables written in markdown" +optional = false +python-versions = "*" +files = [ + {file = "sphinx-markdown-tables-0.0.15.tar.gz", hash = "sha256:722b70a3a14156b6777cf04920d015215eb65b9dfde5cc72f430763ff5e84173"}, + {file = "sphinx_markdown_tables-0.0.15-py3-none-any.whl", hash = "sha256:24a37662d86ee8bceb7d4f7003df0b25bc52401369d1ddc40d13ae7b58697031"}, +] + +[package.dependencies] +markdown = ">=3.0.1" + +[[package]] +name = "streamlit" +version = "1.35.0" +description = "A faster way to build and share data apps" +optional = false +python-versions = "!=3.9.7,>=3.8" +files = [ + {file = "streamlit-1.35.0-py2.py3-none-any.whl", hash = "sha256:e17d1d86830a0d7687c37faf2fe47bffa752d0c95a306e96d7749bd3faa72a5b"}, + {file = "streamlit-1.35.0.tar.gz", hash = "sha256:679d55bb6189743f606abf0696623df0bfd223a6d0c8d96b8d60678d4891d2d6"}, +] + +[package.dependencies] +altair = ">=4.0,<6" +blinker = ">=1.0.0,<2" +cachetools = ">=4.0,<6" +click = ">=7.0,<9" +gitpython = ">=3.0.7,<3.1.19 || >3.1.19,<4" +numpy = ">=1.19.3,<2" +packaging = ">=16.8,<25" +pandas = ">=1.3.0,<3" +pillow = ">=7.1.0,<11" +protobuf = ">=3.20,<5" +pyarrow = ">=7.0" +pydeck = ">=0.8.0b4,<1" +requests = ">=2.27,<3" +rich = ">=10.14.0,<14" +tenacity = ">=8.1.0,<9" +toml = ">=0.10.1,<2" +tornado = ">=6.0.3,<7" +typing-extensions = ">=4.3.0,<5" +watchdog = {version = ">=2.1.5", markers = "platform_system != \"Darwin\""} + +[package.extras] +snowflake = ["snowflake-connector-python (>=2.8.0)", "snowflake-snowpark-python (>=0.9.0)"] + +[[package]] +name = "sympy" +version = "1.12.1" +description = "Computer algebra system (CAS) in Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "sympy-1.12.1-py3-none-any.whl", hash = "sha256:9b2cbc7f1a640289430e13d2a56f02f867a1da0190f2f99d8968c2f74da0e515"}, + {file = "sympy-1.12.1.tar.gz", hash = "sha256:2877b03f998cd8c08f07cd0de5b767119cd3ef40d09f41c30d722f6686b0fb88"}, +] + +[package.dependencies] +mpmath = ">=1.1.0,<1.4.0" + +[[package]] +name = "tabulate" +version = "0.9.0" +description = "Pretty-print tabular data" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f"}, + {file = "tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c"}, +] + +[package.extras] +widechars = ["wcwidth"] + +[[package]] +name = "tenacity" +version = "8.3.0" +description = "Retry code until it succeeds" +optional = false +python-versions = ">=3.8" +files = [ + {file = "tenacity-8.3.0-py3-none-any.whl", hash = "sha256:3649f6443dbc0d9b01b9d8020a9c4ec7a1ff5f6f3c6c8a036ef371f573fe9185"}, + {file = "tenacity-8.3.0.tar.gz", hash = "sha256:953d4e6ad24357bceffbc9707bc74349aca9d245f68eb65419cf0c249a1949a2"}, +] + +[package.extras] +doc = ["reno", "sphinx"] +test = ["pytest", "tornado (>=4.5)", "typeguard"] + +[[package]] +name = "tensorboard" +version = "2.17.0" +description = "TensorBoard lets you watch Tensors Flow" +optional = false +python-versions = ">=3.9" +files = [ + {file = "tensorboard-2.17.0-py3-none-any.whl", hash = "sha256:859a499a9b1fb68a058858964486627100b71fcb21646861c61d31846a6478fb"}, +] + +[package.dependencies] +absl-py = ">=0.4" +grpcio = ">=1.48.2" +markdown = ">=2.6.8" +numpy = ">=1.12.0" +protobuf = ">=3.19.6,<4.24.0 || >4.24.0,<5.0.0" +setuptools = ">=41.0.0" +six = ">1.9" +tensorboard-data-server = ">=0.7.0,<0.8.0" +werkzeug = ">=1.0.1" + +[[package]] +name = "tensorboard-data-server" +version = "0.7.2" +description = "Fast data loading for TensorBoard" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tensorboard_data_server-0.7.2-py3-none-any.whl", hash = "sha256:7e0610d205889588983836ec05dc098e80f97b7e7bbff7e994ebb78f578d0ddb"}, + {file = "tensorboard_data_server-0.7.2-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:9fe5d24221b29625dbc7328b0436ca7fc1c23de4acf4d272f1180856e32f9f60"}, + {file = "tensorboard_data_server-0.7.2-py3-none-manylinux_2_31_x86_64.whl", hash = "sha256:ef687163c24185ae9754ed5650eb5bc4d84ff257aabdc33f0cc6f74d8ba54530"}, +] + +[[package]] +name = "termcolor" +version = "2.4.0" +description = "ANSI color formatting for output in terminal" +optional = false +python-versions = ">=3.8" +files = [ + {file = "termcolor-2.4.0-py3-none-any.whl", hash = "sha256:9297c0df9c99445c2412e832e882a7884038a25617c60cea2ad69488d4040d63"}, + {file = "termcolor-2.4.0.tar.gz", hash = "sha256:aab9e56047c8ac41ed798fa36d892a37aca6b3e9159f3e0c24bc64a9b3ac7b7a"}, +] + +[package.extras] +tests = ["pytest", "pytest-cov"] + +[[package]] +name = "threadpoolctl" +version = "3.5.0" +description = "threadpoolctl" +optional = false +python-versions = ">=3.8" +files = [ + {file = "threadpoolctl-3.5.0-py3-none-any.whl", hash = "sha256:56c1e26c150397e58c4926da8eeee87533b1e32bef131bd4bf6a2f45f3185467"}, + {file = "threadpoolctl-3.5.0.tar.gz", hash = "sha256:082433502dd922bf738de0d8bcc4fdcbf0979ff44c42bd40f5af8a282f6fa107"}, +] + +[[package]] +name = "tokenizers" +version = "0.15.2" +description = "" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tokenizers-0.15.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:52f6130c9cbf70544287575a985bf44ae1bda2da7e8c24e97716080593638012"}, + {file = "tokenizers-0.15.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:054c1cc9c6d68f7ffa4e810b3d5131e0ba511b6e4be34157aa08ee54c2f8d9ee"}, + {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a9b9b070fdad06e347563b88c278995735292ded1132f8657084989a4c84a6d5"}, + {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea621a7eef4b70e1f7a4e84dd989ae3f0eeb50fc8690254eacc08acb623e82f1"}, + {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cf7fd9a5141634fa3aa8d6b7be362e6ae1b4cda60da81388fa533e0b552c98fd"}, + {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:44f2a832cd0825295f7179eaf173381dc45230f9227ec4b44378322d900447c9"}, + {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8b9ec69247a23747669ec4b0ca10f8e3dfb3545d550258129bd62291aabe8605"}, + {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40b6a4c78da863ff26dbd5ad9a8ecc33d8a8d97b535172601cf00aee9d7ce9ce"}, + {file = "tokenizers-0.15.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:5ab2a4d21dcf76af60e05af8063138849eb1d6553a0d059f6534357bce8ba364"}, + {file = "tokenizers-0.15.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a47acfac7e511f6bbfcf2d3fb8c26979c780a91e06fb5b9a43831b2c0153d024"}, + {file = "tokenizers-0.15.2-cp310-none-win32.whl", hash = "sha256:064ff87bb6acdbd693666de9a4b692add41308a2c0ec0770d6385737117215f2"}, + {file = "tokenizers-0.15.2-cp310-none-win_amd64.whl", hash = "sha256:3b919afe4df7eb6ac7cafd2bd14fb507d3f408db7a68c43117f579c984a73843"}, + {file = "tokenizers-0.15.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:89cd1cb93e4b12ff39bb2d626ad77e35209de9309a71e4d3d4672667b4b256e7"}, + {file = "tokenizers-0.15.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cfed5c64e5be23d7ee0f0e98081a25c2a46b0b77ce99a4f0605b1ec43dd481fa"}, + {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a907d76dcfda37023ba203ab4ceeb21bc5683436ebefbd895a0841fd52f6f6f2"}, + {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20ea60479de6fc7b8ae756b4b097572372d7e4032e2521c1bbf3d90c90a99ff0"}, + {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:48e2b9335be2bc0171df9281385c2ed06a15f5cf121c44094338306ab7b33f2c"}, + {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:112a1dd436d2cc06e6ffdc0b06d55ac019a35a63afd26475205cb4b1bf0bfbff"}, + {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4620cca5c2817177ee8706f860364cc3a8845bc1e291aaf661fb899e5d1c45b0"}, + {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ccd73a82751c523b3fc31ff8194702e4af4db21dc20e55b30ecc2079c5d43cb7"}, + {file = "tokenizers-0.15.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:107089f135b4ae7817affe6264f8c7a5c5b4fd9a90f9439ed495f54fcea56fb4"}, + {file = "tokenizers-0.15.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0ff110ecc57b7aa4a594396525a3451ad70988e517237fe91c540997c4e50e29"}, + {file = "tokenizers-0.15.2-cp311-none-win32.whl", hash = "sha256:6d76f00f5c32da36c61f41c58346a4fa7f0a61be02f4301fd30ad59834977cc3"}, + {file = "tokenizers-0.15.2-cp311-none-win_amd64.whl", hash = "sha256:cc90102ed17271cf0a1262babe5939e0134b3890345d11a19c3145184b706055"}, + {file = "tokenizers-0.15.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f86593c18d2e6248e72fb91c77d413a815153b8ea4e31f7cd443bdf28e467670"}, + {file = "tokenizers-0.15.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0774bccc6608eca23eb9d620196687c8b2360624619623cf4ba9dc9bd53e8b51"}, + {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:d0222c5b7c9b26c0b4822a82f6a7011de0a9d3060e1da176f66274b70f846b98"}, + {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3835738be1de66624fff2f4f6f6684775da4e9c00bde053be7564cbf3545cc66"}, + {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0143e7d9dcd811855c1ce1ab9bf5d96d29bf5e528fd6c7824d0465741e8c10fd"}, + {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:db35825f6d54215f6b6009a7ff3eedee0848c99a6271c870d2826fbbedf31a38"}, + {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3f5e64b0389a2be47091d8cc53c87859783b837ea1a06edd9d8e04004df55a5c"}, + {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e0480c452217edd35eca56fafe2029fb4d368b7c0475f8dfa3c5c9c400a7456"}, + {file = "tokenizers-0.15.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a33ab881c8fe70474980577e033d0bc9a27b7ab8272896e500708b212995d834"}, + {file = "tokenizers-0.15.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a308a607ca9de2c64c1b9ba79ec9a403969715a1b8ba5f998a676826f1a7039d"}, + {file = "tokenizers-0.15.2-cp312-none-win32.whl", hash = "sha256:b8fcfa81bcb9447df582c5bc96a031e6df4da2a774b8080d4f02c0c16b42be0b"}, + {file = "tokenizers-0.15.2-cp312-none-win_amd64.whl", hash = "sha256:38d7ab43c6825abfc0b661d95f39c7f8af2449364f01d331f3b51c94dcff7221"}, + {file = "tokenizers-0.15.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:38bfb0204ff3246ca4d5e726e8cc8403bfc931090151e6eede54d0e0cf162ef0"}, + {file = "tokenizers-0.15.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9c861d35e8286a53e06e9e28d030b5a05bcbf5ac9d7229e561e53c352a85b1fc"}, + {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:936bf3842db5b2048eaa53dade907b1160f318e7c90c74bfab86f1e47720bdd6"}, + {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:620beacc3373277700d0e27718aa8b25f7b383eb8001fba94ee00aeea1459d89"}, + {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2735ecbbf37e52db4ea970e539fd2d450d213517b77745114f92867f3fc246eb"}, + {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:473c83c5e2359bb81b0b6fde870b41b2764fcdd36d997485e07e72cc3a62264a"}, + {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:968fa1fb3c27398b28a4eca1cbd1e19355c4d3a6007f7398d48826bbe3a0f728"}, + {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:865c60ae6eaebdde7da66191ee9b7db52e542ed8ee9d2c653b6d190a9351b980"}, + {file = "tokenizers-0.15.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7c0d8b52664ab2d4a8d6686eb5effc68b78608a9008f086a122a7b2996befbab"}, + {file = "tokenizers-0.15.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:f33dfbdec3784093a9aebb3680d1f91336c56d86cc70ddf88708251da1fe9064"}, + {file = "tokenizers-0.15.2-cp37-cp37m-macosx_10_12_x86_64.whl", hash = "sha256:d44ba80988ff9424e33e0a49445072ac7029d8c0e1601ad25a0ca5f41ed0c1d6"}, + {file = "tokenizers-0.15.2-cp37-cp37m-macosx_11_0_arm64.whl", hash = "sha256:dce74266919b892f82b1b86025a613956ea0ea62a4843d4c4237be2c5498ed3a"}, + {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0ef06b9707baeb98b316577acb04f4852239d856b93e9ec3a299622f6084e4be"}, + {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c73e2e74bbb07910da0d37c326869f34113137b23eadad3fc00856e6b3d9930c"}, + {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4eeb12daf02a59e29f578a865f55d87cd103ce62bd8a3a5874f8fdeaa82e336b"}, + {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9ba9f6895af58487ca4f54e8a664a322f16c26bbb442effd01087eba391a719e"}, + {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ccec77aa7150e38eec6878a493bf8c263ff1fa8a62404e16c6203c64c1f16a26"}, + {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3f40604f5042ff210ba82743dda2b6aa3e55aa12df4e9f2378ee01a17e2855e"}, + {file = "tokenizers-0.15.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:5645938a42d78c4885086767c70923abad047163d809c16da75d6b290cb30bbe"}, + {file = "tokenizers-0.15.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:05a77cbfebe28a61ab5c3891f9939cc24798b63fa236d84e5f29f3a85a200c00"}, + {file = "tokenizers-0.15.2-cp37-none-win32.whl", hash = "sha256:361abdc068e8afe9c5b818769a48624687fb6aaed49636ee39bec4e95e1a215b"}, + {file = "tokenizers-0.15.2-cp37-none-win_amd64.whl", hash = "sha256:7ef789f83eb0f9baeb4d09a86cd639c0a5518528f9992f38b28e819df397eb06"}, + {file = "tokenizers-0.15.2-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:4fe1f74a902bee74a3b25aff180fbfbf4f8b444ab37c4d496af7afd13a784ed2"}, + {file = "tokenizers-0.15.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4c4b89038a684f40a6b15d6b09f49650ac64d951ad0f2a3ea9169687bbf2a8ba"}, + {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:d05a1b06f986d41aed5f2de464c003004b2df8aaf66f2b7628254bcbfb72a438"}, + {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:508711a108684111ec8af89d3a9e9e08755247eda27d0ba5e3c50e9da1600f6d"}, + {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:daa348f02d15160cb35439098ac96e3a53bacf35885072611cd9e5be7d333daa"}, + {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:494fdbe5932d3416de2a85fc2470b797e6f3226c12845cadf054dd906afd0442"}, + {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c2d60f5246f4da9373f75ff18d64c69cbf60c3bca597290cea01059c336d2470"}, + {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93268e788825f52de4c7bdcb6ebc1fcd4a5442c02e730faa9b6b08f23ead0e24"}, + {file = "tokenizers-0.15.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6fc7083ab404019fc9acafe78662c192673c1e696bd598d16dc005bd663a5cf9"}, + {file = "tokenizers-0.15.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:41e39b41e5531d6b2122a77532dbea60e171ef87a3820b5a3888daa847df4153"}, + {file = "tokenizers-0.15.2-cp38-none-win32.whl", hash = "sha256:06cd0487b1cbfabefb2cc52fbd6b1f8d4c37799bd6c6e1641281adaa6b2504a7"}, + {file = "tokenizers-0.15.2-cp38-none-win_amd64.whl", hash = "sha256:5179c271aa5de9c71712e31cb5a79e436ecd0d7532a408fa42a8dbfa4bc23fd9"}, + {file = "tokenizers-0.15.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:82f8652a74cc107052328b87ea8b34291c0f55b96d8fb261b3880216a9f9e48e"}, + {file = "tokenizers-0.15.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:02458bee6f5f3139f1ebbb6d042b283af712c0981f5bc50edf771d6b762d5e4f"}, + {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c9a09cd26cca2e1c349f91aa665309ddb48d71636370749414fbf67bc83c5343"}, + {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:158be8ea8554e5ed69acc1ce3fbb23a06060bd4bbb09029431ad6b9a466a7121"}, + {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1ddba9a2b0c8c81633eca0bb2e1aa5b3a15362b1277f1ae64176d0f6eba78ab1"}, + {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3ef5dd1d39797044642dbe53eb2bc56435308432e9c7907728da74c69ee2adca"}, + {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:454c203164e07a860dbeb3b1f4a733be52b0edbb4dd2e5bd75023ffa8b49403a"}, + {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0cf6b7f1d4dc59af960e6ffdc4faffe6460bbfa8dce27a58bf75755ffdb2526d"}, + {file = "tokenizers-0.15.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:2ef09bbc16519f6c25d0c7fc0c6a33a6f62923e263c9d7cca4e58b8c61572afb"}, + {file = "tokenizers-0.15.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c9a2ebdd2ad4ec7a68e7615086e633857c85e2f18025bd05d2a4399e6c5f7169"}, + {file = "tokenizers-0.15.2-cp39-none-win32.whl", hash = "sha256:918fbb0eab96fe08e72a8c2b5461e9cce95585d82a58688e7f01c2bd546c79d0"}, + {file = "tokenizers-0.15.2-cp39-none-win_amd64.whl", hash = "sha256:524e60da0135e106b254bd71f0659be9f89d83f006ea9093ce4d1fab498c6d0d"}, + {file = "tokenizers-0.15.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:6a9b648a58281c4672212fab04e60648fde574877d0139cd4b4f93fe28ca8944"}, + {file = "tokenizers-0.15.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:7c7d18b733be6bbca8a55084027f7be428c947ddf871c500ee603e375013ffba"}, + {file = "tokenizers-0.15.2-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:13ca3611de8d9ddfbc4dc39ef54ab1d2d4aaa114ac8727dfdc6a6ec4be017378"}, + {file = "tokenizers-0.15.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:237d1bf3361cf2e6463e6c140628e6406766e8b27274f5fcc62c747ae3c6f094"}, + {file = "tokenizers-0.15.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67a0fe1e49e60c664915e9fb6b0cb19bac082ab1f309188230e4b2920230edb3"}, + {file = "tokenizers-0.15.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:4e022fe65e99230b8fd89ebdfea138c24421f91c1a4f4781a8f5016fd5cdfb4d"}, + {file = "tokenizers-0.15.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:d857be2df69763362ac699f8b251a8cd3fac9d21893de129bc788f8baaef2693"}, + {file = "tokenizers-0.15.2-pp37-pypy37_pp73-macosx_10_12_x86_64.whl", hash = "sha256:708bb3e4283177236309e698da5fcd0879ce8fd37457d7c266d16b550bcbbd18"}, + {file = "tokenizers-0.15.2-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:64c35e09e9899b72a76e762f9854e8750213f67567787d45f37ce06daf57ca78"}, + {file = "tokenizers-0.15.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1257f4394be0d3b00de8c9e840ca5601d0a4a8438361ce9c2b05c7d25f6057b"}, + {file = "tokenizers-0.15.2-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02272fe48280e0293a04245ca5d919b2c94a48b408b55e858feae9618138aeda"}, + {file = "tokenizers-0.15.2-pp37-pypy37_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:dc3ad9ebc76eabe8b1d7c04d38be884b8f9d60c0cdc09b0aa4e3bcf746de0388"}, + {file = "tokenizers-0.15.2-pp37-pypy37_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:32e16bdeffa7c4f46bf2152172ca511808b952701d13e7c18833c0b73cb5c23f"}, + {file = "tokenizers-0.15.2-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:fb16ba563d59003028b678d2361a27f7e4ae0ab29c7a80690efa20d829c81fdb"}, + {file = "tokenizers-0.15.2-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:2277c36d2d6cdb7876c274547921a42425b6810d38354327dd65a8009acf870c"}, + {file = "tokenizers-0.15.2-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1cf75d32e8d250781940d07f7eece253f2fe9ecdb1dc7ba6e3833fa17b82fcbc"}, + {file = "tokenizers-0.15.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1b3b31884dc8e9b21508bb76da80ebf7308fdb947a17affce815665d5c4d028"}, + {file = "tokenizers-0.15.2-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b10122d8d8e30afb43bb1fe21a3619f62c3e2574bff2699cf8af8b0b6c5dc4a3"}, + {file = "tokenizers-0.15.2-pp38-pypy38_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:d88b96ff0fe8e91f6ef01ba50b0d71db5017fa4e3b1d99681cec89a85faf7bf7"}, + {file = "tokenizers-0.15.2-pp38-pypy38_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:37aaec5a52e959892870a7c47cef80c53797c0db9149d458460f4f31e2fb250e"}, + {file = "tokenizers-0.15.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:e2ea752f2b0fe96eb6e2f3adbbf4d72aaa1272079b0dfa1145507bd6a5d537e6"}, + {file = "tokenizers-0.15.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:4b19a808d8799fda23504a5cd31d2f58e6f52f140380082b352f877017d6342b"}, + {file = "tokenizers-0.15.2-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:64c86e5e068ac8b19204419ed8ca90f9d25db20578f5881e337d203b314f4104"}, + {file = "tokenizers-0.15.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:de19c4dc503c612847edf833c82e9f73cd79926a384af9d801dcf93f110cea4e"}, + {file = "tokenizers-0.15.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea09acd2fe3324174063d61ad620dec3bcf042b495515f27f638270a7d466e8b"}, + {file = "tokenizers-0.15.2-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:cf27fd43472e07b57cf420eee1e814549203d56de00b5af8659cb99885472f1f"}, + {file = "tokenizers-0.15.2-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:7ca22bd897537a0080521445d91a58886c8c04084a6a19e6c78c586e0cfa92a5"}, + {file = "tokenizers-0.15.2.tar.gz", hash = "sha256:e6e9c6e019dd5484be5beafc775ae6c925f4c69a3487040ed09b45e13df2cb91"}, +] + +[package.dependencies] +huggingface_hub = ">=0.16.4,<1.0" + +[package.extras] +dev = ["tokenizers[testing]"] +docs = ["setuptools_rust", "sphinx", "sphinx_rtd_theme"] +testing = ["black (==22.3)", "datasets", "numpy", "pytest", "requests"] + +[[package]] +name = "toml" +version = "0.10.2" +description = "Python Library for Tom's Obvious, Minimal Language" +optional = false +python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"}, + {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"}, +] + +[[package]] +name = "toolz" +version = "0.12.1" +description = "List processing tools and functional utilities" +optional = false +python-versions = ">=3.7" +files = [ + {file = "toolz-0.12.1-py3-none-any.whl", hash = "sha256:d22731364c07d72eea0a0ad45bafb2c2937ab6fd38a3507bf55eae8744aa7d85"}, + {file = "toolz-0.12.1.tar.gz", hash = "sha256:ecca342664893f177a13dac0e6b41cbd8ac25a358e5f215316d43e2100224f4d"}, +] + +[[package]] +name = "torch" +version = "2.1.2" +description = "Tensors and Dynamic neural networks in Python with strong GPU acceleration" +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "torch-2.1.2-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:3a871edd6c02dae77ad810335c0833391c1a4ce49af21ea8cf0f6a5d2096eea8"}, + {file = "torch-2.1.2-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:bef6996c27d8f6e92ea4e13a772d89611da0e103b48790de78131e308cf73076"}, + {file = "torch-2.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:0e13034fd5fb323cbbc29e56d0637a3791e50dd589616f40c79adfa36a5a35a1"}, + {file = "torch-2.1.2-cp310-none-macosx_10_9_x86_64.whl", hash = "sha256:d9b535cad0df3d13997dbe8bd68ac33e0e3ae5377639c9881948e40794a61403"}, + {file = "torch-2.1.2-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:f9a55d55af02826ebfbadf4e9b682f0f27766bc33df8236b48d28d705587868f"}, + {file = "torch-2.1.2-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:a6ebbe517097ef289cc7952783588c72de071d4b15ce0f8b285093f0916b1162"}, + {file = "torch-2.1.2-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:8f32ce591616a30304f37a7d5ea80b69ca9e1b94bba7f308184bf616fdaea155"}, + {file = "torch-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:e0ee6cf90c8970e05760f898d58f9ac65821c37ffe8b04269ec787aa70962b69"}, + {file = "torch-2.1.2-cp311-none-macosx_10_9_x86_64.whl", hash = "sha256:76d37967c31c99548ad2c4d3f2cf191db48476f2e69b35a0937137116da356a1"}, + {file = "torch-2.1.2-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:e2d83f07b4aac983453ea5bf8f9aa9dacf2278a8d31247f5d9037f37befc60e4"}, + {file = "torch-2.1.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:f41fe0c7ecbf903a568c73486139a75cfab287a0f6c17ed0698fdea7a1e8641d"}, + {file = "torch-2.1.2-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:e3225f47d50bb66f756fe9196a768055d1c26b02154eb1f770ce47a2578d3aa7"}, + {file = "torch-2.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:33d59cd03cb60106857f6c26b36457793637512998666ee3ce17311f217afe2b"}, + {file = "torch-2.1.2-cp38-none-macosx_10_9_x86_64.whl", hash = "sha256:8e221deccd0def6c2badff6be403e0c53491805ed9915e2c029adbcdb87ab6b5"}, + {file = "torch-2.1.2-cp38-none-macosx_11_0_arm64.whl", hash = "sha256:05b18594f60a911a0c4f023f38a8bda77131fba5fd741bda626e97dcf5a3dd0a"}, + {file = "torch-2.1.2-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:9ca96253b761e9aaf8e06fb30a66ee301aecbf15bb5a303097de1969077620b6"}, + {file = "torch-2.1.2-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:d93ba70f67b08c2ae5598ee711cbc546a1bc8102cef938904b8c85c2089a51a0"}, + {file = "torch-2.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:255b50bc0608db177e6a3cc118961d77de7e5105f07816585fa6f191f33a9ff3"}, + {file = "torch-2.1.2-cp39-none-macosx_10_9_x86_64.whl", hash = "sha256:6984cd5057c0c977b3c9757254e989d3f1124f4ce9d07caa6cb637783c71d42a"}, + {file = "torch-2.1.2-cp39-none-macosx_11_0_arm64.whl", hash = "sha256:bc195d7927feabc0eb7c110e457c955ed2ab616f3c7c28439dd4188cf589699f"}, +] + +[package.dependencies] +filelock = "*" +fsspec = "*" +jinja2 = "*" +networkx = "*" +nvidia-cublas-cu12 = {version = "12.1.3.1", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cuda-cupti-cu12 = {version = "12.1.105", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cuda-nvrtc-cu12 = {version = "12.1.105", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cuda-runtime-cu12 = {version = "12.1.105", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cudnn-cu12 = {version = "8.9.2.26", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cufft-cu12 = {version = "11.0.2.54", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-curand-cu12 = {version = "10.3.2.106", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cusolver-cu12 = {version = "11.4.5.107", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cusparse-cu12 = {version = "12.1.0.106", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-nccl-cu12 = {version = "2.18.1", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-nvtx-cu12 = {version = "12.1.105", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +sympy = "*" +triton = {version = "2.1.0", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +typing-extensions = "*" + +[package.extras] +dynamo = ["jinja2"] +opt-einsum = ["opt-einsum (>=3.3)"] + +[[package]] +name = "torchaudio" +version = "2.1.2" +description = "An audio package for PyTorch" +optional = false +python-versions = "*" +files = [ + {file = "torchaudio-2.1.2-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:06f8c02814e6cdd78626bbf44ad2bb8afa5b39ab650c6af18328a32311461058"}, + {file = "torchaudio-2.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9d676673c1ce4dd11fca145e3a6cd9b4e5b897cffad0f617d2906f2d3fc8c3a9"}, + {file = "torchaudio-2.1.2-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:23c1b34e98664a0ac239efd4e1a0af407b3dd0a86a5869114bae582c3e5437d7"}, + {file = "torchaudio-2.1.2-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:f82657fc4ec3b473bf6c752c0ee62d7f511af9ef37e5143f8339ec049504d767"}, + {file = "torchaudio-2.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:683eaa721e016ca1f27bb28fa89feae37a6f7b98ff1ceee0d5e5aedd19bd982c"}, + {file = "torchaudio-2.1.2-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:c1084eedf4ced1af9fdd18910690ff615f89baeb30b32030806543fbc6f3657e"}, + {file = "torchaudio-2.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:860acc32e6507063f2c13d81e26718199e215f34a2bcd6c9609a25e9bf21aa36"}, + {file = "torchaudio-2.1.2-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:50c651d60bde7a4e096bf376eddb9ea32da6e37c3827536d6e918798ad203dbf"}, + {file = "torchaudio-2.1.2-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:9a6bade8a2495a724f4ee6acb5e86828ff4083dc6c7c57c6386b54a0ea7afe71"}, + {file = "torchaudio-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:47f322708c282e0b1b7548cdbe4e12451c531061761885d7c7fe2e479a4a3861"}, + {file = "torchaudio-2.1.2-cp38-cp38-macosx_10_13_x86_64.whl", hash = "sha256:d0efd008c35dec962b80f5dce3468bd1b88301cf65152bbfa7f74c0005a17e89"}, + {file = "torchaudio-2.1.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:30ad97112412592518953f3cc2cd1b6ae153d6563dd5bd9eab6a972315fe9d9e"}, + {file = "torchaudio-2.1.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:c33e05c2305bc4d659aaf77a385433e3f8ac07ae235d3b15d6ef4ff995258746"}, + {file = "torchaudio-2.1.2-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:ff7156b30eb05e9124286c30c80da84b93e227d009adb96eb19489600b459332"}, + {file = "torchaudio-2.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:dbaefae9ca0b208ce0157e0358cea8ab796c9e26a2c61c3d181246e4010b04d2"}, + {file = "torchaudio-2.1.2-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:ae50dcf34d5c6f73180cf694195ee31194b9d6090328575c30a5960bc716fa52"}, + {file = "torchaudio-2.1.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:14729cc9df52defa674fcf5ed4de0d6507038ef18012b96a2f56a77ed70676dd"}, + {file = "torchaudio-2.1.2-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:03b4cf02ee468b25280f9593cca95a32b517a88512a1e5f41129e24cd0c17e64"}, + {file = "torchaudio-2.1.2-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:b3bbb5324e705ded77616e546591b249ae7588d35a3e8c2c4c1d986a5ea51ef4"}, + {file = "torchaudio-2.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:03d2a3c9a806486f2d9646381a564a922a880b6df8f18336b6f0e4a0d8356743"}, +] + +[package.dependencies] +torch = "2.1.2" + +[[package]] +name = "torchmetrics" +version = "0.2.0" +description = "PyTorch native Metrics" +optional = false +python-versions = ">=3.6" +files = [ + {file = "torchmetrics-0.2.0-py3-none-any.whl", hash = "sha256:16a8ceac8e579828aa8a5a4f8830fc207a18e0fbc8774257fbb1cbfb95248faf"}, + {file = "torchmetrics-0.2.0.tar.gz", hash = "sha256:481a28759acd2d77cc088acba6bc7dc4a356c7cb767da2e1495e91e612e2d548"}, +] + +[package.dependencies] +torch = ">=1.3.1" + +[[package]] +name = "torchvision" +version = "0.16.2" +description = "image and video datasets and models for torch deep learning" +optional = false +python-versions = ">=3.8" +files = [ + {file = "torchvision-0.16.2-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:bc86f2800cb2c0c1a09c581409cdd6bff66e62f103dc83fc63f73346264c3756"}, + {file = "torchvision-0.16.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b024bd412df6d3a007dcebf311a894eb3c5c21e1af80d12be382bbcb097a7c3a"}, + {file = "torchvision-0.16.2-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:e89f10f3c8351972b6e3fda95bc3e479ea8dbfc9dfcfd2c32902dbad4ba5cfc5"}, + {file = "torchvision-0.16.2-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:96c7583700112a410bdc4e1e4f118c429dab49c29c9a31a2cc3579bc9b08b19d"}, + {file = "torchvision-0.16.2-cp310-cp310-win_amd64.whl", hash = "sha256:9f4032ebb3277fb07ff6a9b818d50a547fb8fcd89d958cfd9e773322454bb688"}, + {file = "torchvision-0.16.2-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:67b1aaf8b8cb02ce75dd445f291a27c8036a502f8c0aa76e28c37a0faac2e153"}, + {file = "torchvision-0.16.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bef30d03e1d1c629761f4dca51d3b7d8a0dc0acce6f4068ab2a1634e8e7b64e0"}, + {file = "torchvision-0.16.2-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:e59cc7b2bd1ab5c0ce4ae382e4e37be8f1c174e8b5de2f6a23c170de9ae28495"}, + {file = "torchvision-0.16.2-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:e130b08cc9b3cc73a6c59d6edf032394a322f9579bfd21d14bc2e1d0999aa758"}, + {file = "torchvision-0.16.2-cp311-cp311-win_amd64.whl", hash = "sha256:8692ab1e48807e9604046a6f4beeb67b523294cee1b00828654bb0df2cfce2b2"}, + {file = "torchvision-0.16.2-cp38-cp38-macosx_10_13_x86_64.whl", hash = "sha256:b82732dcf876a37c852772342aa6ee3480c03bb3e2a802ae109fc5f7e28d26e9"}, + {file = "torchvision-0.16.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4b065143d1a720fe8a9077fd4be35d491f98819ec80b3dbbc3ec64d0b707a906"}, + {file = "torchvision-0.16.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:bc5f274e4ecd1b86062063cdf4fd385a1d39d147a3a2685fbbde9ff08bb720b8"}, + {file = "torchvision-0.16.2-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:335959c43b371c0474af34c1ef2a52efdc7603c45700d29e4475eeb02984170c"}, + {file = "torchvision-0.16.2-cp38-cp38-win_amd64.whl", hash = "sha256:7fd22d86e08eba321af70cad291020c2cdeac069b00ce88b923ca52e06174769"}, + {file = "torchvision-0.16.2-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:56115268b37f0b75364e3654e47ad9abc66ac34c1f9e5e3dfa89a22d6a40017a"}, + {file = "torchvision-0.16.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:82805f8445b094f9d1e770390ee6cc86855e89955e08ce34af2e2274fc0e5c45"}, + {file = "torchvision-0.16.2-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:3f4bd5fcbc361476e2e78016636ac7d5509e59d9962521f06eb98e6803898182"}, + {file = "torchvision-0.16.2-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:8199acdf8ab066a28b84a5b6f4d97b58976d9e164b1acc3a9d14fccfaf74bb3a"}, + {file = "torchvision-0.16.2-cp39-cp39-win_amd64.whl", hash = "sha256:41dd4fa9f176d563fe9f1b9adef3b7e582cdfb60ce8c9bc51b094a025be687c9"}, +] + +[package.dependencies] +numpy = "*" +pillow = ">=5.3.0,<8.3.dev0 || >=8.4.dev0" +requests = "*" +torch = "2.1.2" + +[package.extras] +scipy = ["scipy"] + +[[package]] +name = "tornado" +version = "6.4.1" +description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +optional = false +python-versions = ">=3.8" +files = [ + {file = "tornado-6.4.1-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:163b0aafc8e23d8cdc3c9dfb24c5368af84a81e3364745ccb4427669bf84aec8"}, + {file = "tornado-6.4.1-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:6d5ce3437e18a2b66fbadb183c1d3364fb03f2be71299e7d10dbeeb69f4b2a14"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e20b9113cd7293f164dc46fffb13535266e713cdb87bd2d15ddb336e96cfc4"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ae50a504a740365267b2a8d1a90c9fbc86b780a39170feca9bcc1787ff80842"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:613bf4ddf5c7a95509218b149b555621497a6cc0d46ac341b30bd9ec19eac7f3"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:25486eb223babe3eed4b8aecbac33b37e3dd6d776bc730ca14e1bf93888b979f"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:454db8a7ecfcf2ff6042dde58404164d969b6f5d58b926da15e6b23817950fc4"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a02a08cc7a9314b006f653ce40483b9b3c12cda222d6a46d4ac63bb6c9057698"}, + {file = "tornado-6.4.1-cp38-abi3-win32.whl", hash = "sha256:d9a566c40b89757c9aa8e6f032bcdb8ca8795d7c1a9762910c722b1635c9de4d"}, + {file = "tornado-6.4.1-cp38-abi3-win_amd64.whl", hash = "sha256:b24b8982ed444378d7f21d563f4180a2de31ced9d8d84443907a0a64da2072e7"}, + {file = "tornado-6.4.1.tar.gz", hash = "sha256:92d3ab53183d8c50f8204a51e6f91d18a15d5ef261e84d452800d4ff6fc504e9"}, +] + +[[package]] +name = "tqdm" +version = "4.66.4" +description = "Fast, Extensible Progress Meter" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tqdm-4.66.4-py3-none-any.whl", hash = "sha256:b75ca56b413b030bc3f00af51fd2c1a1a5eac6a0c1cca83cbb37a5c52abce644"}, + {file = "tqdm-4.66.4.tar.gz", hash = "sha256:e4d936c9de8727928f3be6079590e97d9abfe8d39a590be678eb5919ffc186bb"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[package.extras] +dev = ["pytest (>=6)", "pytest-cov", "pytest-timeout", "pytest-xdist"] +notebook = ["ipywidgets (>=6)"] +slack = ["slack-sdk"] +telegram = ["requests"] + +[[package]] +name = "transformers" +version = "4.35.2" +description = "State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow" +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "transformers-4.35.2-py3-none-any.whl", hash = "sha256:9dfa76f8692379544ead84d98f537be01cd1070de75c74efb13abcbc938fbe2f"}, + {file = "transformers-4.35.2.tar.gz", hash = "sha256:2d125e197d77b0cdb6c9201df9fa7e2101493272e448b9fba9341c695bee2f52"}, +] + +[package.dependencies] +filelock = "*" +huggingface-hub = ">=0.16.4,<1.0" +numpy = ">=1.17" +packaging = ">=20.0" +pyyaml = ">=5.1" +regex = "!=2019.12.17" +requests = "*" +safetensors = ">=0.3.1" +tokenizers = ">=0.14,<0.19" +tqdm = ">=4.27" + +[package.extras] +accelerate = ["accelerate (>=0.20.3)"] +agents = ["Pillow (<10.0.0)", "accelerate (>=0.20.3)", "datasets (!=2.5.0)", "diffusers", "opencv-python", "sentencepiece (>=0.1.91,!=0.1.92)", "torch (>=1.10,!=1.12.0)"] +all = ["Pillow (<10.0.0)", "accelerate (>=0.20.3)", "av (==9.2.0)", "codecarbon (==1.2.0)", "decord (==0.6.0)", "flax (>=0.4.1,<=0.7.0)", "jax (>=0.4.1,<=0.4.13)", "jaxlib (>=0.4.1,<=0.4.13)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "onnxconverter-common", "optax (>=0.0.8,<=0.1.4)", "optuna", "phonemizer", "protobuf", "pyctcdecode (>=0.4.0)", "ray[tune]", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "tensorflow (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx", "timm", "tokenizers (>=0.14,<0.19)", "torch (>=1.10,!=1.12.0)", "torchaudio", "torchvision"] +audio = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)"] +codecarbon = ["codecarbon (==1.2.0)"] +deepspeed = ["accelerate (>=0.20.3)", "deepspeed (>=0.9.3)"] +deepspeed-testing = ["GitPython (<3.1.19)", "accelerate (>=0.20.3)", "beautifulsoup4", "black (>=23.1,<24.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "deepspeed (>=0.9.3)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "hf-doc-builder (>=0.3.0)", "nltk", "optuna", "parameterized", "protobuf", "psutil", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "sentencepiece (>=0.1.91,!=0.1.92)", "tensorboard", "timeout-decorator"] +dev = ["GitPython (<3.1.19)", "Pillow (<10.0.0)", "accelerate (>=0.20.3)", "av (==9.2.0)", "beautifulsoup4", "black (>=23.1,<24.0)", "codecarbon (==1.2.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "decord (==0.6.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "flax (>=0.4.1,<=0.7.0)", "fugashi (>=1.0)", "hf-doc-builder", "hf-doc-builder (>=0.3.0)", "ipadic (>=1.0.0,<2.0)", "isort (>=5.5.4)", "jax (>=0.4.1,<=0.4.13)", "jaxlib (>=0.4.1,<=0.4.13)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "nltk", "onnxconverter-common", "optax (>=0.0.8,<=0.1.4)", "optuna", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "ray[tune]", "rhoknp (>=1.1.0,<1.3.1)", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (>=0.0.241,<=0.0.259)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "sudachidict-core (>=20220729)", "sudachipy (>=0.6.6)", "tensorboard", "tensorflow (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx", "timeout-decorator", "timm", "tokenizers (>=0.14,<0.19)", "torch (>=1.10,!=1.12.0)", "torchaudio", "torchvision", "unidic (>=1.0.2)", "unidic-lite (>=1.0.7)", "urllib3 (<2.0.0)"] +dev-tensorflow = ["GitPython (<3.1.19)", "Pillow (<10.0.0)", "beautifulsoup4", "black (>=23.1,<24.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "hf-doc-builder", "hf-doc-builder (>=0.3.0)", "isort (>=5.5.4)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "nltk", "onnxconverter-common", "onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (>=0.0.241,<=0.0.259)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "sentencepiece (>=0.1.91,!=0.1.92)", "tensorboard", "tensorflow (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx", "timeout-decorator", "tokenizers (>=0.14,<0.19)", "urllib3 (<2.0.0)"] +dev-torch = ["GitPython (<3.1.19)", "Pillow (<10.0.0)", "accelerate (>=0.20.3)", "beautifulsoup4", "black (>=23.1,<24.0)", "codecarbon (==1.2.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "fugashi (>=1.0)", "hf-doc-builder", "hf-doc-builder (>=0.3.0)", "ipadic (>=1.0.0,<2.0)", "isort (>=5.5.4)", "kenlm", "librosa", "nltk", "onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)", "optuna", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "ray[tune]", "rhoknp (>=1.1.0,<1.3.1)", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (>=0.0.241,<=0.0.259)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "sudachidict-core (>=20220729)", "sudachipy (>=0.6.6)", "tensorboard", "timeout-decorator", "timm", "tokenizers (>=0.14,<0.19)", "torch (>=1.10,!=1.12.0)", "torchaudio", "torchvision", "unidic (>=1.0.2)", "unidic-lite (>=1.0.7)", "urllib3 (<2.0.0)"] +docs = ["Pillow (<10.0.0)", "accelerate (>=0.20.3)", "av (==9.2.0)", "codecarbon (==1.2.0)", "decord (==0.6.0)", "flax (>=0.4.1,<=0.7.0)", "hf-doc-builder", "jax (>=0.4.1,<=0.4.13)", "jaxlib (>=0.4.1,<=0.4.13)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "onnxconverter-common", "optax (>=0.0.8,<=0.1.4)", "optuna", "phonemizer", "protobuf", "pyctcdecode (>=0.4.0)", "ray[tune]", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "tensorflow (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx", "timm", "tokenizers (>=0.14,<0.19)", "torch (>=1.10,!=1.12.0)", "torchaudio", "torchvision"] +docs-specific = ["hf-doc-builder"] +flax = ["flax (>=0.4.1,<=0.7.0)", "jax (>=0.4.1,<=0.4.13)", "jaxlib (>=0.4.1,<=0.4.13)", "optax (>=0.0.8,<=0.1.4)"] +flax-speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)"] +ftfy = ["ftfy"] +integrations = ["optuna", "ray[tune]", "sigopt"] +ja = ["fugashi (>=1.0)", "ipadic (>=1.0.0,<2.0)", "rhoknp (>=1.1.0,<1.3.1)", "sudachidict-core (>=20220729)", "sudachipy (>=0.6.6)", "unidic (>=1.0.2)", "unidic-lite (>=1.0.7)"] +modelcreation = ["cookiecutter (==1.7.3)"] +natten = ["natten (>=0.14.6)"] +onnx = ["onnxconverter-common", "onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)", "tf2onnx"] +onnxruntime = ["onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)"] +optuna = ["optuna"] +quality = ["GitPython (<3.1.19)", "black (>=23.1,<24.0)", "datasets (!=2.5.0)", "hf-doc-builder (>=0.3.0)", "isort (>=5.5.4)", "ruff (>=0.0.241,<=0.0.259)", "urllib3 (<2.0.0)"] +ray = ["ray[tune]"] +retrieval = ["datasets (!=2.5.0)", "faiss-cpu"] +sagemaker = ["sagemaker (>=2.31.0)"] +sentencepiece = ["protobuf", "sentencepiece (>=0.1.91,!=0.1.92)"] +serving = ["fastapi", "pydantic (<2)", "starlette", "uvicorn"] +sigopt = ["sigopt"] +sklearn = ["scikit-learn"] +speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)", "torchaudio"] +testing = ["GitPython (<3.1.19)", "beautifulsoup4", "black (>=23.1,<24.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "hf-doc-builder (>=0.3.0)", "nltk", "parameterized", "protobuf", "psutil", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "tensorboard", "timeout-decorator"] +tf = ["keras-nlp (>=0.3.1)", "onnxconverter-common", "tensorflow (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx"] +tf-cpu = ["keras-nlp (>=0.3.1)", "onnxconverter-common", "tensorflow-cpu (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx"] +tf-speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)"] +timm = ["timm"] +tokenizers = ["tokenizers (>=0.14,<0.19)"] +torch = ["accelerate (>=0.20.3)", "torch (>=1.10,!=1.12.0)"] +torch-speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)", "torchaudio"] +torch-vision = ["Pillow (<10.0.0)", "torchvision"] +torchhub = ["filelock", "huggingface-hub (>=0.16.4,<1.0)", "importlib-metadata", "numpy (>=1.17)", "packaging (>=20.0)", "protobuf", "regex (!=2019.12.17)", "requests", "sentencepiece (>=0.1.91,!=0.1.92)", "tokenizers (>=0.14,<0.19)", "torch (>=1.10,!=1.12.0)", "tqdm (>=4.27)"] +video = ["av (==9.2.0)", "decord (==0.6.0)"] +vision = ["Pillow (<10.0.0)"] + +[[package]] +name = "triton" +version = "2.1.0" +description = "A language and compiler for custom Deep Learning operations" +optional = false +python-versions = "*" +files = [ + {file = "triton-2.1.0-0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:66439923a30d5d48399b08a9eae10370f6c261a5ec864a64983bae63152d39d7"}, + {file = "triton-2.1.0-0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:919b06453f0033ea52c13eaf7833de0e57db3178d23d4e04f9fc71c4f2c32bf8"}, + {file = "triton-2.1.0-0-cp37-cp37m-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ae4bb8a91de790e1866405211c4d618379781188f40d5c4c399766914e84cd94"}, + {file = "triton-2.1.0-0-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39f6fb6bdccb3e98f3152e3fbea724f1aeae7d749412bbb1fa9c441d474eba26"}, + {file = "triton-2.1.0-0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:21544e522c02005a626c8ad63d39bdff2f31d41069592919ef281e964ed26446"}, + {file = "triton-2.1.0-0-pp37-pypy37_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:143582ca31dd89cd982bd3bf53666bab1c7527d41e185f9e3d8a3051ce1b663b"}, + {file = "triton-2.1.0-0-pp38-pypy38_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:82fc5aeeedf6e36be4e4530cbdcba81a09d65c18e02f52dc298696d45721f3bd"}, + {file = "triton-2.1.0-0-pp39-pypy39_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:81a96d110a738ff63339fc892ded095b31bd0d205e3aace262af8400d40b6fa8"}, +] + +[package.dependencies] +filelock = "*" + +[package.extras] +build = ["cmake (>=3.18)", "lit"] +tests = ["autopep8", "flake8", "isort", "numpy", "pytest", "scipy (>=1.7.1)"] +tutorials = ["matplotlib", "pandas", "tabulate"] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +description = "Backported and Experimental Type Hints for Python 3.8+" +optional = false +python-versions = ">=3.8" +files = [ + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, +] + +[[package]] +name = "urllib3" +version = "2.2.1" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.8" +files = [ + {file = "urllib3-2.2.1-py3-none-any.whl", hash = "sha256:450b20ec296a467077128bff42b73080516e71b56ff59a60a02bef2232c4fa9d"}, + {file = "urllib3-2.2.1.tar.gz", hash = "sha256:d0570876c61ab9e520d776c38acbbb5b05a776d3f9ff98a5c8fd5162a444cf19"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +h2 = ["h2 (>=4,<5)"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["zstandard (>=0.18.0)"] + +[[package]] +name = "wandb" +version = "0.15.12" +description = "A CLI and library for interacting with the Weights & Biases API." +optional = false +python-versions = ">=3.6" +files = [ + {file = "wandb-0.15.12-py3-none-any.whl", hash = "sha256:75c57b5bb8ddae21d45a02f644628585bdd112fea686de3177099a0996f1c41c"}, + {file = "wandb-0.15.12.tar.gz", hash = "sha256:c344d92fb8044b072a6138afd9adc5d3801ad050cf11378fe2af2fe899dcca84"}, +] + +[package.dependencies] +appdirs = ">=1.4.3" +Click = ">=7.1,<8.0.0 || >8.0.0" +docker-pycreds = ">=0.4.0" +GitPython = ">=1.0.0,<3.1.29 || >3.1.29" +pathtools = "*" +protobuf = [ + {version = ">=3.15.0,<4.21.0 || >4.21.0,<5", markers = "python_version == \"3.9\" and sys_platform == \"linux\""}, + {version = ">=3.19.0,<4.21.0 || >4.21.0,<5", markers = "sys_platform != \"linux\""}, +] +psutil = ">=5.0.0" +PyYAML = "*" +requests = ">=2.0.0,<3" +sentry-sdk = ">=1.0.0" +setproctitle = "*" +setuptools = "*" +typing-extensions = {version = "*", markers = "python_version < \"3.10\""} + +[package.extras] +async = ["httpx (>=0.22.0)"] +aws = ["boto3"] +azure = ["azure-identity", "azure-storage-blob"] +gcp = ["google-cloud-storage"] +kubeflow = ["google-cloud-storage", "kubernetes", "minio", "sh"] +launch = ["PyYAML (>=6.0.0)", "awscli", "azure-containerregistry", "azure-identity", "azure-storage-blob", "boto3", "botocore", "chardet", "google-auth", "google-cloud-artifact-registry", "google-cloud-compute", "google-cloud-storage", "iso8601", "kubernetes", "nbconvert", "nbformat", "optuna", "typing-extensions"] +media = ["bokeh", "moviepy", "numpy", "pillow", "plotly", "rdkit-pypi", "soundfile"] +models = ["cloudpickle"] +nexus = ["wandb-core (>=0.16.0b1)"] +perf = ["orjson"] +sweeps = ["sweeps (>=0.2.0)"] + +[[package]] +name = "watchdog" +version = "4.0.1" +description = "Filesystem events monitoring" +optional = false +python-versions = ">=3.8" +files = [ + {file = "watchdog-4.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:da2dfdaa8006eb6a71051795856bedd97e5b03e57da96f98e375682c48850645"}, + {file = "watchdog-4.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e93f451f2dfa433d97765ca2634628b789b49ba8b504fdde5837cdcf25fdb53b"}, + {file = "watchdog-4.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ef0107bbb6a55f5be727cfc2ef945d5676b97bffb8425650dadbb184be9f9a2b"}, + {file = "watchdog-4.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:17e32f147d8bf9657e0922c0940bcde863b894cd871dbb694beb6704cfbd2fb5"}, + {file = "watchdog-4.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:03e70d2df2258fb6cb0e95bbdbe06c16e608af94a3ffbd2b90c3f1e83eb10767"}, + {file = "watchdog-4.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:123587af84260c991dc5f62a6e7ef3d1c57dfddc99faacee508c71d287248459"}, + {file = "watchdog-4.0.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:093b23e6906a8b97051191a4a0c73a77ecc958121d42346274c6af6520dec175"}, + {file = "watchdog-4.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:611be3904f9843f0529c35a3ff3fd617449463cb4b73b1633950b3d97fa4bfb7"}, + {file = "watchdog-4.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:62c613ad689ddcb11707f030e722fa929f322ef7e4f18f5335d2b73c61a85c28"}, + {file = "watchdog-4.0.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:d4925e4bf7b9bddd1c3de13c9b8a2cdb89a468f640e66fbfabaf735bd85b3e35"}, + {file = "watchdog-4.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:cad0bbd66cd59fc474b4a4376bc5ac3fc698723510cbb64091c2a793b18654db"}, + {file = "watchdog-4.0.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a3c2c317a8fb53e5b3d25790553796105501a235343f5d2bf23bb8649c2c8709"}, + {file = "watchdog-4.0.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c9904904b6564d4ee8a1ed820db76185a3c96e05560c776c79a6ce5ab71888ba"}, + {file = "watchdog-4.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:667f3c579e813fcbad1b784db7a1aaa96524bed53437e119f6a2f5de4db04235"}, + {file = "watchdog-4.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d10a681c9a1d5a77e75c48a3b8e1a9f2ae2928eda463e8d33660437705659682"}, + {file = "watchdog-4.0.1-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0144c0ea9997b92615af1d94afc0c217e07ce2c14912c7b1a5731776329fcfc7"}, + {file = "watchdog-4.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:998d2be6976a0ee3a81fb8e2777900c28641fb5bfbd0c84717d89bca0addcdc5"}, + {file = "watchdog-4.0.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e7921319fe4430b11278d924ef66d4daa469fafb1da679a2e48c935fa27af193"}, + {file = "watchdog-4.0.1-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:f0de0f284248ab40188f23380b03b59126d1479cd59940f2a34f8852db710625"}, + {file = "watchdog-4.0.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:bca36be5707e81b9e6ce3208d92d95540d4ca244c006b61511753583c81c70dd"}, + {file = "watchdog-4.0.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:ab998f567ebdf6b1da7dc1e5accfaa7c6992244629c0fdaef062f43249bd8dee"}, + {file = "watchdog-4.0.1-py3-none-manylinux2014_aarch64.whl", hash = "sha256:dddba7ca1c807045323b6af4ff80f5ddc4d654c8bce8317dde1bd96b128ed253"}, + {file = "watchdog-4.0.1-py3-none-manylinux2014_armv7l.whl", hash = "sha256:4513ec234c68b14d4161440e07f995f231be21a09329051e67a2118a7a612d2d"}, + {file = "watchdog-4.0.1-py3-none-manylinux2014_i686.whl", hash = "sha256:4107ac5ab936a63952dea2a46a734a23230aa2f6f9db1291bf171dac3ebd53c6"}, + {file = "watchdog-4.0.1-py3-none-manylinux2014_ppc64.whl", hash = "sha256:6e8c70d2cd745daec2a08734d9f63092b793ad97612470a0ee4cbb8f5f705c57"}, + {file = "watchdog-4.0.1-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:f27279d060e2ab24c0aa98363ff906d2386aa6c4dc2f1a374655d4e02a6c5e5e"}, + {file = "watchdog-4.0.1-py3-none-manylinux2014_s390x.whl", hash = "sha256:f8affdf3c0f0466e69f5b3917cdd042f89c8c63aebdb9f7c078996f607cdb0f5"}, + {file = "watchdog-4.0.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:ac7041b385f04c047fcc2951dc001671dee1b7e0615cde772e84b01fbf68ee84"}, + {file = "watchdog-4.0.1-py3-none-win32.whl", hash = "sha256:206afc3d964f9a233e6ad34618ec60b9837d0582b500b63687e34011e15bb429"}, + {file = "watchdog-4.0.1-py3-none-win_amd64.whl", hash = "sha256:7577b3c43e5909623149f76b099ac49a1a01ca4e167d1785c76eb52fa585745a"}, + {file = "watchdog-4.0.1-py3-none-win_ia64.whl", hash = "sha256:d7b9f5f3299e8dd230880b6c55504a1f69cf1e4316275d1b215ebdd8187ec88d"}, + {file = "watchdog-4.0.1.tar.gz", hash = "sha256:eebaacf674fa25511e8867028d281e602ee6500045b57f43b08778082f7f8b44"}, +] + +[package.extras] +watchmedo = ["PyYAML (>=3.10)"] + +[[package]] +name = "wcwidth" +version = "0.2.13" +description = "Measures the displayed width of unicode strings in a terminal" +optional = false +python-versions = "*" +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "werkzeug" +version = "3.0.3" +description = "The comprehensive WSGI web application library." +optional = false +python-versions = ">=3.8" +files = [ + {file = "werkzeug-3.0.3-py3-none-any.whl", hash = "sha256:fc9645dc43e03e4d630d23143a04a7f947a9a3b5727cd535fdfe155a17cc48c8"}, + {file = "werkzeug-3.0.3.tar.gz", hash = "sha256:097e5bfda9f0aba8da6b8545146def481d06aa7d3266e7448e2cccf67dd8bd18"}, +] + +[package.dependencies] +MarkupSafe = ">=2.1.1" + +[package.extras] +watchdog = ["watchdog (>=2.3)"] + +[[package]] +name = "yarl" +version = "1.9.4" +description = "Yet another URL library" +optional = false +python-versions = ">=3.7" +files = [ + {file = "yarl-1.9.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a8c1df72eb746f4136fe9a2e72b0c9dc1da1cbd23b5372f94b5820ff8ae30e0e"}, + {file = "yarl-1.9.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a3a6ed1d525bfb91b3fc9b690c5a21bb52de28c018530ad85093cc488bee2dd2"}, + {file = "yarl-1.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c38c9ddb6103ceae4e4498f9c08fac9b590c5c71b0370f98714768e22ac6fa66"}, + {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d9e09c9d74f4566e905a0b8fa668c58109f7624db96a2171f21747abc7524234"}, + {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b8477c1ee4bd47c57d49621a062121c3023609f7a13b8a46953eb6c9716ca392"}, + {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5ff2c858f5f6a42c2a8e751100f237c5e869cbde669a724f2062d4c4ef93551"}, + {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:357495293086c5b6d34ca9616a43d329317feab7917518bc97a08f9e55648455"}, + {file = "yarl-1.9.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:54525ae423d7b7a8ee81ba189f131054defdb122cde31ff17477951464c1691c"}, + {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:801e9264d19643548651b9db361ce3287176671fb0117f96b5ac0ee1c3530d53"}, + {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e516dc8baf7b380e6c1c26792610230f37147bb754d6426462ab115a02944385"}, + {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:7d5aaac37d19b2904bb9dfe12cdb08c8443e7ba7d2852894ad448d4b8f442863"}, + {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:54beabb809ffcacbd9d28ac57b0db46e42a6e341a030293fb3185c409e626b8b"}, + {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bac8d525a8dbc2a1507ec731d2867025d11ceadcb4dd421423a5d42c56818541"}, + {file = "yarl-1.9.4-cp310-cp310-win32.whl", hash = "sha256:7855426dfbddac81896b6e533ebefc0af2f132d4a47340cee6d22cac7190022d"}, + {file = "yarl-1.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:848cd2a1df56ddbffeb375535fb62c9d1645dde33ca4d51341378b3f5954429b"}, + {file = "yarl-1.9.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:35a2b9396879ce32754bd457d31a51ff0a9d426fd9e0e3c33394bf4b9036b099"}, + {file = "yarl-1.9.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c7d56b293cc071e82532f70adcbd8b61909eec973ae9d2d1f9b233f3d943f2c"}, + {file = "yarl-1.9.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d8a1c6c0be645c745a081c192e747c5de06e944a0d21245f4cf7c05e457c36e0"}, + {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4b3c1ffe10069f655ea2d731808e76e0f452fc6c749bea04781daf18e6039525"}, + {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:549d19c84c55d11687ddbd47eeb348a89df9cb30e1993f1b128f4685cd0ebbf8"}, + {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a7409f968456111140c1c95301cadf071bd30a81cbd7ab829169fb9e3d72eae9"}, + {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e23a6d84d9d1738dbc6e38167776107e63307dfc8ad108e580548d1f2c587f42"}, + {file = "yarl-1.9.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d8b889777de69897406c9fb0b76cdf2fd0f31267861ae7501d93003d55f54fbe"}, + {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:03caa9507d3d3c83bca08650678e25364e1843b484f19986a527630ca376ecce"}, + {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:4e9035df8d0880b2f1c7f5031f33f69e071dfe72ee9310cfc76f7b605958ceb9"}, + {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:c0ec0ed476f77db9fb29bca17f0a8fcc7bc97ad4c6c1d8959c507decb22e8572"}, + {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:ee04010f26d5102399bd17f8df8bc38dc7ccd7701dc77f4a68c5b8d733406958"}, + {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:49a180c2e0743d5d6e0b4d1a9e5f633c62eca3f8a86ba5dd3c471060e352ca98"}, + {file = "yarl-1.9.4-cp311-cp311-win32.whl", hash = "sha256:81eb57278deb6098a5b62e88ad8281b2ba09f2f1147c4767522353eaa6260b31"}, + {file = "yarl-1.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:d1d2532b340b692880261c15aee4dc94dd22ca5d61b9db9a8a361953d36410b1"}, + {file = "yarl-1.9.4-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0d2454f0aef65ea81037759be5ca9947539667eecebca092733b2eb43c965a81"}, + {file = "yarl-1.9.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:44d8ffbb9c06e5a7f529f38f53eda23e50d1ed33c6c869e01481d3fafa6b8142"}, + {file = "yarl-1.9.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aaaea1e536f98754a6e5c56091baa1b6ce2f2700cc4a00b0d49eca8dea471074"}, + {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3777ce5536d17989c91696db1d459574e9a9bd37660ea7ee4d3344579bb6f129"}, + {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9fc5fc1eeb029757349ad26bbc5880557389a03fa6ada41703db5e068881e5f2"}, + {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea65804b5dc88dacd4a40279af0cdadcfe74b3e5b4c897aa0d81cf86927fee78"}, + {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa102d6d280a5455ad6a0f9e6d769989638718e938a6a0a2ff3f4a7ff8c62cc4"}, + {file = "yarl-1.9.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09efe4615ada057ba2d30df871d2f668af661e971dfeedf0c159927d48bbeff0"}, + {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:008d3e808d03ef28542372d01057fd09168419cdc8f848efe2804f894ae03e51"}, + {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:6f5cb257bc2ec58f437da2b37a8cd48f666db96d47b8a3115c29f316313654ff"}, + {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:992f18e0ea248ee03b5a6e8b3b4738850ae7dbb172cc41c966462801cbf62cf7"}, + {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0e9d124c191d5b881060a9e5060627694c3bdd1fe24c5eecc8d5d7d0eb6faabc"}, + {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3986b6f41ad22988e53d5778f91855dc0399b043fc8946d4f2e68af22ee9ff10"}, + {file = "yarl-1.9.4-cp312-cp312-win32.whl", hash = "sha256:4b21516d181cd77ebd06ce160ef8cc2a5e9ad35fb1c5930882baff5ac865eee7"}, + {file = "yarl-1.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:a9bd00dc3bc395a662900f33f74feb3e757429e545d831eef5bb280252631984"}, + {file = "yarl-1.9.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:63b20738b5aac74e239622d2fe30df4fca4942a86e31bf47a81a0e94c14df94f"}, + {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7d7f7de27b8944f1fee2c26a88b4dabc2409d2fea7a9ed3df79b67277644e17"}, + {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c74018551e31269d56fab81a728f683667e7c28c04e807ba08f8c9e3bba32f14"}, + {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ca06675212f94e7a610e85ca36948bb8fc023e458dd6c63ef71abfd482481aa5"}, + {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5aef935237d60a51a62b86249839b51345f47564208c6ee615ed2a40878dccdd"}, + {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2b134fd795e2322b7684155b7855cc99409d10b2e408056db2b93b51a52accc7"}, + {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:d25039a474c4c72a5ad4b52495056f843a7ff07b632c1b92ea9043a3d9950f6e"}, + {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:f7d6b36dd2e029b6bcb8a13cf19664c7b8e19ab3a58e0fefbb5b8461447ed5ec"}, + {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:957b4774373cf6f709359e5c8c4a0af9f6d7875db657adb0feaf8d6cb3c3964c"}, + {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:d7eeb6d22331e2fd42fce928a81c697c9ee2d51400bd1a28803965883e13cead"}, + {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:6a962e04b8f91f8c4e5917e518d17958e3bdee71fd1d8b88cdce74dd0ebbf434"}, + {file = "yarl-1.9.4-cp37-cp37m-win32.whl", hash = "sha256:f3bc6af6e2b8f92eced34ef6a96ffb248e863af20ef4fde9448cc8c9b858b749"}, + {file = "yarl-1.9.4-cp37-cp37m-win_amd64.whl", hash = "sha256:ad4d7a90a92e528aadf4965d685c17dacff3df282db1121136c382dc0b6014d2"}, + {file = "yarl-1.9.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ec61d826d80fc293ed46c9dd26995921e3a82146feacd952ef0757236fc137be"}, + {file = "yarl-1.9.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8be9e837ea9113676e5754b43b940b50cce76d9ed7d2461df1af39a8ee674d9f"}, + {file = "yarl-1.9.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:bef596fdaa8f26e3d66af846bbe77057237cb6e8efff8cd7cc8dff9a62278bbf"}, + {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2d47552b6e52c3319fede1b60b3de120fe83bde9b7bddad11a69fb0af7db32f1"}, + {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:84fc30f71689d7fc9168b92788abc977dc8cefa806909565fc2951d02f6b7d57"}, + {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4aa9741085f635934f3a2583e16fcf62ba835719a8b2b28fb2917bb0537c1dfa"}, + {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:206a55215e6d05dbc6c98ce598a59e6fbd0c493e2de4ea6cc2f4934d5a18d130"}, + {file = "yarl-1.9.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07574b007ee20e5c375a8fe4a0789fad26db905f9813be0f9fef5a68080de559"}, + {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5a2e2433eb9344a163aced6a5f6c9222c0786e5a9e9cac2c89f0b28433f56e23"}, + {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:6ad6d10ed9b67a382b45f29ea028f92d25bc0bc1daf6c5b801b90b5aa70fb9ec"}, + {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:6fe79f998a4052d79e1c30eeb7d6c1c1056ad33300f682465e1b4e9b5a188b78"}, + {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:a825ec844298c791fd28ed14ed1bffc56a98d15b8c58a20e0e08c1f5f2bea1be"}, + {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8619d6915b3b0b34420cf9b2bb6d81ef59d984cb0fde7544e9ece32b4b3043c3"}, + {file = "yarl-1.9.4-cp38-cp38-win32.whl", hash = "sha256:686a0c2f85f83463272ddffd4deb5e591c98aac1897d65e92319f729c320eece"}, + {file = "yarl-1.9.4-cp38-cp38-win_amd64.whl", hash = "sha256:a00862fb23195b6b8322f7d781b0dc1d82cb3bcac346d1e38689370cc1cc398b"}, + {file = "yarl-1.9.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:604f31d97fa493083ea21bd9b92c419012531c4e17ea6da0f65cacdcf5d0bd27"}, + {file = "yarl-1.9.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8a854227cf581330ffa2c4824d96e52ee621dd571078a252c25e3a3b3d94a1b1"}, + {file = "yarl-1.9.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ba6f52cbc7809cd8d74604cce9c14868306ae4aa0282016b641c661f981a6e91"}, + {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a6327976c7c2f4ee6816eff196e25385ccc02cb81427952414a64811037bbc8b"}, + {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8397a3817d7dcdd14bb266283cd1d6fc7264a48c186b986f32e86d86d35fbac5"}, + {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e0381b4ce23ff92f8170080c97678040fc5b08da85e9e292292aba67fdac6c34"}, + {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23d32a2594cb5d565d358a92e151315d1b2268bc10f4610d098f96b147370136"}, + {file = "yarl-1.9.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ddb2a5c08a4eaaba605340fdee8fc08e406c56617566d9643ad8bf6852778fc7"}, + {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:26a1dc6285e03f3cc9e839a2da83bcbf31dcb0d004c72d0730e755b33466c30e"}, + {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:18580f672e44ce1238b82f7fb87d727c4a131f3a9d33a5e0e82b793362bf18b4"}, + {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:29e0f83f37610f173eb7e7b5562dd71467993495e568e708d99e9d1944f561ec"}, + {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:1f23e4fe1e8794f74b6027d7cf19dc25f8b63af1483d91d595d4a07eca1fb26c"}, + {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:db8e58b9d79200c76956cefd14d5c90af54416ff5353c5bfd7cbe58818e26ef0"}, + {file = "yarl-1.9.4-cp39-cp39-win32.whl", hash = "sha256:c7224cab95645c7ab53791022ae77a4509472613e839dab722a72abe5a684575"}, + {file = "yarl-1.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:824d6c50492add5da9374875ce72db7a0733b29c2394890aef23d533106e2b15"}, + {file = "yarl-1.9.4-py3-none-any.whl", hash = "sha256:928cecb0ef9d5a7946eb6ff58417ad2fe9375762382f1bf5c55e61645f2c43ad"}, + {file = "yarl-1.9.4.tar.gz", hash = "sha256:566db86717cf8080b99b58b083b773a908ae40f06681e87e589a976faf8246bf"}, +] + +[package.dependencies] +idna = ">=2.0" +multidict = ">=4.0" + +[[package]] +name = "zipp" +version = "3.19.2" +description = "Backport of pathlib-compatible object wrapper for zip files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "zipp-3.19.2-py3-none-any.whl", hash = "sha256:f091755f667055f2d02b32c53771a7a6c8b47e1fdbc4b72a8b9072b3eef8015c"}, + {file = "zipp-3.19.2.tar.gz", hash = "sha256:bf1dcf6450f873a13e952a29504887c89e6de7506209e5b1bcc3460135d4de19"}, +] + +[package.extras] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy", "pytest-ruff (>=0.2.1)"] + +[metadata] +lock-version = "2.0" +python-versions = "3.9.2" +content-hash = "8323f9a35aa2797f8e28e84135045ab962e307d5ce4b680956ec4507e6878844" diff --git a/polos/__init__.py b/polos/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/polos/__pycache__/__init__.cpython-39.pyc b/polos/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..038f798a41f695dc974187c11c738e35ff1248b2 Binary files /dev/null and b/polos/__pycache__/__init__.cpython-39.pyc differ diff --git a/polos/__pycache__/clip.cpython-39.pyc b/polos/__pycache__/clip.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4490244addf871add78ccd6212ba956548c27d0 Binary files /dev/null and b/polos/__pycache__/clip.cpython-39.pyc differ diff --git a/polos/__pycache__/model.cpython-39.pyc b/polos/__pycache__/model.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..553af361ac47630eecf8a2d4554921cfa8c892fb Binary files /dev/null and b/polos/__pycache__/model.cpython-39.pyc differ diff --git a/polos/__pycache__/schedulers.cpython-39.pyc b/polos/__pycache__/schedulers.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c44ae24dc561975fe982262243b00f1cef795f7 Binary files /dev/null and b/polos/__pycache__/schedulers.cpython-39.pyc differ diff --git a/polos/__pycache__/simple_tokenizer.cpython-39.pyc b/polos/__pycache__/simple_tokenizer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6003decb51780c59feee8616461621ad0d18a143 Binary files /dev/null and b/polos/__pycache__/simple_tokenizer.cpython-39.pyc differ diff --git a/polos/bpe_simple_vocab_16e6.txt.gz b/polos/bpe_simple_vocab_16e6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..36a15856e00a06a9fbed8cdd34d2393fea4a3113 --- /dev/null +++ b/polos/bpe_simple_vocab_16e6.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:924691ac288e54409236115652ad4aa250f48203de50a9e4722a6ecd48d6804a +size 1356917 diff --git a/polos/cli.py b/polos/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..4fe8c52905ed7b9e5eb64c4a8237b8c03ca2d0d8 --- /dev/null +++ b/polos/cli.py @@ -0,0 +1,191 @@ +# -*- coding: utf-8 -*- +r""" +Polos command line interface (CLI) +============== +Composed by 4 main commands: + train Used to train a machine translation metric. + score Uses Polos to score a list of MT outputs. + download Used to download corpora or pretrained metric. +""" +import json +import os + +import click +import yaml +from pytorch_lightning import seed_everything + +from polos.corpora import corpus2download, download_corpus +from polos.models import download_model, load_checkpoint, model2download, str2model +from polos.trainer import TrainerConfig, build_trainer + + +@click.group() +def polos(): + pass + + +@polos.command() +@click.option( + "--config", + "-f", + type=click.Path(exists=True), + required=True, + help="Path to the configure YAML file", +) +@click.option( + "--resume", + "-r", + type=click.Path(exists=True), + required=False, + help="Path to the configure YAML file", +) +def train(config,resume): + yaml_file = yaml.load(open(config).read(), Loader=yaml.FullLoader) + + # Build Trainer + train_configs = TrainerConfig(yaml_file) + seed_everything(train_configs.seed) + trainer = build_trainer(train_configs.namespace(),resume) + + # Print Trainer parameters into terminal + result = "Hyperparameters:\n" + for k, v in train_configs.namespace().__dict__.items(): + result += "{0:30}| {1}\n".format(k, v) + click.secho(f"{result}", fg="green", nl=False) + + # Build Model + try: + model_config = str2model[train_configs.model].ModelConfig(yaml_file) + print(str2model[train_configs.model].ModelConfig) + print(model_config.namespace()) + model = str2model[train_configs.model](model_config.namespace()) + except KeyError: + raise Exception(f"Invalid model {train_configs.model}!") + + result = "" + for k, v in model_config.namespace().__dict__.items(): + result += "{0:30}| {1}\n".format(k, v) + click.secho(f"{result}", fg="cyan") + + # Train model + click.secho(f"{model.__class__.__name__} train starting:", fg="yellow") + trainer.fit(model) + + # test model + # trainer.test(model) + + +def check_model(ctx, param, reference): + """ Helper function that checks if the model requires references or not. """ + if reference is None and "wmt-large-qe-estimator-1719" not in ctx.params["model"]: + raise click.ClickException("Error: Missing option '--reference' / '-r'.") + return reference + + +@polos.command() +@click.option( + "--model", + default="wmt-large-da-estimator-1719", + help="Name of the pretrained model OR path to a model checkpoint.", + show_default=True, + type=str, + is_eager=True, +) +@click.option( + "--source", + "-s", + required=True, + help="Source segments.", + type=click.File(), +) +@click.option( + "--hypothesis", + "-h", + required=True, + help="MT outputs.", + type=click.File(), +) +@click.option( + "--reference", + "-r", + required=False, + help="Reference segments.", + type=click.File(), + callback=check_model, +) +@click.option( + "--cuda/--cpu", + default=True, + help="Flag that either runs inference on cuda or in cpu.", + show_default=True, +) +@click.option( + "--batch_size", + default=-1, + help="Batch size used during inference. By default uses the same batch size used during training.", + type=int, +) +@click.option( + "--to_json", + default=False, + help="Creates and exports model predictions to a JSON file.", + type=str, + show_default=True, +) +def score(model, source, hypothesis, reference, cuda, batch_size, to_json): + source = [s.strip() for s in source.readlines()] + hypothesis = [s.strip() for s in hypothesis.readlines()] + if reference: + reference = [s.strip() for s in reference.readlines()] + data = {"src": source, "mt": hypothesis, "ref": reference} + else: + data = {"src": source, "mt": hypothesis} + + data = [dict(zip(data, t)) for t in zip(*data.values())] + model = load_checkpoint(model) if os.path.exists(model) else download_model(model) + data, scores = model.predict(data, cuda, show_progress=True, batch_size=batch_size) + + if isinstance(to_json, str): + with open(to_json, "w") as outfile: + json.dump(data, outfile, ensure_ascii=False, indent=4) + click.secho(f"Predictions saved in: {to_json}.", fg="yellow") + + for i in range(len(scores)): + click.secho("Segment {} score: {:.3f}".format(i, scores[i]), fg="yellow") + click.secho( + "Polos system score: {:.3f}".format(sum(scores) / len(scores)), fg="yellow" + ) + + +@polos.command() +@click.option( + "--data", + "-d", + type=click.Choice(corpus2download.keys(), case_sensitive=False), + multiple=True, + help="Public corpora to download.", +) +@click.option( + "--model", + "-m", + type=click.Choice(model2download().keys(), case_sensitive=False), + multiple=True, + help="Pretrained models to download.", +) +@click.option( + "--saving_path", + type=str, + help="Relative path to save the downloaded files.", + required=True, +) +def download(data, model, saving_path): + print("Download ...") + print(data,model) + for d in data: + download_corpus(d, saving_path) + + for m in model: + download_model(m, saving_path) + +if __name__ == '__main__': + polos() \ No newline at end of file diff --git a/polos/clip.py b/polos/clip.py new file mode 100644 index 0000000000000000000000000000000000000000..edd8c047198a3c6d17755948fcbefd7ea46fd0de --- /dev/null +++ b/polos/clip.py @@ -0,0 +1,245 @@ +import hashlib +import os +import urllib +import warnings +from typing import Any, Union, List +from pkg_resources import packaging + +import torch +from PIL import Image +from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize +from tqdm import tqdm + +from polos.model import build_model +from polos.simple_tokenizer import SimpleTokenizer as _Tokenizer + +try: + from torchvision.transforms import InterpolationMode + BICUBIC = InterpolationMode.BICUBIC +except ImportError: + BICUBIC = Image.BICUBIC + + +if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"): + warnings.warn("PyTorch version 1.7.1 or higher is recommended") + + +__all__ = ["available_models", "load", "tokenize"] +_tokenizer = _Tokenizer() + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", + "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt", + "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt", +} + + +def _download(url: str, root: str): + os.makedirs(root, exist_ok=True) + filename = os.path.basename(url) + + expected_sha256 = url.split("/")[-2] + download_target = os.path.join(root, filename) + + if os.path.exists(download_target) and not os.path.isfile(download_target): + raise RuntimeError(f"{download_target} exists and is not a regular file") + + if os.path.isfile(download_target): + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256: + return download_target + else: + warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file") + + with urllib.request.urlopen(url) as source, open(download_target, "wb") as output: + with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True, unit_divisor=1024) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256: + raise RuntimeError("Model has been downloaded but the SHA256 checksum does not not match") + + return download_target + + +def _convert_image_to_rgb(image): + return image.convert("RGB") + + +def _transform(n_px): + return Compose([ + Resize(n_px, interpolation=BICUBIC), + CenterCrop(n_px), + _convert_image_to_rgb, + ToTensor(), + Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) + + +def available_models() -> List[str]: + """Returns the names of available CLIP models""" + return list(_MODELS.keys()) + + +def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", jit: bool = False, download_root: str = None): + """Load a CLIP model + + Parameters + ---------- + name : str + A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict + + 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 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 + """ + if name in _MODELS: + model_path = _download(_MODELS[name], download_root or os.path.expanduser("~/.cache/clip")) + elif os.path.isfile(name): + model_path = name + else: + raise RuntimeError(f"Model {name} not found; available models = {available_models()}") + + with open(model_path, 'rb') as opened_file: + try: + # loading JIT archive + model = torch.jit.load(opened_file, map_location=device if jit else "cpu").eval() + state_dict = None + except RuntimeError: + # loading saved state dict + if jit: + warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead") + jit = False + state_dict = torch.load(opened_file, map_location="cpu") + + if not jit: + model = build_model(state_dict or model.state_dict()).to(device) + if str(device) == "cpu": + model.float() + return model, _transform(model.visual.input_resolution) + + # patch the device names + device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[]) + device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1] + + def _node_get(node: torch._C.Node, key: str): + """Gets attributes of a node which is polymorphic over return type. + + From https://github.com/pytorch/pytorch/pull/82628 + """ + sel = node.kindOf(key) + return getattr(node, sel)(key) + + def patch_device(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("prim::Constant"): + if "value" in node.attributeNames() and str(_node_get(node, "value")).startswith("cuda"): + node.copyAttributes(device_node) + + model.apply(patch_device) + patch_device(model.encode_image) + patch_device(model.encode_text) + + # patch dtype to float32 on CPU + if str(device) == "cpu": + float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[]) + float_input = list(float_holder.graph.findNode("aten::to").inputs())[1] + float_node = float_input.node() + + def patch_float(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("aten::to"): + inputs = list(node.inputs()) + for i in [1, 2]: # dtype can be the second or third argument to aten::to() + if _node_get(inputs[i].node(), "value") == 5: + inputs[i].node().copyAttributes(float_node) + + model.apply(patch_float) + patch_float(model.encode_image) + patch_float(model.encode_text) + + model.float() + + return model, _transform(model.input_resolution.item()) + + +def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> Union[torch.IntTensor, torch.LongTensor]: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + + context_length : int + The context length to use; all CLIP models use 77 as the context length + + truncate: bool + Whether to truncate the text in case its encoding is longer than the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length]. + We return LongTensor when torch version is <1.8.0, since older index_select requires indices to be long. + """ + if isinstance(texts, str): + texts = [texts] + + sot_token = _tokenizer.encoder["<|startoftext|>"] + eot_token = _tokenizer.encoder["<|endoftext|>"] + all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts] + if packaging.version.parse(torch.__version__) < packaging.version.parse("1.8.0"): + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + else: + result = torch.zeros(len(all_tokens), context_length, dtype=torch.int) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + if truncate: + tokens = tokens[:context_length] + tokens[-1] = eot_token + else: + raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}") + result[i, :len(tokens)] = torch.tensor(tokens) + + return result diff --git a/polos/corpora.py b/polos/corpora.py new file mode 100644 index 0000000000000000000000000000000000000000..75d711d78e7a73c8f7175e843996df4827843f19 --- /dev/null +++ b/polos/corpora.py @@ -0,0 +1,55 @@ +# -*- coding: utf-8 -*- +r""" +Corpora +============== + Available corpora to train/test Polos models. +""" +import os + +import click + +from torchnlp.download import download_file_maybe_extract + +corpus2download = { + "apequest": "https://unbabel-experimental-data-sets.s3-eu-west-1.amazonaws.com/polos/hter/apequest.zip", + "qt21": "https://unbabel-experimental-data-sets.s3-eu-west-1.amazonaws.com/polos/hter/qt21.zip", + "wmt-metrics": "https://unbabel-experimental-data-sets.s3-eu-west-1.amazonaws.com/polos/da/wmt-metrics.zip", + "doc-wmt19": "https://unbabel-experimental-data-sets.s3-eu-west-1.amazonaws.com/polos/da/doc-wmt19.zip", +} + + +def download_corpus(corpus: str, saving_directory: str = None) -> None: + """Function that downloads a corpus from AWS. + + :param corpus: Name of the corpus to be loaded. + :param saving_directory: RELATIVE path to the saving folder. + """ + corpus = corpus.lower() + if not saving_directory: + saving_directory = "data/" + + if not os.path.exists(saving_directory): + os.makedirs(saving_directory) + + if os.path.isdir(saving_directory + corpus): + click.secho(f"{corpus} is already in cache.", fg="yellow") + return + + elif corpus in corpus2download: + download_file_maybe_extract( + corpus2download[corpus], + directory=saving_directory, + ) + + else: + raise Exception(f"{corpus} is not a valid corpus!") + + click.secho("Download succeeded.", fg="yellow") + if os.path.exists(saving_directory + corpus + ".zip"): + os.remove(saving_directory + corpus + ".zip") + + elif os.path.exists(saving_directory + corpus + ".tar.gz"): + os.remove(saving_directory + corpus + ".tar.gz") + + else: + click.secho("Fail to delete compressed file.", fg="red") diff --git a/polos/metrics/__init__.py b/polos/metrics/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..edfc9f6c93cec76b9e5b4fea586d599dda90a556 --- /dev/null +++ b/polos/metrics/__init__.py @@ -0,0 +1,4 @@ +from .regression_metrics import RegressionReport, Kendall, Pearson, Spearman +from .ranking_metrics import WMTKendall + +__all__ = ["RegressionReport", "Kendall", "Pearson", "Spearman", "WMTKendall"] diff --git a/polos/metrics/__pycache__/__init__.cpython-39.pyc b/polos/metrics/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f486a064bb29475d3e81f26cdf841dac8e871e4 Binary files /dev/null and b/polos/metrics/__pycache__/__init__.cpython-39.pyc differ diff --git a/polos/metrics/__pycache__/ranking_metrics.cpython-39.pyc b/polos/metrics/__pycache__/ranking_metrics.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2cabd4c31309999a40c3b5e9180d75d5778c2325 Binary files /dev/null and b/polos/metrics/__pycache__/ranking_metrics.cpython-39.pyc differ diff --git a/polos/metrics/__pycache__/regression_metrics.cpython-39.pyc b/polos/metrics/__pycache__/regression_metrics.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..92e7947909616f89fe8e64b33f40cd00043e55b0 Binary files /dev/null and b/polos/metrics/__pycache__/regression_metrics.cpython-39.pyc differ diff --git a/polos/metrics/ranking_metrics.py b/polos/metrics/ranking_metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..c8728143cebe4f4871d2d54e751828c0835ed803 --- /dev/null +++ b/polos/metrics/ranking_metrics.py @@ -0,0 +1,27 @@ +# -*- coding: utf-8 -*- +r""" +Ranking Metrics +============== + Metrics to evaluate ranking quality of ranker models. +""" +import torch + + +class WMTKendall: + def __init__(self): + self.name = "kendall" + + def compute( + self, distance_pos: torch.Tensor, distance_neg: torch.Tensor + ) -> torch.Tensor: + """Computes the level of concordance, discordance and the WMT kendall tau metric + + :param distance_pos: distance between the positive samples and the anchor/s + :param distance_neg: distance between the negative samples and the anchor/s + + :return: Level of agreement, nº of positive sample closer to the anchor + """ + concordance = torch.sum((distance_pos < distance_neg).float()) + discordance = torch.sum((distance_pos >= distance_neg).float()) + kendall = (concordance - discordance) / (concordance + discordance) + return kendall diff --git a/polos/metrics/regression_metrics.py b/polos/metrics/regression_metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..2912626136fc27d3f7f4bea8f1387314d1202492 --- /dev/null +++ b/polos/metrics/regression_metrics.py @@ -0,0 +1,83 @@ +# -*- coding: utf-8 -*- +r""" +Regression Metrics +============== + Metrics to evaluate regression quality of estimator models. +""" +import warnings + +import numpy as np +import torch +from scipy.stats import kendalltau, pearsonr, spearmanr + + +class RegressionReport: + def __init__(self, kendall_type="c"): + super().__init__() + self.metrics = [Pearson(), Kendall(kendall_type), Spearman(), ] + + def compute(self, x: np.array, y: np.array) -> float: + """Computes Kendall correlation. + + :param x: predicted scores. + :param x: ground truth scores. + + :return: Kendall Tau correlation value. + """ + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + return {metric.name: metric.compute(x, y) for metric in self.metrics} + + +class Kendall: + def __init__(self, variant="c"): + self.name = "kendall" + self.variant = variant + + def compute(self, x: np.array, y: np.array) -> float: + """Computes Kendall correlation. + + :param x: predicted scores. + :param x: ground truth scores. + + :return: Kendall Tau correlation value. + """ + if np.isnan(x).any() or np.isnan(y).any(): + return np.nan + return torch.tensor(kendalltau(x, y,variant=self.variant)[0], dtype=torch.float32) + + +class Pearson: + def __init__(self): + self.name = "pearson" + + def compute(self, x: np.array, y: np.array) -> torch.Tensor: + """Computes Pearson correlation. + + :param x: predicted scores. + :param x: ground truth scores. + + :return: Pearson correlation value. + """ + # check nan or inf + if np.isnan(x).any() or np.isnan(y).any(): + return np.nan + return torch.tensor(pearsonr(x, y)[0], dtype=torch.float32) + + +class Spearman: + def __init__(self): + self.name = "spearman" + + def compute(self, x: np.array, y: np.array) -> float: + """Computes Spearman correlation. + + :param x: predicted scores. + :param x: ground truth scores. + + Return: + - Spearman correlation value. + """ + if np.isnan(x).any() or np.isnan(y).any(): + return np.nan + return torch.tensor(spearmanr(x, y)[0], dtype=torch.float32) diff --git a/polos/model.py b/polos/model.py new file mode 100644 index 0000000000000000000000000000000000000000..232b7792eb97440642547bd462cf128df9243933 --- /dev/null +++ b/polos/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() diff --git a/polos/models/__init__.py b/polos/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..97e412c5dabb797df97bb42ec65e4820c9ca646a --- /dev/null +++ b/polos/models/__init__.py @@ -0,0 +1,117 @@ +# -*- coding: utf-8 -*- +import os + +import click +import pandas as pd +import yaml + +from torchnlp.download import download_file_maybe_extract + +from .estimators import PolosEstimator, QualityEstimator +from .model_base import ModelBase +from .ranking import PolosRanker + +str2model = { + "PolosEstimator": PolosEstimator, + "PolosRanker": PolosRanker, + # Model that use source only: + "QualityEstimator": QualityEstimator, +} + +def get_cache_folder(): + if "HOME" in os.environ: + cache_directory = os.environ["HOME"] + "/.cache/torch/yuigawada/" + if not os.path.exists(cache_directory): + os.makedirs(cache_directory) + return cache_directory + else: + raise Exception("HOME environment variable is not defined.") + +def download_model(model: str, saving_directory: str = None) -> ModelBase: + """Function that loads pretrained models from AWS. + :param model: Name of the model to be loaded. + :param saving_directory: RELATIVE path to the saving folder (must end with /). + + Return: + - Pretrained model. + """ + if saving_directory is None: + saving_directory = get_cache_folder() + + if not os.path.exists(saving_directory): + os.makedirs(saving_directory) + + if os.path.exists(saving_directory + "reprod/reprod.ckpt"): + return saving_directory + "reprod/reprod.ckpt" + + models = {"polos" : "https://polos-polaris.s3.ap-northeast-1.amazonaws.com/reprod.zip"} + + if os.path.isdir(saving_directory + model): + click.secho(f"{model} is already in cache.", fg="yellow") + if not model.endswith("/"): + model += "/" + + elif model not in models.keys(): + raise Exception(f"{model} is not a valid Polos model!") + + elif models[model].startswith("https://"): + download_file_maybe_extract(models[model], directory=saving_directory) + + else: + raise Exception("Something went wrong while dowloading the model!") + + if os.path.exists(saving_directory + model + ".zip"): + os.remove(saving_directory + model + ".zip") + + click.secho("Download succeeded. Loading model...", fg="yellow") + experiment_folder = saving_directory + "reprod" + checkpoints = [ + file for file in os.listdir(experiment_folder) if file.endswith(".ckpt") + ] + checkpoint = checkpoints[-1] + checkpoint_path = experiment_folder + "/" + checkpoint + return checkpoint_path + + +def load_checkpoint(checkpoint: str) -> ModelBase: + """Function that loads a model from a checkpoint file. + :param checkpoint: Path to the checkpoint file. + + Returns: + - Polos Model + """ + if not os.path.exists(checkpoint): + raise Exception(f"{checkpoint} file not found!") + + tags_csv_file = "/".join(checkpoint.split("/")[:-1] + ["meta_tags.csv"]) + hparam_yaml_file = "/".join(checkpoint.split("/")[:-1] + ["hparams.yaml"]) + + if os.path.exists(tags_csv_file): + # Uggly convertion from older Lightning checkpoints + tags = pd.read_csv( + tags_csv_file, header=None, index_col=0, squeeze=True + ).to_dict() + hparams = {} + for k, v in tags.items(): + if isinstance(v, str) and v.replace(".", "", 1).isdigit(): + hparams[k] = float(v) if "." in v else int(v) + else: + hparams[k] = v + model = str2model[tags["model"]].load_from_checkpoint( + checkpoint, hparams=hparams + ) + elif os.path.exists(hparam_yaml_file): + with open(hparam_yaml_file) as yaml_file: + hparams = yaml.load(yaml_file.read(), Loader=yaml.FullLoader) + model = str2model[hparams["model"]].load_from_checkpoint( + checkpoint, hparams=hparams + ) + else: + raise Exception( + "[meta_tags.csv|hparams.yaml is missing from the checkpoint folder." + " Please clean your cache folder (~/.cache/torch/yuigawada/) and try to download the model again." + ) + + model.eval() + model.freeze() + return model diff --git a/polos/models/__pycache__/__init__.cpython-39.pyc b/polos/models/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1908ae8e2eb88e3af9573037d06b3b4284e0386a Binary files /dev/null and b/polos/models/__pycache__/__init__.cpython-39.pyc differ diff --git a/polos/models/__pycache__/model_base.cpython-39.pyc b/polos/models/__pycache__/model_base.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dba9440270ad686f99daf832e986c04fa097a6c4 Binary files /dev/null and b/polos/models/__pycache__/model_base.cpython-39.pyc differ diff --git a/polos/models/__pycache__/utils.cpython-39.pyc b/polos/models/__pycache__/utils.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..62248a86ae945ebbdbd926152f568697f9245223 Binary files /dev/null and b/polos/models/__pycache__/utils.cpython-39.pyc differ diff --git a/polos/models/encoders/__init__.py b/polos/models/encoders/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..79d2e9162e0b09bfe7ddd346fb09606c41d574be --- /dev/null +++ b/polos/models/encoders/__init__.py @@ -0,0 +1,8 @@ +# -*- coding: utf-8 -*- +from .bert import BERTEncoder +from .xlmr import XLMREncoder +from .encoder_base import Encoder + +str2encoder = {"BERT": BERTEncoder, "XLMR": XLMREncoder} + +__all__ = ["BERTEncoder", "XLMREncoder"] diff --git a/polos/models/encoders/__pycache__/__init__.cpython-39.pyc b/polos/models/encoders/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2cad4588fd6b655cb9ae3dc399a49ab55fa00540 Binary files /dev/null and b/polos/models/encoders/__pycache__/__init__.cpython-39.pyc differ diff --git a/polos/models/encoders/__pycache__/bert.cpython-39.pyc b/polos/models/encoders/__pycache__/bert.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..247d13a94f38155a960519f4445696a786b460ab Binary files /dev/null and b/polos/models/encoders/__pycache__/bert.cpython-39.pyc differ diff --git a/polos/models/encoders/__pycache__/encoder_base.cpython-39.pyc b/polos/models/encoders/__pycache__/encoder_base.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aa9899c00612c06f2d0534faa34f22dfa15631d8 Binary files /dev/null and b/polos/models/encoders/__pycache__/encoder_base.cpython-39.pyc differ diff --git a/polos/models/encoders/__pycache__/xlmr.cpython-39.pyc b/polos/models/encoders/__pycache__/xlmr.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4ba1445fa420b8142472e805f0a7f3694219ed2 Binary files /dev/null and b/polos/models/encoders/__pycache__/xlmr.cpython-39.pyc differ diff --git a/polos/models/encoders/bert.py b/polos/models/encoders/bert.py new file mode 100644 index 0000000000000000000000000000000000000000..d75b38cadd80ff65c1aac72b70b3ce29fc32059a --- /dev/null +++ b/polos/models/encoders/bert.py @@ -0,0 +1,98 @@ +# -*- coding: utf-8 -*- +r""" +BERT Encoder +============== + Pretrained BERT encoder from Hugging Face. +""" +from argparse import Namespace +from typing import Dict + +import torch +from transformers import AutoModel + +from polos.models.encoders.encoder_base import Encoder +from polos.tokenizers_ import HFTextEncoder +from torchnlp.utils import lengths_to_mask + + +class BERTEncoder(Encoder): + """BERT encoder. + :param tokenizer: BERT text encoder. + :param hparams: ArgumentParser. + """ + + def __init__( + self, + tokenizer: HFTextEncoder, + hparams: Namespace, + ) -> None: + super().__init__(tokenizer) + self.model = AutoModel.from_pretrained(hparams.pretrained_model) + self.model.encoder.output_hidden_states = True + self._output_units = self.model.config.hidden_size + self._n_layers = self.model.config.num_hidden_layers + 1 + self._max_pos = self.model.config.max_position_embeddings + + @classmethod + def from_pretrained(cls, hparams: Namespace) -> Encoder: + """Function that loads a pretrained encoder from Hugging Face. + :param hparams: Namespace. + + :return: Encoder model + """ + tokenizer = HFTextEncoder(model=hparams.pretrained_model) + model = BERTEncoder(tokenizer=tokenizer, hparams=hparams) + return model + + def freeze_embeddings(self) -> None: + """ Frezees the embedding layer of the network to save some memory while training. """ + for param in self.model.embeddings.parameters(): + param.requires_grad = False + + def layerwise_lr(self, lr: float, decay: float): + """ + :return: List with grouped model parameters with layer-wise decaying learning rate + """ + # Embedding Layer + opt_parameters = [ + { + "params": self.model.embeddings.parameters(), + "lr": lr * decay ** (self.num_layers), + } + ] + # All layers + opt_parameters += [ + { + "params": self.model.encoder.layer[l].parameters(), + "lr": lr * decay ** l, + } + for l in range(self.num_layers - 2, 0, -1) + ] + return opt_parameters + + def forward( + self, tokens: torch.Tensor, lengths: torch.Tensor + ) -> Dict[str, torch.Tensor]: + """ + Encodes a batch of sequences. + + :param tokens: Torch tensor with the input sequences [batch_size x seq_len]. + :param lengths: Torch tensor with the lenght of each sequence [seq_len]. + + :return: Dictionary with `sentemb` (tensor with dims [batch_size x output_units]), `wordemb` + (tensor with dims [batch_size x seq_len x output_units]), `mask` (input mask), + `all_layers` (List with word_embeddings from all layers), `extra` (tuple with the + last_hidden_state, the pooler_output representing the entire sentence and the word + embeddings for all BERT layers). + """ + mask = lengths_to_mask(lengths, device=tokens.device) + last_hidden_states, pooler_output, all_layers = self.model( + tokens, mask, output_hidden_states=True, return_dict=False + ) + return { + "sentemb": pooler_output, + "wordemb": last_hidden_states, + "all_layers": all_layers, + "mask": mask, + "extra": (last_hidden_states, pooler_output, all_layers), + } diff --git a/polos/models/encoders/encoder_base.py b/polos/models/encoders/encoder_base.py new file mode 100644 index 0000000000000000000000000000000000000000..f38c18bb2aafef57d307ec07388b16c940c302f2 --- /dev/null +++ b/polos/models/encoders/encoder_base.py @@ -0,0 +1,111 @@ +# -*- coding: utf-8 -*- +r""" +Encoder Model base +==================== + Module defining the common interface between all pretrained encoder models. +""" +import warnings +from argparse import Namespace +from typing import Dict, List + +import torch +import torch.nn as nn + +from polos.tokenizers_ import TextEncoderBase + + +class Encoder(nn.Module): + """Base class for an encoder model. + + :param output_units: Number of output features that will be passed to the Estimator. + """ + + def __init__( + self, + tokenizer: TextEncoderBase, + ) -> None: + super().__init__() + self.tokenizer = tokenizer + + @property + def output_units(self): + """ Max number of tokens the encoder handles. """ + return self._output_units + + @property + def max_positions(self): + """ Max number of tokens the encoder handles. """ + return self._max_pos + + @property + def num_layers(self): + """ Number of model layers available. """ + return self._n_layers + + @property + def lm_head(self): + """ Language modeling head. """ + raise NotImplementedError + + @classmethod + def from_pretrained(cls, hparams: Namespace): + """Function that loads a pretrained encoder and the respective tokenizer. + + :return: Encoder model + """ + raise NotImplementedError + + def check_lengths(self, tokens: torch.Tensor, lengths: torch.Tensor): + """ Checks if lengths are not exceeded and warns user if so.""" + if lengths.max() > self.max_positions: + warnings.warn( + "Encoder max length exceeded ({} > {}).".format( + lengths.max(), self.max_positions + ), + category=RuntimeWarning, + ) + lengths[lengths > self.max_positions] = self.max_positions + tokens = tokens[:, : self.max_positions] + + return tokens, lengths + + def prepare_sample(self, sample: List[str]) -> (torch.Tensor, torch.Tensor): + """ Receives a list of strings and applies model specific tokenization and vectorization.""" + tokens, lengths = self.tokenizer.batch_encode(sample) + tokens, lengths = self.check_lengths(tokens, lengths) + return {"tokens": tokens, "lengths": lengths} + + def freeze(self) -> None: + """ Frezees the entire encoder network. """ + for param in self.parameters(): + param.requires_grad = False + + def unfreeze(self) -> None: + """ Unfrezees the entire encoder network. """ + for param in self.parameters(): + param.requires_grad = True + + def freeze_embeddings(self) -> None: + """ Frezees the embedding layer of the network to save some memory while training. """ + raise NotImplementedError + + def layerwise_lr(self, lr: float, decay: float): + """ + :return: List with grouped model parameters with layer-wise decaying learning rate + """ + raise NotImplementedError + + def forward( + self, tokens: torch.Tensor, lengths: torch.Tensor + ) -> Dict[str, torch.Tensor]: + """ + Encodes a batch of sequences. + + :param tokens: Torch tensor with the input sequences [batch_size x seq_len]. + :param lengths: Torch tensor with the lenght of each sequence [seq_len]. + + :return: Dictionary with `sentemb` (tensor with dims [batch_size x output_units]), `wordemb` + (tensor with dims [batch_size x seq_len x output_units]), `mask` (input mask), + `all_layers` (List with word_embeddings from all layers, `extra` (model specific outputs). + """ + raise NotImplementedError diff --git a/polos/models/encoders/xlmr.py b/polos/models/encoders/xlmr.py new file mode 100644 index 0000000000000000000000000000000000000000..b156cf05d736b2901a1fd218666e510a173e4047 --- /dev/null +++ b/polos/models/encoders/xlmr.py @@ -0,0 +1,187 @@ +# -*- coding: utf-8 -*- +r""" +XLM-R Encoder Model +==================== + Pretrained XLM-RoBERTa from Fairseq framework. + https://github.com/pytorch/fairseq/tree/master/examples/xlmr +""" +import os +from argparse import Namespace +from typing import Dict + +import torch + +from polos.models.encoders.encoder_base import Encoder +from polos.tokenizers_ import XLMRTextEncoder +from fairseq.models.roberta import XLMRModel +from torchnlp.download import download_file_maybe_extract +from torchnlp.utils import lengths_to_mask + +XLMR_LARGE_URL = "https://dl.fbaipublicfiles.com/fairseq/models/xlmr.large.tar.gz" +XLMR_LARGE_MODEL_NAME = "xlmr.large/model.pt" + +XLMR_BASE_URL = "https://dl.fbaipublicfiles.com/fairseq/models/xlmr.base.tar.gz" +XLMR_BASE_MODEL_NAME = "xlmr.base/model.pt" + +XLMR_LARGE_V0_URL = "https://dl.fbaipublicfiles.com/fairseq/models/xlmr.large.v0.tar.gz" +XLMR_LARGE_V0_MODEL_NAME = "xlmr.large.v0/model.pt" + +XLMR_BASE_V0_URL = "https://dl.fbaipublicfiles.com/fairseq/models/xlmr.base.v0.tar.gz" +XLMR_BASE_V0_MODEL_NAME = "xlmr.base.v0/model.pt" + +if "HOME" in os.environ: + saving_directory = os.environ["HOME"] + "/.cache/torch/yuigawada/" +else: + raise Exception("HOME environment variable is not defined.") + + +class XLMREncoder(Encoder): + """ + XLM-RoBERTa encoder from Fairseq. + + :param xlmr: XLM-R model to be used. + :param tokenizer: XLM-R model tokenizer to be used. + :param hparams: Namespace. + """ + + def __init__( + self, xlmr: XLMRModel, tokenizer: XLMRTextEncoder, hparams: Namespace + ) -> None: + super().__init__(tokenizer) + self._output_units = 768 if "base" in hparams.pretrained_model else 1024 + self._n_layers = 13 if "base" in hparams.pretrained_model else 25 + self._max_pos = 512 + # Save some meory by removing the LM and classification heads + # xlmr.model.decoder.lm_head.dense = None + # xlmr.model.decoder.classification_heads = None + self.model = xlmr + + def freeze_embeddings(self) -> None: + """ Freezes the embedding layer of the network to save some memory while training. """ + for ( + param + ) in self.model.model.decoder.sentence_encoder.embed_tokens.parameters(): + param.requires_grad = False + + for ( + param + ) in self.model.model.decoder.sentence_encoder.embed_positions.parameters(): + param.requires_grad = False + + for ( + param + ) in self.model.model.decoder.sentence_encoder.emb_layer_norm.parameters(): + param.requires_grad = False + + def layerwise_lr(self, lr: float, decay: float): + """ + :return: List with grouped model parameters with layer-wise decaying learning rate + """ + # Embedding layer + opt_parameters = [ + { + "params": self.model.model.decoder.sentence_encoder.embed_tokens.parameters(), + "lr": lr * decay ** (self.num_layers), + }, + { + "params": self.model.model.decoder.sentence_encoder.embed_positions.parameters(), + "lr": lr * decay ** (self.num_layers), + }, + { + "params": self.model.model.decoder.sentence_encoder.emb_layer_norm.parameters(), + "lr": lr * decay ** (self.num_layers), + }, + ] + + # Layer wise parameters + opt_parameters += [ + { + "params": self.model.model.decoder.sentence_encoder.layers[ + l + ].parameters(), + "lr": lr * decay ** (self.num_layers - 1 - l), + } + for l in range(self.num_layers - 1) + ] + + # Language Model Head parameters + opt_parameters += [ + { + "params": self.model.model.decoder.lm_head.layer_norm.parameters(), + "lr": lr, + }, + {"params": self.model.model.decoder.lm_head.dense.parameters(), "lr": lr}, + ] + return opt_parameters + + @property + def lm_head(self): + """ Language modeling head. """ + return self.model.model.decoder.lm_head + + @classmethod + def from_pretrained(cls, hparams: Namespace): + if not os.path.exists(saving_directory): + os.makedirs(saving_directory) + + pretrained_model = hparams.pretrained_model + if pretrained_model == "xlmr.base": + download_file_maybe_extract( + XLMR_BASE_URL, + directory=saving_directory, + check_files=[XLMR_BASE_MODEL_NAME], + ) + + elif pretrained_model == "xlmr.large": + download_file_maybe_extract( + XLMR_LARGE_URL, + directory=saving_directory, + check_files=[XLMR_LARGE_MODEL_NAME], + ) + elif pretrained_model == "xlmr.base.v0": + download_file_maybe_extract( + XLMR_BASE_V0_URL, + directory=saving_directory, + check_files=[XLMR_BASE_V0_MODEL_NAME], + ) + + elif pretrained_model == "xlmr.large.v0": + download_file_maybe_extract( + XLMR_LARGE_V0_URL, + directory=saving_directory, + check_files=[XLMR_LARGE_V0_MODEL_NAME], + ) + else: + raise Exception(f"{pretrained_model} is an invalid XLM-R model.") + + xlmr = XLMRModel.from_pretrained( + saving_directory + pretrained_model, checkpoint_file="model.pt" + ) + # xlmr.eval() + tokenizer = XLMRTextEncoder( + xlmr.encode, xlmr.task.source_dictionary.__dict__["indices"] + ) + return XLMREncoder(xlmr=xlmr, tokenizer=tokenizer, hparams=hparams) + + def forward( + self, tokens: torch.Tensor, lengths: torch.Tensor + ) -> Dict[str, torch.Tensor]: + """ + Encodes a batch of sequences. + + :param tokens: Torch tensor with the input sequences [batch_size x seq_len]. + :param lengths: Torch tensor with the length of each sequence [seq_len]. + + :return: Dictionary with `sentemb` (tensor with dims [batch_size x output_units]), `wordemb` + (tensor with dims [batch_size x seq_len x output_units]), `mask` (input mask), + `all_layers` (List with word_embeddings from all layers), `extra` (tuple with all XLM-R layers). + """ + mask = lengths_to_mask(lengths, device=tokens.device) + all_layers = self.model.extract_features(tokens, return_all_hiddens=True) + return { + "sentemb": all_layers[-1][:, 0, :], + "wordemb": all_layers[-1], + "all_layers": all_layers, + "mask": mask, + "extra": (all_layers), + } diff --git a/polos/models/estimators/__init__.py b/polos/models/estimators/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..584371f08a1cc11619dd068826d8f1d7c0f23311 --- /dev/null +++ b/polos/models/estimators/__init__.py @@ -0,0 +1,6 @@ +# -*- coding: utf-8 -*- +from .estimator_base import Estimator +from .polos_estimator import PolosEstimator +from .quality_estimator import QualityEstimator + +__all__ = ["Estimator", "PolosEstimator", "QualityEstimator"] diff --git a/polos/models/estimators/__pycache__/__init__.cpython-39.pyc b/polos/models/estimators/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4d61da91aedc9b6e68b414a9c608c3c48c3d8509 Binary files /dev/null and b/polos/models/estimators/__pycache__/__init__.cpython-39.pyc differ diff --git a/polos/models/estimators/__pycache__/estimator_base.cpython-39.pyc b/polos/models/estimators/__pycache__/estimator_base.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7982c1dc4fc7ad8176e337de31c9f8db6b202e87 Binary files /dev/null and b/polos/models/estimators/__pycache__/estimator_base.cpython-39.pyc differ diff --git a/polos/models/estimators/__pycache__/polos_estimator.cpython-39.pyc b/polos/models/estimators/__pycache__/polos_estimator.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4034b1b0bd2e1cbba879841e22ee5df78f34e8d7 Binary files /dev/null and b/polos/models/estimators/__pycache__/polos_estimator.cpython-39.pyc differ diff --git a/polos/models/estimators/__pycache__/quality_estimator.cpython-39.pyc b/polos/models/estimators/__pycache__/quality_estimator.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de30b53274c1b5d354d3317e72925f31d6d2e2f9 Binary files /dev/null and b/polos/models/estimators/__pycache__/quality_estimator.cpython-39.pyc differ diff --git a/polos/models/estimators/estimator_base.py b/polos/models/estimators/estimator_base.py new file mode 100644 index 0000000000000000000000000000000000000000..76c82a439cf202dc3f0ba43a3601ed1c7c9d8669 --- /dev/null +++ b/polos/models/estimators/estimator_base.py @@ -0,0 +1,375 @@ +# -*- coding: utf-8 -*- +r""" +Estimator Base Model +======================= + Abstract base class used to build new estimator models + inside Polos. +""" +from argparse import Namespace +from typing import Dict, List, Union + +import pandas as pd +import torch +import torch.nn as nn +from tqdm import tqdm + +from polos.metrics import RegressionReport +from polos.models.model_base import ModelBase +from polos.models.utils import average_pooling, max_pooling, move_to_cpu, move_to_cuda + + +class Estimator(ModelBase): + """ + Estimator base class that uses an Encoder to encode sequences. + + :param hparams: Namespace containing the hyperparameters. + """ + + class ModelConfig(ModelBase.ModelConfig): + """ + Estimator ModelConfig: + + --------------------------- Encoder ----------------------------------------- + + :param encoder_learning_rate: Learning rate used for the encoder model. + + :param layerwise_decay: Decay for the layer wise learning rates. If 1.0 no decay is applied. + + :param layer: Layer that will be used to extract embeddings. If 'mix' embeddings + from all layers are combined with a layer-wise attention mechanism + + :param scalar_mix_dropout: If layer='mix' we can regularize layer's importance by + with a given probability setting that weight to - inf before softmax. + + ------------------------- Feed Forward --------------------------------------- + + :param loss: Loss function to be used (options: binary_xent, mse). + + :param hidden_sizes: String with size of the hidden layers in the feedforward. + + :param activations: Activation functions to be used in the feedforward + + :param dropout: Dropout probability to be applied to the feedforward + + :param final_activation: Activation function to be applied after getting the + final regression score. Set to False if you wish to perform an 'unbounded' regression. + """ + + encoder_learning_rate: float = 1e-06 + layerwise_decay: float = 1.0 + layer: str = "mix" + scalar_mix_dropout: float = 0.0 + + loss: str = "mse" + hidden_sizes: str = "1024" + activations: str = "Tanh" + dropout: float = 0.1 + final_activation: str = "Sigmoid" + + def __init__(self, hparams: Namespace) -> None: + super().__init__(hparams) + + def _build_model(self) -> ModelBase: + """ + Initializes the estimator architecture. + """ + super()._build_model() + self.metrics = RegressionReport() + + def _build_loss(self): + """ Initializes the loss function/s. """ + super()._build_loss() + if self.hparams.loss == "mse": + self.loss = nn.MSELoss(reduction="sum") + elif self.hparams.loss == "binary_xent": + self.loss = nn.BCELoss(reduction="sum") + else: + raise Exception("{} is not a valid loss option.".format(self.hparams.loss)) + + def read_csv(self, path: str) -> List[dict]: + """Reads a comma separated value file. + + :param path: path to a csv file. + + :return: List of records as dictionaries + """ + df = pd.read_csv(path) + df = df[["mt","refs","score", "imgid"]] + refs_list = [] + for refs in df["refs"]: + refs = eval(refs) + refs_list.append(refs) + + df["refs"] = refs_list + df["mt"] = df["mt"].astype(str) + df["score"] = df["score"].astype(float) + df["imgid"] = df["imgid"].astype(str) + return df.to_dict("records") + + def compute_loss( + self, model_out: Dict[str, torch.Tensor], targets: Dict[str, torch.Tensor] + ) -> torch.Tensor: + """ + Computes Loss value according to a loss function. + + :param model_out: model specific output. Must contain a key 'score' with + a tensor [batch_size x 1] with model predictions + :param targets: Target score values [batch_size] + """ + assert torch.all((targets["score"] >= 0) & (targets["score"] <= 1)), f"gt({targets['score']}) is not in [0,1]!" + # print("out",model_out["score"].view(-1).shape, targets["score"].shape) + return self.loss(model_out["score"].view(-1), targets["score"]) + + def compute_metrics(self, outputs: List[Dict[str, torch.Tensor]]) -> dict: + """ + Private function that computes metrics of interest based on model predictions and + respective targets. + """ + predictions = ( + torch.cat([batch["val_prediction"]["score"].view(-1) for batch in outputs]) + .cpu() + .numpy() + ) + targets = ( + torch.cat([batch["val_target"]["score"] for batch in outputs]).cpu().numpy() + ) + + self.draw_histogram(predictions, targets) + + return self.metrics.compute(predictions, targets) + + def draw_histogram(self, predictions, targets): + import matplotlib + import matplotlib.pyplot as plt + matplotlib.use('Agg') + plt.figure(figsize=(10, 5)) + + plt.subplot(1, 2, 1) + plt.hist(predictions, bins=20, alpha=0.5, color='blue', label='Predictions') + plt.title('Predictions') + plt.xlabel('Value') + plt.ylabel('Frequency') + + plt.subplot(1, 2, 2) + plt.hist(targets, bins=20, alpha=0.5, color='red', label='Targets') + plt.title('Targets') + plt.xlabel('Value') + plt.ylabel('Frequency') + + plt.tight_layout() + # plt.show() + plt.savefig("histogram.png") + + def get_sentence_embedding( + self, tokens: torch.Tensor, lengths: torch.Tensor, pooling=True + ) -> torch.Tensor: + """Auxiliar function that extracts sentence embeddings for + a single sentence. + + :param tokens: sequences [batch_size x seq_len] + :param lengths: lengths [batch_size] + + :return: torch.Tensor [batch_size x hidden_size] + """ + # When using just one GPU this should not change behavior + # but when splitting batches across GPU the tokens have padding + # from the entire original batch + if self.trainer and self.trainer.use_dp and self.trainer.num_gpus > 1: + tokens = tokens[:, : lengths.max()] + + encoder_out = self.encoder(tokens, lengths) + + if self.scalar_mix: + embeddings = self.scalar_mix(encoder_out["all_layers"], encoder_out["mask"]) + + elif self.layer >= 0 and self.layer < self.encoder.num_layers: + embeddings = encoder_out["all_layers"][self.layer] + + else: + raise Exception("Invalid model layer {}.".format(self.layer)) + + if self.hparams.pool == "default": + sentemb = encoder_out["sentemb"] + + elif self.hparams.pool == "max": + sentemb = max_pooling( + tokens, embeddings, self.encoder.tokenizer.padding_index + ) + + elif self.hparams.pool == "avg": + sentemb = average_pooling( + tokens, + embeddings, + encoder_out["mask"], + self.encoder.tokenizer.padding_index, + ) + # print("sentemb",sentemb[0,:]) + return sentemb, embeddings, encoder_out["mask"], self.encoder.tokenizer.padding_index + + elif self.hparams.pool == "cls": + sentemb = embeddings[:, 0, :] + return sentemb, embeddings, encoder_out["mask"], self.encoder.tokenizer.padding_index + + elif self.hparams.pool == "cls+avg": + cls_sentemb = embeddings[:, 0, :] + avg_sentemb = average_pooling( + tokens, + embeddings, + encoder_out["mask"], + self.encoder.tokenizer.padding_index, + ) + sentemb = torch.cat((cls_sentemb, avg_sentemb), dim=1) + else: + raise Exception("Invalid pooling technique.") + + return sentemb + + def predict( + self, + samples: List[Dict[str, str]], + cuda: bool = False, + show_progress: bool = True, + batch_size: int = -1, + ) -> (Dict[str, Union[str, float]], List[float]): + """Function that runs a model prediction, + + :param samples: List of dictionaries with 'mt' and 'ref' keys. + :param cuda: Flag that runs inference using 1 single GPU. + :param show_progress: Flag to show progress during inference of multiple examples. + :para batch_size: Batch size used during inference. By default uses the same batch size used during training. + + :return: Dictionary with original samples, predicted scores and langid results for SRC and MT + + list of predicted scores + """ + if self.training: + self.eval() + + if cuda and torch.cuda.is_available(): + self.to("cuda") + + batch_size = self.hparams.batch_size if batch_size < 1 else batch_size + with torch.no_grad(): + batches = [ + samples[i : i + batch_size] for i in range(0, len(samples), batch_size) + ] + model_inputs = [] + if show_progress: + pbar = tqdm( + total=len(batches), + desc="Preparing batches...", + dynamic_ncols=True, + leave=None, + ) + for batch in batches: + batch = self.prepare_sample(batch, inference=True) + model_inputs.append(batch) + if show_progress: + pbar.update(1) + + if show_progress: + pbar.close() + + if show_progress: + pbar = tqdm( + total=len(batches), + desc="Scoring hypothesis...", + dynamic_ncols=True, + leave=None, + ) + scores = [] + for model_input in model_inputs: + if cuda and torch.cuda.is_available(): + model_input = move_to_cuda(model_input) + model_out = self.forward(**model_input) + model_out = move_to_cpu(model_out) + else: + model_out = self.forward(**model_input) + + model_scores = model_out["score"].numpy().tolist() + for i in range(len(model_scores)): + scores.append(model_scores[i][0]) + + if show_progress: + pbar.update(1) + + if show_progress: + pbar.close() + + assert len(scores) == len(samples) + for i in range(len(scores)): + samples[i]["predicted_score"] = scores[i] + return samples, scores + + def document_predict( + self, + documents: List[Dict[str, List[str]]], + cuda: bool = False, + show_progress: bool = False, + ) -> (Dict[str, Union[str, float]], List[float]): + """Function that scores entire documents by processing all segments in parallel. + + :param documents: List of dictionaries with 'mt', 'src' and 'ref' keys where each key is + a list of segments. + :param cuda: Flag that runs inference using 1 single GPU. + :param show_progress: Flag to show progress during inference of multiple examples. + + :return: tuple with Dictionary with original samples and predicted document score, micro + average scores, macro average scores. + """ + if self.training: + self.eval() + + if cuda and torch.cuda.is_available(): + self.to("cuda") + + inputs, lengths = [], [] + for d in documents: + d = [dict(zip(d, t)) for t in zip(*d.values())] + # For very long documents we need to create chunks. + # (64 sentences per chunk) + if len(d) > 64: + document_chunks, document_lengths = [], [] + chunks = [d[i : i + 64] for i in range(0, len(d), 64)] + for chunk in chunks: + chunk = self.prepare_sample(chunk, inference=True) + document_lengths.append(chunk["mt_lengths"]) + if cuda and torch.cuda.is_available(): + document_chunks.append(chunk) + lengths.append(torch.cat(document_lengths, dim=0)) + inputs.append(document_chunks) + else: + d_input = self.prepare_sample(d, inference=True) + lengths.append(d_input["mt_lengths"]) + if cuda and torch.cuda.is_available(): + inputs.append(d_input) + + micro_average, average = [], [] + for doc, seg_lengths in tqdm( + zip(inputs, lengths), + total=len(inputs), + desc="Scoring Documents ...", + dynamic_ncols=True, + leave=None, + ): + if isinstance(doc, list): + seg_scores = [] + for chunk in doc: + model_output = self.forward(**move_to_cuda(chunk)) + seg_scores.append(move_to_cpu(model_output)["score"].view(1, -1)[0]) + seg_scores = torch.cat(seg_scores, dim=0) + else: + model_output = self.forward(**move_to_cuda(doc)) + seg_scores = move_to_cpu(model_output)["score"].view(1, -1)[0] + + # Invert segment-level scores for HTER + # seg_scores = torch.ones_like(seg_scores) - seg_scores + micro = (seg_scores * seg_lengths).sum() / seg_lengths.sum() + macro = seg_scores.sum() / seg_scores.size()[0] + micro_average.append(micro.item()) + average.append(macro.item()) + + assert len(micro_average) == len(documents) + for i in range(len(documents)): + documents[i]["predicted_score"] = micro_average[i] + + return documents, micro_average, average diff --git a/polos/models/estimators/polos_estimator.py b/polos/models/estimators/polos_estimator.py new file mode 100644 index 0000000000000000000000000000000000000000..fe10f8d305ca66551cd3586e3893eb5dc898d7ca --- /dev/null +++ b/polos/models/estimators/polos_estimator.py @@ -0,0 +1,230 @@ +# -*- coding: utf-8 -*- +import random +from argparse import Namespace +from typing import Dict, List, Tuple, Union + +import torch + +from polos.models.estimators.estimator_base import Estimator +from polos.modules.feedforward import FeedForward +from polos.modules.scalar_mix import ScalarMixWithDropout +from torchnlp.utils import collate_tensors +import polos.clip as clip +import torch + +from typing import List, Union + +try: + import warnings + from shapely.errors import ShapelyDeprecationWarning + warnings.filterwarnings("ignore", category=ShapelyDeprecationWarning) +except: + pass + +class PolosEstimator(Estimator): + """ + Estimator class that uses a pretrained encoder to extract features from + the sequences and then passes those features to a feed forward estimator. + + :param hparams: Namespace containing the hyperparameters. + """ + + class ModelConfig(Estimator.ModelConfig): + switch_prob: float = 0.0 + + def __init__( + self, + hparams: Namespace, + ) -> None: + super().__init__(hparams) + + def _build_model(self) -> Estimator: + """ + Initializes the estimator architecture. + """ + super()._build_model() + + if self.hparams.encoder_model != "LASER": + self.layer = ( + int(self.hparams.layer) + if self.hparams.layer != "mix" + else self.hparams.layer + ) + + self.scalar_mix = ( + ScalarMixWithDropout( + mixture_size=self.encoder.num_layers, + dropout=self.hparams.scalar_mix_dropout, + do_layer_norm=True, + ) + if self.layer == "mix" and self.hparams.pool != "default" + else None + ) + + parallel_feature_extraction = True + if parallel_feature_extraction: + input_emb_sz = ( + self.encoder.output_units * 4 + 512*6 + if self.hparams.pool != "cls+avg" + else self.encoder.output_units * 2 * 8 + ) + else: + input_emb_sz = ( + self.encoder.output_units * 2 + 512*3 + if self.hparams.pool != "cls+avg" + else self.encoder.output_units * 2 * 8 + ) + + self.ff = torch.nn.Sequential(*[ + FeedForward( + in_dim=input_emb_sz, + # out_dim=input_emb_sz, + hidden_sizes=self.hparams.hidden_sizes, + activations=self.hparams.activations, + dropout=self.hparams.dropout, + final_activation=( + self.hparams.final_activation + if hasattr( + self.hparams, "final_activation" + ) # compatability with older checkpoints! + else "Sigmoid" + ), + ), + torch.nn.Sigmoid() + ]) + + self.clip, self.clip_preprocess = clip.load("ViT-B/32", device="cpu") + self.parallel_feature_extraction = parallel_feature_extraction + + + def configure_optimizers( + self, + ) -> Tuple[List[torch.optim.Optimizer], List[torch.optim.lr_scheduler.LambdaLR]]: + """ Sets different Learning rates for different parameter groups. """ + layer_parameters = self.encoder.layerwise_lr( + self.hparams.encoder_learning_rate, self.hparams.layerwise_decay + ) + ff_parameters = [ + {"params": self.ff.parameters(), "lr": self.hparams.learning_rate} + ] + + if self.hparams.encoder_model != "LASER" and self.scalar_mix: + scalar_mix_parameters = [ + { + "params": self.scalar_mix.parameters(), + "lr": self.hparams.learning_rate, + } + ] + + optimizer = self._build_optimizer( + layer_parameters + ff_parameters + scalar_mix_parameters + ) + else: + optimizer = self._build_optimizer(layer_parameters + ff_parameters) + scheduler = self._build_scheduler(optimizer) + return [optimizer], [scheduler] + + def prepare_sample( + self, sample: List[Dict[str, Union[str, float]]], inference: bool = False + ) -> Union[ + Tuple[Dict[str, torch.Tensor], Dict[str, torch.Tensor]], Dict[str, torch.Tensor] + ]: + """ + Function that prepares a sample to input the model. + + :param sample: list of dictionaries. + :param inference: If set to true prepares only the model inputs. + + :returns: Tuple with 2 dictionaries (model inputs and targets). + If `inference=True` returns only the model inputs. + """ + sample = collate_tensors(sample) + mt_inputs = self.encoder.prepare_sample(sample["mt"]) + ref_inputs = [self.encoder.prepare_sample(ref) for ref in sample["refs"]] + + inputs = { + "mt_inputs": mt_inputs, + "ref_inputs": ref_inputs, + "refs": sample["refs"], + "mt": sample["mt"], + "imgs": sample["img"] + } + + if inference: + return inputs + + targets = {"score": torch.tensor(sample["score"], dtype=torch.float)} + return inputs, targets + + def masked_global_average_pooling(self, input_tensor, mask): + mask = mask.logical_not() # mask[x] = input[x] is not pad + mask_expanded = mask.unsqueeze(-1).expand_as(input_tensor).float() + input_tensor_masked = input_tensor * mask_expanded + num_elements = mask.sum(dim=1,keepdim=True).float() # TODO: チェック + output_tensor = input_tensor_masked.sum(dim=1) / num_elements + return output_tensor + + def forward( + self, + refs, + mt, + ref_inputs, + mt_inputs, + imgs: torch.tensor, + alt_tokens: torch.tensor = None, + alt_lengths: torch.tensor = None, + **kwargs + ) -> Dict[str, torch.Tensor]: + + mt_tokens, mt_lengths = mt_inputs["tokens"], mt_inputs["lengths"] + mt_sentemb, mt_sentembs, mt_mask, padding_index = self.get_sentence_embedding(mt_tokens, mt_lengths,pooling=False) + mt_mask = mt_mask.logical_not() + + ref_sentemb_list = [] + ref_sentembs_list = [] + ref_mask_list = [] + for ref in ref_inputs: + ref_tokens, ref_lengths = ref["tokens"], ref["lengths"] + ref_sentemb, ref_sentembs, ref_mask, _ = self.get_sentence_embedding(ref_tokens, ref_lengths,pooling=False) + ref_mask = ref_mask.logical_not() + ref_sentemb_list.append(ref_sentemb) + ref_sentembs_list.append(ref_sentembs) + ref_mask_list.append(ref_mask) + + + refs_clip = [] + for ref_list in refs: # (ref_cnt, B, L) + subset = [clip.tokenize("A photo depicts " + ref,truncate=True).to(self.device) for ref in ref_list] + subset = torch.cat(subset,dim=0) + refs_tensor = self.clip.encode_text(subset) + refs_clip.append(refs_tensor) + + mts_clip = clip.tokenize(["A photo depicts " + x for x in mt],truncate=True).to(self.device) + imgs_clip = torch.cat([self.clip_preprocess(img).unsqueeze(0) for img in imgs],dim=0).to(self.device) + + imgs_clip = self.clip.encode_image(imgs_clip) + mts_clip = self.clip.encode_text(mts_clip) + del imgs + + scores = [] + for ref_sentemb, ref_clip in zip(ref_sentemb_list,refs_clip): + diff = torch.abs(mt_sentemb - ref_sentemb) + mul = mt_sentemb * ref_sentemb + diff_clip = torch.abs(imgs_clip - mts_clip) + mul_clip = imgs_clip * mts_clip + diff_clip_txt = torch.abs(ref_clip - mts_clip) + mul_clip_txt = ref_clip * mts_clip + if self.parallel_feature_extraction: + x = torch.cat( + (ref_sentemb,mt_sentemb,diff,mul,imgs_clip,mts_clip,diff_clip,mul_clip,diff_clip_txt,mul_clip_txt),dim=1 + ) + else: + x = torch.cat( + (ref_sentemb,mt_sentemb,ref_clip,imgs_clip,mts_clip),dim=1 + ) + score = self.ff(x) + scores.append(score) + + score = torch.max(torch.stack(scores),dim=0).values + + return {"score" : score} \ No newline at end of file diff --git a/polos/models/estimators/quality_estimator.py b/polos/models/estimators/quality_estimator.py new file mode 100644 index 0000000000000000000000000000000000000000..071b4a6a8e502947cc87dd3b76a8a8a06e9a57b0 --- /dev/null +++ b/polos/models/estimators/quality_estimator.py @@ -0,0 +1,132 @@ +# -*- coding: utf-8 -*- +r""" +Quality Estimator Model +======================= + Quality Estimator Model estimates a quality score for the hyphotesis (e.g: the MT text) + by looking only at source and MT. +""" +from argparse import Namespace +from typing import Dict, List, Tuple, Union + +import pandas as pd +import torch + +from polos.models.estimators import PolosEstimator, Estimator +from polos.modules.feedforward import FeedForward +from polos.modules.scalar_mix import ScalarMixWithDropout +from torchnlp.utils import collate_tensors + + +class QualityEstimator(PolosEstimator): + """ + Estimator class that uses a pretrained encoder to extract features from + the sequences and then passes those features to a feed forward estimator. + + :param hparams: Namespace containing the hyperparameters. + """ + + def __init__( + self, + hparams: Namespace, + ) -> None: + super().__init__(hparams) + + def _build_model(self) -> Estimator: + """ + Initializes the estimator architecture. + """ + super()._build_model() + if self.hparams.encoder_model != "LASER": + self.layer = ( + int(self.hparams.layer) + if self.hparams.layer != "mix" + else self.hparams.layer + ) + + self.scalar_mix = ( + ScalarMixWithDropout( + mixture_size=self.encoder.num_layers, + dropout=self.hparams.scalar_mix_dropout, + do_layer_norm=True, + ) + if self.layer == "mix" and self.hparams.pool != "default" + else None + ) + + self.ff = FeedForward( + in_dim=self.encoder.output_units * 4, + hidden_sizes=self.hparams.hidden_sizes, + activations=self.hparams.activations, + dropout=self.hparams.dropout, + ) + + def read_csv(self, path: str) -> List[dict]: + """Reads a comma separated value file. + + :param path: path to a csv file. + + :return: List of records as dictionaries + """ + df = pd.read_csv(path) + df = df[["mt", "src", "score"]] + df["mt"] = df["mt"].astype(str) + df["src"] = df["src"].astype(str) + df["score"] = df["score"].astype(float) + return df.to_dict("records") + + def prepare_sample( + self, sample: List[Dict[str, Union[str, float]]], inference: bool = False + ) -> Union[ + Tuple[Dict[str, torch.Tensor], Dict[str, torch.Tensor]], Dict[str, torch.Tensor] + ]: + """ + Function that prepares a sample to input the model. + :param sample: list of dictionaries. + :param inference: If set to true prepares only the model inputs. + + :returns: Tuple with 2 dictionaries (model inputs and targets). + If `inference=True` returns only the model inputs. + """ + sample = collate_tensors(sample) + mt_inputs = self.encoder.prepare_sample(sample["mt"]) + src_inputs = self.encoder.prepare_sample(sample["src"]) + + mt_inputs = {"mt_" + k: v for k, v in mt_inputs.items()} + src_inputs = {"src_" + k: v for k, v in src_inputs.items()} + + inputs = {**mt_inputs, **src_inputs} + + if inference: + return inputs + + targets = {"score": torch.tensor(sample["score"], dtype=torch.float)} + return inputs, targets + + def forward( + self, + mt_tokens: torch.tensor, + src_tokens: torch.tensor, + mt_lengths: torch.tensor, + src_lengths: torch.tensor, + **kwargs + ) -> Dict[str, torch.Tensor]: + """ + Function that encodes both Source, MT and returns a quality score. + + :param mt_tokens: MT sequences [batch_size x mt_seq_len] + :param src_tokens: SRC sequences [batch_size x src_seq_len] + :param mt_lengths: MT lengths [batch_size] + :param src_lengths: SRC lengths [batch_size] + + :return: Dictionary with model outputs to be passed to the loss function. + """ + mt_sentemb = self.get_sentence_embedding(mt_tokens, mt_lengths) + src_sentemb = self.get_sentence_embedding(src_tokens, src_lengths) + + diff_src = torch.abs(mt_sentemb - src_sentemb) + prod_src = mt_sentemb * src_sentemb + + embedded_sequences = torch.cat( + (mt_sentemb, src_sentemb, prod_src, diff_src), dim=1 + ) + return {"score": self.ff(embedded_sequences)} diff --git a/polos/models/model_base.py b/polos/models/model_base.py new file mode 100644 index 0000000000000000000000000000000000000000..b148af6ce06ce896680e2a8213b0c36fb2d01d28 --- /dev/null +++ b/polos/models/model_base.py @@ -0,0 +1,542 @@ +# -*- coding: utf-8 -*- +r""" +Model Base +============== + Abstract base class used to build new modules inside Polos. + This class is just an extention of PyTorch Lightning main module: + https://pytorch-lightning.readthedocs.io/en/0.8.4/lightning-module.html +""" +from argparse import Namespace +from os import path +import os +from typing import Dict, Generator, List, Tuple, Union + +import click +import numpy as np +import pandas as pd +import torch +from torch.utils.data import DataLoader, RandomSampler, Subset, Dataset +from PIL import Image + +import pytorch_lightning as ptl +from polos.models.encoders import Encoder, str2encoder +from polos.schedulers import str2scheduler + +from PIL import ImageFile +ImageFile.LOAD_TRUNCATED_IMAGES = True + +class ModelBase(ptl.LightningModule): + """ + Extends PyTorch Lightning with a common structure and interface + that will be shared across all architectures. + + :param hparams: Namespace with hyper-parameters + """ + + class ModelConfig: + """ + The ModelConfig class is used to define model hyper-parameters that + are used to initialize our Lightning Modules. These parameters are + then overwritted with the values defined in the YAML file and coverted + to a Namespace to initialize the model. + + :param model: Model class name (to be replaced with the model specified in the YAML) + + -------------------- Training Parameters ------------------------- + + :param batch_size: Batch size used during training. + + :param nr_frozen_epochs: Number of epochs we keep the encoder model frozen. + + :param keep_embeddings_frozen: Keeping the embeddings frozen is a usefull way to save some GPU memory usage. + This is critical to fine-tune large models in GPUs with less than 32GB memory. + + -------------------- Optimizer Parameters ------------------------- + + :param optimizer: Optimizer class to be used. + + :param learning_rate: Overall learning rate. + + -------------------- Scheduler Parameters ------------------------- + + :param scheduler: Scheduler class to be used. + + :param warmup_steps: Warmup steps (only used for schedulers with warmup period). + + -------------------- Architecture Parameters ------------------------- + + :param encoder_model: Encoder class to be used. + + :param pretrained_model: Encoder checkpoint (e.g. xlmr.base vs xlmr.large) + + :param pool: Pooling technique to extract the sentence embeddings. + Options: {max, avg, default, cls} where default uses the `default` sentence embedding + returned by the encoder (e.g. BERT pooler_output) and `cls` is the first token of the + sequence and depends on the selected layer. + + :param load_weights: Loads weights from a checkpoint file that match the architecture. + + -------------------- Data Parameters ------------------------- + + :param train_path: Path to the training data. + + :param val_path: Path to the validation data. + + :param test_path: Path to the test data. + + :param loader_workers: Number of workers used to load and tokenize data during training. + + :param monitor: Metric to be displayed in tqdm bar. Same as trainer monitor flag! + """ + + model: str = None + # TODO: rankerモデルだとこれが必要．要調査 + # 【ここから】 + encoder_learning_rate: float = 1e-06 + layerwise_decay: float = 1.0 + layer: str = "mix" + scalar_mix_dropout: float = 0.0 + + loss: str = "mse" + hidden_sizes: str = "1024" + activations: str = "Tanh" + dropout: float = 0.1 + final_activation: str = "Sigmoid" + # 【ここまで】 + + # Training details + batch_size: int = 8 + nr_frozen_epochs: int = 0 + keep_embeddings_frozen: bool = False + + # Optimizer + optimizer: str = "Adam" + learning_rate: float = 1e-05 + + # Scheduler + scheduler: str = "constant" + warmup_steps: int = None + + # Architecture Definition + encoder_model: str = "XLMR" + pretrained_model: str = "xlmr.base" + pool: str = "avg" + load_weights: str = False + + # Data + train_path: str = None + val_path: str = None + test_path: str = None + train_img_dir_path: str = None + val_img_dir_path: str = None + test_img_dir_path: str = None + loader_workers: int = 8 + + monitor: str = "kendall" + + def __init__(self, initial_data: dict) -> None: + for key in initial_data: + if hasattr(self, key): + setattr(self, key, initial_data[key]) + + def namespace(self) -> Namespace: + return Namespace( + **{ + name: getattr(self, name) + for name in dir(self) + if not callable(getattr(self, name)) and not name.startswith("__") + } + ) + + def __init__(self, hparams: Namespace) -> None: + super(ModelBase, self).__init__() + if isinstance(hparams, dict): + self.hparams = Namespace(**hparams) + else: + self.hparams = hparams + self.encoder = self._build_encoder() + + # Model initialization + self._build_model() + + # Loss criterion initialization. + self._build_loss() + + # The encoder always starts in a frozen state. + if self.hparams.nr_frozen_epochs > 0: + self._frozen = True + self.freeze_encoder() + else: + self._frozen = False + + if ( + hasattr(self.hparams, "keep_embeddings_frozen") + and self.hparams.keep_embeddings_frozen + ): + self.encoder.freeze_embeddings() + + self.nr_frozen_epochs = self.hparams.nr_frozen_epochs + + def _build_loss(self): + """ Initializes the loss function/s. """ + pass + + def _build_model(self) -> ptl.LightningModule: + """ + Initializes the estimator architecture. + """ + # Compatibility with previous Polos versions + if ( + hasattr(self.hparams, "load_weights") + and self.hparams.load_weights + and path.exists(self.hparams.load_weights) + ): + click.secho(f"Loading weights from {self.hparams.load_weights}", fg="red") + self.load_weights(self.hparams.load_weights) + + def _build_encoder(self) -> Encoder: + """ + Initializes the encoder. + """ + try: + return str2encoder[self.hparams.encoder_model].from_pretrained(self.hparams) + except KeyError: + raise Exception(f"{self.hparams.encoder_model} invalid encoder model!") + + def _build_optimizer(self, parameters: Generator) -> torch.optim.Optimizer: + """ + Initializes the Optimizer. + + :param parameters: Module.parameters. + """ + if hasattr(torch.optim, self.hparams.optimizer): + return getattr(torch.optim, self.hparams.optimizer)( + params=parameters, lr=self.hparams.learning_rate + ) + else: + raise Exception(f"{self.hparams.optimizer} invalid optimizer!") + + def _build_scheduler( + self, optimizer: torch.optim.Optimizer + ) -> torch.optim.lr_scheduler.LambdaLR: + """ + Initializes the Scheduler. + + :param optimizer: PyTorch optimizer + """ + self.epoch_total_steps = len(self.train_dataset) // ( + self.hparams.batch_size * max(1, self.trainer.num_gpus) + ) + self.total_steps = self.epoch_total_steps * float(self.trainer.max_epochs) + try: + return { + "scheduler": str2scheduler[self.hparams.scheduler].from_hparams( + optimizer, self.hparams, num_training_steps=self.total_steps + ), + "interval": "step", # called after each training step + } + except KeyError: + raise Exception(f"{self.hparams.scheduler} invalid scheduler!") + + def read_csv(self, path: str) -> List[dict]: + """Reads a comma separated value file. + + :param path: path to a csv file. + + :return: List of records as dictionaries + """ + df = pd.read_csv(path) + return df.to_dict("records") + + def freeze_encoder(self) -> None: + """ Freezes the encoder layer. """ + self.encoder.freeze() + + def unfreeze_encoder(self) -> None: + """ un-freezes the encoder layer. """ + if self._frozen: + if self.trainer.is_global_zero: + click.secho("\nEncoder model fine-tuning", fg="red") + self.encoder.unfreeze() + self._frozen = False + + if ( + hasattr(self.hparams, "keep_embeddings_frozen") + and self.hparams.keep_embeddings_frozen + ): + self.encoder.freeze_embeddings() + + def on_epoch_end(self): + """ Hook used to unfreeze encoder during training. """ + if self.current_epoch + 1 >= self.nr_frozen_epochs and self._frozen: + self.unfreeze_encoder() + self._frozen = False + + def predict( + self, samples: Dict[str, str] + ) -> (Dict[str, Union[str, float]], List[float]): + """Function that runs a model prediction, + + :param samples: dictionary with expected model sequences. + You can also pass a list of dictionaries to predict an entire batch. + + :return: Dictionary with input samples + scores and list with just the scores. + """ + pass + + def forward(self, *args, **kwargs) -> Dict[str, torch.Tensor]: + """ + PyTorch Forward. + + :return: Dictionary with model outputs to be passed to the loss function. + """ + pass + + def compute_loss( + self, model_out: Dict[str, torch.Tensor], targets: Dict[str, torch.Tensor] + ) -> torch.Tensor: + """ + Computes Loss value according to a loss function. + + :param model_out: model specific output. + :param targets: Target score values [batch_size] + """ + pass + + def prepare_sample( + self, sample: List[Dict[str, Union[str, float]]], inference: bool = False + ) -> Union[ + Tuple[Dict[str, torch.Tensor], Dict[str, torch.Tensor]], Dict[str, torch.Tensor] + ]: + """ + Function that prepares a sample to input the model. + + :param sample: List of dictionaries. + :param inference: If set to true prepares only the model inputs. + + :returns: Tuple with 2 dictionaries (model inputs and targets). If `inference=True` + returns only the model inputs. + """ + pass + + def configure_optimizers( + self, + ) -> Tuple[List[torch.optim.Optimizer], List[torch.optim.lr_scheduler.LambdaLR]]: + """ + Function for setting up the optimizers and the schedulers to be used during training. + + :returns: List with as many optimizers as we need and a list with the respective schedulers. + """ + optimizer = self._build_optimizer(self.parameters()) + scheduler = self._build_scheduler(optimizer) + return [optimizer], [scheduler] + + def compute_metrics( + self, outputs: List[Dict[str, torch.Tensor]] + ) -> Dict[str, torch.Tensor]: + """ + Function that computes metrics of interest based on the list of outputs + you defined in validation_step. + """ + pass + + def training_step( + self, + batch: Tuple[Dict[str, torch.Tensor], Dict[str, torch.Tensor]], + batch_nb: int, + *args, + **kwargs, + ) -> Dict[str, torch.Tensor]: + """ + Runs one training step. + This usually consists in the forward function followed by the loss function. + + :param batch: The output of your prepare_sample function. + :param batch_nb: Integer displaying which batch this is. + + :returns: dictionary containing the loss and the metrics to be added to the lightning logger. + """ + batch_input, batch_target = batch + batch_prediction = self.forward(**batch_input) + loss_value = self.compute_loss(batch_prediction, batch_target) + + # in DP mode (default) make sure if result is scalar, there's another dim in the beginning + if self.trainer.use_dp or self.trainer.use_ddp2: + loss_value = loss_value.unsqueeze(0) + + if ( + self.nr_frozen_epochs < 1.0 + and self.nr_frozen_epochs > 0.0 + and batch_nb > self.epoch_total_steps * self.nr_frozen_epochs + ): + self.unfreeze_encoder() + self._frozen = False + + self.log("train_loss", loss_value, on_step=True, on_epoch=True) + return loss_value + + def validation_step( + self, + batch: Tuple[Dict[str, torch.Tensor], Dict[str, torch.Tensor]], + batch_nb: int, + dataloader_idx: int, + ) -> Dict[str, torch.Tensor]: + """ + Similar to the training step but with the model in eval mode. + + :param batch: The output of your prepare_sample function. + :param batch_nb: Integer displaying which batch this is. + :param dataloader_idx: Integer displaying which dataloader this is. + + :returns: dictionary passed to the validation_end function. + """ + batch_input, batch_target = batch + batch_prediction = self.forward(**batch_input) + loss_value = self.compute_loss(batch_prediction, batch_target) + + # in DP mode (default) make sure if result is scalar, there's another dim in the beginning + if self.trainer.use_dp or self.trainer.use_ddp2: + loss_value = loss_value.unsqueeze(0) + + return { + "val_loss": loss_value, + "val_prediction": batch_prediction, + "val_target": batch_target, + } + + def validation_epoch_end( + self, outputs: List[Dict[str, torch.Tensor]] + ) -> Dict[str, Dict[str, torch.Tensor]]: + """ + Function that takes as input a list of dictionaries returned by the validation_step + and measures the model performance accross the entire validation set. + + :param outputs: + + :returns: Dictionary with metrics to be added to the lightning logger. + """ + train_outs, val_outs = outputs + train_loss = torch.stack([x["val_loss"] for x in train_outs]).mean() + val_loss = torch.stack([x["val_loss"] for x in val_outs]).mean() + + # Store Metrics for Reporting... + val_metrics = self.compute_metrics(val_outs) + val_metrics["avg_loss"] = val_loss + self.log_dict(val_metrics, prog_bar=True) + + train_metrics = self.compute_metrics(train_outs) + train_metrics["avg_loss"] = train_loss + self.log_dict({"train_" + k: v for k, v in train_metrics.items()}) + + def test_step( + self, + batch: Tuple[Dict[str, torch.Tensor], Dict[str, torch.Tensor]], + batch_nb: int, + *args, + **kwargs, + ) -> Dict[str, torch.Tensor]: + """ Redirects to the validation_step function """ + return self.validation_step(batch, batch_nb, 0) + + def test_epoch_end( + self, outputs: List[Dict[str, torch.Tensor]] + ) -> Dict[str, Dict[str, torch.Tensor]]: + """ Computes metrics. """ + return self.compute_metrics(outputs) + + def setup(self, stage) -> None: + """Data preparation function called before training by Lightning. + Equivalent to the prepare_data in previous Lightning Versions""" + self.train_dataset = self.read_csv(self.hparams.train_path) + self.val_dataset = self.read_csv(self.hparams.val_path) + + self.train_dataset = CVPRDataset(self.train_dataset, self.hparams.train_img_dir_path) + self.val_dataset = CVPRDataset(self.val_dataset, self.hparams.val_img_dir_path) + print("[SPLIT]: Train: {}, Val: {}".format(len(self.train_dataset), len(self.val_dataset))) + + # Always validate the model with 2k examples from training to control overfit. + train_subset = np.random.choice(a=len(self.train_dataset), size=2000) + self.train_subset = Subset(self.train_dataset, train_subset) + + if self.hparams.test_path: + self.test_dataset = self.read_csv(self.hparams.test_path) + self.test_dataset = CVPRDataset(self.test_dataset, self.hparams.test_img_dir_path) + + def train_dataloader(self) -> DataLoader: + """ Function that loads the train set. """ + return DataLoader( + dataset=self.train_dataset, + sampler=RandomSampler(self.train_dataset), + batch_size=self.hparams.batch_size, + collate_fn=self.prepare_sample, + num_workers=self.hparams.loader_workers, + ) + + def val_dataloader(self) -> DataLoader: + """ Function that loads the validation set. """ + return [ + DataLoader( + dataset=self.train_subset, + batch_size=self.hparams.batch_size, + collate_fn=self.prepare_sample, + num_workers=self.hparams.loader_workers, + ), + DataLoader( + dataset=self.val_dataset, + batch_size=self.hparams.batch_size, + collate_fn=self.prepare_sample, + num_workers=self.hparams.loader_workers, + ), + ] + + def test_dataloader(self) -> DataLoader: + """ Function that loads the validation set. """ + return DataLoader( + dataset=self.test_dataset, + batch_size=self.hparams.batch_size, + collate_fn=self.prepare_sample, + num_workers=self.hparams.loader_workers, + ) + + +class CVPRDataset(Dataset): + def __init__(self, dataset, img_dir_path): + self.dataset = dataset + self.img_dir_path = img_dir_path + + # Filter out entries with broken image files + for data in self.dataset: + assert self.is_image_ok(path.join(img_dir_path, f"{data['imgid']}")) + + def __len__(self): + return len(self.dataset) + + def __getitem__(self, idx): + from copy import deepcopy + # Get image from df + imgid = self.dataset[idx]["imgid"] + img_name = path.join(self.img_dir_path, f"{imgid}") + + # Get label from df + labels = deepcopy(self.dataset[idx]) + + # print(labels) + + # Open image file + # from detectron2.data.detection_utils import read_image + # img = read_image(img_name, format="RGB") + img = Image.open(img_name).convert("RGB") + + labels["img"] = img + + return labels + + @staticmethod + def is_image_ok(img_path): + # Try to open the image file + try: + img = Image.open(img_path) + img.verify() + return True + except (IOError, SyntaxError) as e: + return False diff --git a/polos/models/ranking/__init__.py b/polos/models/ranking/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6d0b0ac65303340330ee3dbe47305b7454ffc39f --- /dev/null +++ b/polos/models/ranking/__init__.py @@ -0,0 +1,4 @@ +from .polos_ranker import PolosRanker +from .ranking_base import RankingBase + +__all__ = ["RankingBase", "PolosRanker"] diff --git a/polos/models/ranking/__pycache__/__init__.cpython-39.pyc b/polos/models/ranking/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..efb258752f7ec4bad6ee6309b3e9a38e96d201b9 Binary files /dev/null and b/polos/models/ranking/__pycache__/__init__.cpython-39.pyc differ diff --git a/polos/models/ranking/__pycache__/polos_ranker.cpython-39.pyc b/polos/models/ranking/__pycache__/polos_ranker.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..544f88ee041cb636ed28888304eabe738ed5f1bd Binary files /dev/null and b/polos/models/ranking/__pycache__/polos_ranker.cpython-39.pyc differ diff --git a/polos/models/ranking/__pycache__/ranking_base.cpython-39.pyc b/polos/models/ranking/__pycache__/ranking_base.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..79213c30885ac787de90b45cffce0eaf607887ab Binary files /dev/null and b/polos/models/ranking/__pycache__/ranking_base.cpython-39.pyc differ diff --git a/polos/models/ranking/polos_ranker.py b/polos/models/ranking/polos_ranker.py new file mode 100644 index 0000000000000000000000000000000000000000..096421eb3067cbe66c1147cb6439405a75ebcf18 --- /dev/null +++ b/polos/models/ranking/polos_ranker.py @@ -0,0 +1,267 @@ +# -*- coding: utf-8 -*- +r""" +Polos Ranker Model +====================== + The goal of this model is to rank good translations closer to the reference and source text + and bad translations further by a small margin. + + https://pytorch.org/docs/stable/nn.html#tripletmarginloss +""" +from argparse import Namespace +from typing import Dict, List, Tuple, Union + +import torch +import torch.nn.functional as F +from tqdm import tqdm + +from polos.models.ranking.ranking_base import RankingBase +from polos.models.utils import move_to_cuda +from torchnlp.utils import collate_tensors + + +class PolosRanker(RankingBase): # extends ptl.LightningModule + """ + Polos Ranker class that uses a pretrained encoder to extract features + from the sequences and then passes those features through a Triplet Margin Loss. + + :param hparams: Namespace containing the hyperparameters. + """ + + def __init__(self, hparams: Namespace) -> None: + super().__init__(hparams) + + def compute_metrics(self, outputs: List[Dict[str, torch.Tensor]]) -> dict: + """ Computes WMT19 shared task kendall tau like metric. """ + distance_pos, distance_neg = [], [] + for minibatch in outputs: + minibatch = minibatch["val_prediction"] + src_embedding = minibatch["src_sentemb"] + ref_embedding = minibatch["ref_sentemb"] + pos_embedding = minibatch["pos_sentemb"] + neg_embedding = minibatch["neg_sentemb"] + + distance_src_pos = F.pairwise_distance(pos_embedding, src_embedding) + distance_ref_pos = F.pairwise_distance(pos_embedding, ref_embedding) + harmonic_distance_pos = (2 * distance_src_pos * distance_ref_pos) / ( + distance_src_pos + distance_ref_pos + ) + distance_pos.append(harmonic_distance_pos) + + distance_src_neg = F.pairwise_distance(neg_embedding, src_embedding) + distance_ref_neg = F.pairwise_distance(neg_embedding, ref_embedding) + harmonic_distance_neg = (2 * distance_src_neg * distance_ref_neg) / ( + distance_src_neg + distance_ref_neg + ) + distance_neg.append(harmonic_distance_neg) + + return { + "kendall": self.metrics.compute( + torch.cat(distance_pos), torch.cat(distance_neg) + ) + } + + def compute_loss(self, model_out: Dict[str, torch.Tensor], *args) -> torch.Tensor: + """ + # forwardの結果がmodel_outに入っているのでlossを計算 + Computes Triplet Margin Loss for both the reference and the source. + + :param model_out: model specific output with src_anchor, ref_anchor, pos and neg + sentence embeddings. + """ + + # 参考 + # "src_sentemb": self.get_sentence_embedding(src_tokens, src_lengths), + # "ref_sentemb": self.get_sentence_embedding(ref_tokens, ref_lengths), + # "pos_sentemb": self.get_sentence_embedding(pos_tokens, pos_lengths), + # "neg_sentemb": self.get_sentence_embedding(neg_tokens, neg_lengths), + + ref_anchor = model_out["ref_sentemb"] + src_anchor = model_out["src_sentemb"] + positive = model_out["pos_sentemb"] + negative = model_out["neg_sentemb"] + + return self.loss(src_anchor, positive, negative) + self.loss( + ref_anchor, positive, negative + ) + + def predict( + self, + samples: Dict[str, str], + cuda: bool = False, + show_progress: bool = False, + batch_size: int = -1, + ) -> (Dict[str, Union[str, float]], List[float]): + """Function that runs a model prediction, + + :param samples: List of dictionaries with 'mt' and 'ref' keys. + :param cuda: Flag that runs inference using 1 single GPU. + :param show_progress: Flag to show progress during inference of multiple examples. + :para batch_size: Batch size used during inference. By default uses the same batch size used during training. + + :return: Dictionary with model outputs + """ + if self.training: + self.eval() + + if cuda and torch.cuda.is_available(): + self.to("cuda") + + batch_size = self.hparams.batch_size if batch_size < 1 else batch_size + with torch.no_grad(): + batches = [ + samples[i : i + batch_size] for i in range(0, len(samples), batch_size) + ] + model_inputs = [] + if show_progress: + pbar = tqdm( + total=len(batches), desc="Preparing batches....", dynamic_ncols=True + ) + for batch in batches: + model_inputs.append(self.prepare_sample(batch, inference=True)) + if show_progress: + pbar.update(1) + + if show_progress: + pbar.close() + + if show_progress: + pbar = tqdm( + total=len(batches), desc="Scoring hypothesis...", dynamic_ncols=True + ) + + distance_weighted, distance_src, distance_ref = [], [], [] + for k, model_input in enumerate(model_inputs): + src_input, mt_input, ref_input, alt_input = model_input + if cuda and torch.cuda.is_available(): + src_embeddings = self.get_sentence_embedding( + **move_to_cuda(src_input) + ) + mt_embeddings = self.get_sentence_embedding( + **move_to_cuda(mt_input) + ) + ref_embeddings = self.get_sentence_embedding( + **move_to_cuda(ref_input) + ) + ref_distances = F.pairwise_distance( + mt_embeddings, ref_embeddings + ).cpu() + src_distances = F.pairwise_distance( + mt_embeddings, src_embeddings + ).cpu() + + # When 2 references are given the distance to the reference is the Min between + # both references. + if alt_input is not None: + alt_embeddings = self.get_sentence_embedding( + **move_to_cuda(alt_input) + ) + alt_distances = F.pairwise_distance( + mt_embeddings, alt_embeddings + ).cpu() + ref_distances = torch.stack([ref_distances, alt_distances]) + ref_distances = ref_distances.min(dim=0).values + + else: + src_embeddings = self.get_sentence_embedding(**src_input) + mt_embeddings = self.get_sentence_embedding(**mt_input) + ref_embeddings = self.get_sentence_embedding(**ref_input) + ref_distances = F.pairwise_distance(mt_embeddings, ref_embeddings) + src_distances = F.pairwise_distance(mt_embeddings, src_embeddings) + + # Harmonic mean between the distances: + distances = (2 * ref_distances * src_distances) / ( + ref_distances + src_distances + ) + src_distances = ref_distances.numpy().tolist() + ref_distances = ref_distances.numpy().tolist() + distances = distances.numpy().tolist() + + for i in range(len(distances)): + distance_weighted.append(1 / (1 + distances[i])) + distance_src.append(1 / (1 + src_distances[i])) + distance_ref.append(1 / (1 + ref_distances[i])) + + if show_progress: + pbar.update(1) + + if show_progress: + pbar.close() + + assert len(distance_weighted) == len(samples) + scores = [] + for i in range(len(samples)): + scores.append(distance_weighted[i]) + samples[i]["predicted_score"] = scores[-1] + samples[i]["reference_distance"] = distance_ref[i] + samples[i]["source_distance"] = distance_src[i] + + return samples, scores + + def prepare_sample( + self, sample: List[Dict[str, Union[str, float]]], inference: bool = False + ) -> Union[Tuple[Dict[str, torch.Tensor], None], List[Dict[str, torch.Tensor]]]: + """ + Function that prepares a sample to input the model. + + :param sample: list of dictionaries. + :param inference: If set to to False, then the model expects + a MT and reference instead of anchor, pos, and neg segments. + + :return: Tuple with a dictionary containing the model inputs and None OR List + with source, MT and reference tokenized and vectorized. + """ + sample = collate_tensors(sample) + if inference: + src_inputs = self.encoder.prepare_sample(sample["src"]) + mt_inputs = self.encoder.prepare_sample(sample["mt"]) + ref_inputs = self.encoder.prepare_sample(sample["ref"]) + alt_inputs = ( + self.encoder.prepare_sample(sample["alt"]) if "alt" in sample else None + ) + return src_inputs, mt_inputs, ref_inputs, alt_inputs + + ref_inputs = self.encoder.prepare_sample(sample["ref"]) + src_inputs = self.encoder.prepare_sample(sample["src"]) + pos_inputs = self.encoder.prepare_sample(sample["pos"]) + neg_inputs = self.encoder.prepare_sample(sample["neg"]) + + ref_inputs = {"ref_" + k: v for k, v in ref_inputs.items()} + src_inputs = {"src_" + k: v for k, v in src_inputs.items()} + pos_inputs = {"pos_" + k: v for k, v in pos_inputs.items()} + neg_inputs = {"neg_" + k: v for k, v in neg_inputs.items()} + + return {**ref_inputs, **src_inputs, **pos_inputs, **neg_inputs}, torch.empty(0) + + def forward( + self, + src_tokens: torch.tensor, + ref_tokens: torch.tensor, + pos_tokens: torch.tensor, + neg_tokens: torch.tensor, + src_lengths: torch.tensor, + ref_lengths: torch.tensor, + pos_lengths: torch.tensor, + neg_lengths: torch.tensor, + **kwargs + ) -> Dict[str, torch.Tensor]: + """ + Function that encodes the anchor, positive samples and negative samples + and returns embeddings for the triplet. + + :param src_tokens: anchor sequences [batch_size x anchor_seq_len] + :param ref_tokens: anchor sequences [batch_size x anchor_seq_len] + :param pos_tokens: positive sequences [batch_size x pos_seq_len] + :param neg_tokens: negative sequences [batch_size x neg_seq_len] + :param src_lengths: anchor lengths [batch_size] + :param ref_lengths: anchor lengths [batch_size] + :param pos_lengths: positive lengths [batch_size] + :param neg_lengths: negative lengths [batch_size] + + :return: Dictionary with model outputs to be passed to the loss function. + """ + return { + "src_sentemb": self.get_sentence_embedding(src_tokens, src_lengths), + "ref_sentemb": self.get_sentence_embedding(ref_tokens, ref_lengths), + "pos_sentemb": self.get_sentence_embedding(pos_tokens, pos_lengths), + "neg_sentemb": self.get_sentence_embedding(neg_tokens, neg_lengths), + } diff --git a/polos/models/ranking/ranking_base.py b/polos/models/ranking/ranking_base.py new file mode 100644 index 0000000000000000000000000000000000000000..a06057b3ee1b3095eb70c7d80d5e58b8b5a0959f --- /dev/null +++ b/polos/models/ranking/ranking_base.py @@ -0,0 +1,127 @@ +# -*- coding: utf-8 -*- +r""" +Translation Ranking Base Model +============================== + Abstract base class used to build new ranking systems inside Polos. + This task consists of ranking "good" translations above "worse" ones. +""" +from argparse import Namespace +from typing import List + +import pandas as pd +import torch +import torch.nn as nn + +from polos.models.model_base import ModelBase +from polos.models.utils import average_pooling, max_pooling +from polos.modules.scalar_mix import ScalarMixWithDropout +from polos.metrics import WMTKendall + + +class RankingBase(ModelBase): + """ + Ranking Model base class used to fine-tune pretrained models such as XLM-R + to produce better sentence embeddings by optmizing Triplet Margin Loss. + + :param hparams: Namespace containing the hyperparameters. + """ + + def __init__( + self, + hparams: Namespace, + ) -> None: + super().__init__(hparams) + + def read_csv(self, path: str) -> List[dict]: + """Reads a comma separated value file. + + :param path: path to a csv file. + + :return: List of records as dictionaries + """ + df = pd.read_csv(path) + df = df[["src", "ref", "pos", "neg"]] + df["src"] = df["src"].astype(str) + df["ref"] = df["ref"].astype(str) + df["pos"] = df["pos"].astype(str) + df["neg"] = df["neg"].astype(str) + return df.to_dict("records") + + def _build_loss(self): + """ Initializes the loss function/s. """ + self.loss = nn.TripletMarginLoss(margin=1.0, p=2) + + def _build_model(self) -> ModelBase: + """ + Initializes the ranking model architecture. + """ + super()._build_model() + self.metrics = WMTKendall() + if self.hparams.encoder_model != "LASER": + self.layer = ( + int(self.hparams.layer) + if self.hparams.layer != "mix" + else self.hparams.layer + ) + + self.scalar_mix = ( + ScalarMixWithDropout( + mixture_size=self.encoder.num_layers, + dropout=self.hparams.scalar_mix_dropout, + do_layer_norm=True, + ) + if self.layer == "mix" and self.hparams.pool != "default" + else None + ) + + def get_sentence_embedding( + self, tokens: torch.Tensor, lengths: torch.Tensor + ) -> torch.Tensor: + """Auxiliar function that extracts sentence embeddings for + a single sentence. + + :param tokens: sequences [batch_size x seq_len] + :param lengths: lengths [batch_size] + + :return: torch.Tensor [batch_size x hidden_size] + """ + # When using just one GPU this should not change behavior + # but when splitting batches across GPU the tokens have padding + # from the entire original batch + if self.trainer and self.trainer.use_dp and self.trainer.num_gpus > 1: + tokens = tokens[:, : lengths.max()] + + encoder_out = self.encoder(tokens, lengths) + # for LASER we dont care about the word embeddings + if self.hparams.encoder_model == "LASER": + pass + elif self.scalar_mix: + embeddings = self.scalar_mix(encoder_out["all_layers"], encoder_out["mask"]) + elif self.layer >= 0 and self.layer < self.encoder.num_layers: + embeddings = encoder_out["all_layers"][self.layer] + else: + raise Exception("Invalid model layer {}.".format(self.layer)) + + if self.hparams.pool == "default" or self.hparams.encoder_model == "LASER": + sentemb = encoder_out["sentemb"] + + elif self.hparams.pool == "max": + sentemb = max_pooling( + tokens, embeddings, self.encoder.tokenizer.padding_index + ) + + elif self.hparams.pool == "avg": + sentemb = average_pooling( + tokens, + embeddings, + encoder_out["mask"], + self.encoder.tokenizer.padding_index, + ) + + elif self.hparams.pool == "cls": + sentemb = embeddings[:, 0, :] + + else: + raise Exception("Invalid pooling technique.") + + return sentemb diff --git a/polos/models/utils.py b/polos/models/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..714968af625fe1af87fe95130881fa046143ce56 --- /dev/null +++ b/polos/models/utils.py @@ -0,0 +1,133 @@ +# -*- coding: utf-8 -*- +import torch + +from polos.tokenizers_ import TextEncoderBase + + +def average_pooling( + tokens: torch.Tensor, + embeddings: torch.Tensor, + mask: torch.Tensor, + padding_index: int, +) -> torch.Tensor: + """Average pooling function. + + :param tokens: Word ids [batch_size x seq_length] + :param embeddings: Word embeddings [batch_size x seq_length x hidden_size] + :param mask: Padding mask [batch_size x seq_length] + :param padding_index: Padding value. + """ + wordemb = mask_fill(0.0, tokens, embeddings, padding_index) + sentemb = torch.sum(wordemb, 1) + sum_mask = mask.unsqueeze(-1).expand(embeddings.size()).float().sum(1) + return sentemb / sum_mask + + +def max_pooling( + tokens: torch.Tensor, embeddings: torch.Tensor, padding_index: int +) -> torch.Tensor: + """Max pooling function. + + :param tokens: Word ids [batch_size x seq_length] + :param embeddings: Word embeddings [batch_size x seq_length x hidden_size] + :param padding_index: Padding value. + """ + return mask_fill(float("-inf"), tokens, embeddings, padding_index).max(dim=1)[0] + + +def mask_fill( + fill_value: float, + tokens: torch.Tensor, + embeddings: torch.Tensor, + padding_index: int, +) -> torch.Tensor: + """ + Function that masks embeddings representing padded elements. + + :param fill_value: the value to fill the embeddings belonging to padded tokens. + :param tokens: The input sequences [bsz x seq_len]. + :param embeddings: word embeddings [bsz x seq_len x hiddens]. + :param padding_index: Index of the padding token. + """ + padding_mask = tokens.eq(padding_index).unsqueeze(-1) + return embeddings.float().masked_fill_(padding_mask, fill_value).type_as(embeddings) + + +def sort_sequences(inputs: torch.Tensor, input_lengths: torch.Tensor): + """ + Sort sequences according to lengths of the input sequence (descendingly). + + :param inputs (Tensor): input sequences, size [B, T, D] + :param input_lengths (Tensor): length of each sequence, size [B] + """ + lengths_sorted, sorted_idx = input_lengths.sort(descending=True) + _, unsorted_idx = sorted_idx.sort() + return inputs[sorted_idx], lengths_sorted, unsorted_idx + + +def apply_to_sample(f, sample): + if hasattr(sample, "__len__") and len(sample) == 0: + return {} + + def _apply(x): + if torch.is_tensor(x): + return f(x) + elif isinstance(x, dict): + return {key: _apply(value) for key, value in x.items()} + elif isinstance(x, list): + return [_apply(x) for x in x] + else: + return x + + return _apply(sample) + + +def move_to_cuda(sample): + """ Moves a sample to cuda. Works with dictionaries, tensors and lists. """ + + def _move_to_cuda(tensor): + return tensor.cuda() + + return apply_to_sample(_move_to_cuda, sample) + + +def move_to_cpu(sample): + """ Moves a sample to cuda. Works with dictionaries, tensors and lists. """ + + def _move_to_cpu(tensor): + return tensor.cpu() + + return apply_to_sample(_move_to_cpu, sample) + + +# --------------- LASER auxiliar functions from facebook research ------------------------------ +def buffered_arange(max): + if not hasattr(buffered_arange, "buf"): + buffered_arange.buf = torch.LongTensor() + if max > buffered_arange.buf.numel(): + torch.arange(max, out=buffered_arange.buf) + return buffered_arange.buf[:max] + + +def convert_padding_direction( + src_tokens, padding_idx, right_to_left=False, left_to_right=False +): + assert right_to_left ^ left_to_right + pad_mask = src_tokens.eq(padding_idx) + if not pad_mask.any(): + # no padding, return early + return src_tokens + if left_to_right and not pad_mask[:, 0].any(): + # already right padded + return src_tokens + if right_to_left and not pad_mask[:, -1].any(): + # already left padded + return src_tokens + max_len = src_tokens.size(1) + range = buffered_arange(max_len).type_as(src_tokens).expand_as(src_tokens) + num_pads = pad_mask.long().sum(dim=1, keepdim=True) + if right_to_left: + index = torch.remainder(range - num_pads, max_len) + else: + index = torch.remainder(range + num_pads, max_len) + return src_tokens.gather(1, index) diff --git a/polos/modules/__init__.py b/polos/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/polos/modules/__pycache__/__init__.cpython-39.pyc b/polos/modules/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..22374886714dc30d1b6e96bdd558248fa294e080 Binary files /dev/null and b/polos/modules/__pycache__/__init__.cpython-39.pyc differ diff --git a/polos/modules/__pycache__/activations.cpython-39.pyc b/polos/modules/__pycache__/activations.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b50181ffc4d8bff0e3388fc6af68a062185e58ac Binary files /dev/null and b/polos/modules/__pycache__/activations.cpython-39.pyc differ diff --git a/polos/modules/__pycache__/feedforward.cpython-39.pyc b/polos/modules/__pycache__/feedforward.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d5e27866dcc80fff232e515ac67164b5cbf8cbc Binary files /dev/null and b/polos/modules/__pycache__/feedforward.cpython-39.pyc differ diff --git a/polos/modules/__pycache__/scalar_mix.cpython-39.pyc b/polos/modules/__pycache__/scalar_mix.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..791dece5ce07281bce2e9d9f0f5774ff5d40f4db Binary files /dev/null and b/polos/modules/__pycache__/scalar_mix.cpython-39.pyc differ diff --git a/polos/modules/activations.py b/polos/modules/activations.py new file mode 100644 index 0000000000000000000000000000000000000000..021abb99618971e37353711e55c40f335b52e643 --- /dev/null +++ b/polos/modules/activations.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +r""" +Activation Functions +============== + Provides an easy to use interface to initialize different activation functions. +""" +import torch +from torch import nn + + +def build_activation(activation: str) -> nn.Module: + """Builder function that returns a nn.module activation function. + + :param activation: string defining the name of the activation function. + + Activations available: + Swish + every native pytorch activation function. + """ + if hasattr(nn, activation): + return getattr(nn, activation)() + elif activation == "Swish": + return Swish() + else: + raise Exception("{} invalid activation function.".format(activation)) + + +def swish(input: torch.Tensor) -> torch.Tensor: + """ + Applies Swish element-wise: A self-gated activation function + swish(x) = x * sigmoid(x) + """ + return input * torch.sigmoid(input) + + +class Swish(nn.Module): + """ + Applies the Swish function element-wise: + + Swish(x) = x * sigmoid(x) + + Shape: + - Input: (N, *) where * means, any number of additional + dimensions + - Output: (N, *), same shape as the input + + References: + - Related paper: + https://arxiv.org/pdf/1710.05941v1.pdf + """ + + def __init__(self) -> None: + """ + Init method. + """ + super().__init__() # init the base class + + def forward(self, input: torch.Tensor) -> torch.Tensor: + """ + Forward pass of the function. + """ + return swish(input) diff --git a/polos/modules/feedforward.py b/polos/modules/feedforward.py new file mode 100644 index 0000000000000000000000000000000000000000..73e50f98e856b97333cb76cd4d7f2cb090c9f662 --- /dev/null +++ b/polos/modules/feedforward.py @@ -0,0 +1,70 @@ +# -*- coding: utf-8 -*- +r""" +Feed Forward +============== + Simple Feed Forward Neural Network module that can be used for classification or regression +""" +import torch +from torch import nn + +from polos.modules.activations import build_activation + + +class FeedForward(nn.Module): + """ + Feed Forward Neural Network. + + :param in_dim: Number input features. + :param out_dim: Number of output features. Default is just a score. + :param hidden_sizes: list with the size of the hidden layers. + This parameter can also be a string with the sizes splited by a comma. + :param activations: Name of the activation function to be used in the hidden layers. + :param final_activation: Name of the final activation function or False if we dont + want a final activation. + :param dropout: dropout to be used in the hidden layers. + """ + + def __init__( + self, + in_dim: int, + out_dim: int = 1, + hidden_sizes: str = "3072,1536,768", + activations: str = "Sigmoid", + final_activation: str = "Sigmoid", + dropout: float = 0.0, + ) -> None: + super().__init__() + + if isinstance(hidden_sizes, str): + hidden_sizes = [int(x) for x in hidden_sizes.split(",")] + + if isinstance(hidden_sizes, int): + hidden_sizes = [hidden_sizes] + + activation_func = build_activation(activations) + + self.ff = torch.nn.Sequential() + self.ff.add_module("linear_1", nn.Linear(in_dim, hidden_sizes[0])) + self.ff.add_module("activation_1", activation_func) + self.ff.add_module("dropout_1", nn.Dropout(dropout)) + + for i in range(1, len(hidden_sizes)): + self.ff.add_module( + "linear_{}".format(i + 1), + nn.Linear(int(hidden_sizes[i - 1]), hidden_sizes[i]), + ) + self.ff.add_module("activation_{}".format(i + 1), activation_func) + self.ff.add_module("dropout_{}".format(i + 1), nn.Dropout(dropout)) + + self.ff.add_module( + "linear_{}".format(len(hidden_sizes) + 1), + nn.Linear(hidden_sizes[-1], int(out_dim)), + ) + if final_activation: + final_activation = build_activation(final_activation) + self.ff.add_module( + "activation_{}".format(len(hidden_sizes) + 1), final_activation + ) + + def forward(self, in_features: torch.Tensor) -> torch.Tensor: + return self.ff(in_features) diff --git a/polos/modules/scalar_mix.py b/polos/modules/scalar_mix.py new file mode 100644 index 0000000000000000000000000000000000000000..3be5071a49666e48c16b7c670a2dc9f5611cc8b9 --- /dev/null +++ b/polos/modules/scalar_mix.py @@ -0,0 +1,125 @@ +# -*- coding: utf-8 -*- +r""" +Layer-Wise Attention Mechanism +================================ + Computes a parameterised scalar mixture of N tensors, `mixture = gamma * sum(s_k * tensor_k)` + where `s = softmax(w)`, with `w` and `gamma` scalar parameters. + + If `do_layer_norm=True` then apply layer normalization to each tensor before weighting. + + If `dropout > 0`, then for each scalar weight, adjust its softmax weight mass to 0 with + the dropout probability (i.e., setting the unnormalized weight to -inf). This effectively + should redistribute dropped probability mass to all other weights. + + Original implementation: + - https://github.com/Hyperparticle/udify +""" +from typing import List + +import torch +from torch.nn import Parameter, ParameterList + + +class ScalarMixWithDropout(torch.nn.Module): + def __init__( + self, + mixture_size: int, + do_layer_norm: bool = False, + initial_scalar_parameters: list = None, + trainable: bool = True, + dropout: float = None, + dropout_value: float = -1e20, + ) -> None: + super(ScalarMixWithDropout, self).__init__() + self.mixture_size = mixture_size + self.do_layer_norm = do_layer_norm + self.dropout = dropout + + if initial_scalar_parameters is None: + initial_scalar_parameters = [0.0] * mixture_size + elif len(initial_scalar_parameters) != mixture_size: + raise Exception( + "Length of initial_scalar_parameters {} differs \ + from mixture_size {}".format( + initial_scalar_parameters, mixture_size + ) + ) + + self.scalar_parameters = ParameterList( + [ + Parameter( + torch.FloatTensor([initial_scalar_parameters[i]]), + requires_grad=trainable, + ) + for i in range(mixture_size) + ] + ) + + self.gamma = Parameter(torch.FloatTensor([1.0]), requires_grad=trainable) + + if self.dropout: + dropout_mask = torch.zeros(len(self.scalar_parameters)) + dropout_fill = torch.empty(len(self.scalar_parameters)).fill_(dropout_value) + self.register_buffer("dropout_mask", dropout_mask) + self.register_buffer("dropout_fill", dropout_fill) + + def forward( + self, + tensors: List[torch.Tensor], # pylint: disable=arguments-differ + mask: torch.Tensor = None, + ) -> torch.Tensor: + """ + Compute a weighted average of the `tensors`. The input tensors an be any shape + with at least two dimensions, but must all be the same shape. + When `do_layer_norm=True`, the `mask` is required input. If the `tensors` are + dimensioned `(dim_0, ..., dim_{n-1}, dim_n)`, then the `mask` is dimensioned + `(dim_0, ..., dim_{n-1})`, as in the typical case with `tensors` of shape + `(batch_size, timesteps, dim)` and `mask` of shape `(batch_size, timesteps)`. + When `do_layer_norm=False` the `mask` is ignored. + """ + if len(tensors) != self.mixture_size: + raise Exception( + "{} tensors were passed, but the module was initialized to \ + mix {} tensors.".format( + len(tensors), self.mixture_size + ) + ) + + def _do_layer_norm(tensor, broadcast_mask, num_elements_not_masked): + tensor_masked = tensor * broadcast_mask + mean = torch.sum(tensor_masked) / num_elements_not_masked + variance = ( + torch.sum(((tensor_masked - mean) * broadcast_mask) ** 2) + / num_elements_not_masked + ) + return (tensor - mean) / torch.sqrt(variance + 1e-12) + + weights = torch.cat([parameter for parameter in self.scalar_parameters]) + + if self.training and self.dropout: + weights = torch.where( + self.dropout_mask.uniform_() > self.dropout, weights, self.dropout_fill + ) + + normed_weights = torch.nn.functional.softmax(weights, dim=0) + normed_weights = torch.split(normed_weights, split_size_or_sections=1) + + if not self.do_layer_norm: + pieces = [] + for weight, tensor in zip(normed_weights, tensors): + pieces.append(weight * tensor) + return self.gamma * sum(pieces) + + else: + mask_float = mask.float() + broadcast_mask = mask_float.unsqueeze(-1) + input_dim = tensors[0].size(-1) + num_elements_not_masked = torch.sum(mask_float) * input_dim + + pieces = [] + for weight, tensor in zip(normed_weights, tensors): + pieces.append( + weight + * _do_layer_norm(tensor, broadcast_mask, num_elements_not_masked) + ) + return self.gamma * sum(pieces) diff --git a/polos/schedulers.py b/polos/schedulers.py new file mode 100644 index 0000000000000000000000000000000000000000..76b22264f4a5c5c3aa456db563e18ccb8c435622 --- /dev/null +++ b/polos/schedulers.py @@ -0,0 +1,139 @@ +# -*- coding: utf-8 -*- +r""" +Schedulers +============== + Leraning Rate schedulers used to train Polos models. +""" +from argparse import Namespace + +from torch.optim import Optimizer +from torch.optim.lr_scheduler import LambdaLR + + +class ConstantPolicy: + """Policy for updating the LR of the ConstantLR scheduler. + With this class LambdaLR objects became picklable. + """ + + def __call__(self, *args, **kwargs): + return 1 + + +class ConstantLR(LambdaLR): + """ + Constant learning rate schedule + + Wrapper for the huggingface Constant LR Scheduler. + https://huggingface.co/transformers/v2.1.1/main_classes/optimizer_schedules.html + + :param optimizer: torch.optim.Optimizer + :param last_epoch: + """ + + def __init__(self, optimizer: Optimizer, last_epoch: int = -1) -> None: + super(ConstantLR, self).__init__(optimizer, ConstantPolicy(), last_epoch) + + @classmethod + def from_hparams( + cls, optimizer: Optimizer, hparams: Namespace, **kwargs + ) -> LambdaLR: + """ Initializes a constant learning rate scheduler. """ + return ConstantLR(optimizer) + + +class WarmupPolicy: + """Policy for updating the LR of the WarmupConstant scheduler. + With this class LambdaLR objects became picklable. + """ + + def __init__(self, warmup_steps): + self.warmup_steps = warmup_steps + + def __call__(self, current_step): + if current_step < self.warmup_steps: + return float(current_step) / float(max(1.0, self.warmup_steps)) + return 1.0 + + +class WarmupConstant(LambdaLR): + """ + Warmup Linear scheduler. + 1) Linearly increases learning rate from 0 to 1 over warmup_steps + training steps. + 2) Keeps the learning rate constant afterwards. + + :param optimizer: torch.optim.Optimizer + :param warmup_steps: Linearly increases learning rate from 0 to 1 over warmup_steps. + :param last_epoch: + """ + + def __init__( + self, optimizer: Optimizer, warmup_steps: int, last_epoch: int = -1 + ) -> None: + super(WarmupConstant, self).__init__( + optimizer, WarmupPolicy(warmup_steps), last_epoch + ) + + @classmethod + def from_hparams( + cls, optimizer: Optimizer, hparams: Namespace, **kwargs + ) -> LambdaLR: + """ Initializes a constant learning rate scheduler with warmup period. """ + return WarmupConstant(optimizer, hparams.warmup_steps) + + +class LinearWarmupPolicy: + """Policy for updating the LR of the LinearWarmup scheduler. + With this class LambdaLR objects became picklable. + """ + + def __init__(self, warmup_steps, num_training_steps): + self.num_training_steps = num_training_steps + self.warmup_steps = warmup_steps + + def __call__(self, current_step): + if current_step < self.warmup_steps: + return float(current_step) / float(max(1, self.warmup_steps)) + return max( + 0.0, + float(self.num_training_steps - current_step) + / float(max(1, self.num_training_steps - self.warmup_steps)), + ) + + +class LinearWarmup(LambdaLR): + """ + Create a schedule with a learning rate that decreases linearly after + linearly increasing during a warmup period. + + :param optimizer: torch.optim.Optimizer + :param warmup_steps: Linearly increases learning rate from 0 to 1*learning_rate over warmup_steps. + :param num_training_steps: Linearly decreases learning rate from 1*learning_rate to 0. over remaining + t_total - warmup_steps steps. + :param last_epoch: + """ + + def __init__( + self, + optimizer: Optimizer, + warmup_steps: int, + num_training_steps: int, + last_epoch: int = -1, + ) -> None: + super(LinearWarmup, self).__init__( + optimizer, LinearWarmupPolicy(warmup_steps, num_training_steps), last_epoch + ) + + @classmethod + def from_hparams( + cls, optimizer: Optimizer, hparams: Namespace, num_training_steps: int + ) -> LambdaLR: + """ Initializes a learning rate scheduler with warmup period and decreasing period. """ + return LinearWarmup(optimizer, hparams.warmup_steps, num_training_steps) + + +str2scheduler = { + "linear_warmup": LinearWarmup, + "constant": ConstantLR, + "warmup_constant": WarmupConstant, +} diff --git a/polos/simple_tokenizer.py b/polos/simple_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..0a66286b7d5019c6e221932a813768038f839c91 --- /dev/null +++ b/polos/simple_tokenizer.py @@ -0,0 +1,132 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + vocab.extend(['<|startoftext|>', '<|endoftext|>']) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'} + self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '',) + pairs = get_pairs(word) + + if not pairs: + return token+'' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('', ' ') + return text diff --git a/polos/tokenizers_/__init__.py b/polos/tokenizers_/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..17e6e64368c09be2c46aca773f61e13f1c075f4b --- /dev/null +++ b/polos/tokenizers_/__init__.py @@ -0,0 +1,9 @@ +from .tokenizer_base import TextEncoderBase +from .hf_tokenizer import HFTextEncoder +from .xlmr_tokenizer import XLMRTextEncoder + +__all__ = [ + "XLMRTextEncoder", + "HFTextEncoder", + "TextEncoderBase", +] diff --git a/polos/tokenizers_/__pycache__/__init__.cpython-39.pyc b/polos/tokenizers_/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4d8bfdfd14a8cc15973fcbf9b2cd09a0abe29e88 Binary files /dev/null and b/polos/tokenizers_/__pycache__/__init__.cpython-39.pyc differ diff --git a/polos/tokenizers_/__pycache__/hf_tokenizer.cpython-39.pyc b/polos/tokenizers_/__pycache__/hf_tokenizer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ff7d36ebf340ee41a13de6c8a9cdc6da412a2ef3 Binary files /dev/null and b/polos/tokenizers_/__pycache__/hf_tokenizer.cpython-39.pyc differ diff --git a/polos/tokenizers_/__pycache__/tokenizer_base.cpython-39.pyc b/polos/tokenizers_/__pycache__/tokenizer_base.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec94a9f7e408932813c04d7866578a02a515097d Binary files /dev/null and b/polos/tokenizers_/__pycache__/tokenizer_base.cpython-39.pyc differ diff --git a/polos/tokenizers_/__pycache__/xlmr_tokenizer.cpython-39.pyc b/polos/tokenizers_/__pycache__/xlmr_tokenizer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a1078cc020c77f458acfa77f945c1f2e808bf27 Binary files /dev/null and b/polos/tokenizers_/__pycache__/xlmr_tokenizer.cpython-39.pyc differ diff --git a/polos/tokenizers_/hf_tokenizer.py b/polos/tokenizers_/hf_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..760ed1ac9712d2bfc537f6faa30fbcda02c57f17 --- /dev/null +++ b/polos/tokenizers_/hf_tokenizer.py @@ -0,0 +1,38 @@ +# -*- coding: utf-8 -*- +import torch +from transformers import AutoTokenizer + +from torchnlp.encoders.text.text_encoder import TextEncoder + +from .tokenizer_base import TextEncoderBase + + +class HFTextEncoder(TextEncoderBase): + """ + Wrapper arround transformers AutoTokenizer: + - https://huggingface.co/transformers/model_doc/auto.html#autotokenizer + + :param model: model to be used. + """ + + def __init__(self, model: str) -> None: + super().__init__() + self.tokenizer = AutoTokenizer.from_pretrained(model) + # Properties from the base class + self.stoi = self.tokenizer.get_vocab() + self.itos = {v: k for k, v in self.stoi.items()} + self._bos_index = self.tokenizer.cls_token_id + self._pad_index = self.tokenizer.pad_token_id + self._eos_index = self.tokenizer.sep_token_id + self._unk_index = self.tokenizer.unk_token_id + self._mask_index = self.tokenizer.mask_token_id + + def encode(self, sequence: str) -> torch.Tensor: + """Encodes a 'sequence'. + :param sequence: String 'sequence' to encode. + + Returns: + - torch.Tensor: Encoding of the 'sequence'. + """ + sequence = TextEncoder.encode(self, sequence) + return torch.tensor(self.tokenizer(sequence, truncation=False)["input_ids"]) diff --git a/polos/tokenizers_/tokenizer_base.py b/polos/tokenizers_/tokenizer_base.py new file mode 100644 index 0000000000000000000000000000000000000000..be0818635213521b2a8a6727f2a9a1d5d1718ae4 --- /dev/null +++ b/polos/tokenizers_/tokenizer_base.py @@ -0,0 +1,101 @@ +# -*- coding: utf-8 -*- +r""" +Text Encoder +============== + Base class difining a common interface between the different tokenizers used + in Polos. +""" +from typing import List, Dict, Tuple, Iterator + +import torch + +from torchnlp.encoders import Encoder +from torchnlp.encoders.text import stack_and_pad_tensors +from torchnlp.encoders.text.text_encoder import TextEncoder + + +class TextEncoderBase(TextEncoder): + """ + Base class for the specific tokenizers of each model. + """ + + def __init__(self) -> None: + self.enforce_reversible = False + + @property + def unk_index(self) -> int: + """ Returns the index used for the unknown token. """ + return self._unk_index + + @property + def bos_index(self) -> int: + """ Returns the index used for the begin-of-sentence token. """ + return self._bos_index + + @property + def eos_index(self) -> int: + """ Returns the index used for the end-of-sentence token. """ + return self._eos_index + + @property + def padding_index(self) -> int: + """ Returns the index used for padding. """ + return self._pad_index + + @property + def mask_index(self) -> int: + """ Returns the index used for masking. """ + return self._mask_index + + @property + def vocab(self) -> Dict[str, int]: + """ + Returns: + dictionary with tokens -> index + """ + return self.stoi + + @property + def vocab_size(self) -> int: + """ + Returns: + int: Number of tokens in the dictionary. + """ + return len(self.itos) + + def tokenize(self, sequence: str) -> List[str]: + """ + Function that tokenizes a string. + - To be extended by subclasses. + """ + raise NotImplementedError + + def encode(self, sequence: str) -> torch.Tensor: + """Encodes a 'sequence'. + :param sequence: String 'sequence' to encode. + + Returns: + - torch.Tensor: Encoding of the 'sequence'. + """ + sequence = super().encode(sequence) + tokens = self.tokenize(sequence) + vector = [self.stoi.get(token, self.unk_index) for token in tokens] + return torch.tensor(vector) + + def batch_encode( + self, iterator: Iterator[str], dim: int = 0, **kwargs + ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + :param iterator (iterator): Batch of text to encode. + :param dim (int, optional): Dimension along which to concatenate tensors. + :param **kwargs: Keyword arguments passed to 'encode'. + + Returns + torch.Tensor, torch.Tensor: Encoded and padded batch of sequences; Original lengths of + sequences. + """ + return stack_and_pad_tensors( + Encoder.batch_encode(self, iterator, **kwargs), + padding_index=self.padding_index, + dim=dim, + ) diff --git a/polos/tokenizers_/xlmr_tokenizer.py b/polos/tokenizers_/xlmr_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..8df7446848930d45d3f2a21a1a83fad94139e081 --- /dev/null +++ b/polos/tokenizers_/xlmr_tokenizer.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +from typing import Callable, Dict + +import torch + +from torchnlp.encoders.text.text_encoder import TextEncoder + +from .tokenizer_base import TextEncoderBase + + +class XLMRTextEncoder(TextEncoderBase): + """ + XLM-RoBERTa encoder from Fairseq. + + :param tokenizer_func: XLM tokenization function. + This can be easily obtain from the fairseq model (e.g: xlmr.encode callable) + :param vocabulary: the dictionary containing the XLM-R vocabulary. + This can be easily obtain from the fairseq model + (e.g: xlmr.task.source_dictionary.__dict__['indices']) + """ + + def __init__(self, encode_func: Callable, vocabulary: Dict[str, int]) -> None: + super().__init__() + + self.encode_func = encode_func + # Properties from the base class + self.stoi = vocabulary + self.itos = {v: k for k, v in vocabulary.items()} + self._pad_index = self.stoi[""] + self._eos_index = self.stoi[""] + self._unk_index = self.stoi[""] + self._bos_index = self.stoi[""] + self._mask_index = self.stoi[""] + + def encode(self, sequence: str) -> torch.Tensor: + """Encodes a 'sequence'. + :param sequence: String 'sequence' to encode. + + Returns: + - torch.Tensor: Encoding of the 'sequence'. + """ + sequence = TextEncoder.encode(self, sequence) + return self.encode_func(sequence) diff --git a/polos/trainer.py b/polos/trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..664208b4f21296cbfa170ef34e8791e13a82d1f9 --- /dev/null +++ b/polos/trainer.py @@ -0,0 +1,200 @@ +# -*- coding: utf-8 -*- +r""" +Lightning Trainer Setup +============== + Setup logic for the lightning trainer. +""" +import os +from argparse import Namespace +from datetime import datetime +from typing import Union + +import click +import pandas as pd + +import pytorch_lightning as pl +from polos.models.utils import apply_to_sample +from pytorch_lightning.callbacks import ( + Callback, + EarlyStopping, + ModelCheckpoint, +) +from pytorch_lightning.loggers import LightningLoggerBase, WandbLogger, TensorBoardLogger +from pytorch_lightning.utilities import rank_zero_only + + +class TrainerConfig: + """ + The TrainerConfig class is used to define default hyper-parameters that + are used to initialize our Lightning Trainer. These parameters are then overwritted + with the values defined in the YAML file. + + -------------------- General Parameters ------------------------- + + :param seed: Training seed. + + :param deterministic: If true enables cudnn.deterministic. Might make your system + slower, but ensures reproducibility. + + :param model: Model class we want to train. + + :param verbode: verbosity mode. + + :param overfit_batches: Uses this much data of the training set. If nonzero, will use + the same training set for validation and testing. If the training dataloaders + have shuffle=True, Lightning will automatically disable it. + + :param lr_finder: Runs a small portion of the training where the learning rate is increased + after each processed batch and the corresponding loss is logged. The result of this is + a lr vs. loss plot that can be used as guidance for choosing a optimal initial lr. + + -------------------- Model Checkpoint & Early Stopping ------------------------- + + :param early_stopping: If true enables EarlyStopping. + + :param save_top_k: If save_top_k == k, the best k models according to the metric + monitored will be saved. + + :param monitor: Metric to be monitored. + + :param save_weights_only: Saves only the weights of the model. + + :param period: Interval (number of epochs) between checkpoints. + + :param metric_mode: One of {min, max}. In min mode, training will stop when the + metric monitored has stopped decreasing; in max mode it will stop when the + metric monitored has stopped increasing. + + :param min_delta: Minimum change in the monitored metric to qualify as an improvement. + + :param patience: Number of epochs with no improvement after which training will be stopped. + """ + + seed: int = 3 + deterministic: bool = True + model: str = None + verbose: bool = False + overfit_batches: Union[int, float] = 0.0 + + # Model Checkpoint & Early Stopping + early_stopping: bool = True + save_top_k: int = 1 + monitor: str = "kendall" + save_weights_only: bool = False + metric_mode: str = "max" + min_delta: float = 0.0 + patience: int = 1 + accumulate_grad_batches: int = 1 + lr_finder: bool = False + + def __init__(self, initial_data: dict) -> None: + trainer_attr = pl.Trainer.default_attributes() + for key in trainer_attr: + setattr(self, key, trainer_attr[key]) + + for key in initial_data: + if hasattr(self, key): + setattr(self, key, initial_data[key]) + + def namespace(self) -> Namespace: + return Namespace( + **{ + name: getattr(self, name) + for name in dir(self) + if not callable(getattr(self, name)) and not name.startswith("__") + } + ) + + +class TrainReport(Callback): + """ Logger Callback that echos results during training. """ + + _stack: list = [] # stack to keep metrics from all epochs + + @rank_zero_only + def on_validation_end( + self, trainer: pl.Trainer, pl_module: pl.LightningModule + ) -> None: + metrics = trainer.callback_metrics + metrics = LightningLoggerBase._flatten_dict(metrics, "_") + metrics = apply_to_sample(lambda x: x.item(), metrics) + self._stack.append(metrics) + # pl_module.print() # Print newline + + @rank_zero_only + def on_fit_end(self, trainer: pl.Trainer, pl_module: pl.LightningModule) -> None: + click.secho("\nTraining Report Experiment:", fg="yellow") + index_column = ["Epoch " + str(i) for i in range(len(self._stack) - 1)] + df = pd.DataFrame(self._stack[1:], index=index_column) + # Clean dataframe columns + del df["train_loss_step"] + del df["gpu_id: 0/memory.used (MB)"] + del df["train_loss_epoch"] + del df["train_avg_loss"] + click.secho("{}".format(df), fg="yellow") + + +def build_trainer(hparams: Namespace, resume_from_checkpoint) -> pl.Trainer: + """ + :param hparams: Namespace + + :returns: Lightning Trainer (obj) + """ + # Early Stopping Callback + early_stop_callback = EarlyStopping( + monitor=hparams.monitor, + min_delta=hparams.min_delta, + patience=hparams.patience, + verbose=hparams.verbose, + mode=hparams.metric_mode, + ) + + # TestTube Logger Callback + wandb_logger = WandbLogger(name="polos", + project="polos_cvpr", + save_dir="experiments/", + version="version_" + datetime.now().strftime("%d-%m-%Y--%H-%M-%S")) + + tb_logger = TensorBoardLogger( + save_dir="experiments/", + version="version_" + datetime.now().strftime("%d-%m-%Y--%H-%M-%S"), + name="lightning", + ) + + # Model Checkpoint Callback + ckpt_path = os.path.join("experiments/lightning/", wandb_logger.version) + + checkpoint_callback = ModelCheckpoint( + dirpath=ckpt_path, + save_top_k=hparams.save_top_k, + verbose=hparams.verbose, + monitor=hparams.monitor, + save_weights_only=hparams.save_weights_only, + period=1, + mode=hparams.metric_mode, + ) + other_callbacks = [early_stop_callback, checkpoint_callback, TrainReport()] + + trainer = pl.Trainer( + logger=[wandb_logger,tb_logger], + callbacks=other_callbacks, + gradient_clip_val=hparams.gradient_clip_val, + gpus=hparams.gpus, + log_gpu_memory="all", + deterministic=hparams.deterministic, + overfit_batches=hparams.overfit_batches, + check_val_every_n_epoch=1, + fast_dev_run=False, + accumulate_grad_batches=hparams.accumulate_grad_batches, + max_epochs=hparams.max_epochs, + min_epochs=hparams.min_epochs, + limit_train_batches=hparams.limit_train_batches, + limit_val_batches=hparams.limit_val_batches, + val_check_interval=hparams.val_check_interval, + distributed_backend=hparams.distributed_backend, + precision=hparams.precision, + weights_summary="top", + profiler=hparams.profiler, + resume_from_checkpoint=resume_from_checkpoint, + ) + return trainer diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..fa49522a90ff430bd7e9188cb9ac91a7ef1d864f --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,64 @@ +[tool.poetry] +name = "polos" +version = "0.1.3" +authors = ["Yuiga Wada "] +description = "[CVPR24] Polos: Multimodal Metric Learning from Human Feedback for Image Captioning" +license = "BSD-3-Clause-Clear" +readme = "README.md" +classifiers = [ + 'Development Status :: 4 - Beta', + 'Environment :: Console', + 'Intended Audience :: Science/Research', + 'Topic :: Scientific/Engineering :: Artificial Intelligence', +] +packages = [ + {include = "polos"}, +] +include = [ + "LICENSE", + "pyproject.toml", + "CONTRIBUTING.md" +] + +[tool.poetry.scripts] +polos = 'polos.cli:polos' + +[tool.poetry.dependencies] +python = "3.9.2" +PyYAML = "5.3.*" +#numpy = "<=1.19" +protobuf="3.20.0" +pandas = "^1.0.0" +#fairseq = "0.9.0" +transformers = "4.*" +pytorch-lightning = "<=1.3" +pytorch-nlp = "0.5.0" +fsspec = "0.8.7" +psycopg2-binary = "^2.9.6" +torch = "^2.1.0" +click = "^8.1.7" +ftfy = "^6.1.1" +regex = "^2023.10.3" +wandb = "^0.15.12" +scikit-learn = "^1.3.2" +fairseq = "^0.12.2" +matplotlib = "^3.8.1" +pycocotools = "^2.0.7" +pycocoevalcap = "^1.2" +termcolor = "^2.3.0" +torchvision = "^0.16.0" +streamlit = "^1.35.0" +setuptools = "69.5.1" + +[tool.poetry.dev-dependencies] +sphinx-markdown-tables = "0.0.15" +coverage = "^5.5" + +[[tool.poetry.source]] +name = "torch_cu118" +url = "https://download.pytorch.org/whl/cu118" +priority = "explicit" + +[build-system] +requires = ["poetry-core>=1.0.0"] +build-backend = "poetry.core.masonry.api" diff --git a/requirements.txt b/requirements.txt index 73d01db64bd054c7d21fd0bd79b3af087c468809..0370dc2dbaa6e2cc2f760cbeef44865179e0def5 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,6 +1,2398 @@ -accelerate -diffusers -invisible_watermark -torch -transformers -xformers \ No newline at end of file +absl-py==2.1.0 ; python_full_version == "3.9.2" \ + --hash=sha256:526a04eadab8b4ee719ce68f204172ead1027549089702d99b9059f129ff1308 \ + --hash=sha256:7820790efbb316739cde8b4e19357243fc3608a152024288513dd968d7d959ff +aiohttp==3.9.5 ; python_full_version == "3.9.2" \ + --hash=sha256:0605cc2c0088fcaae79f01c913a38611ad09ba68ff482402d3410bf59039bfb8 \ + --hash=sha256:0a158704edf0abcac8ac371fbb54044f3270bdbc93e254a82b6c82be1ef08f3c \ + --hash=sha256:0cbf56238f4bbf49dab8c2dc2e6b1b68502b1e88d335bea59b3f5b9f4c001475 \ + --hash=sha256:1732102949ff6087589408d76cd6dea656b93c896b011ecafff418c9661dc4ed \ + --hash=sha256:18f634d540dd099c262e9f887c8bbacc959847cfe5da7a0e2e1cf3f14dbf2daf \ + --hash=sha256:239f975589a944eeb1bad26b8b140a59a3a320067fb3cd10b75c3092405a1372 \ + --hash=sha256:2faa61a904b83142747fc6a6d7ad8fccff898c849123030f8e75d5d967fd4a81 \ + --hash=sha256:320e8618eda64e19d11bdb3bd04ccc0a816c17eaecb7e4945d01deee2a22f95f \ + --hash=sha256:38d80498e2e169bc61418ff36170e0aad0cd268da8b38a17c4cf29d254a8b3f1 \ + --hash=sha256:3916c8692dbd9d55c523374a3b8213e628424d19116ac4308e434dbf6d95bbdd \ + --hash=sha256:393c7aba2b55559ef7ab791c94b44f7482a07bf7640d17b341b79081f5e5cd1a \ + --hash=sha256:3b7b30258348082826d274504fbc7c849959f1989d86c29bc355107accec6cfb \ + --hash=sha256:3fcb4046d2904378e3aeea1df51f697b0467f2aac55d232c87ba162709478c46 \ + --hash=sha256:4109adee842b90671f1b689901b948f347325045c15f46b39797ae1bf17019de \ + --hash=sha256:4558e5012ee03d2638c681e156461d37b7a113fe13970d438d95d10173d25f78 \ + --hash=sha256:45731330e754f5811c314901cebdf19dd776a44b31927fa4b4dbecab9e457b0c \ + --hash=sha256:4715a9b778f4293b9f8ae7a0a7cef9829f02ff8d6277a39d7f40565c737d3771 \ + --hash=sha256:471f0ef53ccedec9995287f02caf0c068732f026455f07db3f01a46e49d76bbb \ + --hash=sha256:4d3ebb9e1316ec74277d19c5f482f98cc65a73ccd5430540d6d11682cd857430 \ + --hash=sha256:4ff550491f5492ab5ed3533e76b8567f4b37bd2995e780a1f46bca2024223233 \ + --hash=sha256:52c27110f3862a1afbcb2af4281fc9fdc40327fa286c4625dfee247c3ba90156 \ + --hash=sha256:55b39c8684a46e56ef8c8d24faf02de4a2b2ac60d26cee93bc595651ff545de9 \ + --hash=sha256:5a7ee16aab26e76add4afc45e8f8206c95d1d75540f1039b84a03c3b3800dd59 \ + --hash=sha256:5ca51eadbd67045396bc92a4345d1790b7301c14d1848feaac1d6a6c9289e888 \ + --hash=sha256:5d6b3f1fabe465e819aed2c421a6743d8debbde79b6a8600739300630a01bf2c \ + --hash=sha256:60cdbd56f4cad9f69c35eaac0fbbdf1f77b0ff9456cebd4902f3dd1cf096464c \ + --hash=sha256:6380c039ec52866c06d69b5c7aad5478b24ed11696f0e72f6b807cfb261453da \ + --hash=sha256:639d0042b7670222f33b0028de6b4e2fad6451462ce7df2af8aee37dcac55424 \ + --hash=sha256:66331d00fb28dc90aa606d9a54304af76b335ae204d1836f65797d6fe27f1ca2 \ + --hash=sha256:67c3119f5ddc7261d47163ed86d760ddf0e625cd6246b4ed852e82159617b5fb \ + --hash=sha256:694d828b5c41255e54bc2dddb51a9f5150b4eefa9886e38b52605a05d96566e8 \ + --hash=sha256:6ae79c1bc12c34082d92bf9422764f799aee4746fd7a392db46b7fd357d4a17a \ + --hash=sha256:702e2c7c187c1a498a4e2b03155d52658fdd6fda882d3d7fbb891a5cf108bb10 \ + --hash=sha256:714d4e5231fed4ba2762ed489b4aec07b2b9953cf4ee31e9871caac895a839c0 \ + --hash=sha256:7b179eea70833c8dee51ec42f3b4097bd6370892fa93f510f76762105568cf09 \ + --hash=sha256:7f64cbd44443e80094309875d4f9c71d0401e966d191c3d469cde4642bc2e031 \ + --hash=sha256:82a6a97d9771cb48ae16979c3a3a9a18b600a8505b1115cfe354dfb2054468b4 \ + --hash=sha256:84dabd95154f43a2ea80deffec9cb44d2e301e38a0c9d331cc4aa0166fe28ae3 \ + --hash=sha256:8676e8fd73141ded15ea586de0b7cda1542960a7b9ad89b2b06428e97125d4fa \ + --hash=sha256:88e311d98cc0bf45b62fc46c66753a83445f5ab20038bcc1b8a1cc05666f428a \ + --hash=sha256:8b4f72fbb66279624bfe83fd5eb6aea0022dad8eec62b71e7bf63ee1caadeafe \ + --hash=sha256:8c64a6dc3fe5db7b1b4d2b5cb84c4f677768bdc340611eca673afb7cf416ef5a \ + --hash=sha256:8cf142aa6c1a751fcb364158fd710b8a9be874b81889c2bd13aa8893197455e2 \ + --hash=sha256:8d1964eb7617907c792ca00b341b5ec3e01ae8c280825deadbbd678447b127e1 \ + --hash=sha256:93e22add827447d2e26d67c9ac0161756007f152fdc5210277d00a85f6c92323 \ + --hash=sha256:9c69e77370cce2d6df5d12b4e12bdcca60c47ba13d1cbbc8645dd005a20b738b \ + --hash=sha256:9dbc053ac75ccc63dc3a3cc547b98c7258ec35a215a92bd9f983e0aac95d3d5b \ + --hash=sha256:9e3a1ae66e3d0c17cf65c08968a5ee3180c5a95920ec2731f53343fac9bad106 \ + --hash=sha256:a6ea1a5b409a85477fd8e5ee6ad8f0e40bf2844c270955e09360418cfd09abac \ + --hash=sha256:a81b1143d42b66ffc40a441379387076243ef7b51019204fd3ec36b9f69e77d6 \ + --hash=sha256:ad7f2919d7dac062f24d6f5fe95d401597fbb015a25771f85e692d043c9d7832 \ + --hash=sha256:afc52b8d969eff14e069a710057d15ab9ac17cd4b6753042c407dcea0e40bf75 \ + --hash=sha256:b3df71da99c98534be076196791adca8819761f0bf6e08e07fd7da25127150d6 \ + --hash=sha256:c088c4d70d21f8ca5c0b8b5403fe84a7bc8e024161febdd4ef04575ef35d474d \ + --hash=sha256:c26959ca7b75ff768e2776d8055bf9582a6267e24556bb7f7bd29e677932be72 \ + --hash=sha256:c413016880e03e69d166efb5a1a95d40f83d5a3a648d16486592c49ffb76d0db \ + --hash=sha256:c6021d296318cb6f9414b48e6a439a7f5d1f665464da507e8ff640848ee2a58a \ + --hash=sha256:c671dc117c2c21a1ca10c116cfcd6e3e44da7fcde37bf83b2be485ab377b25da \ + --hash=sha256:c7a4b7a6cf5b6eb11e109a9755fd4fda7d57395f8c575e166d363b9fc3ec4678 \ + --hash=sha256:c8a02fbeca6f63cb1f0475c799679057fc9268b77075ab7cf3f1c600e81dd46b \ + --hash=sha256:cd2adf5c87ff6d8b277814a28a535b59e20bfea40a101db6b3bdca7e9926bc24 \ + --hash=sha256:d1469f228cd9ffddd396d9948b8c9cd8022b6d1bf1e40c6f25b0fb90b4f893ed \ + --hash=sha256:d153f652a687a8e95ad367a86a61e8d53d528b0530ef382ec5aaf533140ed00f \ + --hash=sha256:d5ab8e1f6bee051a4bf6195e38a5c13e5e161cb7bad83d8854524798bd9fcd6e \ + --hash=sha256:da00da442a0e31f1c69d26d224e1efd3a1ca5bcbf210978a2ca7426dfcae9f58 \ + --hash=sha256:da22dab31d7180f8c3ac7c7635f3bcd53808f374f6aa333fe0b0b9e14b01f91a \ + --hash=sha256:e0ae53e33ee7476dd3d1132f932eeb39bf6125083820049d06edcdca4381f342 \ + --hash=sha256:e7a6a8354f1b62e15d48e04350f13e726fa08b62c3d7b8401c0a1314f02e3558 \ + --hash=sha256:e9a3d838441bebcf5cf442700e3963f58b5c33f015341f9ea86dcd7d503c07e2 \ + --hash=sha256:edea7d15772ceeb29db4aff55e482d4bcfb6ae160ce144f2682de02f6d693551 \ + --hash=sha256:f22eb3a6c1080d862befa0a89c380b4dafce29dc6cd56083f630073d102eb595 \ + --hash=sha256:f26383adb94da5e7fb388d441bf09c61e5e35f455a3217bfd790c6b6bc64b2ee \ + --hash=sha256:f3c2890ca8c59ee683fd09adf32321a40fe1cf164e3387799efb2acebf090c11 \ + --hash=sha256:f64fd07515dad67f24b6ea4a66ae2876c01031de91c93075b8093f07c0a2d93d \ + --hash=sha256:fcde4c397f673fdec23e6b05ebf8d4751314fa7c24f93334bf1f1364c1c69ac7 \ + --hash=sha256:ff84aeb864e0fac81f676be9f4685f0527b660f1efdc40dcede3c251ef1e867f +aiosignal==1.3.1 ; python_full_version == "3.9.2" \ + --hash=sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc \ + --hash=sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17 +altair==5.3.0 ; python_full_version == "3.9.2" \ + --hash=sha256:5a268b1a0983b23d8f9129f819f956174aa7aea2719ed55a52eba9979b9f6675 \ + --hash=sha256:7084a1dab4d83c5e7e5246b92dc1b4451a6c68fd057f3716ee9d315c8980e59a +antlr4-python3-runtime==4.8 ; python_full_version == "3.9.2" \ + --hash=sha256:15793f5d0512a372b4e7d2284058ad32ce7dd27126b105fb0b2245130445db33 +appdirs==1.4.4 ; python_full_version == "3.9.2" \ + --hash=sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41 \ + --hash=sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128 +async-timeout==4.0.3 ; python_full_version == "3.9.2" \ + --hash=sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f \ + --hash=sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028 +attrs==23.2.0 ; python_full_version == "3.9.2" \ + --hash=sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30 \ + --hash=sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1 +bitarray==2.9.2 ; python_full_version == "3.9.2" \ + --hash=sha256:03adaacb79e2fb8f483ab3a67665eec53bb3fd0cd5dbd7358741aef124688db3 \ + --hash=sha256:052c5073bdcaa9dd10628d99d37a2f33ec09364b86dd1f6281e2d9f8d3db3060 \ + --hash=sha256:0a99b23ac845a9ea3157782c97465e6ae026fe0c7c4c1ed1d88f759fd6ea52d9 \ + --hash=sha256:0b3543c8a1cb286ad105f11c25d8d0f712f41c5c55f90be39f0e5a1376c7d0b0 \ + --hash=sha256:128cc3488176145b9b137fdcf54c1c201809bbb8dd30b260ee40afe915843b43 \ + --hash=sha256:1bb33673e7f7190a65f0a940c1ef63266abdb391f4a3e544a47542d40a81f536 \ + --hash=sha256:1e0b63a565e8a311cc8348ff1262d5784df0f79d64031d546411afd5dd7ef67d \ + --hash=sha256:1e497c535f2a9b68c69d36631bf2dba243e05eb343b00b9c7bbdc8c601c6802d \ + --hash=sha256:1ff9e38356cc803e06134cf8ae9758e836ccd1b793135ef3db53c7c5d71e93bc \ + --hash=sha256:21f21e7f56206be346bdbda2a6bdb2165a5e6a11821f88fd4911c5a6bbbdc7e2 \ + --hash=sha256:2c6be1b651fad8f3adb7a5aa12c65b612cd9b89530969af941844ae680f7d981 \ + --hash=sha256:2f32948c86e0d230a296686db28191b67ed229756f84728847daa0c7ab7406e3 \ + --hash=sha256:321841cdad1dd0f58fe62e80e9c9c7531f8ebf8be93f047401e930dc47425b1e \ + --hash=sha256:345c76b349ff145549652436235c5532e5bfe9db690db6f0a6ad301c62b9ef21 \ + --hash=sha256:393cb27fd859af5fd9c16eb26b1c59b17b390ff66b3ae5d0dd258270191baf13 \ + --hash=sha256:3c4344e96642e2211fb3a50558feff682c31563a4c64529a931769d40832ca79 \ + --hash=sha256:3fa909cfd675004aed8b4cc9df352415933656e0155a6209d878b7cb615c787e \ + --hash=sha256:405b83bed28efaae6d86b6ab287c75712ead0adbfab2a1075a1b7ab47dad4d62 \ + --hash=sha256:43847799461d8ba71deb4d97b47250c2c2fb66d82cd3cb8b4caf52bb97c03034 \ + --hash=sha256:461a3dafb9d5fda0bb3385dc507d78b1984b49da3fe4c6d56c869a54373b7008 \ + --hash=sha256:48a30d718d1a6dfc22a49547450107abe8f4afdf2abdcbe76eb9ed88edc49498 \ + --hash=sha256:4a22266fb416a3b6c258bf7f83c9fe531ba0b755a56986a81ad69dc0f3bcc070 \ + --hash=sha256:4b558ce85579b51a2e38703877d1e93b7728a7af664dd45a34e833534f0b755d \ + --hash=sha256:4d0e32530f941c41eddfc77600ec89b65184cb909c549336463a738fab3ed285 \ + --hash=sha256:4da73ebd537d75fa7bccfc2228fcaedea0803f21dd9d0bf0d3b67fef3c4af294 \ + --hash=sha256:4e2936f090bf3f4d1771f44f9077ebccdbc0415d2b598d51a969afcb519df505 \ + --hash=sha256:508069a04f658210fdeee85a7a0ca84db4bcc110cbb1d21f692caa13210f24a7 \ + --hash=sha256:5361413fd2ecfdf44dc8f065177dc6aba97fa80a91b815586cb388763acf7f8d \ + --hash=sha256:54e16e32e60973bb83c315de9975bc1bcfc9bd50bb13001c31da159bc49b0ca1 \ + --hash=sha256:5b7b09489b71f9f1f64c0fa0977e250ec24500767dab7383ba9912495849cadf \ + --hash=sha256:5cb378eaa65cd43098f11ff5d27e48ee3b956d2c00d2d6b5bfc2a09fe183be47 \ + --hash=sha256:5d6fb422772e75385b76ad1c52f45a68bd4efafd8be8d0061c11877be74c4d43 \ + --hash=sha256:5f4dd3af86dd8a617eb6464622fb64ca86e61ce99b59b5c35d8cd33f9c30603d \ + --hash=sha256:603e7d640e54ad764d2b4da6b61e126259af84f253a20f512dd10689566e5478 \ + --hash=sha256:6067f2f07a7121749858c7daa93c8774325c91590b3e81a299621e347740c2ae \ + --hash=sha256:60df43e868a615c7e15117a1e1c2e5e11f48f6457280eba6ddf8fbefbec7da99 \ + --hash=sha256:64115ccabbdbe279c24c367b629c6b1d3da9ed36c7420129e27c338a3971bfee \ + --hash=sha256:6465de861aff7a2559f226b37982007417eab8c3557543879987f58b453519bd \ + --hash=sha256:648d2f2685590b0103c67a937c2fb9e09bcc8dfb166f0c7c77bd341902a6f5b3 \ + --hash=sha256:64b433e26993127732ac7b66a7821b2537c3044355798de7c5fcb0af34b8296f \ + --hash=sha256:677e67f50e2559efc677a4366707070933ad5418b8347a603a49a070890b19bc \ + --hash=sha256:6ab0f1dbfe5070db98771a56aa14797595acd45a1af9eadfb193851a270e7996 \ + --hash=sha256:6d70b1579da7fb71be5a841a1f965d19aca0ef27f629cfc07d06b09aafd0a333 \ + --hash=sha256:6ec84668dd7b937874a2b2c293cd14ba84f37be0d196dead852e0ada9815d807 \ + --hash=sha256:6f71d92f533770fb027388b35b6e11988ab89242b883f48a6fe7202d238c61f8 \ + --hash=sha256:76b76a07d4ee611405045c6950a1e24c4362b6b44808d4ad6eea75e0dbc59af4 \ + --hash=sha256:79a9b8b05f2876c7195a2b698c47528e86a73c61ea203394ff8e7a4434bda5c8 \ + --hash=sha256:7c1f4bf6ea8eb9d7f30808c2e9894237a96650adfecbf5f3643862dc5982f89e \ + --hash=sha256:7dfefdcb0dc6a3ba9936063cec65a74595571b375beabe18742b3d91d087eefd \ + --hash=sha256:7e913098de169c7fc890638ce5e171387363eb812579e637c44261460ac00aa2 \ + --hash=sha256:7eb8be687c50da0b397d5e0ab7ca200b5ebb639e79a9f5e285851d1944c94be9 \ + --hash=sha256:7eea9318293bc0ea6447e9ebfba600a62f3428bea7e9c6d42170ae4f481dbab3 \ + --hash=sha256:852e202875dd6dfd6139ce7ec4e98dac2b17d8d25934dc99900831e81c3adaef \ + --hash=sha256:856bbe1616425f71c0df5ef2e8755e878d9504d5a531acba58ab4273c52c117a \ + --hash=sha256:87580c7f7d14f7ec401eda7adac1e2a25e95153e9c339872c8ae61b3208819a1 \ + --hash=sha256:87abb7f80c0a042f3fe8e5264da1a2756267450bb602110d5327b8eaff7682e7 \ + --hash=sha256:90e3a281ffe3897991091b7c46fca38c2675bfd4399ffe79dfeded6c52715436 \ + --hash=sha256:917905de565d9576eb20f53c797c15ba88b9f4f19728acabec8d01eee1d3756a \ + --hash=sha256:9521f49ae121a17c0a41e5112249e6fa7f6a571245b1118de81fb86e7c1bc1ce \ + --hash=sha256:962892646599529917ef26266091e4cb3077c88b93c3833a909d68dcc971c4e3 \ + --hash=sha256:9ae5b0657380d2581e13e46864d147a52c1e2bbac9f59b59c576e42fa7d10cf0 \ + --hash=sha256:9bbcfc7c279e8d74b076e514e669b683f77b4a2a328585b3f16d4c5259c91222 \ + --hash=sha256:a035da89c959d98afc813e3c62f052690d67cfd55a36592f25d734b70de7d4b0 \ + --hash=sha256:a09c4f81635408e3387348f415521d4b94198c562c23330f560596a6aaa26eaf \ + --hash=sha256:a23397da092ef0a8cfe729571da64c2fc30ac18243caa82ac7c4f965087506ff \ + --hash=sha256:a484061616fb4b158b80789bd3cb511f399d2116525a8b29b6334c68abc2310f \ + --hash=sha256:a5cc9381fd54f3c23ae1039f977bfd6d041a5c3c1518104f616643c3a5a73b15 \ + --hash=sha256:a620d8ce4ea2f1c73c6b6b1399e14cb68c6915e2be3fad5808c2998ed55b4acf \ + --hash=sha256:a6cc6545d6d76542aee3d18c1c9485fb7b9812b8df4ebe52c4535ec42081b48f \ + --hash=sha256:a8873089be2aa15494c0f81af1209f6e1237d762c5065bc4766c1b84321e1b50 \ + --hash=sha256:a8f286a51a32323715d77755ed959f94bef13972e9a2fe71b609e40e6d27957e \ + --hash=sha256:aeb60962ec4813c539a59fbd4f383509c7222b62c3fb1faa76b54943a613e33a \ + --hash=sha256:b069ca9bf728e0c5c5b60e00a89df9af34cc170c695c3bfa3b372d8f40288efb \ + --hash=sha256:b0ef2d0a6f1502d38d911d25609b44c6cc27bee0a4363dd295df78b075041b60 \ + --hash=sha256:b306c4cf66912511422060f7f5e1149c8bdb404f8e00e600561b0749fdd45659 \ + --hash=sha256:b35bfcb08b7693ab4bf9059111a6e9f14e07d57ac93cd967c420db58ab9b71e1 \ + --hash=sha256:b44105792fbdcfbda3e26ee88786790fda409da4c71f6c2b73888108cf8f062f \ + --hash=sha256:b76ffec27c7450b8a334f967366a9ebadaea66ee43f5b530c12861b1a991f503 \ + --hash=sha256:ba0734aa300757c924f3faf8148e1b8c247176a0ac8e16aefdf9c1eb19e868f7 \ + --hash=sha256:bb198c6ed1edbcdaf3d1fa3c9c9d1cdb7e179a5134ef5ee660b53cdec43b34e7 \ + --hash=sha256:bb6b86cfdfc503e92cb71c68766a24565359136961642504a7cc9faf936d9c88 \ + --hash=sha256:be94e5a685e60f9d24532af8fe5c268002e9016fa80272a94727f435de3d1003 \ + --hash=sha256:bed637b674db5e6c8a97a4a321e3e4d73e72d50b5c6b29950008a93069cc64cd \ + --hash=sha256:c5b399ae6ab975257ec359f03b48fc00b1c1cd109471e41903548469b8feae5c \ + --hash=sha256:c71d1cabdeee0cdda4669168618f0e46b7dace207b29da7b63aaa1adc2b54081 \ + --hash=sha256:c7d16beeaaab15b075990cd26963d6b5b22e8c5becd131781514a00b8bdd04bd \ + --hash=sha256:c8919fdbd3bb596b104388b56ae4b266eb28da1f2f7dff2e1f9334a21840fe96 \ + --hash=sha256:c9b87baa7bfff9a5878fcc1bffe49ecde6e647a72a64b39a69cd8a2992a43a34 \ + --hash=sha256:cd56b8ae87ebc71bcacbd73615098e8a8de952ecbb5785b6b4e2b07da8a06e1f \ + --hash=sha256:cd926e8ae4d1ed1ac4a8f37212a62886292f692bc1739fde98013bf210c2d175 \ + --hash=sha256:cf0620da2b81946d28c0b16f3e3704d38e9837d85ee4f0652816e2609aaa4fed \ + --hash=sha256:d14c790b91f6cbcd9b718f88ed737c78939980c69ac8c7f03dd7e60040c12951 \ + --hash=sha256:d4bba8042ea6ab331ade91bc435d81ad72fddb098e49108610b0ce7780c14e68 \ + --hash=sha256:d527172919cdea1e13994a66d9708a80c3d33dedcf2f0548e4925e600fef3a3a \ + --hash=sha256:d656ad38c942e38a470ddbce26b5020e08e1a7ea86b8fd413bb9024b5189993a \ + --hash=sha256:d6fe315355cdfe3ed22ef355b8bdc81a805ca4d0949d921576560e5b227a1112 \ + --hash=sha256:d91406f413ccbf4af6ab5ae7bc78f772a95609f9ddd14123db36ef8c37116d95 \ + --hash=sha256:dac2399ee2889fbdd3472bfc2ede74c34cceb1ccf29a339964281a16eb1d3188 \ + --hash=sha256:dbaf2bb71d6027152d603f1d5f31e0dfd5e50173d06f877bec484e5396d4594b \ + --hash=sha256:e064caa55a6ed493aca1eda06f8b3f689778bc780a75e6ad7724642ba5dc62f7 \ + --hash=sha256:e40b3cb9fa1edb4e0175d7c06345c49c7925fe93e39ef55ecb0bc40c906b0c09 \ + --hash=sha256:e49066d251dbbe4e6e3a5c3937d85b589e40e2669ad0eef41a00f82ec17d844b \ + --hash=sha256:e6ec283d4741befb86e8c3ea2e9ac1d17416c956d392107e45263e736954b1f7 \ + --hash=sha256:e788608ed7767b7b3bbde6d49058bccdf94df0de9ca75d13aa99020cc7e68095 \ + --hash=sha256:e8a9475d415ef1eaae7942df6f780fa4dcd48fce32825eda591a17abba869299 \ + --hash=sha256:e8da5355d7d75a52df5b84750989e34e39919ec7e59fafc4c104cc1607ab2d31 \ + --hash=sha256:ea1923d2e7880f9e1959e035da661767b5a2e16a45dfd57d6aa831e8b65ee1bf \ + --hash=sha256:ea816dc8f8e65841a8bbdd30e921edffeeb6f76efe6a1eb0da147b60d539d1cf \ + --hash=sha256:eb7a9d8a2e400a1026de341ad48e21670a6261a75b06df162c5c39b0d0e7c8f4 \ + --hash=sha256:eceb551dfeaf19c609003a69a0cf8264b0efd7abc3791a11dfabf4788daf0d19 \ + --hash=sha256:ed0f7982f10581bb16553719e5e8f933e003f5b22f7d25a68bdb30fac630a6ff \ + --hash=sha256:f00079f8e69d75c2a417de7961a77612bb77ef46c09bc74607d86de4740771ef \ + --hash=sha256:f0b84fc50b6dbeced4fa390688c07c10a73222810fb0e08392bd1a1b8259de36 \ + --hash=sha256:f135e804986b12bf14f2cd1eb86674c47dea86c4c5f0fa13c88978876b97ebe6 \ + --hash=sha256:f2de9a31c34e543ae089fd2a5ced01292f725190e379921384f695e2d7184bd3 \ + --hash=sha256:f2f8692f95c9e377eb19ca519d30d1f884b02feb7e115f798de47570a359e43f \ + --hash=sha256:f4dcadb7b8034aa3491ee8f5a69b3d9ba9d7d1e55c3cc1fc45be313e708277f8 \ + --hash=sha256:f4f44381b0a4bdf64416082f4f0e7140377ae962c0ced6f983c6d7bbfc034040 \ + --hash=sha256:f708e91fdbe443f3bec2df394ed42328fb9b0446dff5cb4199023ac6499e09fd \ + --hash=sha256:f9346e98fc2abcef90b942973087e2462af6d3e3710e82938078d3493f7fef52 \ + --hash=sha256:fc6d3e80dd8239850f2604833ff3168b28909c8a9357abfed95632cccd17e3e7 \ + --hash=sha256:fe71fd4b76380c2772f96f1e53a524da7063645d647a4fcd3b651bdd80ca0f2e +blinker==1.8.2 ; python_full_version == "3.9.2" \ + --hash=sha256:1779309f71bf239144b9399d06ae925637cf6634cf6bd131104184531bf67c01 \ + --hash=sha256:8f77b09d3bf7c795e969e9486f39c2c5e9c39d4ee07424be2bc594ece9642d83 +cachetools==5.3.3 ; python_full_version == "3.9.2" \ + --hash=sha256:0abad1021d3f8325b2fc1d2e9c8b9c9d57b04c3932657a72465447332c24d945 \ + --hash=sha256:ba29e2dfa0b8b556606f097407ed1aa62080ee108ab0dc5ec9d6a723a007d105 +certifi==2024.6.2 ; python_full_version == "3.9.2" \ + --hash=sha256:3cd43f1c6fa7dedc5899d69d3ad0398fd018ad1a17fba83ddaf78aa46c747516 \ + --hash=sha256:ddc6c8ce995e6987e7faf5e3f1b02b302836a0e5d98ece18392cb1a36c72ad56 +cffi==1.16.0 ; python_full_version == "3.9.2" \ + --hash=sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc \ + --hash=sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a \ + --hash=sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417 \ + --hash=sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab \ + --hash=sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520 \ + --hash=sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36 \ + --hash=sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743 \ + --hash=sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8 \ + --hash=sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed \ + --hash=sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684 \ + --hash=sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56 \ + --hash=sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324 \ + --hash=sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d \ + --hash=sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235 \ + --hash=sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e \ + --hash=sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088 \ + --hash=sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000 \ + --hash=sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7 \ + --hash=sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e \ + --hash=sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673 \ + --hash=sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c \ + --hash=sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe \ + --hash=sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2 \ + --hash=sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098 \ + --hash=sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8 \ + --hash=sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a \ + --hash=sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0 \ + --hash=sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b \ + --hash=sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896 \ + --hash=sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e \ + --hash=sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9 \ + --hash=sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2 \ + --hash=sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b \ + --hash=sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6 \ + --hash=sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404 \ + --hash=sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f \ + --hash=sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0 \ + --hash=sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4 \ + --hash=sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc \ + --hash=sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936 \ + --hash=sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba \ + --hash=sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872 \ + --hash=sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb \ + --hash=sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614 \ + --hash=sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1 \ + --hash=sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d \ + --hash=sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969 \ + --hash=sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b \ + --hash=sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4 \ + --hash=sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627 \ + --hash=sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956 \ + --hash=sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357 +charset-normalizer==3.3.2 ; python_full_version == "3.9.2" \ + --hash=sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027 \ + --hash=sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087 \ + --hash=sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786 \ + --hash=sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8 \ + --hash=sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09 \ + --hash=sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185 \ + --hash=sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574 \ + --hash=sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e \ + --hash=sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519 \ + --hash=sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898 \ + --hash=sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269 \ + --hash=sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3 \ + --hash=sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f \ + --hash=sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6 \ + --hash=sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8 \ + --hash=sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a \ + --hash=sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73 \ + --hash=sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc \ + --hash=sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714 \ + --hash=sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2 \ + --hash=sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc \ + --hash=sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce \ + --hash=sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d \ + --hash=sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e \ + --hash=sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6 \ + --hash=sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269 \ + --hash=sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96 \ + --hash=sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d \ + --hash=sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a \ + --hash=sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4 \ + --hash=sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77 \ + --hash=sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d \ + --hash=sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0 \ + --hash=sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed \ + --hash=sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068 \ + --hash=sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac \ + --hash=sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25 \ + --hash=sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8 \ + --hash=sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab \ + --hash=sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26 \ + --hash=sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2 \ + --hash=sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db \ + --hash=sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f \ + --hash=sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5 \ + --hash=sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99 \ + --hash=sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c \ + --hash=sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d \ + --hash=sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811 \ + --hash=sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa \ + --hash=sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a \ + --hash=sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03 \ + --hash=sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b \ + --hash=sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04 \ + --hash=sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c \ + --hash=sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001 \ + --hash=sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458 \ + --hash=sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389 \ + --hash=sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99 \ + --hash=sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985 \ + --hash=sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537 \ + --hash=sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238 \ + --hash=sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f \ + --hash=sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d \ + --hash=sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796 \ + --hash=sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a \ + --hash=sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143 \ + --hash=sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8 \ + --hash=sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c \ + --hash=sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5 \ + --hash=sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5 \ + --hash=sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711 \ + --hash=sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4 \ + --hash=sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6 \ + --hash=sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c \ + --hash=sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7 \ + --hash=sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4 \ + --hash=sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b \ + --hash=sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae \ + --hash=sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12 \ + --hash=sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c \ + --hash=sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae \ + --hash=sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8 \ + --hash=sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887 \ + --hash=sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b \ + --hash=sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4 \ + --hash=sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f \ + --hash=sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5 \ + --hash=sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33 \ + --hash=sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519 \ + --hash=sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561 +click==8.1.7 ; python_full_version == "3.9.2" \ + --hash=sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28 \ + --hash=sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de +colorama==0.4.6 ; python_full_version == "3.9.2" \ + --hash=sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44 \ + --hash=sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6 +contourpy==1.2.1 ; python_full_version == "3.9.2" \ + --hash=sha256:00e5388f71c1a0610e6fe56b5c44ab7ba14165cdd6d695429c5cd94021e390b2 \ + --hash=sha256:10a37ae557aabf2509c79715cd20b62e4c7c28b8cd62dd7d99e5ed3ce28c3fd9 \ + --hash=sha256:11959f0ce4a6f7b76ec578576a0b61a28bdc0696194b6347ba3f1c53827178b9 \ + --hash=sha256:187fa1d4c6acc06adb0fae5544c59898ad781409e61a926ac7e84b8f276dcef4 \ + --hash=sha256:1a07fc092a4088ee952ddae19a2b2a85757b923217b7eed584fdf25f53a6e7ce \ + --hash=sha256:1cac0a8f71a041aa587410424ad46dfa6a11f6149ceb219ce7dd48f6b02b87a7 \ + --hash=sha256:1d59e739ab0e3520e62a26c60707cc3ab0365d2f8fecea74bfe4de72dc56388f \ + --hash=sha256:2855c8b0b55958265e8b5888d6a615ba02883b225f2227461aa9127c578a4922 \ + --hash=sha256:2e785e0f2ef0d567099b9ff92cbfb958d71c2d5b9259981cd9bee81bd194c9a4 \ + --hash=sha256:309be79c0a354afff9ff7da4aaed7c3257e77edf6c1b448a779329431ee79d7e \ + --hash=sha256:39f3ecaf76cd98e802f094e0d4fbc6dc9c45a8d0c4d185f0f6c2234e14e5f75b \ + --hash=sha256:457499c79fa84593f22454bbd27670227874cd2ff5d6c84e60575c8b50a69619 \ + --hash=sha256:49e70d111fee47284d9dd867c9bb9a7058a3c617274900780c43e38d90fe1205 \ + --hash=sha256:4c75507d0a55378240f781599c30e7776674dbaf883a46d1c90f37e563453480 \ + --hash=sha256:4c863140fafc615c14a4bf4efd0f4425c02230eb8ef02784c9a156461e62c965 \ + --hash=sha256:4d8908b3bee1c889e547867ca4cdc54e5ab6be6d3e078556814a22457f49423c \ + --hash=sha256:5b9eb0ca724a241683c9685a484da9d35c872fd42756574a7cfbf58af26677fd \ + --hash=sha256:6022cecf8f44e36af10bd9118ca71f371078b4c168b6e0fab43d4a889985dbb5 \ + --hash=sha256:6150ffa5c767bc6332df27157d95442c379b7dce3a38dff89c0f39b63275696f \ + --hash=sha256:62828cada4a2b850dbef89c81f5a33741898b305db244904de418cc957ff05dc \ + --hash=sha256:7b4182299f251060996af5249c286bae9361fa8c6a9cda5efc29fe8bfd6062ec \ + --hash=sha256:94b34f32646ca0414237168d68a9157cb3889f06b096612afdd296003fdd32fd \ + --hash=sha256:9ce6889abac9a42afd07a562c2d6d4b2b7134f83f18571d859b25624a331c90b \ + --hash=sha256:9cffe0f850e89d7c0012a1fb8730f75edd4320a0a731ed0c183904fe6ecfc3a9 \ + --hash=sha256:a12a813949e5066148712a0626895c26b2578874e4cc63160bb007e6df3436fe \ + --hash=sha256:a1eea9aecf761c661d096d39ed9026574de8adb2ae1c5bd7b33558af884fb2ce \ + --hash=sha256:a31f94983fecbac95e58388210427d68cd30fe8a36927980fab9c20062645609 \ + --hash=sha256:ac58bdee53cbeba2ecad824fa8159493f0bf3b8ea4e93feb06c9a465d6c87da8 \ + --hash=sha256:af3f4485884750dddd9c25cb7e3915d83c2db92488b38ccb77dd594eac84c4a0 \ + --hash=sha256:b33d2bc4f69caedcd0a275329eb2198f560b325605810895627be5d4b876bf7f \ + --hash=sha256:b59c0ffceff8d4d3996a45f2bb6f4c207f94684a96bf3d9728dbb77428dd8cb8 \ + --hash=sha256:bb6834cbd983b19f06908b45bfc2dad6ac9479ae04abe923a275b5f48f1a186b \ + --hash=sha256:bd3db01f59fdcbce5b22afad19e390260d6d0222f35a1023d9adc5690a889364 \ + --hash=sha256:bd7c23df857d488f418439686d3b10ae2fbf9bc256cd045b37a8c16575ea1040 \ + --hash=sha256:c2528d60e398c7c4c799d56f907664673a807635b857df18f7ae64d3e6ce2d9f \ + --hash=sha256:d31a63bc6e6d87f77d71e1abbd7387ab817a66733734883d1fc0021ed9bfa083 \ + --hash=sha256:d4492d82b3bc7fbb7e3610747b159869468079fe149ec5c4d771fa1f614a14df \ + --hash=sha256:ddcb8581510311e13421b1f544403c16e901c4e8f09083c881fab2be80ee31ba \ + --hash=sha256:e1d59258c3c67c865435d8fbeb35f8c59b8bef3d6f46c1f29f6123556af28445 \ + --hash=sha256:eb3315a8a236ee19b6df481fc5f997436e8ade24a9f03dfdc6bd490fea20c6da \ + --hash=sha256:ef2b055471c0eb466033760a521efb9d8a32b99ab907fc8358481a1dd29e3bd3 \ + --hash=sha256:ef5adb9a3b1d0c645ff694f9bca7702ec2c70f4d734f9922ea34de02294fdf72 \ + --hash=sha256:f32c38afb74bd98ce26de7cc74a67b40afb7b05aae7b42924ea990d51e4dac02 \ + --hash=sha256:fe0ccca550bb8e5abc22f530ec0466136379c01321fd94f30a22231e8a48d985 +cycler==0.12.1 ; python_full_version == "3.9.2" \ + --hash=sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30 \ + --hash=sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c +cython==3.0.10 ; python_full_version == "3.9.2" \ + --hash=sha256:051069638abfb076900b0c2bcb6facf545655b3f429e80dd14365192074af5a4 \ + --hash=sha256:076e9fd4e0ca33c5fa00a7479180dbfb62f17fe928e2909f82da814536e96d2b \ + --hash=sha256:077b61ee789e48700e25d4a16daa4258b8e65167136e457174df400cf9b4feab \ + --hash=sha256:09f2000041db482cad3bfce94e1fa3a4c82b0e57390a164c02566cbbda8c4f12 \ + --hash=sha256:0bac3ccdd4e03924028220c62ae3529e17efa8ca7e9df9330de95de02f582b26 \ + --hash=sha256:0e9a885ec63d3955a08cefc4eec39fefa9fe14989c6e5e2382bd4aeb6bdb9bc3 \ + --hash=sha256:15b6d397f4ee5ad54e373589522af37935a32863f1b23fa8c6922adf833e28e2 \ + --hash=sha256:206e803598010ecc3813db8748ed685f7beeca6c413f982df9f8a505fce56563 \ + --hash=sha256:269f06e6961e8591d56e30b46e1a51b6ccb42cab04c29fa3b30d3e8723485fb4 \ + --hash=sha256:2c9c1e3e78909488f3b16fabae02308423fa6369ed96ab1e250807d344cfffd7 \ + --hash=sha256:2d29e617fd23cf4b83afe8f93f2966566c9f565918ad1e86a4502fe825cc0a79 \ + --hash=sha256:32fbad02d1189be75eb96456d9c73f5548078e5338d8fa153ecb0115b6ee279f \ + --hash=sha256:35f6ede7c74024ed1982832ae61c9fad7cf60cc3f5b8c6a63bb34e38bc291936 \ + --hash=sha256:38d40fa1324ac47c04483d151f5e092406a147eac88a18aec789cf01c089c3f2 \ + --hash=sha256:3919a55ec9b6c7db6f68a004c21c05ed540c40dbe459ced5d801d5a1f326a053 \ + --hash=sha256:3cffb666e649dba23810732497442fb339ee67ba4e0be1f0579991e83fcc2436 \ + --hash=sha256:401aba1869a57aba2922ccb656a6320447e55ace42709b504c2f8e8b166f46e1 \ + --hash=sha256:407840c56385b9c085826fe300213e0e76ba15d1d47daf4b58569078ecb94446 \ + --hash=sha256:40fac59c3a7fbcd9c25aea64c342c890a5e2270ce64a1525e840807800167799 \ + --hash=sha256:4f610964ab252a83e573a427e28b103e2f1dd3c23bee54f32319f9e73c3c5499 \ + --hash=sha256:4fadb84193c25641973666e583df8df4e27c52cdc05ddce7c6f6510d690ba34a \ + --hash=sha256:541fbe725d6534a90b93f8c577eb70924d664b227a4631b90a6e0506d1469591 \ + --hash=sha256:5a036d00caa73550a3a976432ef21c1e3fa12637e1616aab32caded35331ae96 \ + --hash=sha256:5bd49a3a9fdff65446a3e1c2bfc0ec85c6ce4c3cad27cd4ad7ba150a62b7fb59 \ + --hash=sha256:5f465443917d5c0f69825fca3b52b64c74ac3de0143b1fff6db8ba5b48c9fb4a \ + --hash=sha256:64f1f8bba9d8f37c0cffc934792b4ac7c42d0891077127c11deebe9fa0a0f7e4 \ + --hash=sha256:651a15a8534ebfb9b58cb0b87c269c70984b6f9c88bfe65e4f635f0e3f07dfcd \ + --hash=sha256:6c5af936940a38c300977b81598d9c0901158f220a58c177820e17e1774f1cf1 \ + --hash=sha256:712760879600907189c7d0d346851525545484e13cd8b787e94bfd293da8ccf0 \ + --hash=sha256:81f356c1c8c0885b8435bfc468025f545c5d764aa9c75ab662616dd1193c331e \ + --hash=sha256:86998b01f6a6d48398df8467292c7637e57f7e3a2ca68655367f13f66fed7734 \ + --hash=sha256:8adcde00a8a88fab27509b558cd8c2959ab0c70c65d3814cfea8c68b83fa6dcd \ + --hash=sha256:8c9c4c4f3ab8f8c02817b0e16e8fa7b8cc880f76e9b63fe9c010e60c1a6c2b13 \ + --hash=sha256:8f2864ab5fcd27a346f0b50f901ebeb8f60b25a60a575ccfd982e7f3e9674914 \ + --hash=sha256:90e2f514fc753b55245351305a399463103ec18666150bb1c36779b9862388e9 \ + --hash=sha256:950c0c7b770d2a7cec74fb6f5ccc321d0b51d151f48c075c0d0db635a60ba1b5 \ + --hash=sha256:9cc6a0e7e23a96dec3f3c9d39690d4281beabd5297855140d0d30855f950275e \ + --hash=sha256:9ea31184c7b3a728ef1f81fccb161d8948c05aa86c79f63b74fb6f3ddec860ec \ + --hash=sha256:9fa9e7786083b6aa61594c16979d621b62e61fcd9c2edd4761641b95c7fb34b2 \ + --hash=sha256:a181144c2f893ed8e6a994d43d0b96300bc99873f21e3b7334ca26c61c37b680 \ + --hash=sha256:a5e14a8c6a8157d2b0cdc2e8e3444905d20a0e78e19d2a097e89fb8b04b51f6b \ + --hash=sha256:a9bb402674788a7f4061aeef8057632ec440123e74ed0fb425308a59afdfa10e \ + --hash=sha256:a9c976e9ec429539a4367cb4b24d15a1e46b925976f4341143f49f5f161171f5 \ + --hash=sha256:acfbe0fff364d54906058fc61f2393f38cd7fa07d344d80923937b87e339adcf \ + --hash=sha256:adc377aa33c3309191e617bf675fdbb51ca727acb9dc1aa23fc698d8121f7e23 \ + --hash=sha256:b74b700d6a793113d03fb54b63bdbadba6365379424bac7c0470605672769260 \ + --hash=sha256:bcc9795990e525c192bc5c0775e441d7d56d7a7d02210451e9e13c0448dba51b \ + --hash=sha256:d092c0ddba7e9e530a5c5be4ac06db8360258acc27675d1fc86294a5dc8994c5 \ + --hash=sha256:d10fc9aa82e5e53a0b7fd118f9771199cddac8feb4a6d8350b7d4109085aa775 \ + --hash=sha256:d4e83a8ceff7af60064da4ccfce0ac82372544dd5392f1b350c34f1b04d0fae6 \ + --hash=sha256:dcc96739331fb854dcf503f94607576cfe8488066c61ca50dfd55836f132de99 \ + --hash=sha256:e876272548d73583e90babda94c1299537006cad7a34e515a06c51b41f8657aa \ + --hash=sha256:e8df79b596633b8295eaa48b1157d796775c2bb078f32267d32f3001b687f2fd \ + --hash=sha256:f43a58bf2434870d2fc42ac2e9ff8138c9e00c6251468de279d93fa279e9ba3b \ + --hash=sha256:f4780d0f98ce28191c4d841c4358b5d5e79d96520650910cd59904123821c52d \ + --hash=sha256:f8a2b8fa0fd8358bccb5f3304be563c4750aae175100463d212d5ea0ec74cbe0 \ + --hash=sha256:fc6e0faf5b57523b073f0cdefadcaef3a51235d519a0594865925cadb3aeadf0 \ + --hash=sha256:fcbb679c0b43514d591577fd0d20021c55c240ca9ccafbdb82d3fb95e5edfee2 +docker-pycreds==0.4.0 ; python_full_version == "3.9.2" \ + --hash=sha256:6ce3270bcaf404cc4c3e27e4b6c70d3521deae82fb508767870fdbf772d584d4 \ + --hash=sha256:7266112468627868005106ec19cd0d722702d2b7d5912a28e19b826c3d37af49 +fairseq==0.12.2 ; python_full_version == "3.9.2" \ + --hash=sha256:0543905012e39f00bd8c3f3781d9f49e76ab309801eb2eb7de250f5984df0de3 \ + --hash=sha256:08fa308c760f995cdc13d9c385e2b9d923a78b48275d8b4d78f3a854c71a8f29 \ + --hash=sha256:26454f334ca705c67f898846dff34e14c148fcdaf53b4f52d64209773b509347 \ + --hash=sha256:34f1b18426bf3844714534162f065ab733e049597476daa35fffb4d06a92b524 \ + --hash=sha256:3b8c8b6dc368d2fd23a06ff613a2af05959eee275fe90846d7cffef4a43c522a \ + --hash=sha256:c4877d65346797fc580a3a7e6e2364d2331a0026ef099c22eb8311441e49c2c6 \ + --hash=sha256:fe65b07c5121b7cda0c7a17166994a6b0059259ce37881b6daa117b8c209b662 +filelock==3.14.0 ; python_full_version == "3.9.2" \ + --hash=sha256:43339835842f110ca7ae60f1e1c160714c5a6afd15a2873419ab185334975c0f \ + --hash=sha256:6ea72da3be9b8c82afd3edcf99f2fffbb5076335a5ae4d03248bb5b6c3eae78a +fonttools==4.53.0 ; python_full_version == "3.9.2" \ + --hash=sha256:099634631b9dd271d4a835d2b2a9e042ccc94ecdf7e2dd9f7f34f7daf333358d \ + --hash=sha256:0c555e039d268445172b909b1b6bdcba42ada1cf4a60e367d68702e3f87e5f64 \ + --hash=sha256:1e677bfb2b4bd0e5e99e0f7283e65e47a9814b0486cb64a41adf9ef110e078f2 \ + --hash=sha256:2367d47816cc9783a28645bc1dac07f8ffc93e0f015e8c9fc674a5b76a6da6e4 \ + --hash=sha256:28d072169fe8275fb1a0d35e3233f6df36a7e8474e56cb790a7258ad822b6fd6 \ + --hash=sha256:31f0e3147375002aae30696dd1dc596636abbd22fca09d2e730ecde0baad1d6b \ + --hash=sha256:3e0ad3c6ea4bd6a289d958a1eb922767233f00982cf0fe42b177657c86c80a8f \ + --hash=sha256:45b4afb069039f0366a43a5d454bc54eea942bfb66b3fc3e9a2c07ef4d617380 \ + --hash=sha256:4a2a6ba400d386e904fd05db81f73bee0008af37799a7586deaa4aef8cd5971e \ + --hash=sha256:4f520d9ac5b938e6494f58a25c77564beca7d0199ecf726e1bd3d56872c59749 \ + --hash=sha256:52a6e0a7a0bf611c19bc8ec8f7592bdae79c8296c70eb05917fd831354699b20 \ + --hash=sha256:5a4788036201c908079e89ae3f5399b33bf45b9ea4514913f4dbbe4fac08efe0 \ + --hash=sha256:6b4f04b1fbc01a3569d63359f2227c89ab294550de277fd09d8fca6185669fa4 \ + --hash=sha256:715b41c3e231f7334cbe79dfc698213dcb7211520ec7a3bc2ba20c8515e8a3b5 \ + --hash=sha256:73121a9b7ff93ada888aaee3985a88495489cc027894458cb1a736660bdfb206 \ + --hash=sha256:74ae2441731a05b44d5988d3ac2cf784d3ee0a535dbed257cbfff4be8bb49eb9 \ + --hash=sha256:7d6166192dcd925c78a91d599b48960e0a46fe565391c79fe6de481ac44d20ac \ + --hash=sha256:7f193f060391a455920d61684a70017ef5284ccbe6023bb056e15e5ac3de11d1 \ + --hash=sha256:907fa0b662dd8fc1d7c661b90782ce81afb510fc4b7aa6ae7304d6c094b27bce \ + --hash=sha256:93156dd7f90ae0a1b0e8871032a07ef3178f553f0c70c386025a808f3a63b1f4 \ + --hash=sha256:93bc9e5aaa06ff928d751dc6be889ff3e7d2aa393ab873bc7f6396a99f6fbb12 \ + --hash=sha256:95db0c6581a54b47c30860d013977b8a14febc206c8b5ff562f9fe32738a8aca \ + --hash=sha256:973d030180eca8255b1bce6ffc09ef38a05dcec0e8320cc9b7bcaa65346f341d \ + --hash=sha256:9cd7a6beec6495d1dffb1033d50a3f82dfece23e9eb3c20cd3c2444d27514068 \ + --hash=sha256:9fe9096a60113e1d755e9e6bda15ef7e03391ee0554d22829aa506cdf946f796 \ + --hash=sha256:a209d2e624ba492df4f3bfad5996d1f76f03069c6133c60cd04f9a9e715595ec \ + --hash=sha256:a239afa1126b6a619130909c8404070e2b473dd2b7fc4aacacd2e763f8597fea \ + --hash=sha256:ba9f09ff17f947392a855e3455a846f9855f6cf6bec33e9a427d3c1d254c712f \ + --hash=sha256:bb7273789f69b565d88e97e9e1da602b4ee7ba733caf35a6c2affd4334d4f005 \ + --hash=sha256:bd5bc124fae781a4422f61b98d1d7faa47985f663a64770b78f13d2c072410c2 \ + --hash=sha256:bff98816cb144fb7b85e4b5ba3888a33b56ecef075b0e95b95bcd0a5fbf20f06 \ + --hash=sha256:c4ee5a24e281fbd8261c6ab29faa7fd9a87a12e8c0eed485b705236c65999109 \ + --hash=sha256:c93ed66d32de1559b6fc348838c7572d5c0ac1e4a258e76763a5caddd8944002 \ + --hash=sha256:d1a24f51a3305362b94681120c508758a88f207fa0a681c16b5a4172e9e6c7a9 \ + --hash=sha256:d8f191a17369bd53a5557a5ee4bab91d5330ca3aefcdf17fab9a497b0e7cff7a \ + --hash=sha256:daaef7390e632283051e3cf3e16aff2b68b247e99aea916f64e578c0449c9c68 \ + --hash=sha256:e40013572bfb843d6794a3ce076c29ef4efd15937ab833f520117f8eccc84fd6 \ + --hash=sha256:eceef49f457253000e6a2d0f7bd08ff4e9fe96ec4ffce2dbcb32e34d9c1b8161 \ + --hash=sha256:ee595d7ba9bba130b2bec555a40aafa60c26ce68ed0cf509983e0f12d88674fd \ + --hash=sha256:ef50ec31649fbc3acf6afd261ed89d09eb909b97cc289d80476166df8438524d \ + --hash=sha256:fa1f3e34373aa16045484b4d9d352d4c6b5f9f77ac77a178252ccbc851e8b2ee \ + --hash=sha256:fca66d9ff2ac89b03f5aa17e0b21a97c21f3491c46b583bb131eb32c7bab33af +frozenlist==1.4.1 ; python_full_version == "3.9.2" \ + --hash=sha256:04ced3e6a46b4cfffe20f9ae482818e34eba9b5fb0ce4056e4cc9b6e212d09b7 \ + --hash=sha256:0633c8d5337cb5c77acbccc6357ac49a1770b8c487e5b3505c57b949b4b82e98 \ + --hash=sha256:068b63f23b17df8569b7fdca5517edef76171cf3897eb68beb01341131fbd2ad \ + --hash=sha256:0c250a29735d4f15321007fb02865f0e6b6a41a6b88f1f523ca1596ab5f50bd5 \ + --hash=sha256:1979bc0aeb89b33b588c51c54ab0161791149f2461ea7c7c946d95d5f93b56ae \ + --hash=sha256:1a4471094e146b6790f61b98616ab8e44f72661879cc63fa1049d13ef711e71e \ + --hash=sha256:1b280e6507ea8a4fa0c0a7150b4e526a8d113989e28eaaef946cc77ffd7efc0a \ + --hash=sha256:1d0ce09d36d53bbbe566fe296965b23b961764c0bcf3ce2fa45f463745c04701 \ + --hash=sha256:20b51fa3f588ff2fe658663db52a41a4f7aa6c04f6201449c6c7c476bd255c0d \ + --hash=sha256:23b2d7679b73fe0e5a4560b672a39f98dfc6f60df63823b0a9970525325b95f6 \ + --hash=sha256:23b701e65c7b36e4bf15546a89279bd4d8675faabc287d06bbcfac7d3c33e1e6 \ + --hash=sha256:2471c201b70d58a0f0c1f91261542a03d9a5e088ed3dc6c160d614c01649c106 \ + --hash=sha256:27657df69e8801be6c3638054e202a135c7f299267f1a55ed3a598934f6c0d75 \ + --hash=sha256:29acab3f66f0f24674b7dc4736477bcd4bc3ad4b896f5f45379a67bce8b96868 \ + --hash=sha256:32453c1de775c889eb4e22f1197fe3bdfe457d16476ea407472b9442e6295f7a \ + --hash=sha256:3a670dc61eb0d0eb7080890c13de3066790f9049b47b0de04007090807c776b0 \ + --hash=sha256:3e0153a805a98f5ada7e09826255ba99fb4f7524bb81bf6b47fb702666484ae1 \ + --hash=sha256:410478a0c562d1a5bcc2f7ea448359fcb050ed48b3c6f6f4f18c313a9bdb1826 \ + --hash=sha256:442acde1e068288a4ba7acfe05f5f343e19fac87bfc96d89eb886b0363e977ec \ + --hash=sha256:48f6a4533887e189dae092f1cf981f2e3885175f7a0f33c91fb5b7b682b6bab6 \ + --hash=sha256:4f57dab5fe3407b6c0c1cc907ac98e8a189f9e418f3b6e54d65a718aaafe3950 \ + --hash=sha256:4f9c515e7914626b2a2e1e311794b4c35720a0be87af52b79ff8e1429fc25f19 \ + --hash=sha256:55fdc093b5a3cb41d420884cdaf37a1e74c3c37a31f46e66286d9145d2063bd0 \ + --hash=sha256:5667ed53d68d91920defdf4035d1cdaa3c3121dc0b113255124bcfada1cfa1b8 \ + --hash=sha256:590344787a90ae57d62511dd7c736ed56b428f04cd8c161fcc5e7232c130c69a \ + --hash=sha256:5a7d70357e7cee13f470c7883a063aae5fe209a493c57d86eb7f5a6f910fae09 \ + --hash=sha256:5c3894db91f5a489fc8fa6a9991820f368f0b3cbdb9cd8849547ccfab3392d86 \ + --hash=sha256:5c849d495bf5154cd8da18a9eb15db127d4dba2968d88831aff6f0331ea9bd4c \ + --hash=sha256:64536573d0a2cb6e625cf309984e2d873979709f2cf22839bf2d61790b448ad5 \ + --hash=sha256:693945278a31f2086d9bf3df0fe8254bbeaef1fe71e1351c3bd730aa7d31c41b \ + --hash=sha256:6db4667b187a6742b33afbbaf05a7bc551ffcf1ced0000a571aedbb4aa42fc7b \ + --hash=sha256:6eb73fa5426ea69ee0e012fb59cdc76a15b1283d6e32e4f8dc4482ec67d1194d \ + --hash=sha256:722e1124aec435320ae01ee3ac7bec11a5d47f25d0ed6328f2273d287bc3abb0 \ + --hash=sha256:7268252af60904bf52c26173cbadc3a071cece75f873705419c8681f24d3edea \ + --hash=sha256:74fb4bee6880b529a0c6560885fce4dc95936920f9f20f53d99a213f7bf66776 \ + --hash=sha256:780d3a35680ced9ce682fbcf4cb9c2bad3136eeff760ab33707b71db84664e3a \ + --hash=sha256:82e8211d69a4f4bc360ea22cd6555f8e61a1bd211d1d5d39d3d228b48c83a897 \ + --hash=sha256:89aa2c2eeb20957be2d950b85974b30a01a762f3308cd02bb15e1ad632e22dc7 \ + --hash=sha256:8aefbba5f69d42246543407ed2461db31006b0f76c4e32dfd6f42215a2c41d09 \ + --hash=sha256:96ec70beabbd3b10e8bfe52616a13561e58fe84c0101dd031dc78f250d5128b9 \ + --hash=sha256:9750cc7fe1ae3b1611bb8cfc3f9ec11d532244235d75901fb6b8e42ce9229dfe \ + --hash=sha256:9acbb16f06fe7f52f441bb6f413ebae6c37baa6ef9edd49cdd567216da8600cd \ + --hash=sha256:9d3e0c25a2350080e9319724dede4f31f43a6c9779be48021a7f4ebde8b2d742 \ + --hash=sha256:a06339f38e9ed3a64e4c4e43aec7f59084033647f908e4259d279a52d3757d09 \ + --hash=sha256:a0cb6f11204443f27a1628b0e460f37fb30f624be6051d490fa7d7e26d4af3d0 \ + --hash=sha256:a7496bfe1da7fb1a4e1cc23bb67c58fab69311cc7d32b5a99c2007b4b2a0e932 \ + --hash=sha256:a828c57f00f729620a442881cc60e57cfcec6842ba38e1b19fd3e47ac0ff8dc1 \ + --hash=sha256:a9b2de4cf0cdd5bd2dee4c4f63a653c61d2408055ab77b151c1957f221cabf2a \ + --hash=sha256:b46c8ae3a8f1f41a0d2ef350c0b6e65822d80772fe46b653ab6b6274f61d4a49 \ + --hash=sha256:b7e3ed87d4138356775346e6845cccbe66cd9e207f3cd11d2f0b9fd13681359d \ + --hash=sha256:b7f2f9f912dca3934c1baec2e4585a674ef16fe00218d833856408c48d5beee7 \ + --hash=sha256:ba60bb19387e13597fb059f32cd4d59445d7b18b69a745b8f8e5db0346f33480 \ + --hash=sha256:beee944ae828747fd7cb216a70f120767fc9f4f00bacae8543c14a6831673f89 \ + --hash=sha256:bfa4a17e17ce9abf47a74ae02f32d014c5e9404b6d9ac7f729e01562bbee601e \ + --hash=sha256:c037a86e8513059a2613aaba4d817bb90b9d9b6b69aace3ce9c877e8c8ed402b \ + --hash=sha256:c302220494f5c1ebeb0912ea782bcd5e2f8308037b3c7553fad0e48ebad6ad82 \ + --hash=sha256:c6321c9efe29975232da3bd0af0ad216800a47e93d763ce64f291917a381b8eb \ + --hash=sha256:c757a9dd70d72b076d6f68efdbb9bc943665ae954dad2801b874c8c69e185068 \ + --hash=sha256:c99169d4ff810155ca50b4da3b075cbde79752443117d89429595c2e8e37fed8 \ + --hash=sha256:c9c92be9fd329ac801cc420e08452b70e7aeab94ea4233a4804f0915c14eba9b \ + --hash=sha256:cc7b01b3754ea68a62bd77ce6020afaffb44a590c2289089289363472d13aedb \ + --hash=sha256:db9e724bebd621d9beca794f2a4ff1d26eed5965b004a97f1f1685a173b869c2 \ + --hash=sha256:dca69045298ce5c11fd539682cff879cc1e664c245d1c64da929813e54241d11 \ + --hash=sha256:dd9b1baec094d91bf36ec729445f7769d0d0cf6b64d04d86e45baf89e2b9059b \ + --hash=sha256:e02a0e11cf6597299b9f3bbd3f93d79217cb90cfd1411aec33848b13f5c656cc \ + --hash=sha256:e6a20a581f9ce92d389a8c7d7c3dd47c81fd5d6e655c8dddf341e14aa48659d0 \ + --hash=sha256:e7004be74cbb7d9f34553a5ce5fb08be14fb33bc86f332fb71cbe5216362a497 \ + --hash=sha256:e774d53b1a477a67838a904131c4b0eef6b3d8a651f8b138b04f748fccfefe17 \ + --hash=sha256:edb678da49d9f72c9f6c609fbe41a5dfb9a9282f9e6a2253d5a91e0fc382d7c0 \ + --hash=sha256:f146e0911cb2f1da549fc58fc7bcd2b836a44b79ef871980d605ec392ff6b0d2 \ + --hash=sha256:f56e2333dda1fe0f909e7cc59f021eba0d2307bc6f012a1ccf2beca6ba362439 \ + --hash=sha256:f9a3ea26252bd92f570600098783d1371354d89d5f6b7dfd87359d669f2109b5 \ + --hash=sha256:f9aa1878d1083b276b0196f2dfbe00c9b7e752475ed3b682025ff20c1c1f51ac \ + --hash=sha256:fb3c2db03683b5767dedb5769b8a40ebb47d6f7f45b1b3e3b4b51ec8ad9d9825 \ + --hash=sha256:fbeb989b5cc29e8daf7f976b421c220f1b8c731cbf22b9130d8815418ea45887 \ + --hash=sha256:fde5bd59ab5357e3853313127f4d3565fc7dad314a74d7b5d43c22c6a5ed2ced \ + --hash=sha256:fe1a06da377e3a1062ae5fe0926e12b84eceb8a50b350ddca72dc85015873f74 +fsspec==0.8.7 ; python_full_version == "3.9.2" \ + --hash=sha256:4b11557a90ac637089b10afa4c77adf42080c0696f6f2771c41ce92d73c41432 \ + --hash=sha256:65dbf8244a3a3d23342109925f9f588c7551b2b01a5f47e555043b17e2b32d62 +fsspec[http]==0.8.7 ; python_full_version == "3.9.2" \ + --hash=sha256:4b11557a90ac637089b10afa4c77adf42080c0696f6f2771c41ce92d73c41432 \ + --hash=sha256:65dbf8244a3a3d23342109925f9f588c7551b2b01a5f47e555043b17e2b32d62 +ftfy==6.2.0 ; python_full_version == "3.9.2" \ + --hash=sha256:5e42143c7025ef97944ca2619d6b61b0619fc6654f98771d39e862c1424c75c0 \ + --hash=sha256:f94a2c34b76e07475720e3096f5ca80911d152406fbde66fdb45c4d0c9150026 +future==1.0.0 ; python_full_version == "3.9.2" \ + --hash=sha256:929292d34f5872e70396626ef385ec22355a1fae8ad29e1a734c3e43f9fbc216 \ + --hash=sha256:bd2968309307861edae1458a4f8a4f3598c03be43b97521076aebf5d94c07b05 +gitdb==4.0.11 ; python_full_version == "3.9.2" \ + --hash=sha256:81a3407ddd2ee8df444cbacea00e2d038e40150acfa3001696fe0dcf1d3adfa4 \ + --hash=sha256:bf5421126136d6d0af55bc1e7c1af1c397a34f5b7bd79e776cd3e89785c2b04b +gitpython==3.1.43 ; python_full_version == "3.9.2" \ + --hash=sha256:35f314a9f878467f5453cc1fee295c3e18e52f1b99f10f6cf5b1682e968a9e7c \ + --hash=sha256:eec7ec56b92aad751f9912a73404bc02ba212a23adb2c7098ee668417051a1ff +grpcio==1.64.1 ; python_full_version == "3.9.2" \ + --hash=sha256:03b43d0ccf99c557ec671c7dede64f023c7da9bb632ac65dbc57f166e4970040 \ + --hash=sha256:0a12ddb1678ebc6a84ec6b0487feac020ee2b1659cbe69b80f06dbffdb249122 \ + --hash=sha256:0a2813093ddb27418a4c99f9b1c223fab0b053157176a64cc9db0f4557b69bd9 \ + --hash=sha256:0cc79c982ccb2feec8aad0e8fb0d168bcbca85bc77b080d0d3c5f2f15c24ea8f \ + --hash=sha256:1257b76748612aca0f89beec7fa0615727fd6f2a1ad580a9638816a4b2eb18fd \ + --hash=sha256:1262402af5a511c245c3ae918167eca57342c72320dffae5d9b51840c4b2f86d \ + --hash=sha256:19264fc964576ddb065368cae953f8d0514ecc6cb3da8903766d9fb9d4554c33 \ + --hash=sha256:198908f9b22e2672a998870355e226a725aeab327ac4e6ff3a1399792ece4762 \ + --hash=sha256:1de403fc1305fd96cfa75e83be3dee8538f2413a6b1685b8452301c7ba33c294 \ + --hash=sha256:20405cb8b13fd779135df23fabadc53b86522d0f1cba8cca0e87968587f50650 \ + --hash=sha256:2981c7365a9353f9b5c864595c510c983251b1ab403e05b1ccc70a3d9541a73b \ + --hash=sha256:2c3c1b90ab93fed424e454e93c0ed0b9d552bdf1b0929712b094f5ecfe7a23ad \ + --hash=sha256:39b9d0acaa8d835a6566c640f48b50054f422d03e77e49716d4c4e8e279665a1 \ + --hash=sha256:3b64ae304c175671efdaa7ec9ae2cc36996b681eb63ca39c464958396697daff \ + --hash=sha256:4657d24c8063e6095f850b68f2d1ba3b39f2b287a38242dcabc166453e950c59 \ + --hash=sha256:4d6dab6124225496010bd22690f2d9bd35c7cbb267b3f14e7a3eb05c911325d4 \ + --hash=sha256:55260032b95c49bee69a423c2f5365baa9369d2f7d233e933564d8a47b893027 \ + --hash=sha256:55697ecec192bc3f2f3cc13a295ab670f51de29884ca9ae6cd6247df55df2502 \ + --hash=sha256:5841dd1f284bd1b3d8a6eca3a7f062b06f1eec09b184397e1d1d43447e89a7ae \ + --hash=sha256:58b1041e7c870bb30ee41d3090cbd6f0851f30ae4eb68228955d973d3efa2e61 \ + --hash=sha256:5e42634a989c3aa6049f132266faf6b949ec2a6f7d302dbb5c15395b77d757eb \ + --hash=sha256:5e56462b05a6f860b72f0fa50dca06d5b26543a4e88d0396259a07dc30f4e5aa \ + --hash=sha256:5f8b75f64d5d324c565b263c67dbe4f0af595635bbdd93bb1a88189fc62ed2e5 \ + --hash=sha256:62b4e6eb7bf901719fce0ca83e3ed474ae5022bb3827b0a501e056458c51c0a1 \ + --hash=sha256:6503b64c8b2dfad299749cad1b595c650c91e5b2c8a1b775380fcf8d2cbba1e9 \ + --hash=sha256:6c024ffc22d6dc59000faf8ad781696d81e8e38f4078cb0f2630b4a3cf231a90 \ + --hash=sha256:73819689c169417a4f978e562d24f2def2be75739c4bed1992435d007819da1b \ + --hash=sha256:75dbbf415026d2862192fe1b28d71f209e2fd87079d98470db90bebe57b33179 \ + --hash=sha256:8caee47e970b92b3dd948371230fcceb80d3f2277b3bf7fbd7c0564e7d39068e \ + --hash=sha256:8d51dd1c59d5fa0f34266b80a3805ec29a1f26425c2a54736133f6d87fc4968a \ + --hash=sha256:940e3ec884520155f68a3b712d045e077d61c520a195d1a5932c531f11883489 \ + --hash=sha256:a011ac6c03cfe162ff2b727bcb530567826cec85eb8d4ad2bfb4bd023287a52d \ + --hash=sha256:a3a035c37ce7565b8f4f35ff683a4db34d24e53dc487e47438e434eb3f701b2a \ + --hash=sha256:a5e771d0252e871ce194d0fdcafd13971f1aae0ddacc5f25615030d5df55c3a2 \ + --hash=sha256:ac15b6c2c80a4d1338b04d42a02d376a53395ddf0ec9ab157cbaf44191f3ffdd \ + --hash=sha256:b1a82e0b9b3022799c336e1fc0f6210adc019ae84efb7321d668129d28ee1efb \ + --hash=sha256:bac71b4b28bc9af61efcdc7630b166440bbfbaa80940c9a697271b5e1dabbc61 \ + --hash=sha256:bbc5b1d78a7822b0a84c6f8917faa986c1a744e65d762ef6d8be9d75677af2ca \ + --hash=sha256:c1a786ac592b47573a5bb7e35665c08064a5d77ab88a076eec11f8ae86b3e3f6 \ + --hash=sha256:c84ad903d0d94311a2b7eea608da163dace97c5fe9412ea311e72c3684925602 \ + --hash=sha256:d4d29cc612e1332237877dfa7fe687157973aab1d63bd0f84cf06692f04c0367 \ + --hash=sha256:e3d9f8d1221baa0ced7ec7322a981e28deb23749c76eeeb3d33e18b72935ab62 \ + --hash=sha256:e7cd5c1325f6808b8ae31657d281aadb2a51ac11ab081ae335f4f7fc44c1721d \ + --hash=sha256:ed6091fa0adcc7e4ff944090cf203a52da35c37a130efa564ded02b7aff63bcd \ + --hash=sha256:ee73a2f5ca4ba44fa33b4d7d2c71e2c8a9e9f78d53f6507ad68e7d2ad5f64a22 \ + --hash=sha256:f10193c69fc9d3d726e83bbf0f3d316f1847c3071c8c93d8090cf5f326b14309 +huggingface-hub==0.17.3 ; python_full_version == "3.9.2" \ + --hash=sha256:40439632b211311f788964602bf8b0d9d6b7a2314fba4e8d67b2ce3ecea0e3fd \ + --hash=sha256:545eb3665f6ac587add946e73984148f2ea5c7877eac2e845549730570c1933a +hydra-core==1.0.7 ; python_full_version == "3.9.2" \ + --hash=sha256:58cc3f7531995b6d8de162ca21f936e17bdaebd4d1e8614d63c32e17c2e41e45 \ + --hash=sha256:e800c6deb8309395508094851fa93bc13408f2285261eb97e626d37193b58a9f +idna==3.7 ; python_full_version == "3.9.2" \ + --hash=sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc \ + --hash=sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0 +importlib-metadata==7.1.0 ; python_full_version == "3.9.2" \ + --hash=sha256:30962b96c0c223483ed6cc7280e7f0199feb01a0e40cfae4d4450fc6fab1f570 \ + --hash=sha256:b78938b926ee8d5f020fc4772d487045805a55ddbad2ecf21c6d60938dc7fcd2 +importlib-resources==6.4.0 ; python_full_version == "3.9.2" \ + --hash=sha256:50d10f043df931902d4194ea07ec57960f66a80449ff867bfe782b4c486ba78c \ + --hash=sha256:cdb2b453b8046ca4e3798eb1d84f3cce1446a0e8e7b5ef4efb600f19fc398145 +jinja2==3.1.4 ; python_full_version == "3.9.2" \ + --hash=sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369 \ + --hash=sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d +joblib==1.4.2 ; python_full_version == "3.9.2" \ + --hash=sha256:06d478d5674cbc267e7496a410ee875abd68e4340feff4490bcb7afb88060ae6 \ + --hash=sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e +jsonschema-specifications==2023.12.1 ; python_full_version == "3.9.2" \ + --hash=sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc \ + --hash=sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c +jsonschema==4.22.0 ; python_full_version == "3.9.2" \ + --hash=sha256:5b22d434a45935119af990552c862e5d6d564e8f6601206b305a61fdf661a2b7 \ + --hash=sha256:ff4cfd6b1367a40e7bc6411caec72effadd3db0bbe5017de188f2d6108335802 +kiwisolver==1.4.5 ; python_full_version == "3.9.2" \ + --hash=sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf \ + --hash=sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e \ + --hash=sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af \ + --hash=sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f \ + --hash=sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046 \ + --hash=sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3 \ + --hash=sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5 \ + --hash=sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71 \ + --hash=sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee \ + --hash=sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3 \ + --hash=sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9 \ + --hash=sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b \ + --hash=sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985 \ + --hash=sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea \ + --hash=sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16 \ + --hash=sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89 \ + --hash=sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c \ + --hash=sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9 \ + --hash=sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712 \ + --hash=sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342 \ + --hash=sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a \ + --hash=sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958 \ + --hash=sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d \ + --hash=sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a \ + --hash=sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130 \ + --hash=sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff \ + --hash=sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898 \ + --hash=sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b \ + --hash=sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f \ + --hash=sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265 \ + --hash=sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93 \ + --hash=sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929 \ + --hash=sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635 \ + --hash=sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709 \ + --hash=sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b \ + --hash=sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb \ + --hash=sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a \ + --hash=sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920 \ + --hash=sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e \ + --hash=sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544 \ + --hash=sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45 \ + --hash=sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390 \ + --hash=sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77 \ + --hash=sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355 \ + --hash=sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff \ + --hash=sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4 \ + --hash=sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7 \ + --hash=sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20 \ + --hash=sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c \ + --hash=sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162 \ + --hash=sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228 \ + --hash=sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437 \ + --hash=sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc \ + --hash=sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a \ + --hash=sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901 \ + --hash=sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4 \ + --hash=sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770 \ + --hash=sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525 \ + --hash=sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad \ + --hash=sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a \ + --hash=sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29 \ + --hash=sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90 \ + --hash=sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250 \ + --hash=sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d \ + --hash=sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3 \ + --hash=sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54 \ + --hash=sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f \ + --hash=sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1 \ + --hash=sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da \ + --hash=sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238 \ + --hash=sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa \ + --hash=sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523 \ + --hash=sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0 \ + --hash=sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205 \ + --hash=sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3 \ + --hash=sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4 \ + --hash=sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac \ + --hash=sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9 \ + --hash=sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb \ + --hash=sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced \ + --hash=sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd \ + --hash=sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0 \ + --hash=sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da \ + --hash=sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18 \ + --hash=sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9 \ + --hash=sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276 \ + --hash=sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333 \ + --hash=sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b \ + --hash=sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db \ + --hash=sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126 \ + --hash=sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9 \ + --hash=sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09 \ + --hash=sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0 \ + --hash=sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec \ + --hash=sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7 \ + --hash=sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff \ + --hash=sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9 \ + --hash=sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192 \ + --hash=sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8 \ + --hash=sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d \ + --hash=sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6 \ + --hash=sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797 \ + --hash=sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892 \ + --hash=sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f +lxml==5.2.2 ; python_full_version == "3.9.2" \ + --hash=sha256:02437fb7308386867c8b7b0e5bc4cd4b04548b1c5d089ffb8e7b31009b961dc3 \ + --hash=sha256:02f6a8eb6512fdc2fd4ca10a49c341c4e109aa6e9448cc4859af5b949622715a \ + --hash=sha256:05f8757b03208c3f50097761be2dea0aba02e94f0dc7023ed73a7bb14ff11eb0 \ + --hash=sha256:06668e39e1f3c065349c51ac27ae430719d7806c026fec462e5693b08b95696b \ + --hash=sha256:07542787f86112d46d07d4f3c4e7c760282011b354d012dc4141cc12a68cef5f \ + --hash=sha256:08ea0f606808354eb8f2dfaac095963cb25d9d28e27edcc375d7b30ab01abbf6 \ + --hash=sha256:0969e92af09c5687d769731e3f39ed62427cc72176cebb54b7a9d52cc4fa3b73 \ + --hash=sha256:0a028b61a2e357ace98b1615fc03f76eb517cc028993964fe08ad514b1e8892d \ + --hash=sha256:0b3f5016e00ae7630a4b83d0868fca1e3d494c78a75b1c7252606a3a1c5fc2ad \ + --hash=sha256:13e69be35391ce72712184f69000cda04fc89689429179bc4c0ae5f0b7a8c21b \ + --hash=sha256:16a8326e51fcdffc886294c1e70b11ddccec836516a343f9ed0f82aac043c24a \ + --hash=sha256:19b4e485cd07b7d83e3fe3b72132e7df70bfac22b14fe4bf7a23822c3a35bff5 \ + --hash=sha256:1a2569a1f15ae6c8c64108a2cd2b4a858fc1e13d25846be0666fc144715e32ab \ + --hash=sha256:1a7aca7964ac4bb07680d5c9d63b9d7028cace3e2d43175cb50bba8c5ad33316 \ + --hash=sha256:1b590b39ef90c6b22ec0be925b211298e810b4856909c8ca60d27ffbca6c12e6 \ + --hash=sha256:1d8a701774dfc42a2f0b8ccdfe7dbc140500d1049e0632a611985d943fcf12df \ + --hash=sha256:1e275ea572389e41e8b039ac076a46cb87ee6b8542df3fff26f5baab43713bca \ + --hash=sha256:2304d3c93f2258ccf2cf7a6ba8c761d76ef84948d87bf9664e14d203da2cd264 \ + --hash=sha256:23441e2b5339bc54dc949e9e675fa35efe858108404ef9aa92f0456929ef6fe8 \ + --hash=sha256:23cfafd56887eaed93d07bc4547abd5e09d837a002b791e9767765492a75883f \ + --hash=sha256:28bf95177400066596cdbcfc933312493799382879da504633d16cf60bba735b \ + --hash=sha256:2eb2227ce1ff998faf0cd7fe85bbf086aa41dfc5af3b1d80867ecfe75fb68df3 \ + --hash=sha256:2fb0ba3e8566548d6c8e7dd82a8229ff47bd8fb8c2da237607ac8e5a1b8312e5 \ + --hash=sha256:303f540ad2dddd35b92415b74b900c749ec2010e703ab3bfd6660979d01fd4ed \ + --hash=sha256:339ee4a4704bc724757cd5dd9dc8cf4d00980f5d3e6e06d5847c1b594ace68ab \ + --hash=sha256:33ce9e786753743159799fdf8e92a5da351158c4bfb6f2db0bf31e7892a1feb5 \ + --hash=sha256:343ab62e9ca78094f2306aefed67dcfad61c4683f87eee48ff2fd74902447726 \ + --hash=sha256:34e17913c431f5ae01d8658dbf792fdc457073dcdfbb31dc0cc6ab256e664a8d \ + --hash=sha256:364d03207f3e603922d0d3932ef363d55bbf48e3647395765f9bfcbdf6d23632 \ + --hash=sha256:38b67afb0a06b8575948641c1d6d68e41b83a3abeae2ca9eed2ac59892b36706 \ + --hash=sha256:3a745cc98d504d5bd2c19b10c79c61c7c3df9222629f1b6210c0368177589fb8 \ + --hash=sha256:3b019d4ee84b683342af793b56bb35034bd749e4cbdd3d33f7d1107790f8c472 \ + --hash=sha256:3b6a30a9ab040b3f545b697cb3adbf3696c05a3a68aad172e3fd7ca73ab3c835 \ + --hash=sha256:3d1e35572a56941b32c239774d7e9ad724074d37f90c7a7d499ab98761bd80cf \ + --hash=sha256:3d98de734abee23e61f6b8c2e08a88453ada7d6486dc7cdc82922a03968928db \ + --hash=sha256:453d037e09a5176d92ec0fd282e934ed26d806331a8b70ab431a81e2fbabf56d \ + --hash=sha256:45f9494613160d0405682f9eee781c7e6d1bf45f819654eb249f8f46a2c22545 \ + --hash=sha256:4820c02195d6dfb7b8508ff276752f6b2ff8b64ae5d13ebe02e7667e035000b9 \ + --hash=sha256:49095a38eb333aaf44c06052fd2ec3b8f23e19747ca7ec6f6c954ffea6dbf7be \ + --hash=sha256:4aefd911793b5d2d7a921233a54c90329bf3d4a6817dc465f12ffdfe4fc7b8fe \ + --hash=sha256:4bc6cb140a7a0ad1f7bc37e018d0ed690b7b6520ade518285dc3171f7a117905 \ + --hash=sha256:4c30a2f83677876465f44c018830f608fa3c6a8a466eb223535035fbc16f3438 \ + --hash=sha256:50127c186f191b8917ea2fb8b206fbebe87fd414a6084d15568c27d0a21d60db \ + --hash=sha256:50ccb5d355961c0f12f6cf24b7187dbabd5433f29e15147a67995474f27d1776 \ + --hash=sha256:519895c99c815a1a24a926d5b60627ce5ea48e9f639a5cd328bda0515ea0f10c \ + --hash=sha256:54401c77a63cc7d6dc4b4e173bb484f28a5607f3df71484709fe037c92d4f0ed \ + --hash=sha256:546cf886f6242dff9ec206331209db9c8e1643ae642dea5fdbecae2453cb50fd \ + --hash=sha256:55ce6b6d803890bd3cc89975fca9de1dff39729b43b73cb15ddd933b8bc20484 \ + --hash=sha256:56793b7a1a091a7c286b5f4aa1fe4ae5d1446fe742d00cdf2ffb1077865db10d \ + --hash=sha256:57f0a0bbc9868e10ebe874e9f129d2917750adf008fe7b9c1598c0fbbfdde6a6 \ + --hash=sha256:5b8c041b6265e08eac8a724b74b655404070b636a8dd6d7a13c3adc07882ef30 \ + --hash=sha256:5e097646944b66207023bc3c634827de858aebc226d5d4d6d16f0b77566ea182 \ + --hash=sha256:60499fe961b21264e17a471ec296dcbf4365fbea611bf9e303ab69db7159ce61 \ + --hash=sha256:610b5c77428a50269f38a534057444c249976433f40f53e3b47e68349cca1425 \ + --hash=sha256:625e3ef310e7fa3a761d48ca7ea1f9d8718a32b1542e727d584d82f4453d5eeb \ + --hash=sha256:657a972f46bbefdbba2d4f14413c0d079f9ae243bd68193cb5061b9732fa54c1 \ + --hash=sha256:69ab77a1373f1e7563e0fb5a29a8440367dec051da6c7405333699d07444f511 \ + --hash=sha256:6a520b4f9974b0a0a6ed73c2154de57cdfd0c8800f4f15ab2b73238ffed0b36e \ + --hash=sha256:6d68ce8e7b2075390e8ac1e1d3a99e8b6372c694bbe612632606d1d546794207 \ + --hash=sha256:6dcc3d17eac1df7859ae01202e9bb11ffa8c98949dcbeb1069c8b9a75917e01b \ + --hash=sha256:6dfdc2bfe69e9adf0df4915949c22a25b39d175d599bf98e7ddf620a13678585 \ + --hash=sha256:739e36ef7412b2bd940f75b278749106e6d025e40027c0b94a17ef7968d55d56 \ + --hash=sha256:7429e7faa1a60cad26ae4227f4dd0459efde239e494c7312624ce228e04f6391 \ + --hash=sha256:74da9f97daec6928567b48c90ea2c82a106b2d500f397eeb8941e47d30b1ca85 \ + --hash=sha256:74e4f025ef3db1c6da4460dd27c118d8cd136d0391da4e387a15e48e5c975147 \ + --hash=sha256:75a9632f1d4f698b2e6e2e1ada40e71f369b15d69baddb8968dcc8e683839b18 \ + --hash=sha256:76acba4c66c47d27c8365e7c10b3d8016a7da83d3191d053a58382311a8bf4e1 \ + --hash=sha256:79d1fb9252e7e2cfe4de6e9a6610c7cbb99b9708e2c3e29057f487de5a9eaefa \ + --hash=sha256:7ce7ad8abebe737ad6143d9d3bf94b88b93365ea30a5b81f6877ec9c0dee0a48 \ + --hash=sha256:7ed07b3062b055d7a7f9d6557a251cc655eed0b3152b76de619516621c56f5d3 \ + --hash=sha256:7ff762670cada8e05b32bf1e4dc50b140790909caa8303cfddc4d702b71ea184 \ + --hash=sha256:8268cbcd48c5375f46e000adb1390572c98879eb4f77910c6053d25cc3ac2c67 \ + --hash=sha256:875a3f90d7eb5c5d77e529080d95140eacb3c6d13ad5b616ee8095447b1d22e7 \ + --hash=sha256:89feb82ca055af0fe797a2323ec9043b26bc371365847dbe83c7fd2e2f181c34 \ + --hash=sha256:8a7e24cb69ee5f32e003f50e016d5fde438010c1022c96738b04fc2423e61706 \ + --hash=sha256:8ab6a358d1286498d80fe67bd3d69fcbc7d1359b45b41e74c4a26964ca99c3f8 \ + --hash=sha256:8b8df03a9e995b6211dafa63b32f9d405881518ff1ddd775db4e7b98fb545e1c \ + --hash=sha256:8cf85a6e40ff1f37fe0f25719aadf443686b1ac7652593dc53c7ef9b8492b115 \ + --hash=sha256:8e8d351ff44c1638cb6e980623d517abd9f580d2e53bfcd18d8941c052a5a009 \ + --hash=sha256:9164361769b6ca7769079f4d426a41df6164879f7f3568be9086e15baca61466 \ + --hash=sha256:96e85aa09274955bb6bd483eaf5b12abadade01010478154b0ec70284c1b1526 \ + --hash=sha256:981a06a3076997adf7c743dcd0d7a0415582661e2517c7d961493572e909aa1d \ + --hash=sha256:9cd5323344d8ebb9fb5e96da5de5ad4ebab993bbf51674259dbe9d7a18049525 \ + --hash=sha256:9d6c6ea6a11ca0ff9cd0390b885984ed31157c168565702959c25e2191674a14 \ + --hash=sha256:a02d3c48f9bb1e10c7788d92c0c7db6f2002d024ab6e74d6f45ae33e3d0288a3 \ + --hash=sha256:a233bb68625a85126ac9f1fc66d24337d6e8a0f9207b688eec2e7c880f012ec0 \ + --hash=sha256:a2f6a1bc2460e643785a2cde17293bd7a8f990884b822f7bca47bee0a82fc66b \ + --hash=sha256:a6d17e0370d2516d5bb9062c7b4cb731cff921fc875644c3d751ad857ba9c5b1 \ + --hash=sha256:a6d2092797b388342c1bc932077ad232f914351932353e2e8706851c870bca1f \ + --hash=sha256:ab67ed772c584b7ef2379797bf14b82df9aa5f7438c5b9a09624dd834c1c1aaf \ + --hash=sha256:ac6540c9fff6e3813d29d0403ee7a81897f1d8ecc09a8ff84d2eea70ede1cdbf \ + --hash=sha256:ae4073a60ab98529ab8a72ebf429f2a8cc612619a8c04e08bed27450d52103c0 \ + --hash=sha256:ae791f6bd43305aade8c0e22f816b34f3b72b6c820477aab4d18473a37e8090b \ + --hash=sha256:aef5474d913d3b05e613906ba4090433c515e13ea49c837aca18bde190853dff \ + --hash=sha256:b0b3f2df149efb242cee2ffdeb6674b7f30d23c9a7af26595099afaf46ef4e88 \ + --hash=sha256:b128092c927eaf485928cec0c28f6b8bead277e28acf56800e972aa2c2abd7a2 \ + --hash=sha256:b16db2770517b8799c79aa80f4053cd6f8b716f21f8aca962725a9565ce3ee40 \ + --hash=sha256:b336b0416828022bfd5a2e3083e7f5ba54b96242159f83c7e3eebaec752f1716 \ + --hash=sha256:b47633251727c8fe279f34025844b3b3a3e40cd1b198356d003aa146258d13a2 \ + --hash=sha256:b537bd04d7ccd7c6350cdaaaad911f6312cbd61e6e6045542f781c7f8b2e99d2 \ + --hash=sha256:b5e4ef22ff25bfd4ede5f8fb30f7b24446345f3e79d9b7455aef2836437bc38a \ + --hash=sha256:b74b9ea10063efb77a965a8d5f4182806fbf59ed068b3c3fd6f30d2ac7bee734 \ + --hash=sha256:bb2dc4898180bea79863d5487e5f9c7c34297414bad54bcd0f0852aee9cfdb87 \ + --hash=sha256:bbc4b80af581e18568ff07f6395c02114d05f4865c2812a1f02f2eaecf0bfd48 \ + --hash=sha256:bcc98f911f10278d1daf14b87d65325851a1d29153caaf146877ec37031d5f36 \ + --hash=sha256:be49ad33819d7dcc28a309b86d4ed98e1a65f3075c6acd3cd4fe32103235222b \ + --hash=sha256:bec4bd9133420c5c52d562469c754f27c5c9e36ee06abc169612c959bd7dbb07 \ + --hash=sha256:c2faf60c583af0d135e853c86ac2735ce178f0e338a3c7f9ae8f622fd2eb788c \ + --hash=sha256:c689d0d5381f56de7bd6966a4541bff6e08bf8d3871bbd89a0c6ab18aa699573 \ + --hash=sha256:c7079d5eb1c1315a858bbf180000757db8ad904a89476653232db835c3114001 \ + --hash=sha256:cb3942960f0beb9f46e2a71a3aca220d1ca32feb5a398656be934320804c0df9 \ + --hash=sha256:cd9e78285da6c9ba2d5c769628f43ef66d96ac3085e59b10ad4f3707980710d3 \ + --hash=sha256:cf2a978c795b54c539f47964ec05e35c05bd045db5ca1e8366988c7f2fe6b3ce \ + --hash=sha256:d14a0d029a4e176795cef99c056d58067c06195e0c7e2dbb293bf95c08f772a3 \ + --hash=sha256:d237ba6664b8e60fd90b8549a149a74fcc675272e0e95539a00522e4ca688b04 \ + --hash=sha256:d26a618ae1766279f2660aca0081b2220aca6bd1aa06b2cf73f07383faf48927 \ + --hash=sha256:d28cb356f119a437cc58a13f8135ab8a4c8ece18159eb9194b0d269ec4e28083 \ + --hash=sha256:d4ed0c7cbecde7194cd3228c044e86bf73e30a23505af852857c09c24e77ec5d \ + --hash=sha256:d83e2d94b69bf31ead2fa45f0acdef0757fa0458a129734f59f67f3d2eb7ef32 \ + --hash=sha256:d8bbcd21769594dbba9c37d3c819e2d5847656ca99c747ddb31ac1701d0c0ed9 \ + --hash=sha256:d9b342c76003c6b9336a80efcc766748a333573abf9350f4094ee46b006ec18f \ + --hash=sha256:dc911208b18842a3a57266d8e51fc3cfaccee90a5351b92079beed912a7914c2 \ + --hash=sha256:dfa7c241073d8f2b8e8dbc7803c434f57dbb83ae2a3d7892dd068d99e96efe2c \ + --hash=sha256:e282aedd63c639c07c3857097fc0e236f984ceb4089a8b284da1c526491e3f3d \ + --hash=sha256:e290d79a4107d7d794634ce3e985b9ae4f920380a813717adf61804904dc4393 \ + --hash=sha256:e3d9d13603410b72787579769469af730c38f2f25505573a5888a94b62b920f8 \ + --hash=sha256:e481bba1e11ba585fb06db666bfc23dbe181dbafc7b25776156120bf12e0d5a6 \ + --hash=sha256:e49b052b768bb74f58c7dda4e0bdf7b79d43a9204ca584ffe1fb48a6f3c84c66 \ + --hash=sha256:eb00b549b13bd6d884c863554566095bf6fa9c3cecb2e7b399c4bc7904cb33b5 \ + --hash=sha256:ec87c44f619380878bd49ca109669c9f221d9ae6883a5bcb3616785fa8f94c97 \ + --hash=sha256:edcfa83e03370032a489430215c1e7783128808fd3e2e0a3225deee278585196 \ + --hash=sha256:f11ae142f3a322d44513de1018b50f474f8f736bc3cd91d969f464b5bfef8836 \ + --hash=sha256:f2a09f6184f17a80897172863a655467da2b11151ec98ba8d7af89f17bf63dae \ + --hash=sha256:f5b65529bb2f21ac7861a0e94fdbf5dc0daab41497d18223b46ee8515e5ad297 \ + --hash=sha256:f60fdd125d85bf9c279ffb8e94c78c51b3b6a37711464e1f5f31078b45002421 \ + --hash=sha256:f61efaf4bed1cc0860e567d2ecb2363974d414f7f1f124b1df368bbf183453a6 \ + --hash=sha256:f90e552ecbad426eab352e7b2933091f2be77115bb16f09f78404861c8322981 \ + --hash=sha256:f956196ef61369f1685d14dad80611488d8dc1ef00be57c0c5a03064005b0f30 \ + --hash=sha256:fb91819461b1b56d06fa4bcf86617fac795f6a99d12239fb0c68dbeba41a0a30 \ + --hash=sha256:fbc9d316552f9ef7bba39f4edfad4a734d3d6f93341232a9dddadec4f15d425f \ + --hash=sha256:ff69a9a0b4b17d78170c73abe2ab12084bdf1691550c5629ad1fe7849433f324 \ + --hash=sha256:ffb2be176fed4457e445fe540617f0252a72a8bc56208fd65a690fdb1f57660b +markdown-it-py==3.0.0 ; python_full_version == "3.9.2" \ + --hash=sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1 \ + --hash=sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb +markdown==3.6 ; python_full_version == "3.9.2" \ + --hash=sha256:48f276f4d8cfb8ce6527c8f79e2ee29708508bf4d40aa410fbc3b4ee832c850f \ + --hash=sha256:ed4f41f6daecbeeb96e576ce414c41d2d876daa9a16cb35fa8ed8c2ddfad0224 +markupsafe==2.1.5 ; python_full_version == "3.9.2" \ + --hash=sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf \ + --hash=sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff \ + --hash=sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f \ + --hash=sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3 \ + --hash=sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532 \ + --hash=sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f \ + --hash=sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617 \ + --hash=sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df \ + --hash=sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4 \ + --hash=sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906 \ + --hash=sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f \ + --hash=sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4 \ + --hash=sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8 \ + --hash=sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371 \ + --hash=sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2 \ + --hash=sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465 \ + --hash=sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52 \ + --hash=sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6 \ + --hash=sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169 \ + --hash=sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad \ + --hash=sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2 \ + --hash=sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0 \ + --hash=sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029 \ + --hash=sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f \ + --hash=sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a \ + --hash=sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced \ + --hash=sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5 \ + --hash=sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c \ + --hash=sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf \ + --hash=sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9 \ + --hash=sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb \ + --hash=sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad \ + --hash=sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3 \ + --hash=sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1 \ + --hash=sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46 \ + --hash=sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc \ + --hash=sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a \ + --hash=sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee \ + --hash=sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900 \ + --hash=sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5 \ + --hash=sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea \ + --hash=sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f \ + --hash=sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5 \ + --hash=sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e \ + --hash=sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a \ + --hash=sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f \ + --hash=sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50 \ + --hash=sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a \ + --hash=sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b \ + --hash=sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4 \ + --hash=sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff \ + --hash=sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2 \ + --hash=sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46 \ + --hash=sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b \ + --hash=sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf \ + --hash=sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5 \ + --hash=sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5 \ + --hash=sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab \ + --hash=sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd \ + --hash=sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68 +matplotlib==3.9.0 ; python_full_version == "3.9.2" \ + --hash=sha256:063af8587fceeac13b0936c42a2b6c732c2ab1c98d38abc3337e430e1ff75e38 \ + --hash=sha256:06a478f0d67636554fa78558cfbcd7b9dba85b51f5c3b5a0c9be49010cf5f321 \ + --hash=sha256:0a490715b3b9984fa609116481b22178348c1a220a4499cda79132000a79b4db \ + --hash=sha256:0fc51eaa5262553868461c083d9adadb11a6017315f3a757fc45ec6ec5f02888 \ + --hash=sha256:13beb4840317d45ffd4183a778685e215939be7b08616f431c7795276e067463 \ + --hash=sha256:290d304e59be2b33ef5c2d768d0237f5bd132986bdcc66f80bc9bcc300066a03 \ + --hash=sha256:2bcee1dffaf60fe7656183ac2190bd630842ff87b3153afb3e384d966b57fe56 \ + --hash=sha256:2e7f03e5cbbfacdd48c8ea394d365d91ee8f3cae7e6ec611409927b5ed997ee4 \ + --hash=sha256:3f988bafb0fa39d1074ddd5bacd958c853e11def40800c5824556eb630f94d3b \ + --hash=sha256:52146fc3bd7813cc784562cb93a15788be0b2875c4655e2cc6ea646bfa30344b \ + --hash=sha256:550cdda3adbd596078cca7d13ed50b77879104e2e46392dcd7c75259d8f00e85 \ + --hash=sha256:616fabf4981a3b3c5a15cd95eba359c8489c4e20e03717aea42866d8d0465956 \ + --hash=sha256:76cce0f31b351e3551d1f3779420cf8f6ec0d4a8cf9c0237a3b549fd28eb4abb \ + --hash=sha256:7ff2e239c26be4f24bfa45860c20ffccd118d270c5b5d081fa4ea409b5469fcd \ + --hash=sha256:8146ce83cbc5dc71c223a74a1996d446cd35cfb6a04b683e1446b7e6c73603b7 \ + --hash=sha256:81c40af649d19c85f8073e25e5806926986806fa6d54be506fbf02aef47d5a89 \ + --hash=sha256:9a2fa6d899e17ddca6d6526cf6e7ba677738bf2a6a9590d702c277204a7c6152 \ + --hash=sha256:a5be985db2596d761cdf0c2eaf52396f26e6a64ab46bd8cd810c48972349d1be \ + --hash=sha256:af4001b7cae70f7eaacfb063db605280058246de590fa7874f00f62259f2df7e \ + --hash=sha256:bd4f2831168afac55b881db82a7730992aa41c4f007f1913465fb182d6fb20c0 \ + --hash=sha256:bdd1ecbe268eb3e7653e04f451635f0fb0f77f07fd070242b44c076c9106da84 \ + --hash=sha256:c53aeb514ccbbcbab55a27f912d79ea30ab21ee0531ee2c09f13800efb272674 \ + --hash=sha256:c79f3a585f1368da6049318bdf1f85568d8d04b2e89fc24b7e02cc9b62017382 \ + --hash=sha256:cd53c79fd02f1c1808d2cfc87dd3cf4dbc63c5244a58ee7944497107469c8d8a \ + --hash=sha256:d38e85a1a6d732f645f1403ce5e6727fd9418cd4574521d5803d3d94911038e5 \ + --hash=sha256:d91a4ffc587bacf5c4ce4ecfe4bcd23a4b675e76315f2866e588686cc97fccdf \ + --hash=sha256:e6d29ea6c19e34b30fb7d88b7081f869a03014f66fe06d62cc77d5a6ea88ed7a \ + --hash=sha256:eaf3978060a106fab40c328778b148f590e27f6fa3cd15a19d6892575bce387d \ + --hash=sha256:fe428e191ea016bb278758c8ee82a8129c51d81d8c4bc0846c09e7e8e9057241 +mdurl==0.1.2 ; python_full_version == "3.9.2" \ + --hash=sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8 \ + --hash=sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba +mpmath==1.3.0 ; python_full_version == "3.9.2" \ + --hash=sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f \ + --hash=sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c +multidict==6.0.5 ; python_full_version == "3.9.2" \ + --hash=sha256:01265f5e40f5a17f8241d52656ed27192be03bfa8764d88e8220141d1e4b3556 \ + --hash=sha256:0275e35209c27a3f7951e1ce7aaf93ce0d163b28948444bec61dd7badc6d3f8c \ + --hash=sha256:04bde7a7b3de05732a4eb39c94574db1ec99abb56162d6c520ad26f83267de29 \ + --hash=sha256:04da1bb8c8dbadf2a18a452639771951c662c5ad03aefe4884775454be322c9b \ + --hash=sha256:09a892e4a9fb47331da06948690ae38eaa2426de97b4ccbfafbdcbe5c8f37ff8 \ + --hash=sha256:0d63c74e3d7ab26de115c49bffc92cc77ed23395303d496eae515d4204a625e7 \ + --hash=sha256:107c0cdefe028703fb5dafe640a409cb146d44a6ae201e55b35a4af8e95457dd \ + --hash=sha256:141b43360bfd3bdd75f15ed811850763555a251e38b2405967f8e25fb43f7d40 \ + --hash=sha256:14c2976aa9038c2629efa2c148022ed5eb4cb939e15ec7aace7ca932f48f9ba6 \ + --hash=sha256:19fe01cea168585ba0f678cad6f58133db2aa14eccaf22f88e4a6dccadfad8b3 \ + --hash=sha256:1d147090048129ce3c453f0292e7697d333db95e52616b3793922945804a433c \ + --hash=sha256:1d9ea7a7e779d7a3561aade7d596649fbecfa5c08a7674b11b423783217933f9 \ + --hash=sha256:215ed703caf15f578dca76ee6f6b21b7603791ae090fbf1ef9d865571039ade5 \ + --hash=sha256:21fd81c4ebdb4f214161be351eb5bcf385426bf023041da2fd9e60681f3cebae \ + --hash=sha256:220dd781e3f7af2c2c1053da9fa96d9cf3072ca58f057f4c5adaaa1cab8fc442 \ + --hash=sha256:228b644ae063c10e7f324ab1ab6b548bdf6f8b47f3ec234fef1093bc2735e5f9 \ + --hash=sha256:29bfeb0dff5cb5fdab2023a7a9947b3b4af63e9c47cae2a10ad58394b517fddc \ + --hash=sha256:2f4848aa3baa109e6ab81fe2006c77ed4d3cd1e0ac2c1fbddb7b1277c168788c \ + --hash=sha256:2faa5ae9376faba05f630d7e5e6be05be22913782b927b19d12b8145968a85ea \ + --hash=sha256:2ffc42c922dbfddb4a4c3b438eb056828719f07608af27d163191cb3e3aa6cc5 \ + --hash=sha256:37b15024f864916b4951adb95d3a80c9431299080341ab9544ed148091b53f50 \ + --hash=sha256:3cc2ad10255f903656017363cd59436f2111443a76f996584d1077e43ee51182 \ + --hash=sha256:3d25f19500588cbc47dc19081d78131c32637c25804df8414463ec908631e453 \ + --hash=sha256:403c0911cd5d5791605808b942c88a8155c2592e05332d2bf78f18697a5fa15e \ + --hash=sha256:411bf8515f3be9813d06004cac41ccf7d1cd46dfe233705933dd163b60e37600 \ + --hash=sha256:425bf820055005bfc8aa9a0b99ccb52cc2f4070153e34b701acc98d201693733 \ + --hash=sha256:435a0984199d81ca178b9ae2c26ec3d49692d20ee29bc4c11a2a8d4514c67eda \ + --hash=sha256:4a6a4f196f08c58c59e0b8ef8ec441d12aee4125a7d4f4fef000ccb22f8d7241 \ + --hash=sha256:4cc0ef8b962ac7a5e62b9e826bd0cd5040e7d401bc45a6835910ed699037a461 \ + --hash=sha256:51d035609b86722963404f711db441cf7134f1889107fb171a970c9701f92e1e \ + --hash=sha256:53689bb4e102200a4fafa9de9c7c3c212ab40a7ab2c8e474491914d2305f187e \ + --hash=sha256:55205d03e8a598cfc688c71ca8ea5f66447164efff8869517f175ea632c7cb7b \ + --hash=sha256:5c0631926c4f58e9a5ccce555ad7747d9a9f8b10619621f22f9635f069f6233e \ + --hash=sha256:5cb241881eefd96b46f89b1a056187ea8e9ba14ab88ba632e68d7a2ecb7aadf7 \ + --hash=sha256:60d698e8179a42ec85172d12f50b1668254628425a6bd611aba022257cac1386 \ + --hash=sha256:612d1156111ae11d14afaf3a0669ebf6c170dbb735e510a7438ffe2369a847fd \ + --hash=sha256:6214c5a5571802c33f80e6c84713b2c79e024995b9c5897f794b43e714daeec9 \ + --hash=sha256:6939c95381e003f54cd4c5516740faba40cf5ad3eeff460c3ad1d3e0ea2549bf \ + --hash=sha256:69db76c09796b313331bb7048229e3bee7928eb62bab5e071e9f7fcc4879caee \ + --hash=sha256:6bf7a982604375a8d49b6cc1b781c1747f243d91b81035a9b43a2126c04766f5 \ + --hash=sha256:766c8f7511df26d9f11cd3a8be623e59cca73d44643abab3f8c8c07620524e4a \ + --hash=sha256:76c0de87358b192de7ea9649beb392f107dcad9ad27276324c24c91774ca5271 \ + --hash=sha256:76f067f5121dcecf0d63a67f29080b26c43c71a98b10c701b0677e4a065fbd54 \ + --hash=sha256:7901c05ead4b3fb75113fb1dd33eb1253c6d3ee37ce93305acd9d38e0b5f21a4 \ + --hash=sha256:79660376075cfd4b2c80f295528aa6beb2058fd289f4c9252f986751a4cd0496 \ + --hash=sha256:79a6d2ba910adb2cbafc95dad936f8b9386e77c84c35bc0add315b856d7c3abb \ + --hash=sha256:7afcdd1fc07befad18ec4523a782cde4e93e0a2bf71239894b8d61ee578c1319 \ + --hash=sha256:7be7047bd08accdb7487737631d25735c9a04327911de89ff1b26b81745bd4e3 \ + --hash=sha256:7c6390cf87ff6234643428991b7359b5f59cc15155695deb4eda5c777d2b880f \ + --hash=sha256:7df704ca8cf4a073334e0427ae2345323613e4df18cc224f647f251e5e75a527 \ + --hash=sha256:85f67aed7bb647f93e7520633d8f51d3cbc6ab96957c71272b286b2f30dc70ed \ + --hash=sha256:896ebdcf62683551312c30e20614305f53125750803b614e9e6ce74a96232604 \ + --hash=sha256:92d16a3e275e38293623ebf639c471d3e03bb20b8ebb845237e0d3664914caef \ + --hash=sha256:99f60d34c048c5c2fabc766108c103612344c46e35d4ed9ae0673d33c8fb26e8 \ + --hash=sha256:9fe7b0653ba3d9d65cbe7698cca585bf0f8c83dbbcc710db9c90f478e175f2d5 \ + --hash=sha256:a3145cb08d8625b2d3fee1b2d596a8766352979c9bffe5d7833e0503d0f0b5e5 \ + --hash=sha256:aeaf541ddbad8311a87dd695ed9642401131ea39ad7bc8cf3ef3967fd093b626 \ + --hash=sha256:b55358304d7a73d7bdf5de62494aaf70bd33015831ffd98bc498b433dfe5b10c \ + --hash=sha256:b82cc8ace10ab5bd93235dfaab2021c70637005e1ac787031f4d1da63d493c1d \ + --hash=sha256:c0868d64af83169e4d4152ec612637a543f7a336e4a307b119e98042e852ad9c \ + --hash=sha256:c1c1496e73051918fcd4f58ff2e0f2f3066d1c76a0c6aeffd9b45d53243702cc \ + --hash=sha256:c9bf56195c6bbd293340ea82eafd0071cb3d450c703d2c93afb89f93b8386ccc \ + --hash=sha256:cbebcd5bcaf1eaf302617c114aa67569dd3f090dd0ce8ba9e35e9985b41ac35b \ + --hash=sha256:cd6c8fca38178e12c00418de737aef1261576bd1b6e8c6134d3e729a4e858b38 \ + --hash=sha256:ceb3b7e6a0135e092de86110c5a74e46bda4bd4fbfeeb3a3bcec79c0f861e450 \ + --hash=sha256:cf590b134eb70629e350691ecca88eac3e3b8b3c86992042fb82e3cb1830d5e1 \ + --hash=sha256:d3eb1ceec286eba8220c26f3b0096cf189aea7057b6e7b7a2e60ed36b373b77f \ + --hash=sha256:d65f25da8e248202bd47445cec78e0025c0fe7582b23ec69c3b27a640dd7a8e3 \ + --hash=sha256:d6f6d4f185481c9669b9447bf9d9cf3b95a0e9df9d169bbc17e363b7d5487755 \ + --hash=sha256:d84a5c3a5f7ce6db1f999fb9438f686bc2e09d38143f2d93d8406ed2dd6b9226 \ + --hash=sha256:d946b0a9eb8aaa590df1fe082cee553ceab173e6cb5b03239716338629c50c7a \ + --hash=sha256:dce1c6912ab9ff5f179eaf6efe7365c1f425ed690b03341911bf4939ef2f3046 \ + --hash=sha256:de170c7b4fe6859beb8926e84f7d7d6c693dfe8e27372ce3b76f01c46e489fcf \ + --hash=sha256:e02021f87a5b6932fa6ce916ca004c4d441509d33bbdbeca70d05dff5e9d2479 \ + --hash=sha256:e030047e85cbcedbfc073f71836d62dd5dadfbe7531cae27789ff66bc551bd5e \ + --hash=sha256:e0e79d91e71b9867c73323a3444724d496c037e578a0e1755ae159ba14f4f3d1 \ + --hash=sha256:e4428b29611e989719874670fd152b6625500ad6c686d464e99f5aaeeaca175a \ + --hash=sha256:e4972624066095e52b569e02b5ca97dbd7a7ddd4294bf4e7247d52635630dd83 \ + --hash=sha256:e7be68734bd8c9a513f2b0cfd508802d6609da068f40dc57d4e3494cefc92929 \ + --hash=sha256:e8e94e6912639a02ce173341ff62cc1201232ab86b8a8fcc05572741a5dc7d93 \ + --hash=sha256:ea1456df2a27c73ce51120fa2f519f1bea2f4a03a917f4a43c8707cf4cbbae1a \ + --hash=sha256:ebd8d160f91a764652d3e51ce0d2956b38efe37c9231cd82cfc0bed2e40b581c \ + --hash=sha256:eca2e9d0cc5a889850e9bbd68e98314ada174ff6ccd1129500103df7a94a7a44 \ + --hash=sha256:edd08e6f2f1a390bf137080507e44ccc086353c8e98c657e666c017718561b89 \ + --hash=sha256:f285e862d2f153a70586579c15c44656f888806ed0e5b56b64489afe4a2dbfba \ + --hash=sha256:f2a1dee728b52b33eebff5072817176c172050d44d67befd681609b4746e1c2e \ + --hash=sha256:f7e301075edaf50500f0b341543c41194d8df3ae5caf4702f2095f3ca73dd8da \ + --hash=sha256:fb616be3538599e797a2017cccca78e354c767165e8858ab5116813146041a24 \ + --hash=sha256:fce28b3c8a81b6b36dfac9feb1de115bab619b3c13905b419ec71d03a3fc1423 \ + --hash=sha256:fe5d7785250541f7f5019ab9cba2c71169dc7d74d0f45253f8313f436458a4ef +networkx==3.2.1 ; python_full_version == "3.9.2" \ + --hash=sha256:9f1bb5cf3409bf324e0a722c20bdb4c20ee39bf1c30ce8ae499c8502b0b5e0c6 \ + --hash=sha256:f18c69adc97877c42332c170849c96cefa91881c99a7cb3e95b7c659ebdc1ec2 +numpy==1.26.4 ; python_full_version == "3.9.2" \ + --hash=sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b \ + --hash=sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818 \ + --hash=sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20 \ + --hash=sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0 \ + --hash=sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010 \ + --hash=sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a \ + --hash=sha256:3373d5d70a5fe74a2c1bb6d2cfd9609ecf686d47a2d7b1d37a8f3b6bf6003aea \ + --hash=sha256:47711010ad8555514b434df65f7d7b076bb8261df1ca9bb78f53d3b2db02e95c \ + --hash=sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71 \ + --hash=sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110 \ + --hash=sha256:52b8b60467cd7dd1e9ed082188b4e6bb35aa5cdd01777621a1658910745b90be \ + --hash=sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a \ + --hash=sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a \ + --hash=sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5 \ + --hash=sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed \ + --hash=sha256:679b0076f67ecc0138fd2ede3a8fd196dddc2ad3254069bcb9faf9a79b1cebcd \ + --hash=sha256:7349ab0fa0c429c82442a27a9673fc802ffdb7c7775fad780226cb234965e53c \ + --hash=sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e \ + --hash=sha256:7e50d0a0cc3189f9cb0aeb3a6a6af18c16f59f004b866cd2be1c14b36134a4a0 \ + --hash=sha256:95a7476c59002f2f6c590b9b7b998306fba6a5aa646b1e22ddfeaf8f78c3a29c \ + --hash=sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a \ + --hash=sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b \ + --hash=sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0 \ + --hash=sha256:a354325ee03388678242a4d7ebcd08b5c727033fcff3b2f536aea978e15ee9e6 \ + --hash=sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2 \ + --hash=sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a \ + --hash=sha256:afedb719a9dcfc7eaf2287b839d8198e06dcd4cb5d276a3df279231138e83d30 \ + --hash=sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218 \ + --hash=sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5 \ + --hash=sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07 \ + --hash=sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2 \ + --hash=sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4 \ + --hash=sha256:d5241e0a80d808d70546c697135da2c613f30e28251ff8307eb72ba696945764 \ + --hash=sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef \ + --hash=sha256:f870204a840a60da0b12273ef34f7051e98c3b5961b61b0c2c1be6dfd64fbcd3 \ + --hash=sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f +nvidia-cublas-cu12==12.1.3.1 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:2b964d60e8cf11b5e1073d179d85fa340c120e99b3067558f3cf98dd69d02906 \ + --hash=sha256:ee53ccca76a6fc08fb9701aa95b6ceb242cdaab118c3bb152af4e579af792728 +nvidia-cuda-cupti-cu12==12.1.105 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:bea8236d13a0ac7190bd2919c3e8e6ce1e402104276e6f9694479e48bb0eb2a4 \ + --hash=sha256:e54fde3983165c624cb79254ae9818a456eb6e87a7fd4d56a2352c24ee542d7e +nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:0a98a522d9ff138b96c010a65e145dc1b4850e9ecb75a0172371793752fd46ed \ + --hash=sha256:339b385f50c309763ca65456ec75e17bbefcbbf2893f462cb8b90584cd27a1c2 +nvidia-cuda-runtime-cu12==12.1.105 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:6e258468ddf5796e25f1dc591a31029fa317d97a0a94ed93468fc86301d61e40 \ + --hash=sha256:dfb46ef84d73fababab44cf03e3b83f80700d27ca300e537f85f636fac474344 +nvidia-cudnn-cu12==8.9.2.26 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:5ccb288774fdfb07a7e7025ffec286971c06d8d7b4fb162525334616d7629ff9 +nvidia-cufft-cu12==11.0.2.54 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:794e3948a1aa71fd817c3775866943936774d1c14e7628c74f6f7417224cdf56 \ + --hash=sha256:d9ac353f78ff89951da4af698f80870b1534ed69993f10a4cf1d96f21357e253 +nvidia-curand-cu12==10.3.2.106 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:75b6b0c574c0037839121317e17fd01f8a69fd2ef8e25853d826fec30bdba74a \ + --hash=sha256:9d264c5036dde4e64f1de8c50ae753237c12e0b1348738169cd0f8a536c0e1e0 +nvidia-cusolver-cu12==11.4.5.107 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:74e0c3a24c78612192a74fcd90dd117f1cf21dea4822e66d89e8ea80e3cd2da5 \ + --hash=sha256:8a7ec542f0412294b15072fa7dab71d31334014a69f953004ea7a118206fe0dd +nvidia-cusparse-cu12==12.1.0.106 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:b798237e81b9719373e8fae8d4f091b70a0cf09d9d85c95a557e11df2d8e9a5a \ + --hash=sha256:f3b50f42cf363f86ab21f720998517a659a48131e8d538dc02f8768237bd884c +nvidia-nccl-cu12==2.18.1 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:1a6c4acefcbebfa6de320f412bf7866de856e786e0462326ba1bac40de0b5e71 +nvidia-nvjitlink-cu12==12.5.40 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:c3401dc8543b52d3a8158007a0c1ab4e9c768fcbd24153a48c86972102197ddd \ + --hash=sha256:d9714f27c1d0f0895cd8915c07a87a1d0029a0aa36acaf9156952ec2a8a12189 +nvidia-nvtx-cu12==12.1.105 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:65f4d98982b31b60026e0e6de73fbdfc09d08a96f4656dd3665ca616a11e1e82 \ + --hash=sha256:dc21cf308ca5691e7c04d962e213f8a4aa9bbfa23d95412f452254c2caeb09e5 +omegaconf==2.0.6 ; python_full_version == "3.9.2" \ + --hash=sha256:92ca535a788d21651bf4c2eaf5c1ca4c7a8003b2dab4a87cbb09109784268806 \ + --hash=sha256:9e349fd76819b95b47aa628edea1ff83fed5b25108608abdd6c7fdca188e302a +packaging==24.1 ; python_full_version == "3.9.2" \ + --hash=sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002 \ + --hash=sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124 +pandas==1.5.3 ; python_full_version == "3.9.2" \ + --hash=sha256:14e45300521902689a81f3f41386dc86f19b8ba8dd5ac5a3c7010ef8d2932813 \ + --hash=sha256:26d9c71772c7afb9d5046e6e9cf42d83dd147b5cf5bcb9d97252077118543792 \ + --hash=sha256:3749077d86e3a2f0ed51367f30bf5b82e131cc0f14260c4d3e499186fccc4406 \ + --hash=sha256:41179ce559943d83a9b4bbacb736b04c928b095b5f25dd2b7389eda08f46f373 \ + --hash=sha256:478ff646ca42b20376e4ed3fa2e8d7341e8a63105586efe54fa2508ee087f328 \ + --hash=sha256:50869a35cbb0f2e0cd5ec04b191e7b12ed688874bd05dd777c19b28cbea90996 \ + --hash=sha256:565fa34a5434d38e9d250af3c12ff931abaf88050551d9fbcdfafca50d62babf \ + --hash=sha256:5f2b952406a1588ad4cad5b3f55f520e82e902388a6d5a4a91baa8d38d23c7f6 \ + --hash=sha256:5fbcb19d6fceb9e946b3e23258757c7b225ba450990d9ed63ccceeb8cae609f7 \ + --hash=sha256:6973549c01ca91ec96199e940495219c887ea815b2083722821f1d7abfa2b4dc \ + --hash=sha256:74a3fd7e5a7ec052f183273dc7b0acd3a863edf7520f5d3a1765c04ffdb3b0b1 \ + --hash=sha256:7a0a56cef15fd1586726dace5616db75ebcfec9179a3a55e78f72c5639fa2a23 \ + --hash=sha256:7cec0bee9f294e5de5bbfc14d0573f65526071029d036b753ee6507d2a21480a \ + --hash=sha256:87bd9c03da1ac870a6d2c8902a0e1fd4267ca00f13bc494c9e5a9020920e1d51 \ + --hash=sha256:972d8a45395f2a2d26733eb8d0f629b2f90bebe8e8eddbb8829b180c09639572 \ + --hash=sha256:9842b6f4b8479e41968eced654487258ed81df7d1c9b7b870ceea24ed9459b31 \ + --hash=sha256:9f69c4029613de47816b1bb30ff5ac778686688751a5e9c99ad8c7031f6508e5 \ + --hash=sha256:a50d9a4336a9621cab7b8eb3fb11adb82de58f9b91d84c2cd526576b881a0c5a \ + --hash=sha256:bc4c368f42b551bf72fac35c5128963a171b40dce866fb066540eeaf46faa003 \ + --hash=sha256:c39a8da13cede5adcd3be1182883aea1c925476f4e84b2807a46e2775306305d \ + --hash=sha256:c3ac844a0fe00bfaeb2c9b51ab1424e5c8744f89860b138434a363b1f620f354 \ + --hash=sha256:c4c00e0b0597c8e4f59e8d461f797e5d70b4d025880516a8261b2817c47759ee \ + --hash=sha256:c74a62747864ed568f5a82a49a23a8d7fe171d0c69038b38cedf0976831296fa \ + --hash=sha256:dd05f7783b3274aa206a1af06f0ceed3f9b412cf665b7247eacd83be41cf7bf0 \ + --hash=sha256:dfd681c5dc216037e0b0a2c821f5ed99ba9f03ebcf119c7dac0e9a7b960b9ec9 \ + --hash=sha256:e474390e60ed609cec869b0da796ad94f420bb057d86784191eefc62b65819ae \ + --hash=sha256:f76d097d12c82a535fda9dfe5e8dd4127952b45fea9b0276cb30cca5ea313fbc +pathtools==0.1.2 ; python_full_version == "3.9.2" \ + --hash=sha256:7c35c5421a39bb82e58018febd90e3b6e5db34c5443aaaf742b3f33d4655f1c0 +pillow==10.3.0 ; python_full_version == "3.9.2" \ + --hash=sha256:048ad577748b9fa4a99a0548c64f2cb8d672d5bf2e643a739ac8faff1164238c \ + --hash=sha256:048eeade4c33fdf7e08da40ef402e748df113fd0b4584e32c4af74fe78baaeb2 \ + --hash=sha256:0ba26351b137ca4e0db0342d5d00d2e355eb29372c05afd544ebf47c0956ffeb \ + --hash=sha256:0ea2a783a2bdf2a561808fe4a7a12e9aa3799b701ba305de596bc48b8bdfce9d \ + --hash=sha256:1530e8f3a4b965eb6a7785cf17a426c779333eb62c9a7d1bbcf3ffd5bf77a4aa \ + --hash=sha256:16563993329b79513f59142a6b02055e10514c1a8e86dca8b48a893e33cf91e3 \ + --hash=sha256:19aeb96d43902f0a783946a0a87dbdad5c84c936025b8419da0a0cd7724356b1 \ + --hash=sha256:1a1d1915db1a4fdb2754b9de292642a39a7fb28f1736699527bb649484fb966a \ + --hash=sha256:1b87bd9d81d179bd8ab871603bd80d8645729939f90b71e62914e816a76fc6bd \ + --hash=sha256:1dfc94946bc60ea375cc39cff0b8da6c7e5f8fcdc1d946beb8da5c216156ddd8 \ + --hash=sha256:2034f6759a722da3a3dbd91a81148cf884e91d1b747992ca288ab88c1de15999 \ + --hash=sha256:261ddb7ca91fcf71757979534fb4c128448b5b4c55cb6152d280312062f69599 \ + --hash=sha256:2ed854e716a89b1afcedea551cd85f2eb2a807613752ab997b9974aaa0d56936 \ + --hash=sha256:3102045a10945173d38336f6e71a8dc71bcaeed55c3123ad4af82c52807b9375 \ + --hash=sha256:339894035d0ede518b16073bdc2feef4c991ee991a29774b33e515f1d308e08d \ + --hash=sha256:412444afb8c4c7a6cc11a47dade32982439925537e483be7c0ae0cf96c4f6a0b \ + --hash=sha256:4203efca580f0dd6f882ca211f923168548f7ba334c189e9eab1178ab840bf60 \ + --hash=sha256:45ebc7b45406febf07fef35d856f0293a92e7417ae7933207e90bf9090b70572 \ + --hash=sha256:4b5ec25d8b17217d635f8935dbc1b9aa5907962fae29dff220f2659487891cd3 \ + --hash=sha256:4c8e73e99da7db1b4cad7f8d682cf6abad7844da39834c288fbfa394a47bbced \ + --hash=sha256:4e6f7d1c414191c1199f8996d3f2282b9ebea0945693fb67392c75a3a320941f \ + --hash=sha256:4eaa22f0d22b1a7e93ff0a596d57fdede2e550aecffb5a1ef1106aaece48e96b \ + --hash=sha256:50b8eae8f7334ec826d6eeffaeeb00e36b5e24aa0b9df322c247539714c6df19 \ + --hash=sha256:50fd3f6b26e3441ae07b7c979309638b72abc1a25da31a81a7fbd9495713ef4f \ + --hash=sha256:51243f1ed5161b9945011a7360e997729776f6e5d7005ba0c6879267d4c5139d \ + --hash=sha256:5d512aafa1d32efa014fa041d38868fda85028e3f930a96f85d49c7d8ddc0383 \ + --hash=sha256:5f77cf66e96ae734717d341c145c5949c63180842a545c47a0ce7ae52ca83795 \ + --hash=sha256:6b02471b72526ab8a18c39cb7967b72d194ec53c1fd0a70b050565a0f366d355 \ + --hash=sha256:6fb1b30043271ec92dc65f6d9f0b7a830c210b8a96423074b15c7bc999975f57 \ + --hash=sha256:7161ec49ef0800947dc5570f86568a7bb36fa97dd09e9827dc02b718c5643f09 \ + --hash=sha256:72d622d262e463dfb7595202d229f5f3ab4b852289a1cd09650362db23b9eb0b \ + --hash=sha256:74d28c17412d9caa1066f7a31df8403ec23d5268ba46cd0ad2c50fb82ae40462 \ + --hash=sha256:78618cdbccaa74d3f88d0ad6cb8ac3007f1a6fa5c6f19af64b55ca170bfa1edf \ + --hash=sha256:793b4e24db2e8742ca6423d3fde8396db336698c55cd34b660663ee9e45ed37f \ + --hash=sha256:798232c92e7665fe82ac085f9d8e8ca98826f8e27859d9a96b41d519ecd2e49a \ + --hash=sha256:81d09caa7b27ef4e61cb7d8fbf1714f5aec1c6b6c5270ee53504981e6e9121ad \ + --hash=sha256:8ab74c06ffdab957d7670c2a5a6e1a70181cd10b727cd788c4dd9005b6a8acd9 \ + --hash=sha256:8eb0908e954d093b02a543dc963984d6e99ad2b5e36503d8a0aaf040505f747d \ + --hash=sha256:90b9e29824800e90c84e4022dd5cc16eb2d9605ee13f05d47641eb183cd73d45 \ + --hash=sha256:9797a6c8fe16f25749b371c02e2ade0efb51155e767a971c61734b1bf6293994 \ + --hash=sha256:9d2455fbf44c914840c793e89aa82d0e1763a14253a000743719ae5946814b2d \ + --hash=sha256:9d3bea1c75f8c53ee4d505c3e67d8c158ad4df0d83170605b50b64025917f338 \ + --hash=sha256:9e2ec1e921fd07c7cda7962bad283acc2f2a9ccc1b971ee4b216b75fad6f0463 \ + --hash=sha256:9e91179a242bbc99be65e139e30690e081fe6cb91a8e77faf4c409653de39451 \ + --hash=sha256:a0eaa93d054751ee9964afa21c06247779b90440ca41d184aeb5d410f20ff591 \ + --hash=sha256:a2c405445c79c3f5a124573a051062300936b0281fee57637e706453e452746c \ + --hash=sha256:aa7e402ce11f0885305bfb6afb3434b3cd8f53b563ac065452d9d5654c7b86fd \ + --hash=sha256:aff76a55a8aa8364d25400a210a65ff59d0168e0b4285ba6bf2bd83cf675ba32 \ + --hash=sha256:b09b86b27a064c9624d0a6c54da01c1beaf5b6cadfa609cf63789b1d08a797b9 \ + --hash=sha256:b14f16f94cbc61215115b9b1236f9c18403c15dd3c52cf629072afa9d54c1cbf \ + --hash=sha256:b50811d664d392f02f7761621303eba9d1b056fb1868c8cdf4231279645c25f5 \ + --hash=sha256:b7bc2176354defba3edc2b9a777744462da2f8e921fbaf61e52acb95bafa9828 \ + --hash=sha256:c78e1b00a87ce43bb37642c0812315b411e856a905d58d597750eb79802aaaa3 \ + --hash=sha256:c83341b89884e2b2e55886e8fbbf37c3fa5efd6c8907124aeb72f285ae5696e5 \ + --hash=sha256:ca2870d5d10d8726a27396d3ca4cf7976cec0f3cb706debe88e3a5bd4610f7d2 \ + --hash=sha256:ccce24b7ad89adb5a1e34a6ba96ac2530046763912806ad4c247356a8f33a67b \ + --hash=sha256:cd5e14fbf22a87321b24c88669aad3a51ec052eb145315b3da3b7e3cc105b9a2 \ + --hash=sha256:ce49c67f4ea0609933d01c0731b34b8695a7a748d6c8d186f95e7d085d2fe475 \ + --hash=sha256:d33891be6df59d93df4d846640f0e46f1a807339f09e79a8040bc887bdcd7ed3 \ + --hash=sha256:d3b2348a78bc939b4fed6552abfd2e7988e0f81443ef3911a4b8498ca084f6eb \ + --hash=sha256:d886f5d353333b4771d21267c7ecc75b710f1a73d72d03ca06df49b09015a9ef \ + --hash=sha256:d93480005693d247f8346bc8ee28c72a2191bdf1f6b5db469c096c0c867ac015 \ + --hash=sha256:dc1a390a82755a8c26c9964d457d4c9cbec5405896cba94cf51f36ea0d855002 \ + --hash=sha256:dd78700f5788ae180b5ee8902c6aea5a5726bac7c364b202b4b3e3ba2d293170 \ + --hash=sha256:e46f38133e5a060d46bd630faa4d9fa0202377495df1f068a8299fd78c84de84 \ + --hash=sha256:e4b878386c4bf293578b48fc570b84ecfe477d3b77ba39a6e87150af77f40c57 \ + --hash=sha256:f0d0591a0aeaefdaf9a5e545e7485f89910c977087e7de2b6c388aec32011e9f \ + --hash=sha256:fdcbb4068117dfd9ce0138d068ac512843c52295ed996ae6dd1faf537b6dbc27 \ + --hash=sha256:ff61bfd9253c3915e6d41c651d5f962da23eda633cf02262990094a18a55371a +portalocker==2.8.2 ; python_full_version == "3.9.2" \ + --hash=sha256:2b035aa7828e46c58e9b31390ee1f169b98e1066ab10b9a6a861fe7e25ee4f33 \ + --hash=sha256:cfb86acc09b9aa7c3b43594e19be1345b9d16af3feb08bf92f23d4dce513a28e +protobuf==3.20.0 ; python_full_version == "3.9.2" \ + --hash=sha256:001c2160c03b6349c04de39cf1a58e342750da3632f6978a1634a3dcca1ec10e \ + --hash=sha256:0b250c60256c8824219352dc2a228a6b49987e5bf94d3ffcf4c46585efcbd499 \ + --hash=sha256:1d24c81c2310f0063b8fc1c20c8ed01f3331be9374b4b5c2de846f69e11e21fb \ + --hash=sha256:1eb13f5a5a59ca4973bcfa2fc8fff644bd39f2109c3f7a60bd5860cb6a49b679 \ + --hash=sha256:25d2fcd6eef340082718ec9ad2c58d734429f2b1f7335d989523852f2bba220b \ + --hash=sha256:32bf4a90c207a0b4e70ca6dd09d43de3cb9898f7d5b69c2e9e3b966a7f342820 \ + --hash=sha256:38fd9eb74b852e4ee14b16e9670cd401d147ee3f3ec0d4f7652e0c921d6227f8 \ + --hash=sha256:47257d932de14a7b6c4ae1b7dbf592388153ee35ec7cae216b87ae6490ed39a3 \ + --hash=sha256:4eda68bd9e2a4879385e6b1ea528c976f59cd9728382005cc54c28bcce8db983 \ + --hash=sha256:52bae32a147c375522ce09bd6af4d2949aca32a0415bc62df1456b3ad17c6001 \ + --hash=sha256:542f25a4adf3691a306dcc00bf9a73176554938ec9b98f20f929a044f80acf1b \ + --hash=sha256:5b5860b790498f233cdc8d635a17fc08de62e59d4dcd8cdb6c6c0d38a31edf2b \ + --hash=sha256:6efe066a7135233f97ce51a1aa007d4fb0be28ef093b4f88dac4ad1b3a2b7b6f \ + --hash=sha256:71b2c3d1cd26ed1ec7c8196834143258b2ad7f444efff26fdc366c6f5e752702 \ + --hash=sha256:7a53d4035427b9dbfbb397f46642754d294f131e93c661d056366f2a31438263 \ + --hash=sha256:7dcd84dc31ebb35ade755e06d1561d1bd3b85e85dbdbf6278011fc97b22810db \ + --hash=sha256:88c8be0558bdfc35e68c42ae5bf785eb9390d25915d4863bbc7583d23da77074 \ + --hash=sha256:8be43a91ab66fe995e85ccdbdd1046d9f0443d59e060c0840319290de25b7d33 \ + --hash=sha256:8d84453422312f8275455d1cb52d850d6a4d7d714b784e41b573c6f5bfc2a029 \ + --hash=sha256:9d0f3aca8ca51c8b5e204ab92bd8afdb2a8e3df46bd0ce0bd39065d79aabcaa4 \ + --hash=sha256:a1eebb6eb0653e594cb86cd8e536b9b083373fca9aba761ade6cd412d46fb2ab \ + --hash=sha256:bc14037281db66aa60856cd4ce4541a942040686d290e3f3224dd3978f88f554 \ + --hash=sha256:fbcbb068ebe67c4ff6483d2e2aa87079c325f8470b24b098d6bf7d4d21d57a69 \ + --hash=sha256:fd7133b885e356fa4920ead8289bb45dc6f185a164e99e10279f33732ed5ce15 +psutil==5.9.8 ; python_full_version == "3.9.2" \ + --hash=sha256:02615ed8c5ea222323408ceba16c60e99c3f91639b07da6373fb7e6539abc56d \ + --hash=sha256:05806de88103b25903dff19bb6692bd2e714ccf9e668d050d144012055cbca73 \ + --hash=sha256:26bd09967ae00920df88e0352a91cff1a78f8d69b3ecabbfe733610c0af486c8 \ + --hash=sha256:27cc40c3493bb10de1be4b3f07cae4c010ce715290a5be22b98493509c6299e2 \ + --hash=sha256:36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e \ + --hash=sha256:50187900d73c1381ba1454cf40308c2bf6f34268518b3f36a9b663ca87e65e36 \ + --hash=sha256:611052c4bc70432ec770d5d54f64206aa7203a101ec273a0cd82418c86503bb7 \ + --hash=sha256:6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c \ + --hash=sha256:7d79560ad97af658a0f6adfef8b834b53f64746d45b403f225b85c5c2c140eee \ + --hash=sha256:8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421 \ + --hash=sha256:8db4c1b57507eef143a15a6884ca10f7c73876cdf5d51e713151c1236a0e68cf \ + --hash=sha256:aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81 \ + --hash=sha256:bc56c2a1b0d15aa3eaa5a60c9f3f8e3e565303b465dbf57a1b730e7a2b9844e0 \ + --hash=sha256:bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631 \ + --hash=sha256:d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4 \ + --hash=sha256:d16bbddf0693323b8c6123dd804100241da461e41d6e332fb0ba6058f630f8c8 +psycopg2-binary==2.9.9 ; python_full_version == "3.9.2" \ + --hash=sha256:03ef7df18daf2c4c07e2695e8cfd5ee7f748a1d54d802330985a78d2a5a6dca9 \ + --hash=sha256:0a602ea5aff39bb9fac6308e9c9d82b9a35c2bf288e184a816002c9fae930b77 \ + --hash=sha256:0c009475ee389757e6e34611d75f6e4f05f0cf5ebb76c6037508318e1a1e0d7e \ + --hash=sha256:0ef4854e82c09e84cc63084a9e4ccd6d9b154f1dbdd283efb92ecd0b5e2b8c84 \ + --hash=sha256:1236ed0952fbd919c100bc839eaa4a39ebc397ed1c08a97fc45fee2a595aa1b3 \ + --hash=sha256:143072318f793f53819048fdfe30c321890af0c3ec7cb1dfc9cc87aa88241de2 \ + --hash=sha256:15208be1c50b99203fe88d15695f22a5bed95ab3f84354c494bcb1d08557df67 \ + --hash=sha256:1873aade94b74715be2246321c8650cabf5a0d098a95bab81145ffffa4c13876 \ + --hash=sha256:18d0ef97766055fec15b5de2c06dd8e7654705ce3e5e5eed3b6651a1d2a9a152 \ + --hash=sha256:1ea665f8ce695bcc37a90ee52de7a7980be5161375d42a0b6c6abedbf0d81f0f \ + --hash=sha256:2293b001e319ab0d869d660a704942c9e2cce19745262a8aba2115ef41a0a42a \ + --hash=sha256:246b123cc54bb5361588acc54218c8c9fb73068bf227a4a531d8ed56fa3ca7d6 \ + --hash=sha256:275ff571376626195ab95a746e6a04c7df8ea34638b99fc11160de91f2fef503 \ + --hash=sha256:281309265596e388ef483250db3640e5f414168c5a67e9c665cafce9492eda2f \ + --hash=sha256:2d423c8d8a3c82d08fe8af900ad5b613ce3632a1249fd6a223941d0735fce493 \ + --hash=sha256:2e5afae772c00980525f6d6ecf7cbca55676296b580c0e6abb407f15f3706996 \ + --hash=sha256:30dcc86377618a4c8f3b72418df92e77be4254d8f89f14b8e8f57d6d43603c0f \ + --hash=sha256:31a34c508c003a4347d389a9e6fcc2307cc2150eb516462a7a17512130de109e \ + --hash=sha256:323ba25b92454adb36fa425dc5cf6f8f19f78948cbad2e7bc6cdf7b0d7982e59 \ + --hash=sha256:34eccd14566f8fe14b2b95bb13b11572f7c7d5c36da61caf414d23b91fcc5d94 \ + --hash=sha256:3a58c98a7e9c021f357348867f537017057c2ed7f77337fd914d0bedb35dace7 \ + --hash=sha256:3f78fd71c4f43a13d342be74ebbc0666fe1f555b8837eb113cb7416856c79682 \ + --hash=sha256:4154ad09dac630a0f13f37b583eae260c6aa885d67dfbccb5b02c33f31a6d420 \ + --hash=sha256:420f9bbf47a02616e8554e825208cb947969451978dceb77f95ad09c37791dae \ + --hash=sha256:4686818798f9194d03c9129a4d9a702d9e113a89cb03bffe08c6cf799e053291 \ + --hash=sha256:57fede879f08d23c85140a360c6a77709113efd1c993923c59fde17aa27599fe \ + --hash=sha256:60989127da422b74a04345096c10d416c2b41bd7bf2a380eb541059e4e999980 \ + --hash=sha256:64cf30263844fa208851ebb13b0732ce674d8ec6a0c86a4e160495d299ba3c93 \ + --hash=sha256:68fc1f1ba168724771e38bee37d940d2865cb0f562380a1fb1ffb428b75cb692 \ + --hash=sha256:6e6f98446430fdf41bd36d4faa6cb409f5140c1c2cf58ce0bbdaf16af7d3f119 \ + --hash=sha256:729177eaf0aefca0994ce4cffe96ad3c75e377c7b6f4efa59ebf003b6d398716 \ + --hash=sha256:72dffbd8b4194858d0941062a9766f8297e8868e1dd07a7b36212aaa90f49472 \ + --hash=sha256:75723c3c0fbbf34350b46a3199eb50638ab22a0228f93fb472ef4d9becc2382b \ + --hash=sha256:77853062a2c45be16fd6b8d6de2a99278ee1d985a7bd8b103e97e41c034006d2 \ + --hash=sha256:78151aa3ec21dccd5cdef6c74c3e73386dcdfaf19bced944169697d7ac7482fc \ + --hash=sha256:7f01846810177d829c7692f1f5ada8096762d9172af1b1a28d4ab5b77c923c1c \ + --hash=sha256:804d99b24ad523a1fe18cc707bf741670332f7c7412e9d49cb5eab67e886b9b5 \ + --hash=sha256:81ff62668af011f9a48787564ab7eded4e9fb17a4a6a74af5ffa6a457400d2ab \ + --hash=sha256:8359bf4791968c5a78c56103702000105501adb557f3cf772b2c207284273984 \ + --hash=sha256:83791a65b51ad6ee6cf0845634859d69a038ea9b03d7b26e703f94c7e93dbcf9 \ + --hash=sha256:8532fd6e6e2dc57bcb3bc90b079c60de896d2128c5d9d6f24a63875a95a088cf \ + --hash=sha256:876801744b0dee379e4e3c38b76fc89f88834bb15bf92ee07d94acd06ec890a0 \ + --hash=sha256:8dbf6d1bc73f1d04ec1734bae3b4fb0ee3cb2a493d35ede9badbeb901fb40f6f \ + --hash=sha256:8f8544b092a29a6ddd72f3556a9fcf249ec412e10ad28be6a0c0d948924f2212 \ + --hash=sha256:911dda9c487075abd54e644ccdf5e5c16773470a6a5d3826fda76699410066fb \ + --hash=sha256:977646e05232579d2e7b9c59e21dbe5261f403a88417f6a6512e70d3f8a046be \ + --hash=sha256:9dba73be7305b399924709b91682299794887cbbd88e38226ed9f6712eabee90 \ + --hash=sha256:a148c5d507bb9b4f2030a2025c545fccb0e1ef317393eaba42e7eabd28eb6041 \ + --hash=sha256:a6cdcc3ede532f4a4b96000b6362099591ab4a3e913d70bcbac2b56c872446f7 \ + --hash=sha256:ac05fb791acf5e1a3e39402641827780fe44d27e72567a000412c648a85ba860 \ + --hash=sha256:b0605eaed3eb239e87df0d5e3c6489daae3f7388d455d0c0b4df899519c6a38d \ + --hash=sha256:b58b4710c7f4161b5e9dcbe73bb7c62d65670a87df7bcce9e1faaad43e715245 \ + --hash=sha256:b6356793b84728d9d50ead16ab43c187673831e9d4019013f1402c41b1db9b27 \ + --hash=sha256:b76bedd166805480ab069612119ea636f5ab8f8771e640ae103e05a4aae3e417 \ + --hash=sha256:bc7bb56d04601d443f24094e9e31ae6deec9ccb23581f75343feebaf30423359 \ + --hash=sha256:c2470da5418b76232f02a2fcd2229537bb2d5a7096674ce61859c3229f2eb202 \ + --hash=sha256:c332c8d69fb64979ebf76613c66b985414927a40f8defa16cf1bc028b7b0a7b0 \ + --hash=sha256:c6af2a6d4b7ee9615cbb162b0738f6e1fd1f5c3eda7e5da17861eacf4c717ea7 \ + --hash=sha256:c77e3d1862452565875eb31bdb45ac62502feabbd53429fdc39a1cc341d681ba \ + --hash=sha256:ca08decd2697fdea0aea364b370b1249d47336aec935f87b8bbfd7da5b2ee9c1 \ + --hash=sha256:ca49a8119c6cbd77375ae303b0cfd8c11f011abbbd64601167ecca18a87e7cdd \ + --hash=sha256:cb16c65dcb648d0a43a2521f2f0a2300f40639f6f8c1ecbc662141e4e3e1ee07 \ + --hash=sha256:d2997c458c690ec2bc6b0b7ecbafd02b029b7b4283078d3b32a852a7ce3ddd98 \ + --hash=sha256:d3f82c171b4ccd83bbaf35aa05e44e690113bd4f3b7b6cc54d2219b132f3ae55 \ + --hash=sha256:dc4926288b2a3e9fd7b50dc6a1909a13bbdadfc67d93f3374d984e56f885579d \ + --hash=sha256:ead20f7913a9c1e894aebe47cccf9dc834e1618b7aa96155d2091a626e59c972 \ + --hash=sha256:ebdc36bea43063116f0486869652cb2ed7032dbc59fbcb4445c4862b5c1ecf7f \ + --hash=sha256:ed1184ab8f113e8d660ce49a56390ca181f2981066acc27cf637d5c1e10ce46e \ + --hash=sha256:ee825e70b1a209475622f7f7b776785bd68f34af6e7a46e2e42f27b659b5bc26 \ + --hash=sha256:f7ae5d65ccfbebdfa761585228eb4d0df3a8b15cfb53bd953e713e09fbb12957 \ + --hash=sha256:f7fc5a5acafb7d6ccca13bfa8c90f8c51f13d8fb87d95656d3950f0158d3ce53 \ + --hash=sha256:f9b5571d33660d5009a8b3c25dc1db560206e2d2f89d3df1cb32d72c0d117d52 +pyarrow==16.1.0 ; python_full_version == "3.9.2" \ + --hash=sha256:06ebccb6f8cb7357de85f60d5da50e83507954af617d7b05f48af1621d331c9a \ + --hash=sha256:0d07de3ee730647a600037bc1d7b7994067ed64d0eba797ac74b2bc77384f4c2 \ + --hash=sha256:0d27bf89dfc2576f6206e9cd6cf7a107c9c06dc13d53bbc25b0bd4556f19cf5f \ + --hash=sha256:0d32000693deff8dc5df444b032b5985a48592c0697cb6e3071a5d59888714e2 \ + --hash=sha256:15fbb22ea96d11f0b5768504a3f961edab25eaf4197c341720c4a387f6c60315 \ + --hash=sha256:17e23b9a65a70cc733d8b738baa6ad3722298fa0c81d88f63ff94bf25eaa77b9 \ + --hash=sha256:185d121b50836379fe012753cf15c4ba9638bda9645183ab36246923875f8d1b \ + --hash=sha256:18da9b76a36a954665ccca8aa6bd9f46c1145f79c0bb8f4f244f5f8e799bca55 \ + --hash=sha256:19741c4dbbbc986d38856ee7ddfdd6a00fc3b0fc2d928795b95410d38bb97d15 \ + --hash=sha256:25233642583bf658f629eb230b9bb79d9af4d9f9229890b3c878699c82f7d11e \ + --hash=sha256:2e51ca1d6ed7f2e9d5c3c83decf27b0d17bb207a7dea986e8dc3e24f80ff7d6f \ + --hash=sha256:2e73cfc4a99e796727919c5541c65bb88b973377501e39b9842ea71401ca6c1c \ + --hash=sha256:31a1851751433d89a986616015841977e0a188662fcffd1a5677453f1df2de0a \ + --hash=sha256:3b20bd67c94b3a2ea0a749d2a5712fc845a69cb5d52e78e6449bbd295611f3aa \ + --hash=sha256:4740cc41e2ba5d641071d0ab5e9ef9b5e6e8c7611351a5cb7c1d175eaf43674a \ + --hash=sha256:48be160782c0556156d91adbdd5a4a7e719f8d407cb46ae3bb4eaee09b3111bd \ + --hash=sha256:8785bb10d5d6fd5e15d718ee1d1f914fe768bf8b4d1e5e9bf253de8a26cb1628 \ + --hash=sha256:98100e0268d04e0eec47b73f20b39c45b4006f3c4233719c3848aa27a03c1aef \ + --hash=sha256:99f7549779b6e434467d2aa43ab2b7224dd9e41bdde486020bae198978c9e05e \ + --hash=sha256:9cf389d444b0f41d9fe1444b70650fea31e9d52cfcb5f818b7888b91b586efff \ + --hash=sha256:a33a64576fddfbec0a44112eaf844c20853647ca833e9a647bfae0582b2ff94b \ + --hash=sha256:a8914cd176f448e09746037b0c6b3a9d7688cef451ec5735094055116857580c \ + --hash=sha256:b04707f1979815f5e49824ce52d1dceb46e2f12909a48a6a753fe7cafbc44a0c \ + --hash=sha256:b5f5705ab977947a43ac83b52ade3b881eb6e95fcc02d76f501d549a210ba77f \ + --hash=sha256:ba8ac20693c0bb0bf4b238751d4409e62852004a8cf031c73b0e0962b03e45e3 \ + --hash=sha256:bf9251264247ecfe93e5f5a0cd43b8ae834f1e61d1abca22da55b20c788417f6 \ + --hash=sha256:d0ebea336b535b37eee9eee31761813086d33ed06de9ab6fc6aaa0bace7b250c \ + --hash=sha256:ddf5aace92d520d3d2a20031d8b0ec27b4395cab9f74e07cc95edf42a5cc0147 \ + --hash=sha256:ddfe389a08ea374972bd4065d5f25d14e36b43ebc22fc75f7b951f24378bf0b5 \ + --hash=sha256:e1369af39587b794873b8a307cc6623a3b1194e69399af0efd05bb202195a5a7 \ + --hash=sha256:e6b6d3cd35fbb93b70ade1336022cc1147b95ec6af7d36906ca7fe432eb09710 \ + --hash=sha256:f07fdffe4fd5b15f5ec15c8b64584868d063bc22b86b46c9695624ca3505b7b4 \ + --hash=sha256:f2c5fb249caa17b94e2b9278b36a05ce03d3180e6da0c4c3b3ce5b2788f30eed \ + --hash=sha256:f68f409e7b283c085f2da014f9ef81e885d90dcd733bd648cfba3ef265961848 \ + --hash=sha256:fbef391b63f708e103df99fbaa3acf9f671d77a183a07546ba2f2c297b361e83 \ + --hash=sha256:febde33305f1498f6df85e8020bca496d0e9ebf2093bab9e0f65e2b4ae2b3444 +pycocoevalcap==1.2 ; python_full_version == "3.9.2" \ + --hash=sha256:083ed7910f1aec000b0a237ef6665f74edf19954204d0b1cbdb8399ed132228d \ + --hash=sha256:7857f4d596ca2fa0b1a9a3c2067588a4257556077b7ad614d00b2b7b8f57cdde +pycocotools==2.0.7 ; python_full_version == "3.9.2" \ + --hash=sha256:0ac4f30bac1503c780072053e6922971392fa3628b2e6967192bfca1f14736e2 \ + --hash=sha256:121017ca87e2eec4e9081636d1a79519b50f473959defc5671c2d1ce0eec482e \ + --hash=sha256:1dbc429018149dc34e206ea32ee6297ff30b55a8615a3f7f4c6e3842f9df73db \ + --hash=sha256:254506c0eecabb3abbde17640f82103c0c04d53148ae920657664cab9cd649fc \ + --hash=sha256:363a6be808125306ace1a163c0b9ba479ee08eceec1fbd3889a88bd8245f73dc \ + --hash=sha256:3e6f7bfa1c5fb206a614bf2382c923d56092219a12dfd0fec3b5f83c13e29e00 \ + --hash=sha256:4a8ec6f439638120e11f49120e1ddb6c66e0b1f293d7884207d02703a73d25a1 \ + --hash=sha256:4d517ec315e53ef8df9f6b0899ebc4c79bd61fd715383861949bb1c3fca2c6d5 \ + --hash=sha256:623b941bbafecbfee574aedbf3cb257f7a879f4fdb79394e6d3fb9c76e7ad6cf \ + --hash=sha256:625388f52e543f6f798f75f1ec125fe519580f22e72ccbd75eee0355ce336e18 \ + --hash=sha256:6469089b9b36a1f645dc9ee830f29d261e99b4b3be73cb260688fd8b6d02760c \ + --hash=sha256:6541340f26bae32e044eedc5d8ccdac5bd0cb64eb2b0a342dac859b696edd0aa \ + --hash=sha256:66864bec8b30d47faa946bb55c8e8d6b7acb9fba0c17ff6aaa37abd78cda962a \ + --hash=sha256:73dc251ae4a06b7c10747ca7e2d29faabb4f13e5fc43760945966845581e79ae \ + --hash=sha256:8def3c46349e919999d6d5a1d6b7e587e6891524cc28f8b4a11e463bf0914621 \ + --hash=sha256:9eb5d46900375adaba88eedb5cbc29d8cbcf43e82505d67378df1c3b720a8c5f \ + --hash=sha256:a6683a002fcb4500edbcec94bdf48be69f578a9aa5c638db38614df1f45cc935 \ + --hash=sha256:b29086b6ce7b73e4ddaf3045006f5c059f344a2720605cd4474814017ff2af53 \ + --hash=sha256:da8b7815196eebf0adabf67fcc459126cbc6498bbc6ab1fd144c371465d86879 \ + --hash=sha256:f1a675728e459d72be6e3bb3546672bb37c7daffdc2e5335aa7b834aece2b560 +pycparser==2.22 ; python_full_version == "3.9.2" \ + --hash=sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6 \ + --hash=sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc +pydeck==0.9.1 ; python_full_version == "3.9.2" \ + --hash=sha256:b3f75ba0d273fc917094fa61224f3f6076ca8752b93d46faf3bcfd9f9d59b038 \ + --hash=sha256:f74475ae637951d63f2ee58326757f8d4f9cd9f2a457cf42950715003e2cb605 +pygments==2.18.0 ; python_full_version == "3.9.2" \ + --hash=sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199 \ + --hash=sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a +pyparsing==3.1.2 ; python_full_version == "3.9.2" \ + --hash=sha256:a1bac0ce561155ecc3ed78ca94d3c9378656ad4c94c1270de543f621420f94ad \ + --hash=sha256:f9db75911801ed778fe61bb643079ff86601aca99fcae6345aa67292038fb742 +python-dateutil==2.9.0.post0 ; python_full_version == "3.9.2" \ + --hash=sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3 \ + --hash=sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427 +pytorch-lightning==1.2.10 ; python_full_version == "3.9.2" \ + --hash=sha256:2d8365e30ded0c20e73ce6e5b6028478ae460b8fd33727df2275666df005a301 \ + --hash=sha256:52d05dda39e6ddd7ab6775c4ca8943e7881000acd9c9218c7e3c9feae43489b2 +pytorch-nlp==0.5.0 ; python_full_version == "3.9.2" \ + --hash=sha256:aba7aecbc6f0952edde8bc067394c8d43b74a35c5949d6106666d01a64d9cfab \ + --hash=sha256:ddce6448819d1518d2694622573caff268a20c19832f55f7f5b672e2a64a400f +pytz==2024.1 ; python_full_version == "3.9.2" \ + --hash=sha256:2a29735ea9c18baf14b448846bde5a48030ed267578472d8955cd0e7443a9812 \ + --hash=sha256:328171f4e3623139da4983451950b28e95ac706e13f3f2630a879749e7a8b319 +pywin32==306 ; platform_system == "Windows" and python_full_version == "3.9.2" \ + --hash=sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d \ + --hash=sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65 \ + --hash=sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e \ + --hash=sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b \ + --hash=sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4 \ + --hash=sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040 \ + --hash=sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a \ + --hash=sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36 \ + --hash=sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8 \ + --hash=sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e \ + --hash=sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802 \ + --hash=sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a \ + --hash=sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407 \ + --hash=sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0 +pyyaml==5.3.1 ; python_full_version == "3.9.2" \ + --hash=sha256:06a0d7ba600ce0b2d2fe2e78453a470b5a6e000a985dd4a4e54e436cc36b0e97 \ + --hash=sha256:240097ff019d7c70a4922b6869d8a86407758333f02203e0fc6ff79c5dcede76 \ + --hash=sha256:4f4b913ca1a7319b33cfb1369e91e50354d6f07a135f3b901aca02aa95940bd2 \ + --hash=sha256:6034f55dab5fea9e53f436aa68fa3ace2634918e8b5994d82f3621c04ff5ed2e \ + --hash=sha256:69f00dca373f240f842b2931fb2c7e14ddbacd1397d57157a9b005a6a9942648 \ + --hash=sha256:73f099454b799e05e5ab51423c7bcf361c58d3206fa7b0d555426b1f4d9a3eaf \ + --hash=sha256:74809a57b329d6cc0fdccee6318f44b9b8649961fa73144a98735b0aaf029f1f \ + --hash=sha256:7739fc0fa8205b3ee8808aea45e968bc90082c10aef6ea95e855e10abf4a37b2 \ + --hash=sha256:95f71d2af0ff4227885f7a6605c37fd53d3a106fcab511b8860ecca9fcf400ee \ + --hash=sha256:ad9c67312c84def58f3c04504727ca879cb0013b2517c85a9a253f0cb6380c0a \ + --hash=sha256:b8eac752c5e14d3eca0e6dd9199cd627518cb5ec06add0de9d32baeee6fe645d \ + --hash=sha256:cc8955cfbfc7a115fa81d85284ee61147059a753344bc51098f3ccd69b0d7e0c \ + --hash=sha256:d13155f591e6fcc1ec3b30685d50bf0711574e2c0dfffd7644babf8b5102ca1a +referencing==0.35.1 ; python_full_version == "3.9.2" \ + --hash=sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c \ + --hash=sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de +regex==2023.12.25 ; python_full_version == "3.9.2" \ + --hash=sha256:0694219a1d54336fd0445ea382d49d36882415c0134ee1e8332afd1529f0baa5 \ + --hash=sha256:086dd15e9435b393ae06f96ab69ab2d333f5d65cbe65ca5a3ef0ec9564dfe770 \ + --hash=sha256:094ba386bb5c01e54e14434d4caabf6583334090865b23ef58e0424a6286d3dc \ + --hash=sha256:09da66917262d9481c719599116c7dc0c321ffcec4b1f510c4f8a066f8768105 \ + --hash=sha256:0ecf44ddf9171cd7566ef1768047f6e66975788258b1c6c6ca78098b95cf9a3d \ + --hash=sha256:0fda75704357805eb953a3ee15a2b240694a9a514548cd49b3c5124b4e2ad01b \ + --hash=sha256:11a963f8e25ab5c61348d090bf1b07f1953929c13bd2309a0662e9ff680763c9 \ + --hash=sha256:150c39f5b964e4d7dba46a7962a088fbc91f06e606f023ce57bb347a3b2d4630 \ + --hash=sha256:1b9d811f72210fa9306aeb88385b8f8bcef0dfbf3873410413c00aa94c56c2b6 \ + --hash=sha256:1e0eabac536b4cc7f57a5f3d095bfa557860ab912f25965e08fe1545e2ed8b4c \ + --hash=sha256:22a86d9fff2009302c440b9d799ef2fe322416d2d58fc124b926aa89365ec482 \ + --hash=sha256:22f3470f7524b6da61e2020672df2f3063676aff444db1daa283c2ea4ed259d6 \ + --hash=sha256:263ef5cc10979837f243950637fffb06e8daed7f1ac1e39d5910fd29929e489a \ + --hash=sha256:283fc8eed679758de38fe493b7d7d84a198b558942b03f017b1f94dda8efae80 \ + --hash=sha256:29171aa128da69afdf4bde412d5bedc335f2ca8fcfe4489038577d05f16181e5 \ + --hash=sha256:298dc6354d414bc921581be85695d18912bea163a8b23cac9a2562bbcd5088b1 \ + --hash=sha256:2aae8101919e8aa05ecfe6322b278f41ce2994c4a430303c4cd163fef746e04f \ + --hash=sha256:2f4e475a80ecbd15896a976aa0b386c5525d0ed34d5c600b6d3ebac0a67c7ddf \ + --hash=sha256:34e4af5b27232f68042aa40a91c3b9bb4da0eeb31b7632e0091afc4310afe6cb \ + --hash=sha256:37f8e93a81fc5e5bd8db7e10e62dc64261bcd88f8d7e6640aaebe9bc180d9ce2 \ + --hash=sha256:3a17d3ede18f9cedcbe23d2daa8a2cd6f59fe2bf082c567e43083bba3fb00347 \ + --hash=sha256:3b1de218d5375cd6ac4b5493e0b9f3df2be331e86520f23382f216c137913d20 \ + --hash=sha256:43f7cd5754d02a56ae4ebb91b33461dc67be8e3e0153f593c509e21d219c5060 \ + --hash=sha256:4558410b7a5607a645e9804a3e9dd509af12fb72b9825b13791a37cd417d73a5 \ + --hash=sha256:4719bb05094d7d8563a450cf8738d2e1061420f79cfcc1fa7f0a44744c4d8f73 \ + --hash=sha256:4bfc2b16e3ba8850e0e262467275dd4d62f0d045e0e9eda2bc65078c0110a11f \ + --hash=sha256:518440c991f514331f4850a63560321f833979d145d7d81186dbe2f19e27ae3d \ + --hash=sha256:51f4b32f793812714fd5307222a7f77e739b9bc566dc94a18126aba3b92b98a3 \ + --hash=sha256:531ac6cf22b53e0696f8e1d56ce2396311254eb806111ddd3922c9d937151dae \ + --hash=sha256:5cd05d0f57846d8ba4b71d9c00f6f37d6b97d5e5ef8b3c3840426a475c8f70f4 \ + --hash=sha256:5dd58946bce44b53b06d94aa95560d0b243eb2fe64227cba50017a8d8b3cd3e2 \ + --hash=sha256:60080bb3d8617d96f0fb7e19796384cc2467447ef1c491694850ebd3670bc457 \ + --hash=sha256:636ba0a77de609d6510235b7f0e77ec494d2657108f777e8765efc060094c98c \ + --hash=sha256:67d3ccfc590e5e7197750fcb3a2915b416a53e2de847a728cfa60141054123d4 \ + --hash=sha256:68191f80a9bad283432385961d9efe09d783bcd36ed35a60fb1ff3f1ec2efe87 \ + --hash=sha256:7502534e55c7c36c0978c91ba6f61703faf7ce733715ca48f499d3dbbd7657e0 \ + --hash=sha256:7aa47c2e9ea33a4a2a05f40fcd3ea36d73853a2aae7b4feab6fc85f8bf2c9704 \ + --hash=sha256:7d2af3f6b8419661a0c421584cfe8aaec1c0e435ce7e47ee2a97e344b98f794f \ + --hash=sha256:7e316026cc1095f2a3e8cc012822c99f413b702eaa2ca5408a513609488cb62f \ + --hash=sha256:88ad44e220e22b63b0f8f81f007e8abbb92874d8ced66f32571ef8beb0643b2b \ + --hash=sha256:88d1f7bef20c721359d8675f7d9f8e414ec5003d8f642fdfd8087777ff7f94b5 \ + --hash=sha256:89723d2112697feaa320c9d351e5f5e7b841e83f8b143dba8e2d2b5f04e10923 \ + --hash=sha256:8a0ccf52bb37d1a700375a6b395bff5dd15c50acb745f7db30415bae3c2b0715 \ + --hash=sha256:8c2c19dae8a3eb0ea45a8448356ed561be843b13cbc34b840922ddf565498c1c \ + --hash=sha256:905466ad1702ed4acfd67a902af50b8db1feeb9781436372261808df7a2a7bca \ + --hash=sha256:9852b76ab558e45b20bf1893b59af64a28bd3820b0c2efc80e0a70a4a3ea51c1 \ + --hash=sha256:98a2636994f943b871786c9e82bfe7883ecdaba2ef5df54e1450fa9869d1f756 \ + --hash=sha256:9aa1a67bbf0f957bbe096375887b2505f5d8ae16bf04488e8b0f334c36e31360 \ + --hash=sha256:9eda5f7a50141291beda3edd00abc2d4a5b16c29c92daf8d5bd76934150f3edc \ + --hash=sha256:a6d1047952c0b8104a1d371f88f4ab62e6275567d4458c1e26e9627ad489b445 \ + --hash=sha256:a9b6d73353f777630626f403b0652055ebfe8ff142a44ec2cf18ae470395766e \ + --hash=sha256:a9cc99d6946d750eb75827cb53c4371b8b0fe89c733a94b1573c9dd16ea6c9e4 \ + --hash=sha256:ad83e7545b4ab69216cef4cc47e344d19622e28aabec61574b20257c65466d6a \ + --hash=sha256:b014333bd0217ad3d54c143de9d4b9a3ca1c5a29a6d0d554952ea071cff0f1f8 \ + --hash=sha256:b43523d7bc2abd757119dbfb38af91b5735eea45537ec6ec3a5ec3f9562a1c53 \ + --hash=sha256:b521dcecebc5b978b447f0f69b5b7f3840eac454862270406a39837ffae4e697 \ + --hash=sha256:b77e27b79448e34c2c51c09836033056a0547aa360c45eeeb67803da7b0eedaf \ + --hash=sha256:b7a635871143661feccce3979e1727c4e094f2bdfd3ec4b90dfd4f16f571a87a \ + --hash=sha256:b7fca9205b59c1a3d5031f7e64ed627a1074730a51c2a80e97653e3e9fa0d415 \ + --hash=sha256:ba1b30765a55acf15dce3f364e4928b80858fa8f979ad41f862358939bdd1f2f \ + --hash=sha256:ba99d8077424501b9616b43a2d208095746fb1284fc5ba490139651f971d39d9 \ + --hash=sha256:c25a8ad70e716f96e13a637802813f65d8a6760ef48672aa3502f4c24ea8b400 \ + --hash=sha256:c3c4a78615b7762740531c27cf46e2f388d8d727d0c0c739e72048beb26c8a9d \ + --hash=sha256:c40281f7d70baf6e0db0c2f7472b31609f5bc2748fe7275ea65a0b4601d9b392 \ + --hash=sha256:c7ad32824b7f02bb3c9f80306d405a1d9b7bb89362d68b3c5a9be53836caebdb \ + --hash=sha256:cb3fe77aec8f1995611f966d0c656fdce398317f850d0e6e7aebdfe61f40e1cd \ + --hash=sha256:cc038b2d8b1470364b1888a98fd22d616fba2b6309c5b5f181ad4483e0017861 \ + --hash=sha256:cc37b9aeebab425f11f27e5e9e6cf580be7206c6582a64467a14dda211abc232 \ + --hash=sha256:cc6bb9aa69aacf0f6032c307da718f61a40cf970849e471254e0e91c56ffca95 \ + --hash=sha256:d126361607b33c4eb7b36debc173bf25d7805847346dd4d99b5499e1fef52bc7 \ + --hash=sha256:d15b274f9e15b1a0b7a45d2ac86d1f634d983ca40d6b886721626c47a400bf39 \ + --hash=sha256:d166eafc19f4718df38887b2bbe1467a4f74a9830e8605089ea7a30dd4da8887 \ + --hash=sha256:d498eea3f581fbe1b34b59c697512a8baef88212f92e4c7830fcc1499f5b45a5 \ + --hash=sha256:d6f7e255e5fa94642a0724e35406e6cb7001c09d476ab5fce002f652b36d0c39 \ + --hash=sha256:d78bd484930c1da2b9679290a41cdb25cc127d783768a0369d6b449e72f88beb \ + --hash=sha256:d865984b3f71f6d0af64d0d88f5733521698f6c16f445bb09ce746c92c97c586 \ + --hash=sha256:d902a43085a308cef32c0d3aea962524b725403fd9373dea18110904003bac97 \ + --hash=sha256:d94a1db462d5690ebf6ae86d11c5e420042b9898af5dcf278bd97d6bda065423 \ + --hash=sha256:da695d75ac97cb1cd725adac136d25ca687da4536154cdc2815f576e4da11c69 \ + --hash=sha256:db2a0b1857f18b11e3b0e54ddfefc96af46b0896fb678c85f63fb8c37518b3e7 \ + --hash=sha256:df26481f0c7a3f8739fecb3e81bc9da3fcfae34d6c094563b9d4670b047312e1 \ + --hash=sha256:e14b73607d6231f3cc4622809c196b540a6a44e903bcfad940779c80dffa7be7 \ + --hash=sha256:e2610e9406d3b0073636a3a2e80db05a02f0c3169b5632022b4e81c0364bcda5 \ + --hash=sha256:e692296c4cc2873967771345a876bcfc1c547e8dd695c6b89342488b0ea55cd8 \ + --hash=sha256:e693e233ac92ba83a87024e1d32b5f9ab15ca55ddd916d878146f4e3406b5c91 \ + --hash=sha256:e81469f7d01efed9b53740aedd26085f20d49da65f9c1f41e822a33992cb1590 \ + --hash=sha256:e8c7e08bb566de4faaf11984af13f6bcf6a08f327b13631d41d62592681d24fe \ + --hash=sha256:ed19b3a05ae0c97dd8f75a5d8f21f7723a8c33bbc555da6bbe1f96c470139d3c \ + --hash=sha256:efb2d82f33b2212898f1659fb1c2e9ac30493ac41e4d53123da374c3b5541e64 \ + --hash=sha256:f44dd4d68697559d007462b0a3a1d9acd61d97072b71f6d1968daef26bc744bd \ + --hash=sha256:f72cbae7f6b01591f90814250e636065850c5926751af02bb48da94dfced7baa \ + --hash=sha256:f7bc09bc9c29ebead055bcba136a67378f03d66bf359e87d0f7c759d6d4ffa31 \ + --hash=sha256:ff100b203092af77d1a5a7abe085b3506b7eaaf9abf65b73b7d6905b6cb76988 +requests==2.32.3 ; python_full_version == "3.9.2" \ + --hash=sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760 \ + --hash=sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6 +rich==13.7.1 ; python_full_version == "3.9.2" \ + --hash=sha256:4edbae314f59eb482f54e9e30bf00d33350aaa94f4bfcd4e9e3110e64d0d7222 \ + --hash=sha256:9be308cb1fe2f1f57d67ce99e95af38a1e2bc71ad9813b0e247cf7ffbcc3a432 +rpds-py==0.18.1 ; python_full_version == "3.9.2" \ + --hash=sha256:05f3d615099bd9b13ecf2fc9cf2d839ad3f20239c678f461c753e93755d629ee \ + --hash=sha256:06d218939e1bf2ca50e6b0ec700ffe755e5216a8230ab3e87c059ebb4ea06afc \ + --hash=sha256:07f2139741e5deb2c5154a7b9629bc5aa48c766b643c1a6750d16f865a82c5fc \ + --hash=sha256:08d74b184f9ab6289b87b19fe6a6d1a97fbfea84b8a3e745e87a5de3029bf944 \ + --hash=sha256:0abeee75434e2ee2d142d650d1e54ac1f8b01e6e6abdde8ffd6eeac6e9c38e20 \ + --hash=sha256:154bf5c93d79558b44e5b50cc354aa0459e518e83677791e6adb0b039b7aa6a7 \ + --hash=sha256:17c6d2155e2423f7e79e3bb18151c686d40db42d8645e7977442170c360194d4 \ + --hash=sha256:1805d5901779662d599d0e2e4159d8a82c0b05faa86ef9222bf974572286b2b6 \ + --hash=sha256:19ba472b9606c36716062c023afa2484d1e4220548751bda14f725a7de17b4f6 \ + --hash=sha256:19e515b78c3fc1039dd7da0a33c28c3154458f947f4dc198d3c72db2b6b5dc93 \ + --hash=sha256:1d54f74f40b1f7aaa595a02ff42ef38ca654b1469bef7d52867da474243cc633 \ + --hash=sha256:207c82978115baa1fd8d706d720b4a4d2b0913df1c78c85ba73fe6c5804505f0 \ + --hash=sha256:2625f03b105328729f9450c8badda34d5243231eef6535f80064d57035738360 \ + --hash=sha256:27bba383e8c5231cd559affe169ca0b96ec78d39909ffd817f28b166d7ddd4d8 \ + --hash=sha256:2c3caec4ec5cd1d18e5dd6ae5194d24ed12785212a90b37f5f7f06b8bedd7139 \ + --hash=sha256:2cc7c1a47f3a63282ab0f422d90ddac4aa3034e39fc66a559ab93041e6505da7 \ + --hash=sha256:2fc24a329a717f9e2448f8cd1f960f9dac4e45b6224d60734edeb67499bab03a \ + --hash=sha256:312fe69b4fe1ffbe76520a7676b1e5ac06ddf7826d764cc10265c3b53f96dbe9 \ + --hash=sha256:32b7daaa3e9389db3695964ce8e566e3413b0c43e3394c05e4b243a4cd7bef26 \ + --hash=sha256:338dee44b0cef8b70fd2ef54b4e09bb1b97fc6c3a58fea5db6cc083fd9fc2724 \ + --hash=sha256:352a88dc7892f1da66b6027af06a2e7e5d53fe05924cc2cfc56495b586a10b72 \ + --hash=sha256:35b2b771b13eee8729a5049c976197ff58a27a3829c018a04341bcf1ae409b2b \ + --hash=sha256:38e14fb4e370885c4ecd734f093a2225ee52dc384b86fa55fe3f74638b2cfb09 \ + --hash=sha256:3c20f05e8e3d4fc76875fc9cb8cf24b90a63f5a1b4c5b9273f0e8225e169b100 \ + --hash=sha256:3dd3cd86e1db5aadd334e011eba4e29d37a104b403e8ca24dcd6703c68ca55b3 \ + --hash=sha256:489bdfe1abd0406eba6b3bb4fdc87c7fa40f1031de073d0cfb744634cc8fa261 \ + --hash=sha256:48c2faaa8adfacefcbfdb5f2e2e7bdad081e5ace8d182e5f4ade971f128e6bb3 \ + --hash=sha256:4a98a1f0552b5f227a3d6422dbd61bc6f30db170939bd87ed14f3c339aa6c7c9 \ + --hash=sha256:4adec039b8e2928983f885c53b7cc4cda8965b62b6596501a0308d2703f8af1b \ + --hash=sha256:4e0ee01ad8260184db21468a6e1c37afa0529acc12c3a697ee498d3c2c4dcaf3 \ + --hash=sha256:51584acc5916212e1bf45edd17f3a6b05fe0cbb40482d25e619f824dccb679de \ + --hash=sha256:531796fb842b53f2695e94dc338929e9f9dbf473b64710c28af5a160b2a8927d \ + --hash=sha256:5463c47c08630007dc0fe99fb480ea4f34a89712410592380425a9b4e1611d8e \ + --hash=sha256:5c45a639e93a0c5d4b788b2613bd637468edd62f8f95ebc6fcc303d58ab3f0a8 \ + --hash=sha256:6031b25fb1b06327b43d841f33842b383beba399884f8228a6bb3df3088485ff \ + --hash=sha256:607345bd5912aacc0c5a63d45a1f73fef29e697884f7e861094e443187c02be5 \ + --hash=sha256:618916f5535784960f3ecf8111581f4ad31d347c3de66d02e728de460a46303c \ + --hash=sha256:636a15acc588f70fda1661234761f9ed9ad79ebed3f2125d44be0862708b666e \ + --hash=sha256:673fdbbf668dd958eff750e500495ef3f611e2ecc209464f661bc82e9838991e \ + --hash=sha256:6afd80f6c79893cfc0574956f78a0add8c76e3696f2d6a15bca2c66c415cf2d4 \ + --hash=sha256:6b5ff7e1d63a8281654b5e2896d7f08799378e594f09cf3674e832ecaf396ce8 \ + --hash=sha256:6c4c4c3f878df21faf5fac86eda32671c27889e13570645a9eea0a1abdd50922 \ + --hash=sha256:6cd8098517c64a85e790657e7b1e509b9fe07487fd358e19431cb120f7d96338 \ + --hash=sha256:6d1e42d2735d437e7e80bab4d78eb2e459af48c0a46e686ea35f690b93db792d \ + --hash=sha256:6e30ac5e329098903262dc5bdd7e2086e0256aa762cc8b744f9e7bf2a427d3f8 \ + --hash=sha256:70a838f7754483bcdc830444952fd89645569e7452e3226de4a613a4c1793fb2 \ + --hash=sha256:720edcb916df872d80f80a1cc5ea9058300b97721efda8651efcd938a9c70a72 \ + --hash=sha256:732672fbc449bab754e0b15356c077cc31566df874964d4801ab14f71951ea80 \ + --hash=sha256:740884bc62a5e2bbb31e584f5d23b32320fd75d79f916f15a788d527a5e83644 \ + --hash=sha256:7700936ef9d006b7ef605dc53aa364da2de5a3aa65516a1f3ce73bf82ecfc7ae \ + --hash=sha256:7732770412bab81c5a9f6d20aeb60ae943a9b36dcd990d876a773526468e7163 \ + --hash=sha256:7750569d9526199c5b97e5a9f8d96a13300950d910cf04a861d96f4273d5b104 \ + --hash=sha256:7f1944ce16401aad1e3f7d312247b3d5de7981f634dc9dfe90da72b87d37887d \ + --hash=sha256:81c5196a790032e0fc2464c0b4ab95f8610f96f1f2fa3d4deacce6a79852da60 \ + --hash=sha256:8352f48d511de5f973e4f2f9412736d7dea76c69faa6d36bcf885b50c758ab9a \ + --hash=sha256:8927638a4d4137a289e41d0fd631551e89fa346d6dbcfc31ad627557d03ceb6d \ + --hash=sha256:8c7672e9fba7425f79019db9945b16e308ed8bc89348c23d955c8c0540da0a07 \ + --hash=sha256:8d2e182c9ee01135e11e9676e9a62dfad791a7a467738f06726872374a83db49 \ + --hash=sha256:910e71711d1055b2768181efa0a17537b2622afeb0424116619817007f8a2b10 \ + --hash=sha256:942695a206a58d2575033ff1e42b12b2aece98d6003c6bc739fbf33d1773b12f \ + --hash=sha256:9437ca26784120a279f3137ee080b0e717012c42921eb07861b412340f85bae2 \ + --hash=sha256:967342e045564cef76dfcf1edb700b1e20838d83b1aa02ab313e6a497cf923b8 \ + --hash=sha256:998125738de0158f088aef3cb264a34251908dd2e5d9966774fdab7402edfab7 \ + --hash=sha256:9e6934d70dc50f9f8ea47081ceafdec09245fd9f6032669c3b45705dea096b88 \ + --hash=sha256:a3d456ff2a6a4d2adcdf3c1c960a36f4fd2fec6e3b4902a42a384d17cf4e7a65 \ + --hash=sha256:a7b28c5b066bca9a4eb4e2f2663012debe680f097979d880657f00e1c30875a0 \ + --hash=sha256:a888e8bdb45916234b99da2d859566f1e8a1d2275a801bb8e4a9644e3c7e7909 \ + --hash=sha256:aa3679e751408d75a0b4d8d26d6647b6d9326f5e35c00a7ccd82b78ef64f65f8 \ + --hash=sha256:aaa71ee43a703c321906813bb252f69524f02aa05bf4eec85f0c41d5d62d0f4c \ + --hash=sha256:b646bf655b135ccf4522ed43d6902af37d3f5dbcf0da66c769a2b3938b9d8184 \ + --hash=sha256:b906b5f58892813e5ba5c6056d6a5ad08f358ba49f046d910ad992196ea61397 \ + --hash=sha256:b9bb1f182a97880f6078283b3505a707057c42bf55d8fca604f70dedfdc0772a \ + --hash=sha256:bd1105b50ede37461c1d51b9698c4f4be6e13e69a908ab7751e3807985fc0346 \ + --hash=sha256:bf18932d0003c8c4d51a39f244231986ab23ee057d235a12b2684ea26a353590 \ + --hash=sha256:c273e795e7a0f1fddd46e1e3cb8be15634c29ae8ff31c196debb620e1edb9333 \ + --hash=sha256:c69882964516dc143083d3795cb508e806b09fc3800fd0d4cddc1df6c36e76bb \ + --hash=sha256:c827576e2fa017a081346dce87d532a5310241648eb3700af9a571a6e9fc7e74 \ + --hash=sha256:cbfbea39ba64f5e53ae2915de36f130588bba71245b418060ec3330ebf85678e \ + --hash=sha256:ce0bb20e3a11bd04461324a6a798af34d503f8d6f1aa3d2aa8901ceaf039176d \ + --hash=sha256:d0cee71bc618cd93716f3c1bf56653740d2d13ddbd47673efa8bf41435a60daa \ + --hash=sha256:d21be4770ff4e08698e1e8e0bce06edb6ea0626e7c8f560bc08222880aca6a6f \ + --hash=sha256:d31dea506d718693b6b2cffc0648a8929bdc51c70a311b2770f09611caa10d53 \ + --hash=sha256:d44607f98caa2961bab4fa3c4309724b185b464cdc3ba6f3d7340bac3ec97cc1 \ + --hash=sha256:d58ad6317d188c43750cb76e9deacf6051d0f884d87dc6518e0280438648a9ac \ + --hash=sha256:d70129cef4a8d979caa37e7fe957202e7eee8ea02c5e16455bc9808a59c6b2f0 \ + --hash=sha256:d85164315bd68c0806768dc6bb0429c6f95c354f87485ee3593c4f6b14def2bd \ + --hash=sha256:d960de62227635d2e61068f42a6cb6aae91a7fe00fca0e3aeed17667c8a34611 \ + --hash=sha256:dc48b479d540770c811fbd1eb9ba2bb66951863e448efec2e2c102625328e92f \ + --hash=sha256:e1735502458621921cee039c47318cb90b51d532c2766593be6207eec53e5c4c \ + --hash=sha256:e2be6e9dd4111d5b31ba3b74d17da54a8319d8168890fbaea4b9e5c3de630ae5 \ + --hash=sha256:e4c39ad2f512b4041343ea3c7894339e4ca7839ac38ca83d68a832fc8b3748ab \ + --hash=sha256:ed402d6153c5d519a0faf1bb69898e97fb31613b49da27a84a13935ea9164dfc \ + --hash=sha256:ee17cd26b97d537af8f33635ef38be873073d516fd425e80559f4585a7b90c43 \ + --hash=sha256:f3027be483868c99b4985fda802a57a67fdf30c5d9a50338d9db646d590198da \ + --hash=sha256:f5bab211605d91db0e2995a17b5c6ee5edec1270e46223e513eaa20da20076ac \ + --hash=sha256:f6f8e3fecca256fefc91bb6765a693d96692459d7d4c644660a9fff32e517843 \ + --hash=sha256:f7afbfee1157e0f9376c00bb232e80a60e59ed716e3211a80cb8506550671e6e \ + --hash=sha256:fa242ac1ff583e4ec7771141606aafc92b361cd90a05c30d93e343a0c2d82a89 \ + --hash=sha256:fab6ce90574645a0d6c58890e9bcaac8d94dff54fb51c69e5522a7358b80ab64 +sacrebleu==2.4.2 ; python_full_version == "3.9.2" \ + --hash=sha256:611a581d205828912f0b05f806b110180087184d3be2dc650fda7a729d6ecb89 +safetensors==0.4.3 ; python_full_version == "3.9.2" \ + --hash=sha256:018b691383026a2436a22b648873ed11444a364324e7088b99cd2503dd828400 \ + --hash=sha256:01e4b22e3284cd866edeabe4f4d896229495da457229408d2e1e4810c5187121 \ + --hash=sha256:01feb3089e5932d7e662eda77c3ecc389f97c0883c4a12b5cfdc32b589a811c3 \ + --hash=sha256:02318f01e332cc23ffb4f6716e05a492c5f18b1d13e343c49265149396284a44 \ + --hash=sha256:02ef3a24face643456020536591fbd3c717c5abaa2737ec428ccbbc86dffa7a4 \ + --hash=sha256:03a4447c784917c9bf01d8f2ac5080bc15c41692202cd5f406afba16629e84d6 \ + --hash=sha256:084fc436e317f83f7071fc6a62ca1c513b2103db325cd09952914b50f51cf78f \ + --hash=sha256:0bf4f9d6323d9f86eef5567eabd88f070691cf031d4c0df27a40d3b4aaee755b \ + --hash=sha256:0d52c958dc210265157573f81d34adf54e255bc2b59ded6218500c9b15a750eb \ + --hash=sha256:0d5ffc6a80f715c30af253e0e288ad1cd97a3d0086c9c87995e5093ebc075e50 \ + --hash=sha256:0d9cd8e1560dfc514b6d7859247dc6a86ad2f83151a62c577428d5102d872721 \ + --hash=sha256:0dd37306546b58d3043eb044c8103a02792cc024b51d1dd16bd3dd1f334cb3ed \ + --hash=sha256:1139eb436fd201c133d03c81209d39ac57e129f5e74e34bb9ab60f8d9b726270 \ + --hash=sha256:19bbdf95de2cf64f25cd614c5236c8b06eb2cfa47cbf64311f4b5d80224623a3 \ + --hash=sha256:1ab6527a20586d94291c96e00a668fa03f86189b8a9defa2cdd34a1a01acc7d5 \ + --hash=sha256:1b89381517891a7bb7d1405d828b2bf5d75528299f8231e9346b8eba092227f9 \ + --hash=sha256:1f598b713cc1a4eb31d3b3203557ac308acf21c8f41104cdd74bf640c6e538e3 \ + --hash=sha256:22d21760dc6ebae42e9c058d75aa9907d9f35e38f896e3c69ba0e7b213033856 \ + --hash=sha256:22f3b5d65e440cec0de8edaa672efa888030802e11c09b3d6203bff60ebff05a \ + --hash=sha256:2a0deb16a1d3ea90c244ceb42d2c6c276059616be21a19ac7101aa97da448faf \ + --hash=sha256:2a1f4430cc0c9d6afa01214a4b3919d0a029637df8e09675ceef1ca3f0dfa0df \ + --hash=sha256:2d603846a8585b9432a0fd415db1d4c57c0f860eb4aea21f92559ff9902bae4d \ + --hash=sha256:2f85fc50c4e07a21e95c24e07460fe6f7e2859d0ce88092838352b798ce711c2 \ + --hash=sha256:309b10dbcab63269ecbf0e2ca10ce59223bb756ca5d431ce9c9eeabd446569da \ + --hash=sha256:3615a96dd2dcc30eb66d82bc76cda2565f4f7bfa89fcb0e31ba3cea8a1a9ecbb \ + --hash=sha256:38e2a8666178224a51cca61d3cb4c88704f696eac8f72a49a598a93bbd8a4af9 \ + --hash=sha256:393e6e391467d1b2b829c77e47d726f3b9b93630e6a045b1d1fca67dc78bf632 \ + --hash=sha256:3f9cdca09052f585e62328c1c2923c70f46814715c795be65f0b93f57ec98a02 \ + --hash=sha256:41a727a7f5e6ad9f1db6951adee21bbdadc632363d79dc434876369a17de6ad6 \ + --hash=sha256:420a98f593ff9930f5822560d14c395ccbc57342ddff3b463bc0b3d6b1951550 \ + --hash=sha256:446e9fe52c051aeab12aac63d1017e0f68a02a92a027b901c4f8e931b24e5397 \ + --hash=sha256:455d538aa1aae4a8b279344a08136d3f16334247907b18a5c3c7fa88ef0d3c46 \ + --hash=sha256:4f9bac020faba7f5dc481e881b14b6425265feabb5bfc552551d21189c0eddc3 \ + --hash=sha256:53c4879b9c6bd7cd25d114ee0ef95420e2812e676314300624594940a8d6a91f \ + --hash=sha256:5757e4688f20df083e233b47de43845d1adb7e17b6cf7da5f8444416fc53828d \ + --hash=sha256:585c9ae13a205807b63bef8a37994f30c917ff800ab8a1ca9c9b5d73024f97ee \ + --hash=sha256:5d07cbca5b99babb692d76d8151bec46f461f8ad8daafbfd96b2fca40cadae65 \ + --hash=sha256:5fc6775529fb9f0ce2266edd3e5d3f10aab068e49f765e11f6f2a63b5367021d \ + --hash=sha256:622afd28968ef3e9786562d352659a37de4481a4070f4ebac883f98c5836563e \ + --hash=sha256:6f9568f380f513a60139971169c4a358b8731509cc19112369902eddb33faa4d \ + --hash=sha256:70a5319ef409e7f88686a46607cbc3c428271069d8b770076feaf913664a07ac \ + --hash=sha256:74707624b81f1b7f2b93f5619d4a9f00934d5948005a03f2c1845ffbfff42212 \ + --hash=sha256:7c4fa560ebd4522adddb71dcd25d09bf211b5634003f015a4b815b7647d62ebe \ + --hash=sha256:7de32d0d34b6623bb56ca278f90db081f85fb9c5d327e3c18fd23ac64f465768 \ + --hash=sha256:840b7ac0eff5633e1d053cc9db12fdf56b566e9403b4950b2dc85393d9b88d67 \ + --hash=sha256:840caf38d86aa7014fe37ade5d0d84e23dcfbc798b8078015831996ecbc206a3 \ + --hash=sha256:8651c7299cbd8b4161a36cd6a322fa07d39cd23535b144d02f1c1972d0c62f3c \ + --hash=sha256:868ad1b6fc41209ab6bd12f63923e8baeb1a086814cb2e81a65ed3d497e0cf8f \ + --hash=sha256:88887f69f7a00cf02b954cdc3034ffb383b2303bc0ab481d4716e2da51ddc10e \ + --hash=sha256:89f9f17b0dacb913ed87d57afbc8aad85ea42c1085bd5de2f20d83d13e9fc4b2 \ + --hash=sha256:8c496c5401c1b9c46d41a7688e8ff5b0310a3b9bae31ce0f0ae870e1ea2b8caf \ + --hash=sha256:8cf18888606dad030455d18f6c381720e57fc6a4170ee1966adb7ebc98d4d6a3 \ + --hash=sha256:8d22c1a10dff3f64d0d68abb8298a3fd88ccff79f408a3e15b3e7f637ef5c980 \ + --hash=sha256:90964917f5b0fa0fa07e9a051fbef100250c04d150b7026ccbf87a34a54012e0 \ + --hash=sha256:9bfb92f82574d9e58401d79c70c716985dc049b635fef6eecbb024c79b2c46ad \ + --hash=sha256:9c6ad011c1b4e3acff058d6b090f1da8e55a332fbf84695cf3100c649cc452d1 \ + --hash=sha256:a11c374eb63a9c16c5ed146457241182f310902bd2a9c18255781bb832b6748b \ + --hash=sha256:a7cef55929dcbef24af3eb40bedec35d82c3c2fa46338bb13ecf3c5720af8a61 \ + --hash=sha256:a844cdb5d7cbc22f5f16c7e2a0271170750763c4db08381b7f696dbd2c78a361 \ + --hash=sha256:ae7613a119a71a497d012ccc83775c308b9c1dab454806291427f84397d852fd \ + --hash=sha256:b1648568667f820b8c48317c7006221dc40aced1869908c187f493838a1362bc \ + --hash=sha256:b1e31be7945f66be23f4ec1682bb47faa3df34cb89fc68527de6554d3c4258a4 \ + --hash=sha256:b277482120df46e27a58082df06a15aebda4481e30a1c21eefd0921ae7e03f65 \ + --hash=sha256:b7ffba80aa49bd09195145a7fd233a7781173b422eeb995096f2b30591639517 \ + --hash=sha256:b852e47eb08475c2c1bd8131207b405793bfc20d6f45aff893d3baaad449ed14 \ + --hash=sha256:bb4f8c5d0358a31e9a08daeebb68f5e161cdd4018855426d3f0c23bb51087055 \ + --hash=sha256:bbae3b4b9d997971431c346edbfe6e41e98424a097860ee872721e176040a893 \ + --hash=sha256:befdf0167ad626f22f6aac6163477fcefa342224a22f11fdd05abb3995c1783c \ + --hash=sha256:c0acbe31340ab150423347e5b9cc595867d814244ac14218932a5cf1dd38eb39 \ + --hash=sha256:c41e1893d1206aa7054029681778d9a58b3529d4c807002c156d58426c225173 \ + --hash=sha256:c59d51f182c729f47e841510b70b967b0752039f79f1de23bcdd86462a9b09ee \ + --hash=sha256:cd6fff9e56df398abc5866b19a32124815b656613c1c5ec0f9350906fd798aac \ + --hash=sha256:cdd0a3b5da66e7f377474599814dbf5cbf135ff059cc73694de129b58a5e8a2c \ + --hash=sha256:cf476bca34e1340ee3294ef13e2c625833f83d096cfdf69a5342475602004f95 \ + --hash=sha256:d0dd4a1db09db2dba0f94d15addc7e7cd3a7b0d393aa4c7518c39ae7374623c3 \ + --hash=sha256:d1456f814655b224d4bf6e7915c51ce74e389b413be791203092b7ff78c936dd \ + --hash=sha256:d14d30c25897b2bf19b6fb5ff7e26cc40006ad53fd4a88244fdf26517d852dd7 \ + --hash=sha256:d244bcafeb1bc06d47cfee71727e775bca88a8efda77a13e7306aae3813fa7e4 \ + --hash=sha256:d8815b5e1dac85fc534a97fd339e12404db557878c090f90442247e87c8aeaea \ + --hash=sha256:d88b33980222085dd6001ae2cad87c6068e0991d4f5ccf44975d216db3b57376 \ + --hash=sha256:d8c5093206ef4b198600ae484230402af6713dab1bd5b8e231905d754022bec7 \ + --hash=sha256:d9c289f140a9ae4853fc2236a2ffc9a9f2d5eae0cb673167e0f1b8c18c0961ac \ + --hash=sha256:dcf5705cab159ce0130cd56057f5f3425023c407e170bca60b4868048bae64fd \ + --hash=sha256:e011cc162503c19f4b1fd63dfcddf73739c7a243a17dac09b78e57a00983ab35 \ + --hash=sha256:e066e8861eef6387b7c772344d1fe1f9a72800e04ee9a54239d460c400c72aab \ + --hash=sha256:e0b2104df1579d6ba9052c0ae0e3137c9698b2d85b0645507e6fd1813b70931a \ + --hash=sha256:e375d975159ac534c7161269de24ddcd490df2157b55c1a6eeace6cbb56903f0 \ + --hash=sha256:e4119532cd10dba04b423e0f86aecb96cfa5a602238c0aa012f70c3a40c44b50 \ + --hash=sha256:e7dbbde64b6c534548696808a0e01276d28ea5773bc9a2dfb97a88cd3dffe3df \ + --hash=sha256:e9afd5358719f1b2cf425fad638fc3c887997d6782da317096877e5b15b2ce93 \ + --hash=sha256:ec4b52ce9a396260eb9731eb6aea41a7320de22ed73a1042c2230af0212758ce \ + --hash=sha256:edb5698a7bc282089f64c96c477846950358a46ede85a1c040e0230344fdde10 \ + --hash=sha256:ee463219d9ec6c2be1d331ab13a8e0cd50d2f32240a81d498266d77d07b7e71e \ + --hash=sha256:efcc860be094b8d19ac61b452ec635c7acb9afa77beb218b1d7784c6d41fe8ad \ + --hash=sha256:f5e6883af9a68c0028f70a4c19d5a6ab6238a379be36ad300a22318316c00cb0 \ + --hash=sha256:f9650713b2cfa9537a2baf7dd9fee458b24a0aaaa6cafcea8bdd5fb2b8efdc34 \ + --hash=sha256:faefeb3b81bdfb4e5a55b9bbdf3d8d8753f65506e1d67d03f5c851a6c87150e9 \ + --hash=sha256:fb9c65bd82f9ef3ce4970dc19ee86be5f6f93d032159acf35e663c6bea02b237 \ + --hash=sha256:fe746d03ed8d193674a26105e4f0fe6c726f5bb602ffc695b409eaf02f04763d \ + --hash=sha256:fef5d70683643618244a4f5221053567ca3e77c2531e42ad48ae05fae909f542 +scikit-learn==1.5.0 ; python_full_version == "3.9.2" \ + --hash=sha256:057b991ac64b3e75c9c04b5f9395eaf19a6179244c089afdebaad98264bff37c \ + --hash=sha256:118a8d229a41158c9f90093e46b3737120a165181a1b58c03461447aa4657415 \ + --hash=sha256:12e40ac48555e6b551f0a0a5743cc94cc5a765c9513fe708e01f0aa001da2801 \ + --hash=sha256:174beb56e3e881c90424e21f576fa69c4ffcf5174632a79ab4461c4c960315ac \ + --hash=sha256:1b94d6440603752b27842eda97f6395f570941857456c606eb1d638efdb38184 \ + --hash=sha256:1f77547165c00625551e5c250cefa3f03f2fc92c5e18668abd90bfc4be2e0bff \ + --hash=sha256:261fe334ca48f09ed64b8fae13f9b46cc43ac5f580c4a605cbb0a517456c8f71 \ + --hash=sha256:2a65af2d8a6cce4e163a7951a4cfbfa7fceb2d5c013a4b593686c7f16445cf9d \ + --hash=sha256:2c75ea812cd83b1385bbfa94ae971f0d80adb338a9523f6bbcb5e0b0381151d4 \ + --hash=sha256:40fb7d4a9a2db07e6e0cae4dc7bdbb8fada17043bac24104d8165e10e4cff1a2 \ + --hash=sha256:460806030c666addee1f074788b3978329a5bfdc9b7d63e7aad3f6d45c67a210 \ + --hash=sha256:47132440050b1c5beb95f8ba0b2402bbd9057ce96ec0ba86f2f445dd4f34df67 \ + --hash=sha256:4c0c56c3005f2ec1db3787aeaabefa96256580678cec783986836fc64f8ff622 \ + --hash=sha256:789e3db01c750ed6d496fa2db7d50637857b451e57bcae863bff707c1247bef7 \ + --hash=sha256:855fc5fa8ed9e4f08291203af3d3e5fbdc4737bd617a371559aaa2088166046e \ + --hash=sha256:a03b09f9f7f09ffe8c5efffe2e9de1196c696d811be6798ad5eddf323c6f4d40 \ + --hash=sha256:a3a10e1d9e834e84d05e468ec501a356226338778769317ee0b84043c0d8fb06 \ + --hash=sha256:a90c5da84829a0b9b4bf00daf62754b2be741e66b5946911f5bdfaa869fcedd6 \ + --hash=sha256:d82c2e573f0f2f2f0be897e7a31fcf4e73869247738ab8c3ce7245549af58ab8 \ + --hash=sha256:df8ccabbf583315f13160a4bb06037bde99ea7d8211a69787a6b7c5d4ebb6fc3 \ + --hash=sha256:f405c4dae288f5f6553b10c4ac9ea7754d5180ec11e296464adb5d6ac68b6ef5 +scipy==1.13.1 ; python_full_version == "3.9.2" \ + --hash=sha256:017367484ce5498445aade74b1d5ab377acdc65e27095155e448c88497755a5d \ + --hash=sha256:095a87a0312b08dfd6a6155cbbd310a8c51800fc931b8c0b84003014b874ed3c \ + --hash=sha256:20335853b85e9a49ff7572ab453794298bcf0354d8068c5f6775a0eabf350aca \ + --hash=sha256:27e52b09c0d3a1d5b63e1105f24177e544a222b43611aaf5bc44d4a0979e32f9 \ + --hash=sha256:2831f0dc9c5ea9edd6e51e6e769b655f08ec6db6e2e10f86ef39bd32eb11da54 \ + --hash=sha256:2ac65fb503dad64218c228e2dc2d0a0193f7904747db43014645ae139c8fad16 \ + --hash=sha256:392e4ec766654852c25ebad4f64e4e584cf19820b980bc04960bca0b0cd6eaa2 \ + --hash=sha256:436bbb42a94a8aeef855d755ce5a465479c721e9d684de76bf61a62e7c2b81d5 \ + --hash=sha256:45484bee6d65633752c490404513b9ef02475b4284c4cfab0ef946def50b3f59 \ + --hash=sha256:54f430b00f0133e2224c3ba42b805bfd0086fe488835effa33fa291561932326 \ + --hash=sha256:5713f62f781eebd8d597eb3f88b8bf9274e79eeabf63afb4a737abc6c84ad37b \ + --hash=sha256:5d72782f39716b2b3509cd7c33cdc08c96f2f4d2b06d51e52fb45a19ca0c86a1 \ + --hash=sha256:637e98dcf185ba7f8e663e122ebf908c4702420477ae52a04f9908707456ba4d \ + --hash=sha256:8335549ebbca860c52bf3d02f80784e91a004b71b059e3eea9678ba994796a24 \ + --hash=sha256:949ae67db5fa78a86e8fa644b9a6b07252f449dcf74247108c50e1d20d2b4627 \ + --hash=sha256:a014c2b3697bde71724244f63de2476925596c24285c7a637364761f8710891c \ + --hash=sha256:a78b4b3345f1b6f68a763c6e25c0c9a23a9fd0f39f5f3d200efe8feda560a5fa \ + --hash=sha256:cdd7dacfb95fea358916410ec61bbc20440f7860333aee6d882bb8046264e949 \ + --hash=sha256:cfa31f1def5c819b19ecc3a8b52d28ffdcc7ed52bb20c9a7589669dd3c250989 \ + --hash=sha256:d533654b7d221a6a97304ab63c41c96473ff04459e404b83275b60aa8f4b7004 \ + --hash=sha256:d605e9c23906d1994f55ace80e0125c587f96c020037ea6aa98d01b4bd2e222f \ + --hash=sha256:de3ade0e53bc1f21358aa74ff4830235d716211d7d077e340c7349bc3542e884 \ + --hash=sha256:e89369d27f9e7b0884ae559a3a956e77c02114cc60a6058b4e5011572eea9299 \ + --hash=sha256:eccfa1906eacc02de42d70ef4aecea45415f5be17e72b61bafcfd329bdc52e94 \ + --hash=sha256:f26264b282b9da0952a024ae34710c2aff7d27480ee91a2e82b7b7073c24722f +sentry-sdk==2.5.1 ; python_full_version == "3.9.2" \ + --hash=sha256:1f87acdce4a43a523ae5aa21a3fc37522d73ebd9ec04b1dbf01aa3d173852def \ + --hash=sha256:fbc40a78a8a9c6675133031116144f0d0940376fa6e4e1acd5624c90b0aaf58b +setproctitle==1.3.3 ; python_full_version == "3.9.2" \ + --hash=sha256:00e6e7adff74796ef12753ff399491b8827f84f6c77659d71bd0b35870a17d8f \ + --hash=sha256:059f4ce86f8cc92e5860abfc43a1dceb21137b26a02373618d88f6b4b86ba9b2 \ + --hash=sha256:088b9efc62d5aa5d6edf6cba1cf0c81f4488b5ce1c0342a8b67ae39d64001120 \ + --hash=sha256:0d3a953c50776751e80fe755a380a64cb14d61e8762bd43041ab3f8cc436092f \ + --hash=sha256:1342f4fdb37f89d3e3c1c0a59d6ddbedbde838fff5c51178a7982993d238fe4f \ + --hash=sha256:184239903bbc6b813b1a8fc86394dc6ca7d20e2ebe6f69f716bec301e4b0199d \ + --hash=sha256:195c961f54a09eb2acabbfc90c413955cf16c6e2f8caa2adbf2237d1019c7dd8 \ + --hash=sha256:1f5d9027eeda64d353cf21a3ceb74bb1760bd534526c9214e19f052424b37e42 \ + --hash=sha256:200620c3b15388d7f3f97e0ae26599c0c378fdf07ae9ac5a13616e933cbd2086 \ + --hash=sha256:200ede6fd11233085ba9b764eb055a2a191fb4ffb950c68675ac53c874c22e20 \ + --hash=sha256:21112fcd2195d48f25760f0eafa7a76510871bbb3b750219310cf88b04456ae3 \ + --hash=sha256:224602f0939e6fb9d5dd881be1229d485f3257b540f8a900d4271a2c2aa4e5f4 \ + --hash=sha256:287490eb90e7a0ddd22e74c89a92cc922389daa95babc833c08cf80c84c4df0a \ + --hash=sha256:2982efe7640c4835f7355fdb4da313ad37fb3b40f5c69069912f8048f77b28c8 \ + --hash=sha256:2df2b67e4b1d7498632e18c56722851ba4db5d6a0c91aaf0fd395111e51cdcf4 \ + --hash=sha256:2e4a8104db15d3462e29d9946f26bed817a5b1d7a47eabca2d9dc2b995991503 \ + --hash=sha256:2e71f6365744bf53714e8bd2522b3c9c1d83f52ffa6324bd7cbb4da707312cd8 \ + --hash=sha256:334f7ed39895d692f753a443102dd5fed180c571eb6a48b2a5b7f5b3564908c8 \ + --hash=sha256:33c5609ad51cd99d388e55651b19148ea99727516132fb44680e1f28dd0d1de9 \ + --hash=sha256:37a62cbe16d4c6294e84670b59cf7adcc73faafe6af07f8cb9adaf1f0e775b19 \ + --hash=sha256:38ae9a02766dad331deb06855fb7a6ca15daea333b3967e214de12cfae8f0ef5 \ + --hash=sha256:38da436a0aaace9add67b999eb6abe4b84397edf4a78ec28f264e5b4c9d53cd5 \ + --hash=sha256:415bfcfd01d1fbf5cbd75004599ef167a533395955305f42220a585f64036081 \ + --hash=sha256:417de6b2e214e837827067048f61841f5d7fc27926f2e43954567094051aff18 \ + --hash=sha256:477d3da48e216d7fc04bddab67b0dcde633e19f484a146fd2a34bb0e9dbb4a1e \ + --hash=sha256:4a6ba2494a6449b1f477bd3e67935c2b7b0274f2f6dcd0f7c6aceae10c6c6ba3 \ + --hash=sha256:4fe1c49486109f72d502f8be569972e27f385fe632bd8895f4730df3c87d5ac8 \ + --hash=sha256:507e8dc2891021350eaea40a44ddd887c9f006e6b599af8d64a505c0f718f170 \ + --hash=sha256:53bc0d2358507596c22b02db079618451f3bd720755d88e3cccd840bafb4c41c \ + --hash=sha256:554eae5a5b28f02705b83a230e9d163d645c9a08914c0ad921df363a07cf39b1 \ + --hash=sha256:59335d000c6250c35989394661eb6287187854e94ac79ea22315469ee4f4c244 \ + --hash=sha256:5a740f05d0968a5a17da3d676ce6afefebeeeb5ce137510901bf6306ba8ee002 \ + --hash=sha256:5bc94cf128676e8fac6503b37763adb378e2b6be1249d207630f83fc325d9b11 \ + --hash=sha256:64286f8a995f2cd934082b398fc63fca7d5ffe31f0e27e75b3ca6b4efda4e353 \ + --hash=sha256:664698ae0013f986118064b6676d7dcd28fefd0d7d5a5ae9497cbc10cba48fa5 \ + --hash=sha256:68f960bc22d8d8e4ac886d1e2e21ccbd283adcf3c43136161c1ba0fa509088e0 \ + --hash=sha256:69d565d20efe527bd8a9b92e7f299ae5e73b6c0470f3719bd66f3cd821e0d5bd \ + --hash=sha256:6a143b31d758296dc2f440175f6c8e0b5301ced3b0f477b84ca43cdcf7f2f476 \ + --hash=sha256:6a249415f5bb88b5e9e8c4db47f609e0bf0e20a75e8d744ea787f3092ba1f2d0 \ + --hash=sha256:6b9e62ddb3db4b5205c0321dd69a406d8af9ee1693529d144e86bd43bcb4b6c0 \ + --hash=sha256:7f1d36a1e15a46e8ede4e953abb104fdbc0845a266ec0e99cc0492a4364f8c44 \ + --hash=sha256:816330675e3504ae4d9a2185c46b573105d2310c20b19ea2b4596a9460a4f674 \ + --hash=sha256:87e668f9561fd3a457ba189edfc9e37709261287b52293c115ae3487a24b92f6 \ + --hash=sha256:897a73208da48db41e687225f355ce993167079eda1260ba5e13c4e53be7f754 \ + --hash=sha256:8c331e91a14ba4076f88c29c777ad6b58639530ed5b24b5564b5ed2fd7a95452 \ + --hash=sha256:950f6476d56ff7817a8fed4ab207727fc5260af83481b2a4b125f32844df513a \ + --hash=sha256:9617b676b95adb412bb69645d5b077d664b6882bb0d37bfdafbbb1b999568d85 \ + --hash=sha256:9e3b99b338598de0bd6b2643bf8c343cf5ff70db3627af3ca427a5e1a1a90dd9 \ + --hash=sha256:a1fcac43918b836ace25f69b1dca8c9395253ad8152b625064415b1d2f9be4fb \ + --hash=sha256:a680d62c399fa4b44899094027ec9a1bdaf6f31c650e44183b50d4c4d0ccc085 \ + --hash=sha256:a6d50252377db62d6a0bb82cc898089916457f2db2041e1d03ce7fadd4a07381 \ + --hash=sha256:a83ca086fbb017f0d87f240a8f9bbcf0809f3b754ee01cec928fff926542c450 \ + --hash=sha256:a911b26264dbe9e8066c7531c0591cfab27b464459c74385b276fe487ca91c12 \ + --hash=sha256:ab2900d111e93aff5df9fddc64cf51ca4ef2c9f98702ce26524f1acc5a786ae7 \ + --hash=sha256:ab92e51cd4a218208efee4c6d37db7368fdf182f6e7ff148fb295ecddf264287 \ + --hash=sha256:accb66d7b3ccb00d5cd11d8c6e07055a4568a24c95cf86109894dcc0c134cc89 \ + --hash=sha256:ad6d20f9541f5f6ac63df553b6d7a04f313947f550eab6a61aa758b45f0d5657 \ + --hash=sha256:aeaa71fb9568ebe9b911ddb490c644fbd2006e8c940f21cb9a1e9425bd709574 \ + --hash=sha256:af2c67ae4c795d1674a8d3ac1988676fa306bcfa1e23fddb5e0bd5f5635309ca \ + --hash=sha256:af4061f67fd7ec01624c5e3c21f6b7af2ef0e6bab7fbb43f209e6506c9ce0092 \ + --hash=sha256:b1067647ac7aba0b44b591936118a22847bda3c507b0a42d74272256a7a798e9 \ + --hash=sha256:b5901a31012a40ec913265b64e48c2a4059278d9f4e6be628441482dd13fb8b5 \ + --hash=sha256:bbbd6c7de0771c84b4aa30e70b409565eb1fc13627a723ca6be774ed6b9d9fa3 \ + --hash=sha256:bdfd7254745bb737ca1384dee57e6523651892f0ea2a7344490e9caefcc35e64 \ + --hash=sha256:c05ac48ef16ee013b8a326c63e4610e2430dbec037ec5c5b58fcced550382b74 \ + --hash=sha256:c1c84beab776b0becaa368254801e57692ed749d935469ac10e2b9b825dbdd8e \ + --hash=sha256:c32c41ace41f344d317399efff4cffb133e709cec2ef09c99e7a13e9f3b9483c \ + --hash=sha256:c3ba57029c9c50ecaf0c92bb127224cc2ea9fda057b5d99d3f348c9ec2855ad3 \ + --hash=sha256:c7951820b77abe03d88b114b998867c0f99da03859e5ab2623d94690848d3e45 \ + --hash=sha256:c913e151e7ea01567837ff037a23ca8740192880198b7fbb90b16d181607caae \ + --hash=sha256:c9a402881ec269d0cc9c354b149fc29f9ec1a1939a777f1c858cdb09c7a261df \ + --hash=sha256:cbf16381c7bf7f963b58fb4daaa65684e10966ee14d26f5cc90f07049bfd8c1e \ + --hash=sha256:d4460795a8a7a391e3567b902ec5bdf6c60a47d791c3b1d27080fc203d11c9dc \ + --hash=sha256:d7f27e0268af2d7503386e0e6be87fb9b6657afd96f5726b733837121146750d \ + --hash=sha256:d876d355c53d975c2ef9c4f2487c8f83dad6aeaaee1b6571453cb0ee992f55f6 \ + --hash=sha256:da0d57edd4c95bf221b2ebbaa061e65b1788f1544977288bdf95831b6e44e44d \ + --hash=sha256:ddedd300cd690a3b06e7eac90ed4452348b1348635777ce23d460d913b5b63c3 \ + --hash=sha256:df3f4274b80709d8bcab2f9a862973d453b308b97a0b423a501bcd93582852e3 \ + --hash=sha256:e18b7bd0898398cc97ce2dfc83bb192a13a087ef6b2d5a8a36460311cb09e775 \ + --hash=sha256:e5119a211c2e98ff18b9908ba62a3bd0e3fabb02a29277a7232a6fb4b2560aa0 \ + --hash=sha256:e5e08e232b78ba3ac6bc0d23ce9e2bee8fad2be391b7e2da834fc9a45129eb87 \ + --hash=sha256:eae8988e78192fd1a3245a6f4f382390b61bce6cfcc93f3809726e4c885fa68d \ + --hash=sha256:f05e66746bf9fe6a3397ec246fe481096664a9c97eb3fea6004735a4daf867fd \ + --hash=sha256:f1da82c3e11284da4fcbf54957dafbf0655d2389cd3d54e4eaba636faf6d117a \ + --hash=sha256:f38d48abc121263f3b62943f84cbaede05749047e428409c2c199664feb6abc7 \ + --hash=sha256:f5e7266498cd31a4572378c61920af9f6b4676a73c299fce8ba93afd694f8ae7 \ + --hash=sha256:fc74e84fdfa96821580fb5e9c0b0777c1c4779434ce16d3d62a9c4d8c710df39 \ + --hash=sha256:ff814dea1e5c492a4980e3e7d094286077054e7ea116cbeda138819db194b2cd +setuptools==69.5.1 ; python_full_version == "3.9.2" \ + --hash=sha256:6c1fccdac05a97e598fb0ae3bbed5904ccb317337a51139dcd51453611bbb987 \ + --hash=sha256:c636ac361bc47580504644275c9ad802c50415c7522212252c033bd15f301f32 +six==1.16.0 ; python_full_version == "3.9.2" \ + --hash=sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926 \ + --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254 +smmap==5.0.1 ; python_full_version == "3.9.2" \ + --hash=sha256:dceeb6c0028fdb6734471eb07c0cd2aae706ccaecab45965ee83f11c8d3b1f62 \ + --hash=sha256:e6d8668fa5f93e706934a62d7b4db19c8d9eb8cf2adbb75ef1b675aa332b69da +streamlit==1.35.0 ; python_full_version == "3.9.2" \ + --hash=sha256:679d55bb6189743f606abf0696623df0bfd223a6d0c8d96b8d60678d4891d2d6 \ + --hash=sha256:e17d1d86830a0d7687c37faf2fe47bffa752d0c95a306e96d7749bd3faa72a5b +sympy==1.12.1 ; python_full_version == "3.9.2" \ + --hash=sha256:2877b03f998cd8c08f07cd0de5b767119cd3ef40d09f41c30d722f6686b0fb88 \ + --hash=sha256:9b2cbc7f1a640289430e13d2a56f02f867a1da0190f2f99d8968c2f74da0e515 +tabulate==0.9.0 ; python_full_version == "3.9.2" \ + --hash=sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c \ + --hash=sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f +tenacity==8.3.0 ; python_full_version == "3.9.2" \ + --hash=sha256:3649f6443dbc0d9b01b9d8020a9c4ec7a1ff5f6f3c6c8a036ef371f573fe9185 \ + --hash=sha256:953d4e6ad24357bceffbc9707bc74349aca9d245f68eb65419cf0c249a1949a2 +tensorboard-data-server==0.7.2 ; python_full_version == "3.9.2" \ + --hash=sha256:7e0610d205889588983836ec05dc098e80f97b7e7bbff7e994ebb78f578d0ddb \ + --hash=sha256:9fe5d24221b29625dbc7328b0436ca7fc1c23de4acf4d272f1180856e32f9f60 \ + --hash=sha256:ef687163c24185ae9754ed5650eb5bc4d84ff257aabdc33f0cc6f74d8ba54530 +tensorboard==2.17.0 ; python_full_version == "3.9.2" \ + --hash=sha256:859a499a9b1fb68a058858964486627100b71fcb21646861c61d31846a6478fb +termcolor==2.4.0 ; python_full_version == "3.9.2" \ + --hash=sha256:9297c0df9c99445c2412e832e882a7884038a25617c60cea2ad69488d4040d63 \ + --hash=sha256:aab9e56047c8ac41ed798fa36d892a37aca6b3e9159f3e0c24bc64a9b3ac7b7a +threadpoolctl==3.5.0 ; python_full_version == "3.9.2" \ + --hash=sha256:082433502dd922bf738de0d8bcc4fdcbf0979ff44c42bd40f5af8a282f6fa107 \ + --hash=sha256:56c1e26c150397e58c4926da8eeee87533b1e32bef131bd4bf6a2f45f3185467 +tokenizers==0.15.2 ; python_full_version == "3.9.2" \ + --hash=sha256:0143e7d9dcd811855c1ce1ab9bf5d96d29bf5e528fd6c7824d0465741e8c10fd \ + --hash=sha256:02272fe48280e0293a04245ca5d919b2c94a48b408b55e858feae9618138aeda \ + --hash=sha256:02458bee6f5f3139f1ebbb6d042b283af712c0981f5bc50edf771d6b762d5e4f \ + --hash=sha256:054c1cc9c6d68f7ffa4e810b3d5131e0ba511b6e4be34157aa08ee54c2f8d9ee \ + --hash=sha256:05a77cbfebe28a61ab5c3891f9939cc24798b63fa236d84e5f29f3a85a200c00 \ + --hash=sha256:064ff87bb6acdbd693666de9a4b692add41308a2c0ec0770d6385737117215f2 \ + --hash=sha256:06cd0487b1cbfabefb2cc52fbd6b1f8d4c37799bd6c6e1641281adaa6b2504a7 \ + --hash=sha256:0774bccc6608eca23eb9d620196687c8b2360624619623cf4ba9dc9bd53e8b51 \ + --hash=sha256:0cf6b7f1d4dc59af960e6ffdc4faffe6460bbfa8dce27a58bf75755ffdb2526d \ + --hash=sha256:0ef06b9707baeb98b316577acb04f4852239d856b93e9ec3a299622f6084e4be \ + --hash=sha256:0ff110ecc57b7aa4a594396525a3451ad70988e517237fe91c540997c4e50e29 \ + --hash=sha256:107089f135b4ae7817affe6264f8c7a5c5b4fd9a90f9439ed495f54fcea56fb4 \ + --hash=sha256:112a1dd436d2cc06e6ffdc0b06d55ac019a35a63afd26475205cb4b1bf0bfbff \ + --hash=sha256:13ca3611de8d9ddfbc4dc39ef54ab1d2d4aaa114ac8727dfdc6a6ec4be017378 \ + --hash=sha256:158be8ea8554e5ed69acc1ce3fbb23a06060bd4bbb09029431ad6b9a466a7121 \ + --hash=sha256:1cf75d32e8d250781940d07f7eece253f2fe9ecdb1dc7ba6e3833fa17b82fcbc \ + --hash=sha256:1ddba9a2b0c8c81633eca0bb2e1aa5b3a15362b1277f1ae64176d0f6eba78ab1 \ + --hash=sha256:20ea60479de6fc7b8ae756b4b097572372d7e4032e2521c1bbf3d90c90a99ff0 \ + --hash=sha256:2277c36d2d6cdb7876c274547921a42425b6810d38354327dd65a8009acf870c \ + --hash=sha256:237d1bf3361cf2e6463e6c140628e6406766e8b27274f5fcc62c747ae3c6f094 \ + --hash=sha256:2735ecbbf37e52db4ea970e539fd2d450d213517b77745114f92867f3fc246eb \ + --hash=sha256:2ef09bbc16519f6c25d0c7fc0c6a33a6f62923e263c9d7cca4e58b8c61572afb \ + --hash=sha256:32e16bdeffa7c4f46bf2152172ca511808b952701d13e7c18833c0b73cb5c23f \ + --hash=sha256:361abdc068e8afe9c5b818769a48624687fb6aaed49636ee39bec4e95e1a215b \ + --hash=sha256:37aaec5a52e959892870a7c47cef80c53797c0db9149d458460f4f31e2fb250e \ + --hash=sha256:3835738be1de66624fff2f4f6f6684775da4e9c00bde053be7564cbf3545cc66 \ + --hash=sha256:38bfb0204ff3246ca4d5e726e8cc8403bfc931090151e6eede54d0e0cf162ef0 \ + --hash=sha256:38d7ab43c6825abfc0b661d95f39c7f8af2449364f01d331f3b51c94dcff7221 \ + --hash=sha256:3b919afe4df7eb6ac7cafd2bd14fb507d3f408db7a68c43117f579c984a73843 \ + --hash=sha256:3ef5dd1d39797044642dbe53eb2bc56435308432e9c7907728da74c69ee2adca \ + --hash=sha256:3f5e64b0389a2be47091d8cc53c87859783b837ea1a06edd9d8e04004df55a5c \ + --hash=sha256:40b6a4c78da863ff26dbd5ad9a8ecc33d8a8d97b535172601cf00aee9d7ce9ce \ + --hash=sha256:41e39b41e5531d6b2122a77532dbea60e171ef87a3820b5a3888daa847df4153 \ + --hash=sha256:44f2a832cd0825295f7179eaf173381dc45230f9227ec4b44378322d900447c9 \ + --hash=sha256:454c203164e07a860dbeb3b1f4a733be52b0edbb4dd2e5bd75023ffa8b49403a \ + --hash=sha256:4620cca5c2817177ee8706f860364cc3a8845bc1e291aaf661fb899e5d1c45b0 \ + --hash=sha256:473c83c5e2359bb81b0b6fde870b41b2764fcdd36d997485e07e72cc3a62264a \ + --hash=sha256:48e2b9335be2bc0171df9281385c2ed06a15f5cf121c44094338306ab7b33f2c \ + --hash=sha256:494fdbe5932d3416de2a85fc2470b797e6f3226c12845cadf054dd906afd0442 \ + --hash=sha256:4b19a808d8799fda23504a5cd31d2f58e6f52f140380082b352f877017d6342b \ + --hash=sha256:4c4b89038a684f40a6b15d6b09f49650ac64d951ad0f2a3ea9169687bbf2a8ba \ + --hash=sha256:4e022fe65e99230b8fd89ebdfea138c24421f91c1a4f4781a8f5016fd5cdfb4d \ + --hash=sha256:4eeb12daf02a59e29f578a865f55d87cd103ce62bd8a3a5874f8fdeaa82e336b \ + --hash=sha256:4fe1f74a902bee74a3b25aff180fbfbf4f8b444ab37c4d496af7afd13a784ed2 \ + --hash=sha256:508711a108684111ec8af89d3a9e9e08755247eda27d0ba5e3c50e9da1600f6d \ + --hash=sha256:5179c271aa5de9c71712e31cb5a79e436ecd0d7532a408fa42a8dbfa4bc23fd9 \ + --hash=sha256:524e60da0135e106b254bd71f0659be9f89d83f006ea9093ce4d1fab498c6d0d \ + --hash=sha256:52f6130c9cbf70544287575a985bf44ae1bda2da7e8c24e97716080593638012 \ + --hash=sha256:5645938a42d78c4885086767c70923abad047163d809c16da75d6b290cb30bbe \ + --hash=sha256:5ab2a4d21dcf76af60e05af8063138849eb1d6553a0d059f6534357bce8ba364 \ + --hash=sha256:620beacc3373277700d0e27718aa8b25f7b383eb8001fba94ee00aeea1459d89 \ + --hash=sha256:64c35e09e9899b72a76e762f9854e8750213f67567787d45f37ce06daf57ca78 \ + --hash=sha256:64c86e5e068ac8b19204419ed8ca90f9d25db20578f5881e337d203b314f4104 \ + --hash=sha256:67a0fe1e49e60c664915e9fb6b0cb19bac082ab1f309188230e4b2920230edb3 \ + --hash=sha256:6a9b648a58281c4672212fab04e60648fde574877d0139cd4b4f93fe28ca8944 \ + --hash=sha256:6d76f00f5c32da36c61f41c58346a4fa7f0a61be02f4301fd30ad59834977cc3 \ + --hash=sha256:6fc7083ab404019fc9acafe78662c192673c1e696bd598d16dc005bd663a5cf9 \ + --hash=sha256:708bb3e4283177236309e698da5fcd0879ce8fd37457d7c266d16b550bcbbd18 \ + --hash=sha256:7c0d8b52664ab2d4a8d6686eb5effc68b78608a9008f086a122a7b2996befbab \ + --hash=sha256:7c7d18b733be6bbca8a55084027f7be428c947ddf871c500ee603e375013ffba \ + --hash=sha256:7ca22bd897537a0080521445d91a58886c8c04084a6a19e6c78c586e0cfa92a5 \ + --hash=sha256:7ef789f83eb0f9baeb4d09a86cd639c0a5518528f9992f38b28e819df397eb06 \ + --hash=sha256:82f8652a74cc107052328b87ea8b34291c0f55b96d8fb261b3880216a9f9e48e \ + --hash=sha256:865c60ae6eaebdde7da66191ee9b7db52e542ed8ee9d2c653b6d190a9351b980 \ + --hash=sha256:89cd1cb93e4b12ff39bb2d626ad77e35209de9309a71e4d3d4672667b4b256e7 \ + --hash=sha256:8b9ec69247a23747669ec4b0ca10f8e3dfb3545d550258129bd62291aabe8605 \ + --hash=sha256:918fbb0eab96fe08e72a8c2b5461e9cce95585d82a58688e7f01c2bd546c79d0 \ + --hash=sha256:93268e788825f52de4c7bdcb6ebc1fcd4a5442c02e730faa9b6b08f23ead0e24 \ + --hash=sha256:936bf3842db5b2048eaa53dade907b1160f318e7c90c74bfab86f1e47720bdd6 \ + --hash=sha256:968fa1fb3c27398b28a4eca1cbd1e19355c4d3a6007f7398d48826bbe3a0f728 \ + --hash=sha256:9ba9f6895af58487ca4f54e8a664a322f16c26bbb442effd01087eba391a719e \ + --hash=sha256:9c861d35e8286a53e06e9e28d030b5a05bcbf5ac9d7229e561e53c352a85b1fc \ + --hash=sha256:9e0480c452217edd35eca56fafe2029fb4d368b7c0475f8dfa3c5c9c400a7456 \ + --hash=sha256:a308a607ca9de2c64c1b9ba79ec9a403969715a1b8ba5f998a676826f1a7039d \ + --hash=sha256:a33ab881c8fe70474980577e033d0bc9a27b7ab8272896e500708b212995d834 \ + --hash=sha256:a47acfac7e511f6bbfcf2d3fb8c26979c780a91e06fb5b9a43831b2c0153d024 \ + --hash=sha256:a907d76dcfda37023ba203ab4ceeb21bc5683436ebefbd895a0841fd52f6f6f2 \ + --hash=sha256:a9b9b070fdad06e347563b88c278995735292ded1132f8657084989a4c84a6d5 \ + --hash=sha256:b10122d8d8e30afb43bb1fe21a3619f62c3e2574bff2699cf8af8b0b6c5dc4a3 \ + --hash=sha256:b8fcfa81bcb9447df582c5bc96a031e6df4da2a774b8080d4f02c0c16b42be0b \ + --hash=sha256:c1257f4394be0d3b00de8c9e840ca5601d0a4a8438361ce9c2b05c7d25f6057b \ + --hash=sha256:c2d60f5246f4da9373f75ff18d64c69cbf60c3bca597290cea01059c336d2470 \ + --hash=sha256:c73e2e74bbb07910da0d37c326869f34113137b23eadad3fc00856e6b3d9930c \ + --hash=sha256:c9a09cd26cca2e1c349f91aa665309ddb48d71636370749414fbf67bc83c5343 \ + --hash=sha256:c9a2ebdd2ad4ec7a68e7615086e633857c85e2f18025bd05d2a4399e6c5f7169 \ + --hash=sha256:cc90102ed17271cf0a1262babe5939e0134b3890345d11a19c3145184b706055 \ + --hash=sha256:ccd73a82751c523b3fc31ff8194702e4af4db21dc20e55b30ecc2079c5d43cb7 \ + --hash=sha256:ccec77aa7150e38eec6878a493bf8c263ff1fa8a62404e16c6203c64c1f16a26 \ + --hash=sha256:cf27fd43472e07b57cf420eee1e814549203d56de00b5af8659cb99885472f1f \ + --hash=sha256:cf7fd9a5141634fa3aa8d6b7be362e6ae1b4cda60da81388fa533e0b552c98fd \ + --hash=sha256:cfed5c64e5be23d7ee0f0e98081a25c2a46b0b77ce99a4f0605b1ec43dd481fa \ + --hash=sha256:d0222c5b7c9b26c0b4822a82f6a7011de0a9d3060e1da176f66274b70f846b98 \ + --hash=sha256:d05a1b06f986d41aed5f2de464c003004b2df8aaf66f2b7628254bcbfb72a438 \ + --hash=sha256:d44ba80988ff9424e33e0a49445072ac7029d8c0e1601ad25a0ca5f41ed0c1d6 \ + --hash=sha256:d857be2df69763362ac699f8b251a8cd3fac9d21893de129bc788f8baaef2693 \ + --hash=sha256:d88b96ff0fe8e91f6ef01ba50b0d71db5017fa4e3b1d99681cec89a85faf7bf7 \ + --hash=sha256:daa348f02d15160cb35439098ac96e3a53bacf35885072611cd9e5be7d333daa \ + --hash=sha256:db35825f6d54215f6b6009a7ff3eedee0848c99a6271c870d2826fbbedf31a38 \ + --hash=sha256:dc3ad9ebc76eabe8b1d7c04d38be884b8f9d60c0cdc09b0aa4e3bcf746de0388 \ + --hash=sha256:dce74266919b892f82b1b86025a613956ea0ea62a4843d4c4237be2c5498ed3a \ + --hash=sha256:de19c4dc503c612847edf833c82e9f73cd79926a384af9d801dcf93f110cea4e \ + --hash=sha256:e2ea752f2b0fe96eb6e2f3adbbf4d72aaa1272079b0dfa1145507bd6a5d537e6 \ + --hash=sha256:e6e9c6e019dd5484be5beafc775ae6c925f4c69a3487040ed09b45e13df2cb91 \ + --hash=sha256:ea09acd2fe3324174063d61ad620dec3bcf042b495515f27f638270a7d466e8b \ + --hash=sha256:ea621a7eef4b70e1f7a4e84dd989ae3f0eeb50fc8690254eacc08acb623e82f1 \ + --hash=sha256:f1b3b31884dc8e9b21508bb76da80ebf7308fdb947a17affce815665d5c4d028 \ + --hash=sha256:f33dfbdec3784093a9aebb3680d1f91336c56d86cc70ddf88708251da1fe9064 \ + --hash=sha256:f3f40604f5042ff210ba82743dda2b6aa3e55aa12df4e9f2378ee01a17e2855e \ + --hash=sha256:f86593c18d2e6248e72fb91c77d413a815153b8ea4e31f7cd443bdf28e467670 \ + --hash=sha256:fb16ba563d59003028b678d2361a27f7e4ae0ab29c7a80690efa20d829c81fdb +toml==0.10.2 ; python_full_version == "3.9.2" \ + --hash=sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b \ + --hash=sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f +toolz==0.12.1 ; python_full_version == "3.9.2" \ + --hash=sha256:d22731364c07d72eea0a0ad45bafb2c2937ab6fd38a3507bf55eae8744aa7d85 \ + --hash=sha256:ecca342664893f177a13dac0e6b41cbd8ac25a358e5f215316d43e2100224f4d +torch==2.1.2 ; python_full_version == "3.9.2" \ + --hash=sha256:05b18594f60a911a0c4f023f38a8bda77131fba5fd741bda626e97dcf5a3dd0a \ + --hash=sha256:0e13034fd5fb323cbbc29e56d0637a3791e50dd589616f40c79adfa36a5a35a1 \ + --hash=sha256:255b50bc0608db177e6a3cc118961d77de7e5105f07816585fa6f191f33a9ff3 \ + --hash=sha256:33d59cd03cb60106857f6c26b36457793637512998666ee3ce17311f217afe2b \ + --hash=sha256:3a871edd6c02dae77ad810335c0833391c1a4ce49af21ea8cf0f6a5d2096eea8 \ + --hash=sha256:6984cd5057c0c977b3c9757254e989d3f1124f4ce9d07caa6cb637783c71d42a \ + --hash=sha256:76d37967c31c99548ad2c4d3f2cf191db48476f2e69b35a0937137116da356a1 \ + --hash=sha256:8e221deccd0def6c2badff6be403e0c53491805ed9915e2c029adbcdb87ab6b5 \ + --hash=sha256:8f32ce591616a30304f37a7d5ea80b69ca9e1b94bba7f308184bf616fdaea155 \ + --hash=sha256:9ca96253b761e9aaf8e06fb30a66ee301aecbf15bb5a303097de1969077620b6 \ + --hash=sha256:a6ebbe517097ef289cc7952783588c72de071d4b15ce0f8b285093f0916b1162 \ + --hash=sha256:bc195d7927feabc0eb7c110e457c955ed2ab616f3c7c28439dd4188cf589699f \ + --hash=sha256:bef6996c27d8f6e92ea4e13a772d89611da0e103b48790de78131e308cf73076 \ + --hash=sha256:d93ba70f67b08c2ae5598ee711cbc546a1bc8102cef938904b8c85c2089a51a0 \ + --hash=sha256:d9b535cad0df3d13997dbe8bd68ac33e0e3ae5377639c9881948e40794a61403 \ + --hash=sha256:e0ee6cf90c8970e05760f898d58f9ac65821c37ffe8b04269ec787aa70962b69 \ + --hash=sha256:e2d83f07b4aac983453ea5bf8f9aa9dacf2278a8d31247f5d9037f37befc60e4 \ + --hash=sha256:e3225f47d50bb66f756fe9196a768055d1c26b02154eb1f770ce47a2578d3aa7 \ + --hash=sha256:f41fe0c7ecbf903a568c73486139a75cfab287a0f6c17ed0698fdea7a1e8641d \ + --hash=sha256:f9a55d55af02826ebfbadf4e9b682f0f27766bc33df8236b48d28d705587868f +torchaudio==2.1.2 ; python_full_version == "3.9.2" \ + --hash=sha256:03b4cf02ee468b25280f9593cca95a32b517a88512a1e5f41129e24cd0c17e64 \ + --hash=sha256:03d2a3c9a806486f2d9646381a564a922a880b6df8f18336b6f0e4a0d8356743 \ + --hash=sha256:06f8c02814e6cdd78626bbf44ad2bb8afa5b39ab650c6af18328a32311461058 \ + --hash=sha256:14729cc9df52defa674fcf5ed4de0d6507038ef18012b96a2f56a77ed70676dd \ + --hash=sha256:23c1b34e98664a0ac239efd4e1a0af407b3dd0a86a5869114bae582c3e5437d7 \ + --hash=sha256:30ad97112412592518953f3cc2cd1b6ae153d6563dd5bd9eab6a972315fe9d9e \ + --hash=sha256:47f322708c282e0b1b7548cdbe4e12451c531061761885d7c7fe2e479a4a3861 \ + --hash=sha256:50c651d60bde7a4e096bf376eddb9ea32da6e37c3827536d6e918798ad203dbf \ + --hash=sha256:683eaa721e016ca1f27bb28fa89feae37a6f7b98ff1ceee0d5e5aedd19bd982c \ + --hash=sha256:860acc32e6507063f2c13d81e26718199e215f34a2bcd6c9609a25e9bf21aa36 \ + --hash=sha256:9a6bade8a2495a724f4ee6acb5e86828ff4083dc6c7c57c6386b54a0ea7afe71 \ + --hash=sha256:9d676673c1ce4dd11fca145e3a6cd9b4e5b897cffad0f617d2906f2d3fc8c3a9 \ + --hash=sha256:ae50dcf34d5c6f73180cf694195ee31194b9d6090328575c30a5960bc716fa52 \ + --hash=sha256:b3bbb5324e705ded77616e546591b249ae7588d35a3e8c2c4c1d986a5ea51ef4 \ + --hash=sha256:c1084eedf4ced1af9fdd18910690ff615f89baeb30b32030806543fbc6f3657e \ + --hash=sha256:c33e05c2305bc4d659aaf77a385433e3f8ac07ae235d3b15d6ef4ff995258746 \ + --hash=sha256:d0efd008c35dec962b80f5dce3468bd1b88301cf65152bbfa7f74c0005a17e89 \ + --hash=sha256:dbaefae9ca0b208ce0157e0358cea8ab796c9e26a2c61c3d181246e4010b04d2 \ + --hash=sha256:f82657fc4ec3b473bf6c752c0ee62d7f511af9ef37e5143f8339ec049504d767 \ + --hash=sha256:ff7156b30eb05e9124286c30c80da84b93e227d009adb96eb19489600b459332 +torchmetrics==0.2.0 ; python_full_version == "3.9.2" \ + --hash=sha256:16a8ceac8e579828aa8a5a4f8830fc207a18e0fbc8774257fbb1cbfb95248faf \ + --hash=sha256:481a28759acd2d77cc088acba6bc7dc4a356c7cb767da2e1495e91e612e2d548 +torchvision==0.16.2 ; python_full_version == "3.9.2" \ + --hash=sha256:335959c43b371c0474af34c1ef2a52efdc7603c45700d29e4475eeb02984170c \ + --hash=sha256:3f4bd5fcbc361476e2e78016636ac7d5509e59d9962521f06eb98e6803898182 \ + --hash=sha256:41dd4fa9f176d563fe9f1b9adef3b7e582cdfb60ce8c9bc51b094a025be687c9 \ + --hash=sha256:4b065143d1a720fe8a9077fd4be35d491f98819ec80b3dbbc3ec64d0b707a906 \ + --hash=sha256:56115268b37f0b75364e3654e47ad9abc66ac34c1f9e5e3dfa89a22d6a40017a \ + --hash=sha256:67b1aaf8b8cb02ce75dd445f291a27c8036a502f8c0aa76e28c37a0faac2e153 \ + --hash=sha256:7fd22d86e08eba321af70cad291020c2cdeac069b00ce88b923ca52e06174769 \ + --hash=sha256:8199acdf8ab066a28b84a5b6f4d97b58976d9e164b1acc3a9d14fccfaf74bb3a \ + --hash=sha256:82805f8445b094f9d1e770390ee6cc86855e89955e08ce34af2e2274fc0e5c45 \ + --hash=sha256:8692ab1e48807e9604046a6f4beeb67b523294cee1b00828654bb0df2cfce2b2 \ + --hash=sha256:96c7583700112a410bdc4e1e4f118c429dab49c29c9a31a2cc3579bc9b08b19d \ + --hash=sha256:9f4032ebb3277fb07ff6a9b818d50a547fb8fcd89d958cfd9e773322454bb688 \ + --hash=sha256:b024bd412df6d3a007dcebf311a894eb3c5c21e1af80d12be382bbcb097a7c3a \ + --hash=sha256:b82732dcf876a37c852772342aa6ee3480c03bb3e2a802ae109fc5f7e28d26e9 \ + --hash=sha256:bc5f274e4ecd1b86062063cdf4fd385a1d39d147a3a2685fbbde9ff08bb720b8 \ + --hash=sha256:bc86f2800cb2c0c1a09c581409cdd6bff66e62f103dc83fc63f73346264c3756 \ + --hash=sha256:bef30d03e1d1c629761f4dca51d3b7d8a0dc0acce6f4068ab2a1634e8e7b64e0 \ + --hash=sha256:e130b08cc9b3cc73a6c59d6edf032394a322f9579bfd21d14bc2e1d0999aa758 \ + --hash=sha256:e59cc7b2bd1ab5c0ce4ae382e4e37be8f1c174e8b5de2f6a23c170de9ae28495 \ + --hash=sha256:e89f10f3c8351972b6e3fda95bc3e479ea8dbfc9dfcfd2c32902dbad4ba5cfc5 +tornado==6.4.1 ; python_full_version == "3.9.2" \ + --hash=sha256:163b0aafc8e23d8cdc3c9dfb24c5368af84a81e3364745ccb4427669bf84aec8 \ + --hash=sha256:25486eb223babe3eed4b8aecbac33b37e3dd6d776bc730ca14e1bf93888b979f \ + --hash=sha256:454db8a7ecfcf2ff6042dde58404164d969b6f5d58b926da15e6b23817950fc4 \ + --hash=sha256:613bf4ddf5c7a95509218b149b555621497a6cc0d46ac341b30bd9ec19eac7f3 \ + --hash=sha256:6d5ce3437e18a2b66fbadb183c1d3364fb03f2be71299e7d10dbeeb69f4b2a14 \ + --hash=sha256:8ae50a504a740365267b2a8d1a90c9fbc86b780a39170feca9bcc1787ff80842 \ + --hash=sha256:92d3ab53183d8c50f8204a51e6f91d18a15d5ef261e84d452800d4ff6fc504e9 \ + --hash=sha256:a02a08cc7a9314b006f653ce40483b9b3c12cda222d6a46d4ac63bb6c9057698 \ + --hash=sha256:b24b8982ed444378d7f21d563f4180a2de31ced9d8d84443907a0a64da2072e7 \ + --hash=sha256:d9a566c40b89757c9aa8e6f032bcdb8ca8795d7c1a9762910c722b1635c9de4d \ + --hash=sha256:e2e20b9113cd7293f164dc46fffb13535266e713cdb87bd2d15ddb336e96cfc4 +tqdm==4.66.4 ; python_full_version == "3.9.2" \ + --hash=sha256:b75ca56b413b030bc3f00af51fd2c1a1a5eac6a0c1cca83cbb37a5c52abce644 \ + --hash=sha256:e4d936c9de8727928f3be6079590e97d9abfe8d39a590be678eb5919ffc186bb +transformers==4.35.2 ; python_full_version == "3.9.2" \ + --hash=sha256:2d125e197d77b0cdb6c9201df9fa7e2101493272e448b9fba9341c695bee2f52 \ + --hash=sha256:9dfa76f8692379544ead84d98f537be01cd1070de75c74efb13abcbc938fbe2f +triton==2.1.0 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.9.2" \ + --hash=sha256:143582ca31dd89cd982bd3bf53666bab1c7527d41e185f9e3d8a3051ce1b663b \ + --hash=sha256:21544e522c02005a626c8ad63d39bdff2f31d41069592919ef281e964ed26446 \ + --hash=sha256:39f6fb6bdccb3e98f3152e3fbea724f1aeae7d749412bbb1fa9c441d474eba26 \ + --hash=sha256:66439923a30d5d48399b08a9eae10370f6c261a5ec864a64983bae63152d39d7 \ + --hash=sha256:81a96d110a738ff63339fc892ded095b31bd0d205e3aace262af8400d40b6fa8 \ + --hash=sha256:82fc5aeeedf6e36be4e4530cbdcba81a09d65c18e02f52dc298696d45721f3bd \ + --hash=sha256:919b06453f0033ea52c13eaf7833de0e57db3178d23d4e04f9fc71c4f2c32bf8 \ + --hash=sha256:ae4bb8a91de790e1866405211c4d618379781188f40d5c4c399766914e84cd94 +typing-extensions==4.12.2 ; python_full_version == "3.9.2" \ + --hash=sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d \ + --hash=sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8 +urllib3==2.2.1 ; python_full_version == "3.9.2" \ + --hash=sha256:450b20ec296a467077128bff42b73080516e71b56ff59a60a02bef2232c4fa9d \ + --hash=sha256:d0570876c61ab9e520d776c38acbbb5b05a776d3f9ff98a5c8fd5162a444cf19 +wandb==0.15.12 ; python_full_version == "3.9.2" \ + --hash=sha256:75c57b5bb8ddae21d45a02f644628585bdd112fea686de3177099a0996f1c41c \ + --hash=sha256:c344d92fb8044b072a6138afd9adc5d3801ad050cf11378fe2af2fe899dcca84 +watchdog==4.0.1 ; platform_system != "Darwin" and python_full_version == "3.9.2" \ + --hash=sha256:0144c0ea9997b92615af1d94afc0c217e07ce2c14912c7b1a5731776329fcfc7 \ + --hash=sha256:03e70d2df2258fb6cb0e95bbdbe06c16e608af94a3ffbd2b90c3f1e83eb10767 \ + --hash=sha256:093b23e6906a8b97051191a4a0c73a77ecc958121d42346274c6af6520dec175 \ + --hash=sha256:123587af84260c991dc5f62a6e7ef3d1c57dfddc99faacee508c71d287248459 \ + --hash=sha256:17e32f147d8bf9657e0922c0940bcde863b894cd871dbb694beb6704cfbd2fb5 \ + --hash=sha256:206afc3d964f9a233e6ad34618ec60b9837d0582b500b63687e34011e15bb429 \ + --hash=sha256:4107ac5ab936a63952dea2a46a734a23230aa2f6f9db1291bf171dac3ebd53c6 \ + --hash=sha256:4513ec234c68b14d4161440e07f995f231be21a09329051e67a2118a7a612d2d \ + --hash=sha256:611be3904f9843f0529c35a3ff3fd617449463cb4b73b1633950b3d97fa4bfb7 \ + --hash=sha256:62c613ad689ddcb11707f030e722fa929f322ef7e4f18f5335d2b73c61a85c28 \ + --hash=sha256:667f3c579e813fcbad1b784db7a1aaa96524bed53437e119f6a2f5de4db04235 \ + --hash=sha256:6e8c70d2cd745daec2a08734d9f63092b793ad97612470a0ee4cbb8f5f705c57 \ + --hash=sha256:7577b3c43e5909623149f76b099ac49a1a01ca4e167d1785c76eb52fa585745a \ + --hash=sha256:998d2be6976a0ee3a81fb8e2777900c28641fb5bfbd0c84717d89bca0addcdc5 \ + --hash=sha256:a3c2c317a8fb53e5b3d25790553796105501a235343f5d2bf23bb8649c2c8709 \ + --hash=sha256:ab998f567ebdf6b1da7dc1e5accfaa7c6992244629c0fdaef062f43249bd8dee \ + --hash=sha256:ac7041b385f04c047fcc2951dc001671dee1b7e0615cde772e84b01fbf68ee84 \ + --hash=sha256:bca36be5707e81b9e6ce3208d92d95540d4ca244c006b61511753583c81c70dd \ + --hash=sha256:c9904904b6564d4ee8a1ed820db76185a3c96e05560c776c79a6ce5ab71888ba \ + --hash=sha256:cad0bbd66cd59fc474b4a4376bc5ac3fc698723510cbb64091c2a793b18654db \ + --hash=sha256:d10a681c9a1d5a77e75c48a3b8e1a9f2ae2928eda463e8d33660437705659682 \ + --hash=sha256:d4925e4bf7b9bddd1c3de13c9b8a2cdb89a468f640e66fbfabaf735bd85b3e35 \ + --hash=sha256:d7b9f5f3299e8dd230880b6c55504a1f69cf1e4316275d1b215ebdd8187ec88d \ + --hash=sha256:da2dfdaa8006eb6a71051795856bedd97e5b03e57da96f98e375682c48850645 \ + --hash=sha256:dddba7ca1c807045323b6af4ff80f5ddc4d654c8bce8317dde1bd96b128ed253 \ + --hash=sha256:e7921319fe4430b11278d924ef66d4daa469fafb1da679a2e48c935fa27af193 \ + --hash=sha256:e93f451f2dfa433d97765ca2634628b789b49ba8b504fdde5837cdcf25fdb53b \ + --hash=sha256:eebaacf674fa25511e8867028d281e602ee6500045b57f43b08778082f7f8b44 \ + --hash=sha256:ef0107bbb6a55f5be727cfc2ef945d5676b97bffb8425650dadbb184be9f9a2b \ + --hash=sha256:f0de0f284248ab40188f23380b03b59126d1479cd59940f2a34f8852db710625 \ + --hash=sha256:f27279d060e2ab24c0aa98363ff906d2386aa6c4dc2f1a374655d4e02a6c5e5e \ + --hash=sha256:f8affdf3c0f0466e69f5b3917cdd042f89c8c63aebdb9f7c078996f607cdb0f5 +wcwidth==0.2.13 ; python_full_version == "3.9.2" \ + --hash=sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859 \ + --hash=sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5 +werkzeug==3.0.3 ; python_full_version == "3.9.2" \ + --hash=sha256:097e5bfda9f0aba8da6b8545146def481d06aa7d3266e7448e2cccf67dd8bd18 \ + --hash=sha256:fc9645dc43e03e4d630d23143a04a7f947a9a3b5727cd535fdfe155a17cc48c8 +yarl==1.9.4 ; python_full_version == "3.9.2" \ + --hash=sha256:008d3e808d03ef28542372d01057fd09168419cdc8f848efe2804f894ae03e51 \ + --hash=sha256:03caa9507d3d3c83bca08650678e25364e1843b484f19986a527630ca376ecce \ + --hash=sha256:07574b007ee20e5c375a8fe4a0789fad26db905f9813be0f9fef5a68080de559 \ + --hash=sha256:09efe4615ada057ba2d30df871d2f668af661e971dfeedf0c159927d48bbeff0 \ + --hash=sha256:0d2454f0aef65ea81037759be5ca9947539667eecebca092733b2eb43c965a81 \ + --hash=sha256:0e9d124c191d5b881060a9e5060627694c3bdd1fe24c5eecc8d5d7d0eb6faabc \ + --hash=sha256:18580f672e44ce1238b82f7fb87d727c4a131f3a9d33a5e0e82b793362bf18b4 \ + --hash=sha256:1f23e4fe1e8794f74b6027d7cf19dc25f8b63af1483d91d595d4a07eca1fb26c \ + --hash=sha256:206a55215e6d05dbc6c98ce598a59e6fbd0c493e2de4ea6cc2f4934d5a18d130 \ + --hash=sha256:23d32a2594cb5d565d358a92e151315d1b2268bc10f4610d098f96b147370136 \ + --hash=sha256:26a1dc6285e03f3cc9e839a2da83bcbf31dcb0d004c72d0730e755b33466c30e \ + --hash=sha256:29e0f83f37610f173eb7e7b5562dd71467993495e568e708d99e9d1944f561ec \ + --hash=sha256:2b134fd795e2322b7684155b7855cc99409d10b2e408056db2b93b51a52accc7 \ + --hash=sha256:2d47552b6e52c3319fede1b60b3de120fe83bde9b7bddad11a69fb0af7db32f1 \ + --hash=sha256:357495293086c5b6d34ca9616a43d329317feab7917518bc97a08f9e55648455 \ + --hash=sha256:35a2b9396879ce32754bd457d31a51ff0a9d426fd9e0e3c33394bf4b9036b099 \ + --hash=sha256:3777ce5536d17989c91696db1d459574e9a9bd37660ea7ee4d3344579bb6f129 \ + --hash=sha256:3986b6f41ad22988e53d5778f91855dc0399b043fc8946d4f2e68af22ee9ff10 \ + --hash=sha256:44d8ffbb9c06e5a7f529f38f53eda23e50d1ed33c6c869e01481d3fafa6b8142 \ + --hash=sha256:49a180c2e0743d5d6e0b4d1a9e5f633c62eca3f8a86ba5dd3c471060e352ca98 \ + --hash=sha256:4aa9741085f635934f3a2583e16fcf62ba835719a8b2b28fb2917bb0537c1dfa \ + --hash=sha256:4b21516d181cd77ebd06ce160ef8cc2a5e9ad35fb1c5930882baff5ac865eee7 \ + --hash=sha256:4b3c1ffe10069f655ea2d731808e76e0f452fc6c749bea04781daf18e6039525 \ + --hash=sha256:4c7d56b293cc071e82532f70adcbd8b61909eec973ae9d2d1f9b233f3d943f2c \ + --hash=sha256:4e9035df8d0880b2f1c7f5031f33f69e071dfe72ee9310cfc76f7b605958ceb9 \ + --hash=sha256:54525ae423d7b7a8ee81ba189f131054defdb122cde31ff17477951464c1691c \ + --hash=sha256:549d19c84c55d11687ddbd47eeb348a89df9cb30e1993f1b128f4685cd0ebbf8 \ + --hash=sha256:54beabb809ffcacbd9d28ac57b0db46e42a6e341a030293fb3185c409e626b8b \ + --hash=sha256:566db86717cf8080b99b58b083b773a908ae40f06681e87e589a976faf8246bf \ + --hash=sha256:5a2e2433eb9344a163aced6a5f6c9222c0786e5a9e9cac2c89f0b28433f56e23 \ + --hash=sha256:5aef935237d60a51a62b86249839b51345f47564208c6ee615ed2a40878dccdd \ + --hash=sha256:604f31d97fa493083ea21bd9b92c419012531c4e17ea6da0f65cacdcf5d0bd27 \ + --hash=sha256:63b20738b5aac74e239622d2fe30df4fca4942a86e31bf47a81a0e94c14df94f \ + --hash=sha256:686a0c2f85f83463272ddffd4deb5e591c98aac1897d65e92319f729c320eece \ + --hash=sha256:6a962e04b8f91f8c4e5917e518d17958e3bdee71fd1d8b88cdce74dd0ebbf434 \ + --hash=sha256:6ad6d10ed9b67a382b45f29ea028f92d25bc0bc1daf6c5b801b90b5aa70fb9ec \ + --hash=sha256:6f5cb257bc2ec58f437da2b37a8cd48f666db96d47b8a3115c29f316313654ff \ + --hash=sha256:6fe79f998a4052d79e1c30eeb7d6c1c1056ad33300f682465e1b4e9b5a188b78 \ + --hash=sha256:7855426dfbddac81896b6e533ebefc0af2f132d4a47340cee6d22cac7190022d \ + --hash=sha256:7d5aaac37d19b2904bb9dfe12cdb08c8443e7ba7d2852894ad448d4b8f442863 \ + --hash=sha256:801e9264d19643548651b9db361ce3287176671fb0117f96b5ac0ee1c3530d53 \ + --hash=sha256:81eb57278deb6098a5b62e88ad8281b2ba09f2f1147c4767522353eaa6260b31 \ + --hash=sha256:824d6c50492add5da9374875ce72db7a0733b29c2394890aef23d533106e2b15 \ + --hash=sha256:8397a3817d7dcdd14bb266283cd1d6fc7264a48c186b986f32e86d86d35fbac5 \ + --hash=sha256:848cd2a1df56ddbffeb375535fb62c9d1645dde33ca4d51341378b3f5954429b \ + --hash=sha256:84fc30f71689d7fc9168b92788abc977dc8cefa806909565fc2951d02f6b7d57 \ + --hash=sha256:8619d6915b3b0b34420cf9b2bb6d81ef59d984cb0fde7544e9ece32b4b3043c3 \ + --hash=sha256:8a854227cf581330ffa2c4824d96e52ee621dd571078a252c25e3a3b3d94a1b1 \ + --hash=sha256:8be9e837ea9113676e5754b43b940b50cce76d9ed7d2461df1af39a8ee674d9f \ + --hash=sha256:928cecb0ef9d5a7946eb6ff58417ad2fe9375762382f1bf5c55e61645f2c43ad \ + --hash=sha256:957b4774373cf6f709359e5c8c4a0af9f6d7875db657adb0feaf8d6cb3c3964c \ + --hash=sha256:992f18e0ea248ee03b5a6e8b3b4738850ae7dbb172cc41c966462801cbf62cf7 \ + --hash=sha256:9fc5fc1eeb029757349ad26bbc5880557389a03fa6ada41703db5e068881e5f2 \ + --hash=sha256:a00862fb23195b6b8322f7d781b0dc1d82cb3bcac346d1e38689370cc1cc398b \ + --hash=sha256:a3a6ed1d525bfb91b3fc9b690c5a21bb52de28c018530ad85093cc488bee2dd2 \ + --hash=sha256:a6327976c7c2f4ee6816eff196e25385ccc02cb81427952414a64811037bbc8b \ + --hash=sha256:a7409f968456111140c1c95301cadf071bd30a81cbd7ab829169fb9e3d72eae9 \ + --hash=sha256:a825ec844298c791fd28ed14ed1bffc56a98d15b8c58a20e0e08c1f5f2bea1be \ + --hash=sha256:a8c1df72eb746f4136fe9a2e72b0c9dc1da1cbd23b5372f94b5820ff8ae30e0e \ + --hash=sha256:a9bd00dc3bc395a662900f33f74feb3e757429e545d831eef5bb280252631984 \ + --hash=sha256:aa102d6d280a5455ad6a0f9e6d769989638718e938a6a0a2ff3f4a7ff8c62cc4 \ + --hash=sha256:aaaea1e536f98754a6e5c56091baa1b6ce2f2700cc4a00b0d49eca8dea471074 \ + --hash=sha256:ad4d7a90a92e528aadf4965d685c17dacff3df282db1121136c382dc0b6014d2 \ + --hash=sha256:b8477c1ee4bd47c57d49621a062121c3023609f7a13b8a46953eb6c9716ca392 \ + --hash=sha256:ba6f52cbc7809cd8d74604cce9c14868306ae4aa0282016b641c661f981a6e91 \ + --hash=sha256:bac8d525a8dbc2a1507ec731d2867025d11ceadcb4dd421423a5d42c56818541 \ + --hash=sha256:bef596fdaa8f26e3d66af846bbe77057237cb6e8efff8cd7cc8dff9a62278bbf \ + --hash=sha256:c0ec0ed476f77db9fb29bca17f0a8fcc7bc97ad4c6c1d8959c507decb22e8572 \ + --hash=sha256:c38c9ddb6103ceae4e4498f9c08fac9b590c5c71b0370f98714768e22ac6fa66 \ + --hash=sha256:c7224cab95645c7ab53791022ae77a4509472613e839dab722a72abe5a684575 \ + --hash=sha256:c74018551e31269d56fab81a728f683667e7c28c04e807ba08f8c9e3bba32f14 \ + --hash=sha256:ca06675212f94e7a610e85ca36948bb8fc023e458dd6c63ef71abfd482481aa5 \ + --hash=sha256:d1d2532b340b692880261c15aee4dc94dd22ca5d61b9db9a8a361953d36410b1 \ + --hash=sha256:d25039a474c4c72a5ad4b52495056f843a7ff07b632c1b92ea9043a3d9950f6e \ + --hash=sha256:d5ff2c858f5f6a42c2a8e751100f237c5e869cbde669a724f2062d4c4ef93551 \ + --hash=sha256:d7d7f7de27b8944f1fee2c26a88b4dabc2409d2fea7a9ed3df79b67277644e17 \ + --hash=sha256:d7eeb6d22331e2fd42fce928a81c697c9ee2d51400bd1a28803965883e13cead \ + --hash=sha256:d8a1c6c0be645c745a081c192e747c5de06e944a0d21245f4cf7c05e457c36e0 \ + --hash=sha256:d8b889777de69897406c9fb0b76cdf2fd0f31267861ae7501d93003d55f54fbe \ + --hash=sha256:d9e09c9d74f4566e905a0b8fa668c58109f7624db96a2171f21747abc7524234 \ + --hash=sha256:db8e58b9d79200c76956cefd14d5c90af54416ff5353c5bfd7cbe58818e26ef0 \ + --hash=sha256:ddb2a5c08a4eaaba605340fdee8fc08e406c56617566d9643ad8bf6852778fc7 \ + --hash=sha256:e0381b4ce23ff92f8170080c97678040fc5b08da85e9e292292aba67fdac6c34 \ + --hash=sha256:e23a6d84d9d1738dbc6e38167776107e63307dfc8ad108e580548d1f2c587f42 \ + --hash=sha256:e516dc8baf7b380e6c1c26792610230f37147bb754d6426462ab115a02944385 \ + --hash=sha256:ea65804b5dc88dacd4a40279af0cdadcfe74b3e5b4c897aa0d81cf86927fee78 \ + --hash=sha256:ec61d826d80fc293ed46c9dd26995921e3a82146feacd952ef0757236fc137be \ + --hash=sha256:ee04010f26d5102399bd17f8df8bc38dc7ccd7701dc77f4a68c5b8d733406958 \ + --hash=sha256:f3bc6af6e2b8f92eced34ef6a96ffb248e863af20ef4fde9448cc8c9b858b749 \ + --hash=sha256:f7d6b36dd2e029b6bcb8a13cf19664c7b8e19ab3a58e0fefbb5b8461447ed5ec +zipp==3.19.2 ; python_full_version == "3.9.2" \ + --hash=sha256:bf1dcf6450f873a13e952a29504887c89e6de7506209e5b1bcc3460135d4de19 \ + --hash=sha256:f091755f667055f2d02b32c53771a7a6c8b47e1fdbc4b72a8b9072b3eef8015c diff --git a/test.jpg b/test.jpg new file mode 100644 index 0000000000000000000000000000000000000000..40457c7e18de1781db7f2aa9733ea174b70d6fa5 Binary files /dev/null and b/test.jpg differ diff --git a/train.sh b/train.sh new file mode 100644 index 0000000000000000000000000000000000000000..9bdfc9446af1abe93eb10d4f71b594cd2e1eafa4 --- /dev/null +++ b/train.sh @@ -0,0 +1,18 @@ +#!/bin/bash +export PYTHONPATH=`pwd`/SAN +alias python_='python' + +yecho(){ # yellow echo + echo "\e[1;33m$1\e[m" +} + +arg=$1 +if [ "$arg" = "pdb" ]; then + yecho 'Launch pdb ...' + alias python_='python -m pdb -c c' +else + yecho 'Launch without pdb ...' +fi + +python_ polos/cli.py train -f configs/polos-trainer.yaml && \ +sh validate_cvpr.sh diff --git a/validate.sh b/validate.sh new file mode 100644 index 0000000000000000000000000000000000000000..bcd578d3e4fb8b5d7f5b4ff311a6305c761cbd30 --- /dev/null +++ b/validate.sh @@ -0,0 +1,3 @@ +ckpt=`find . -name "*.ckpt" | xargs ls -lt | awk '{ print $NF }' | grep -v '^$' | head -n 1` +echo $ckpt +python validate/validate_cvpr.py --model=$ckpt --polos --foil --pascal --coef --flickr \ No newline at end of file diff --git a/validate/clip_score.py b/validate/clip_score.py new file mode 100644 index 0000000000000000000000000000000000000000..1bf86dac5ed74dff95801314dbf5107fe534e700 --- /dev/null +++ b/validate/clip_score.py @@ -0,0 +1,60 @@ +import torch +import clip +import torch.nn.functional as F +from tqdm import tqdm +from PIL import Image + +def read_image(imgid): + from pathlib import Path + vanilla = Path(imgid) + fixed = Path(f"data_en/images/{imgid}") + assert not (vanilla.exists() == fixed.exists()) # 両者共に存在/不在だと困る + + path = vanilla if vanilla.exists() else fixed + return Image.open(path).convert("RGB") + +class CLIPScore(): + def __init__(self,device="cuda"): + self.clip, self.clip_preprocess = clip.load("ViT-B/32", device=device) + self.device = device + + def batchify(self, targets, batch_size): + return [targets[i:i+batch_size] for i in range(0,len(targets),batch_size)] + + def __call__(self, mt_list, refs_list, img_list, no_ref=False): + B = 32 + mt_list, refs_list, img_list = [self.batchify(x,B) for x in [mt_list,refs_list,img_list]] + scores = [] + assert len(mt_list) == len(refs_list) == len(img_list) + for mt, refs, imgs in (pbar:= tqdm(zip(mt_list,refs_list, img_list),total=len(mt_list))): + pbar.set_description(f"CLIPScore (noref: {no_ref})") + imgs = [read_image(imgid) for imgid in imgs] + refs_token = [] + for ref_list in refs: + refs_token.append([clip.tokenize("A photo depicts " + ref,truncate=True).to(self.device) for ref in ref_list]) + + refs = [torch.cat(ref,dim=0) for ref in refs_token] + mts = clip.tokenize(["A photo depicts " + x for x in mt],truncate=True).to(self.device) + imgs = torch.cat([self.clip_preprocess(img).unsqueeze(0) for img in imgs],dim=0).to(self.device) + + imgs = self.clip.encode_image(imgs) + mts = self.clip.encode_text(mts) + cos = F.cosine_similarity(imgs, mts,eps=0) + cos[cos < 0.] = 0. + clip_score = 2.5 * cos + + if no_ref: + scores.extend(clip_score.tolist()) + continue + + cos = F.cosine_similarity(imgs, mts,eps=0) + cos[cos < 0.] = 0. + clip_score2 = cos + + assert clip_score.shape == clip_score2.shape + clip_score = 2.0 * clip_score * clip_score2 / (clip_score + clip_score2) + + if not no_ref: + scores.extend(clip_score.tolist()) + + return scores diff --git a/validate/compute_correlations.py b/validate/compute_correlations.py new file mode 100644 index 0000000000000000000000000000000000000000..9ffb3e0523a0ce12c58d3106ea8bc48cb4c2ff96 --- /dev/null +++ b/validate/compute_correlations.py @@ -0,0 +1,129 @@ +import sys +sys.path.append("./pacscore") + +import argparse +import torch +import pacscore.evaluation as evaluation +import scipy.stats + +from pacscore.models.clip import clip +from pacscore.utils import collate_fn +from pacscore.evaluation import PACScore, RefPACScore +from pacscore.models import open_clip +from data import Flickr8k +from torch.utils.data import DataLoader +from polos.metrics.regression_metrics import RegressionReport +from polos.models import load_checkpoint +import argparse +from polos.models import load_checkpoint +from PIL import Image +from utils import * + +def collect_coef(memory, dataset_name, method, coef_tensor): + memory.setdefault(dataset_name, {}) + coef = {k : round(float(v.numpy() if not isinstance(v,float) else v),4) for k, v in coef_tensor.items()} + memory[dataset_name].update({method : coef}) + gprint(f"[{dataset_name}]",method,coef) + +def compute_correlation_scores(memory, dataloader, pacscore, polos, preprocess, args): + gen = {} + gts = {} + + human_scores = list() + ims_cs = list() + gen_cs = list() + gts_cs = list() + all_scores = dict() + pacscore.eval() + polos.eval() + + for it, (images, candidates, references, scores) in enumerate(iter(dataloader)): + for i, (im_i, gts_i, gen_i, score_i) in enumerate(zip(images, references, candidates, scores)): + gen['%d_%d' % (it, i)] = [gen_i, ] + gts['%d_%d' % (it, i)] = gts_i + + ims_cs.append(im_i) + gen_cs.append(gen_i) + gts_cs.append(gts_i) + human_scores.append(score_i) + + gts = evaluation.PTBTokenizer.tokenize(gts) + gen = evaluation.PTBTokenizer.tokenize(gen) + all_scores_metrics = evaluation.get_all_metrics(gts, gen, return_per_cap=True) + + for k, v in all_scores_metrics.items(): + if k == 'BLEU': + all_scores['BLEU-1'] = v[0] + all_scores['BLEU-4'] = v[-1] + else: + all_scores[k] = v + + # PAC-S + _, pac_scores, candidate_feats, len_candidates = PACScore(pacscore, preprocess, ims_cs, gen_cs, args.device, w=2.0) + all_scores['PAC-S'] = pac_scores + + # RefPAC-S + _, per_instance_text_text = RefPACScore(pacscore, gts_cs, candidate_feats, args.device, torch.tensor(len_candidates)) + refpac_scores = 2 * pac_scores * per_instance_text_text / (pac_scores + per_instance_text_text) + all_scores['RefPAC-S'] = refpac_scores + + # Polos + data = [{ + "mt" : gen, + "refs": refs, + "img": Image.open(image).convert("RGB") + } for image, refs, gen in zip(ims_cs, gts_cs, gen_cs) + ] + _, sys_score = polos.predict(data,cuda=True,batch_size=32) + all_scores['Polos'] = sys_score + del data + + for k, v in all_scores.items(): + kendalltau_b = 100 * scipy.stats.kendalltau(v, human_scores, variant='b')[0] + kendalltau_c = 100 * scipy.stats.kendalltau(v, human_scores, variant='c')[0] + print('%s \t Kendall Tau-b: %.3f \t Kendall Tau-c: %.3f' + % (k, kendalltau_b, kendalltau_c)) + collect_coef(memory, + args.dataset_name, + k, + {"Kendall" : kendalltau_c if args.kendall_type == "c" else kendalltau_b} + ) + return memory + +def compute_scores(memory, pacscore, polos, preprocess, args): + args.datasets = ['flickr8k_expert', 'flickr8k_cf'] + + args.batch_size_compute_score = 10 + for d in args.datasets: + print("Computing correlation scores on dataset: " + d) + if d == 'flickr8k_expert': + dataset = Flickr8k(root='data_en/flickr8k/',json_file='flickr8k.json') + dataloader = DataLoader(dataset, batch_size=args.batch_size_compute_score, shuffle=False, collate_fn=collate_fn) + args.kendall_type = "c" + elif d == 'flickr8k_cf': + dataset = Flickr8k(root='data_en/flickr8k/',json_file='crowdflower_flickr8k.json') + dataloader = DataLoader(dataset, batch_size=args.batch_size_compute_score, shuffle=False, collate_fn=collate_fn) + args.kendall_type = "b" + + args.dataset_name = d + memory = compute_correlation_scores(memory, dataloader, pacscore, polos, preprocess, args) + return memory + + +def compute_flickr(args,checkpoint,memory,tops): + # Polos + polos = load_checkpoint(checkpoint) + + # PAC-S + device = "cuda" if torch.cuda.is_available() else "cpu" + pacscore, preprocess = clip.load("ViT-B/32", device=device) + pacscore = pacscore.to(device) + pacscore = pacscore.float() + + checkpoint = torch.load("pacscore/checkpoints/clip_ViT-B-32.pth") # Use checkpoints trained with PACScore + pacscore.load_state_dict(checkpoint['state_dict']) + pacscore.eval() + + args.device = device + memory = compute_scores(memory, pacscore, polos, preprocess, args) + return memory, tops \ No newline at end of file diff --git a/validate/compute_foil.py b/validate/compute_foil.py new file mode 100644 index 0000000000000000000000000000000000000000..66f4947de2a40e5877fdcd69ec6bcc5436004c14 --- /dev/null +++ b/validate/compute_foil.py @@ -0,0 +1,175 @@ +import json +from polos.metrics.regression_metrics import RegressionReport +from polos.models import load_checkpoint +from tqdm import tqdm +import json +from polos.models import download_model, load_checkpoint, model2download, str2model +from polos.trainer import TrainerConfig, build_trainer +import yaml +from utils import * +from dataset import * +from pascal50s import Pascal50sDataset +from PIL import Image +from pathlib import Path +from copy import deepcopy + +class FoilDatset: + def __init__(self, coco_root_path="data_en/coco", foil_path="data_en/foil/foilv1.0_test_2017.json"): + coco_root_path = Path(coco_root_path) + coco_path = coco_root_path / Path("captions_val2014.json") + coco_refs = self._read_coco(coco_path) + self.data = self._build_foil(foil_path, coco_refs) # data[anno_id][foil or orig] = [anno1, anno2, ...] + self.coco_root_path = coco_root_path + self.dataset = {"one_ref" : None, "four_ref" : None} + + def _read_coco(self, coco_annos): + refs = {} + with open(coco_annos) as f: + coco = json.load(f) + for ann in coco["annotations"]: + refs.setdefault(ann['image_id'],[]).append(ann['caption']) + return refs + + def _build_foil(self, path, coco_refs): + with open(path) as f: + self.data = json.load(f) + images = self.data["images"] + annos = self.data["annotations"] + + data = {} + imgid_to_img = {img["id"] : img for img in images} + for anno in annos: + anno_id = anno["id"] + data.setdefault(anno_id, {"foil" : [], "orig" : []}) + key = "foil" if anno["foil"] else "orig" + anno["image"] = imgid_to_img[anno["image_id"]] + anno["refs"] = coco_refs[anno["image_id"]] + data[anno_id][key].append(anno) + + return data + + def get_data(self,one_ref): + key = "one_ref" if one_ref else "four_ref" + if self.dataset[key] is not None: + return self.dataset[key] + + dataset = [] + for _, data in (pbar := tqdm(self.data.items())): # data[anno_id][foil or orig] = [anno1, anno2, ...] + pbar.set_description("Prepare dataset ...") + foiles, origs = data["foil"], data["orig"] + + assert len(origs) == 1 + N = len(foiles) + for foil, orig in zip(foiles, [origs[0]]*N): + refs = foil["refs"] + refs = [r for r in refs if r != orig["caption"]] + if one_ref: + refs = [refs[0]] + + filename = Path(foil["image"]["file_name"]) + img_path = Path("data_en/images") / filename + + dataset.append({ + "imgid" : img_path, + "refs": refs, + "mt": foil["caption"], + "type": "foil" + }) + dataset.append({ + "imgid" : img_path, + "refs": refs, + "mt": orig["caption"], + "type": "orig" + }) + + self.dataset[key] = dataset + return self.dataset[key] + +def collect_acc(memory, dataset_name, method, acc): + memory.setdefault(dataset_name, {}) + memory[dataset_name].update({method : acc}) + gprint(f"[{dataset_name}]",method,acc) + +def polos(dataset,args): + yprint("Compute Polos ...") + rep = RegressionReport() + if args.model: + model = load_checkpoint(args.model) + elif args.hparams: + yaml_file = yaml.load(open(args.hparams).read(), Loader=yaml.FullLoader) + train_configs = TrainerConfig(yaml_file) + model_config = str2model[train_configs.model].ModelConfig(yaml_file) + print(str2model[train_configs.model].ModelConfig) + print(model_config.namespace()) + model = str2model[train_configs.model](model_config.namespace()) + model.eval() + model.freeze() + + data = [] + gt_scores = [] + for data_ in (pbar := tqdm(dataset)): + pbar.set_description("Prepare dataset ...") + data.append(data_) + + _, sys_score = model.predict(data,cuda=True,batch_size=32) + return sys_score + +def compute_acc(model_fn,dataset,one_ref,**kwargs): + # Split by buckets because images do not fit in RAM. + bucket_count = 10 + data = dataset.get_data(one_ref) + + print("Compute ...") + sys_score = [] + for i in range(bucket_count): + bucket_size = len(data) // bucket_count + subset = deepcopy(data[i*bucket_size:(i+1)*bucket_size]) + for j, sub in enumerate(pbar := tqdm(subset)): + pbar.set_description(f"Processing {i+1}/{bucket_count}") + subset[j].update({"img" : Image.open(sub["imgid"]).convert("RGB")}) + sub_sys_score = model_fn(subset,**kwargs) + sys_score.extend(sub_sys_score) + del subset + + assert len(sys_score) == len(data) + assert len(sys_score) % 2 == 0 + + acc = 0. + N = len(sys_score) // 2 + for i in range(0,2*N,2): + s1 = sys_score[i] # foil + s2 = sys_score[i+1] # orig + + # sanity check + assert data[i]["type"] == "foil" and data[i+1]["type"] == "orig" + + if s2 > s1: + acc += 1. + + acc /= N + rprint(f"acc: {acc}") + + return acc + + +def compute_foil(args, memory, tops): + dataset = FoilDatset() + dataset_name = "foil" + for one_ref in [True, False]: + suffix = "(one_ref)" if one_ref else "(four-ref)" + dataset_name += suffix + if args.polos: + polos_acc = compute_acc(polos, dataset, one_ref, args=args) + collect_acc(memory, dataset_name, f"Polos{suffix}", polos_acc) + + # aggregate + max_acc = ("", 0.) + for method, acc in memory[dataset_name].items(): + if max_acc[1] < acc: + max_acc = (method, acc) + + rprint("[TOP]") + rprint(max_acc) + tops[dataset_name] = max_acc + + return memory, tops \ No newline at end of file diff --git a/validate/compute_pascal50s.py b/validate/compute_pascal50s.py new file mode 100644 index 0000000000000000000000000000000000000000..5672be2bec4c2e4242792f7d8bc2774b6c7768af --- /dev/null +++ b/validate/compute_pascal50s.py @@ -0,0 +1,103 @@ +from polos.metrics.regression_metrics import RegressionReport +from polos.models import load_checkpoint +from tqdm import tqdm +from polos.models import download_model, load_checkpoint, model2download, str2model +from polos.trainer import TrainerConfig, build_trainer +import yaml +from utils import * +from dataset import * +from pascal50s import Pascal50sDataset +from PIL import Image + +def collect_acc(memory, dataset_name, method, acc): + memory.setdefault(dataset_name, {}) + memory[dataset_name].update({method : acc}) + gprint(f"[{dataset_name}]",method,acc) + +def polos(dataset,args): + yprint("Compute Polos ...") + rep = RegressionReport() + if args.model: + model = load_checkpoint(args.model) + elif args.hparams: + yaml_file = yaml.load(open(args.hparams).read(), Loader=yaml.FullLoader) + train_configs = TrainerConfig(yaml_file) + model_config = str2model[train_configs.model].ModelConfig(yaml_file) + print(str2model[train_configs.model].ModelConfig) + print(model_config.namespace()) + model = str2model[train_configs.model](model_config.namespace()) + model.eval() + model.freeze() + + data = [] + gt_scores = [] + for data_ in (pbar := tqdm(dataset)): + pbar.set_description("Prepare dataset ...") + data.append(data_) + + _, sys_score = model.predict(data,cuda=True,batch_size=32) + return sys_score + +def compute_acc(model_fn,dataset,**kwargs): + data = {} + gt = {} + for (img_path, a, b, references, category_str, label) in (pbar := tqdm(dataset)): + pbar.set_description("Prepare dataset ...") + data.setdefault(category_str, {"A" : [], "B" : [], "gt": []}) + data[category_str]["A"].append({ + "img" : Image.open(img_path).convert("RGB"), + "imgid" : img_path, + "refs": references, + "mt": a, + }) + data[category_str]["B"].append({ + "img" : Image.open(img_path).convert("RGB"), + "imgid" : img_path, + "refs": references, + "mt": b, + }) + data[category_str]["gt"].append(label) # 0 if A > B else 1 + + accs = {} + for category_str, data_ in (pbar := tqdm(data.items())): + pbar.set_description(f"Compute {category_str}") + print("Compute type A ...") + sys_scoreA = model_fn(data_["A"],**kwargs) + + print("Compute type B ...") + sys_scoreB = model_fn(data_["B"],**kwargs) + + print("Compute accuracy ...") + assert len(sys_scoreA) == len(sys_scoreB) == len(data_["gt"]) + acc, N = 0, len(sys_scoreA) + for a, b, gt in zip(sys_scoreA,sys_scoreB,data_["gt"]): + score = 0 if a > b else 1 + acc += 1 if score == gt else 0 + + acc /= N + accs[category_str] = acc + rprint(f"acc({category_str}) : {acc}") + + return accs + + +def compute_pascal50S(args, memory, tops): + dataset = Pascal50sDataset(root="data_en/pascal/", voc_path="data_en/pascal/VOCdevkit/VOC2010") + dataset_name = "pascal50s" + if args.polos: + polos_acc = compute_acc(polos, dataset, args=args) + collect_acc(memory, dataset_name, "Polos", polos_acc) + + # aggregate + max_acc = {} + for method, accs in memory[dataset_name].items(): + for category, acc in accs.items(): + max_acc.setdefault(category, ("",0)) + if max_acc[category][1] < acc: + max_acc[category] = (method, acc) + + rprint("[TOP]") + rprint(max_acc) + tops[dataset_name] = max_acc + + return memory, tops \ No newline at end of file diff --git a/validate/dataset.py b/validate/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..a93e88446d9608ea477c0c4fb060c4e36c465cc2 --- /dev/null +++ b/validate/dataset.py @@ -0,0 +1,55 @@ +import pandas as pd +import itertools +from polos.models.model_base import CVPRDataset + +def get_dataset(path): + df = pd.read_csv(path) + df = df[["mt","refs","score", "imgid"]] + refs_list = [] + for refs in df["refs"]: + refs = eval(refs) + refs_list.append(refs) + + df["refs"] = refs_list + df["mt"] = df["mt"].astype(str) + df["score"] = df["score"].astype(float) + df["imgid"] = df["imgid"].astype(str) + test_dataset = df.to_dict("records") + test_dataset = CVPRDataset(test_dataset, "data_en/polaris/images") + return test_dataset + + + +# def get_dataset(path, permute=False): +# dataset_list = [] +# if permute: +# df = pd.read_csv(path) +# df = df[["mt","refs","score", "imgid"]] +# min_len = 1e18 +# for refs in df["refs"]: +# refs = eval(refs) +# min_len = min(len(refs), min_len) +# idxs = list(range(min_len)) +# idx_list = itertools.permutations(idxs, 2) +# else: +# idx_list = [(0, 1)] + +# for idx1, idx2 in idx_list: +# df = pd.read_csv(path) +# df = df[["mt","refs","score", "imgid"]] +# src, ref = [], [] +# for refs in df["refs"]: +# refs = eval(refs) +# src.append(refs[idx1]) +# ref.append(refs[idx2]) + +# df["src"] = src +# df["ref"] = ref +# df["mt"] = df["mt"].astype(str) +# df["score"] = df["score"].astype(float) +# df["imgid"] = df["imgid"].astype(str) +# test_dataset = df.to_dict("records") +# test_dataset = CVPRDataset(test_dataset, "data_en/images") +# dataset_list.append(test_dataset) + +# return dataset_list \ No newline at end of file diff --git a/validate/metrics.py b/validate/metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..22fc79c8521ba57aabab9dc0138fdebd055a1ce3 --- /dev/null +++ b/validate/metrics.py @@ -0,0 +1,38 @@ +import json +import shutil +import os +from polos.metrics.regression_metrics import RegressionReport +from polos.models import load_checkpoint +from tqdm import tqdm +import json +from polos.models import download_model, load_checkpoint, model2download, str2model +from polos.trainer import TrainerConfig, build_trainer +import yaml +from utils import * +from dataset import * + +def compute_polos_coef(args,test_dataset,dataset_name,kendall_type): + yprint("Compute Polos ...") + rep = RegressionReport(kendall_type) + if args.model: + model = load_checkpoint(args.model) + elif args.hparams: + yaml_file = yaml.load(open(args.hparams).read(), Loader=yaml.FullLoader) + train_configs = TrainerConfig(yaml_file) + model_config = str2model[train_configs.model].ModelConfig(yaml_file) + print(str2model[train_configs.model].ModelConfig) + print(model_config.namespace()) + model = str2model[train_configs.model](model_config.namespace()) + model.eval() + model.freeze() + + data = [] + gt_scores = [] + for data_ in (pbar := tqdm(test_dataset)): + pbar.set_description("Prepare dataset ...") + data.append(data_) + gt_scores.append(data_["score"]) + + _, sys_score = model.predict(data,cuda=True,batch_size=32) + coef = rep.compute(sys_score, gt_scores) + return coef \ No newline at end of file diff --git a/validate/mid.py b/validate/mid.py new file mode 100644 index 0000000000000000000000000000000000000000..ea44ac73c3fec2cf9e54c8423cde1d0897191849 --- /dev/null +++ b/validate/mid.py @@ -0,0 +1,146 @@ +from typing import * +import random + +import torch +from torch import Tensor + +from torchmetrics.metric import Metric +from torchmetrics.utilities import rank_zero_info +import clip +import torch.nn.functional as F +from tqdm import tqdm +from PIL import Image + +def read_image(imgid): + from pathlib import Path + vanilla = Path(imgid) + fixed = Path(f"data_en/images/{imgid}") + assert not (vanilla.exists() == fixed.exists()) # 両者共に存在/不在だと困る + + path = vanilla if vanilla.exists() else fixed + return Image.open(path).convert("RGB") + + +class MID(): + def __init__(self,device="cuda"): + self.clip, self.clip_preprocess = clip.load("ViT-B/32", device=device) + self.device = device + + def batchify(self, targets, batch_size): + return [targets[i:i+batch_size] for i in range(0,len(targets),batch_size)] + + def __call__(self, mt_list, refs_list, img_list, no_ref=False): + B = 32 + mt_list, refs_list, img_list = [self.batchify(x,B) for x in [mt_list,refs_list,img_list]] + scores = [] + assert len(mt_list) == len(refs_list) == len(img_list) + for mt, refs, imgs in (pbar:= tqdm(zip(mt_list,refs_list, img_list),total=len(mt_list))): + pbar.set_description(f"MID") + imgs = [read_image(imgid) for imgid in imgs] + refs_token = [] + for ref_list in refs: + refs_token.append([clip.tokenize(ref,truncate=True).to(self.device) for ref in ref_list]) + + refs = torch.cat([torch.cat(ref,dim=0) for ref in refs_token], dim=0) + mts = clip.tokenize([x for x in mt],truncate=True).to(self.device) + imgs = torch.cat([self.clip_preprocess(img).unsqueeze(0) for img in imgs],dim=0).to(self.device) + + imgs = self.clip.encode_image(imgs) + mts = self.clip.encode_text(mts) + refs = self.clip.encode_text(refs) + compute_pmi(imgs,refs,mts) + + return scores + + + +def log_det(X): + eigenvalues = X.svd()[1] + return eigenvalues.log().sum() + + +def robust_inv(x, eps=0): + Id = torch.eye(x.shape[0]).to(x.device) + return (x + eps * Id).inverse() + + +def exp_smd(a, b, reduction=True): + a_inv = robust_inv(a) + if reduction: + assert b.shape[0] == b.shape[1] + return (a_inv @ b).trace() + else: + return (b @ a_inv @ b.t()).diag() + + +def compute_pmi(x: Tensor, y: Tensor, x0: Tensor, limit: int = 30000, + reduction: bool = True, full: bool = False) -> Tensor: + r""" + A numerical stable version of the MID score. + + Args: + x (Tensor): features for real samples + y (Tensor): features for text samples + x0 (Tensor): features for fake samples + limit (int): limit the number of samples + reduction (bool): returns the expectation of PMI if true else sample-wise results + full (bool): use full samples from real images + + Returns: + Scalar value of the mutual information divergence between the sets. + """ + N = x.shape[0] + excess = N - limit + if 0 < excess: + if not full: + x = x[:-excess] + y = y[:-excess] + x0 = x0[:-excess] + N = x.shape[0] + M = x0.shape[0] + + assert N >= x.shape[1], "not full rank for matrix inversion!" + if x.shape[0] < 30000: + rank_zero_info("if it underperforms, please consider to use " + "the epsilon of 5e-4 or something else.") + + z = torch.cat([x, y], dim=-1) + z0 = torch.cat([x0, y[:x0.shape[0]]], dim=-1) + x_mean = x.mean(dim=0, keepdim=True) + y_mean = y.mean(dim=0, keepdim=True) + z_mean = torch.cat([x_mean, y_mean], dim=-1) + x0_mean = x0.mean(dim=0, keepdim=True) + z0_mean = z0.mean(dim=0, keepdim=True) + + X = (x - x_mean).t() @ (x - x_mean) / (N - 1) + Y = (y - y_mean).t() @ (y - y_mean) / (N - 1) + Z = (z - z_mean).t() @ (z - z_mean) / (N - 1) + X0 = (x0 - x_mean).t() @ (x0 - x_mean) / (M - 1) # use the reference mean + Z0 = (z0 - z_mean).t() @ (z0 - z_mean) / (M - 1) # use the reference mean + + alternative_comp = False + # notice that it may have numerical unstability. we don't use this. + if alternative_comp: + def factorized_cov(x, m): + N = x.shape[0] + return (x.t() @ x - N * m.t() @ m) / (N - 1) + X0 = factorized_cov(x0, x_mean) + Z0 = factorized_cov(z0, z_mean) + + # assert double precision + for _ in [X, Y, Z, X0, Z0]: + assert _.dtype == torch.float64 + + # Expectation of PMI + mi = (log_det(X) + log_det(Y) - log_det(Z)) / 2 + rank_zero_info(f"MI of real images: {mi:.4f}") + + # Squared Mahalanobis Distance terms + if reduction: + smd = (exp_smd(X, X0) + exp_smd(Y, Y) - exp_smd(Z, Z0)) / 2 + else: + smd = (exp_smd(X, x0 - x_mean, False) + exp_smd(Y, y - y_mean, False) + - exp_smd(Z, z0 - z_mean, False)) / 2 + mi = mi.unsqueeze(0) # for broadcasting + + return mi + smd diff --git a/validate/pascal50s.py b/validate/pascal50s.py new file mode 100644 index 0000000000000000000000000000000000000000..eabceaa8ad023dbd6519a986baac14510b61aea3 --- /dev/null +++ b/validate/pascal50s.py @@ -0,0 +1,119 @@ +# from https://github.com/jmhessel/clipscore/issues/4 + +import torch +import random +import scipy +import os +from tqdm import tqdm + +class Pascal50sDataset(torch.utils.data.Dataset): + + def __init__(self, + root: str = "data/Pascal-50s/", + media_size: int = 224, + voc_path: str = "data/VOC2010/"): + super().__init__() + self.voc_path = voc_path + self.fix_seed() + self.read_data(root) + self.read_score(root) + self.idx2cat = {1: 'HC', 2: 'HI', 3: 'HM', 4: 'MM'} + + @staticmethod + def loadmat(path): + return scipy.io.loadmat(path) + + def fix_seed(self, seed=42): + torch.manual_seed(seed) + random.seed(seed) + + def read_data(self, root): + mat = self.loadmat( + os.path.join(root, "pyCIDErConsensus/pair_pascal.mat")) + self.data = mat["new_input"][0] + self.categories = mat["category"][0] + # sanity check + c = torch.Tensor(mat["new_data"]) + hc = (c.sum(dim=-1) == 12).int() + hi = (c.sum(dim=-1) == 13).int() + hm = ((c < 6).sum(dim=-1) == 1).int() + mm = ((c < 6).sum(dim=-1) == 2).int() + assert 1000 == hc.sum() + assert 1000 == hi.sum() + assert 1000 == hm.sum() + assert 1000 == mm.sum() + assert (hc + hi + hm + mm).sum() == self.categories.shape[0] + chk = (torch.Tensor(self.categories) - hc - hi * 2 - hm * 3 - mm * 4) + assert 0 == chk.abs().sum(), chk + + def read_score(self, root): + mat = self.loadmat( + os.path.join(root, "pyCIDErConsensus/consensus_pascal.mat")) + data = mat["triplets"][0] + self.labels = [] + self.references = [] + for i in range(len(self)): + votes = {} + refs = [] + for j in range(i * 48, (i + 1) * 48): + a,b,c,d = [x[0][0] for x in data[j]] + key = b[0].strip() if 1 == d else c[0].strip() + refs.append(a[0].strip()) + votes[key] = votes.get(key, 0) + 1 + assert 2 >= len(votes.keys()), votes + assert len(votes.keys()) > 0 + try: + vote_a = votes.get(self.data[i][1][0].strip(), 0) + vote_b = votes.get(self.data[i][2][0].strip(), 0) + except KeyError: + print("warning: data mismatch!") + print(f"a: {self.data[i][1][0].strip()}") + print(f"b: {self.data[i][2][0].strip()}") + print(votes) + exit() + # Ties are broken randomly. + label = 0 if vote_a > vote_b + random.random() - .5 else 1 # a == bの場合は0.5の確率で0か1を選ぶ + self.labels.append(label) + self.references.append(refs) + + def __len__(self): + return len(self.data) + + def get_image_path(self, filename: str): + path = os.path.join(self.voc_path, "JPEGImages") + return os.path.join(path, filename) + + def __getitem__(self, idx: int): + vid, a, b = [x[0] for x in self.data[idx]] + label = self.labels[idx] + img_path = self.get_image_path(vid) + a = a.strip() + b = b.strip() + references = self.references[idx] + category = self.categories[idx] + category_str = self.idx2cat[category] + return img_path, a, b, references, category_str, label + +def sanity_check(detail=False): + # sanity check + dataset = Pascal50sDataset(root="pascal/", voc_path="pascal/VOCdevkit/VOC2010") + one_sample = dataset[0] + assert one_sample is not None + + dprint = lambda *args, **kwargs: print(*args, **kwargs) if detail else None + for it, one_sample in enumerate(tqdm(dataset)): + dprint("="*20) + dprint("sample:",it) + dprint("="*20) + img_path, a, b, references, category, label = one_sample + assert os.path.exists(img_path) + + dprint("img_path:", img_path) + dprint("a:", a) + dprint("b:", b) + dprint("references:", references) + dprint("category:", category) + dprint("label:", label) + +if __name__ == "__main__": + sanity_check(detail=False) diff --git a/validate/utils.py b/validate/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ebdb992330140ac749052e9929ee76751b2c683f --- /dev/null +++ b/validate/utils.py @@ -0,0 +1,38 @@ +from termcolor import colored +def rprint(*args): + combined_text = ' '.join(map(str, args)) + print(colored(combined_text, 'white', 'on_red', attrs=["bold"])) + +def yprint(*args): + combined_text = ' '.join(map(str, args)) + print(colored(combined_text, 'yellow',attrs=["bold"])) + +def gprint(*args): + combined_text = ' '.join(map(str, args)) + print(colored(combined_text, 'green',attrs=["bold"])) + +def draw_histogram(predictions, targets, save_path): + import matplotlib + import matplotlib.pyplot as plt + from pathlib import Path + save_path = Path(save_path) + save_path.parent.mkdir(parents=True, exist_ok=True) + + matplotlib.use('Agg') + plt.figure(figsize=(10, 5)) + + plt.subplot(1, 2, 1) + plt.hist(predictions, bins=20, alpha=0.5, color='blue', label='Predictions') + plt.title('Predictions') + plt.xlabel('Value') + plt.ylabel('Frequency') + + plt.subplot(1, 2, 2) + plt.hist(targets, bins=20, alpha=0.5, color='red', label='Targets') + plt.title('Targets') + plt.xlabel('Value') + plt.ylabel('Frequency') + + plt.tight_layout() + # plt.show() + plt.savefig(save_path) \ No newline at end of file diff --git a/validate/validate_cvpr.py b/validate/validate_cvpr.py new file mode 100644 index 0000000000000000000000000000000000000000..8422c3dd76b2c54a6864d0cafb8583760fb515aa --- /dev/null +++ b/validate/validate_cvpr.py @@ -0,0 +1,72 @@ +import json +import argparse +import json +from utils import * +from dataset import * +from metrics import * +from compute_correlations import compute_flickr +from compute_pascal50s import compute_pascal50S +from compute_foil import compute_foil + +def collect_coef(memory, dataset_name, method, coef_tensor): + memory.setdefault(dataset_name, {}) + coef = {k : round(float(v.numpy() if not isinstance(v,float) else v),4) for k, v in coef_tensor.items()} + memory[dataset_name].update({method : coef}) + gprint(f"[{dataset_name}]",method,coef) + +def compute_coef(args,memory,tops): + dataset_name = "test" + path = f"data_en/polaris/polaris_{dataset_name}.csv" + yprint(f"Processing {dataset_name} ... (path: {path})") + test_dataset = get_dataset(path) + + # mypolos + if args.polos: + polos_coef = compute_polos_coef(args,test_dataset,dataset_name,kendall_type='c') + collect_coef(memory, dataset_name, "Polos", polos_coef) + + return memory, tops + + +def main(args): + memory, tops = {}, {} + if args.flickr: + memory, tops = compute_flickr(args,args.model,memory,tops) + if args.coef: + memory, tops = compute_coef(args, memory, tops) + if args.pascal: + memory, tops = compute_pascal50S(args, memory, tops) + if args.foil: + memory, tops = compute_foil(args, memory, tops) + + with open("zeroshot_test_results.json", "w") as f: + json.dump(memory, f, indent=4) + + yprint("[RESULTS]") + gprint(json.dumps(memory, indent=4)) + + rprint("[TOP]") + for dataset_name, values in tops.items(): + rprint(f"> {dataset_name}") + if isinstance(values,dict): # coef + for kind, coef in values.items(): + rprint(f"{kind}: {coef[0]} ({coef[1]})") + else: # acc + method, acc = values + rprint(f"{method} ({acc})") + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + # models + parser.add_argument('--model', default=None) + parser.add_argument('--hparams',default=None) + parser.add_argument('--polos', action='store_true') + + # benchmarks + parser.add_argument('--coef', action='store_true') + parser.add_argument('--flickr', action='store_true') + parser.add_argument('--pascal', action='store_true') + parser.add_argument('--foil', action='store_true') + + args = parser.parse_args() + main(args)