add original

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.meta filter=lfs diff=lfs merge=lfs -text

original/anytext_v1.1.ckpt

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

original/clip-vit-large-patch14/.gitattributes

@@ -0,0 +1,28 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text 
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+model.safetensors filter=lfs diff=lfs merge=lfs -text

original/clip-vit-large-patch14/README.md

@@ -0,0 +1,145 @@
+---
+tags:
+- vision
+widget:
+- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/cat-dog-music.png
+  candidate_labels: playing music, playing sports
+  example_title: Cat & Dog
+---
+
+# Model Card: CLIP
+
+Disclaimer: The model card is taken and modified from the official CLIP repository, it can be found [here](https://github.com/openai/CLIP/blob/main/model-card.md).
+
+## 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 ViT-L/14 Transformer architecture 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.
+
+The original implementation had two variants: one using a ResNet image encoder and the other using a Vision Transformer. This repository has the variant with the Vision Transformer.
+
+
+### Documents
+
+- [Blog Post](https://openai.com/blog/clip/)
+- [CLIP Paper](https://arxiv.org/abs/2103.00020)
+
+
+### Use with Transformers
+
+```python
+from PIL import Image
+import requests
+
+from transformers import CLIPProcessor, CLIPModel
+
+model = CLIPModel.from_pretrained("openai/clip-vit-large-patch14")
+processor = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14")
+
+url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+image = Image.open(requests.get(url, stream=True).raw)
+
+inputs = processor(text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True)
+
+outputs = model(**inputs)
+logits_per_image = outputs.logits_per_image # this is the image-text similarity score
+probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities
+```
+
+
+## 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)

original/clip-vit-large-patch14/config.json

@@ -0,0 +1,171 @@
+{
+  "_name_or_path": "clip-vit-large-patch14/",
+  "architectures": [
+    "CLIPModel"
+  ],
+  "initializer_factor": 1.0,
+  "logit_scale_init_value": 2.6592,
+  "model_type": "clip",
+  "projection_dim": 768,
+  "text_config": {
+    "_name_or_path": "",
+    "add_cross_attention": false,
+    "architectures": null,
+    "attention_dropout": 0.0,
+    "bad_words_ids": null,
+    "bos_token_id": 0,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "dropout": 0.0,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": 2,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "quick_gelu",
+    "hidden_size": 768,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_eps": 1e-05,
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "max_position_embeddings": 77,
+    "min_length": 0,
+    "model_type": "clip_text_model",
+    "no_repeat_ngram_size": 0,
+    "num_attention_heads": 12,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_hidden_layers": 12,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": 1,
+    "prefix": null,
+    "problem_type": null,
+    "projection_dim" : 768,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": null,
+    "torchscript": false,
+    "transformers_version": "4.16.0.dev0",
+    "use_bfloat16": false,
+    "vocab_size": 49408
+  },
+  "text_config_dict": {
+    "hidden_size": 768,
+    "intermediate_size": 3072,
+    "num_attention_heads": 12,
+    "num_hidden_layers": 12,
+    "projection_dim": 768
+  },
+  "torch_dtype": "float32",
+  "transformers_version": null,
+  "vision_config": {
+    "_name_or_path": "",
+    "add_cross_attention": false,
+    "architectures": null,
+    "attention_dropout": 0.0,
+    "bad_words_ids": null,
+    "bos_token_id": null,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "dropout": 0.0,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "quick_gelu",
+    "hidden_size": 1024,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "image_size": 224,
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 4096,
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_eps": 1e-05,
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "min_length": 0,
+    "model_type": "clip_vision_model",
+    "no_repeat_ngram_size": 0,
+    "num_attention_heads": 16,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_hidden_layers": 24,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": null,
+    "patch_size": 14,
+    "prefix": null,
+    "problem_type": null,
+    "projection_dim" : 768,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": null,
+    "torchscript": false,
+    "transformers_version": "4.16.0.dev0",
+    "use_bfloat16": false
+  },
+  "vision_config_dict": {
+    "hidden_size": 1024,
+    "intermediate_size": 4096,
+    "num_attention_heads": 16,
+    "num_hidden_layers": 24,
+    "patch_size": 14,
+    "projection_dim": 768
+  }
+}

original/clip-vit-large-patch14/preprocessor_config.json

@@ -0,0 +1,19 @@
+{
+  "crop_size": 224,
+  "do_center_crop": true,
+  "do_normalize": true,
+  "do_resize": true,
+  "feature_extractor_type": "CLIPFeatureExtractor",
+  "image_mean": [
+    0.48145466,
+    0.4578275,
+    0.40821073
+  ],
+  "image_std": [
+    0.26862954,
+    0.26130258,
+    0.27577711
+  ],
+  "resample": 3,
+  "size": 224
+}

original/clip-vit-large-patch14/pytorch_model.bin

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

original/clip-vit-large-patch14/special_tokens_map.json

@@ -0,0 +1 @@
+{"bos_token": {"content": "<|startoftext|>", "single_word": false, "lstrip": false, "rstrip": false, "normalized": true}, "eos_token": {"content": "<|endoftext|>", "single_word": false, "lstrip": false, "rstrip": false, "normalized": true}, "unk_token": {"content": "<|endoftext|>", "single_word": false, "lstrip": false, "rstrip": false, "normalized": true}, "pad_token": "<|endoftext|>"}

original/clip-vit-large-patch14/tokenizer_config.json

@@ -0,0 +1,34 @@
+{
+    "unk_token": {
+        "content": "<|endoftext|>",
+        "single_word": false,
+        "lstrip": false,
+        "rstrip": false,
+        "normalized": true,
+        "__type": "AddedToken"
+    },
+    "bos_token": {
+        "content": "<|startoftext|>",
+        "single_word": false,
+        "lstrip": false,
+        "rstrip": false,
+        "normalized": true,
+        "__type": "AddedToken"
+    },
+    "eos_token": {
+        "content": "<|endoftext|>",
+        "single_word": false,
+        "lstrip": false,
+        "rstrip": false,
+        "normalized": true,
+        "__type": "AddedToken"
+    },
+    "pad_token": "<|endoftext|>",
+    "add_prefix_space": false,
+    "errors": "replace",
+    "do_lower_case": true,
+    "name_or_path": "openai/clip-vit-base-patch32",
+    "model_max_length": 77,
+    "special_tokens_map_file": "./special_tokens_map.json",
+    "tokenizer_class": "CLIPTokenizer"
+}

original/configuration.json

@@ -0,0 +1 @@
+{"framework":"pytorch","task":"my-anytext-task","model":{"type":"my-custom-model"},"pipeline":{"type":"my-custom-pipeline"},"allow_remote":true}

original/ms_wrapper.py

@@ -0,0 +1,385 @@
+'''
+AnyText: Multilingual Visual Text Generation And Editing
+Paper: https://arxiv.org/abs/2311.03054
+Code: https://github.com/tyxsspa/AnyText
+Copyright (c) Alibaba, Inc. and its affiliates.
+'''
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+import torch
+import random
+import re
+import numpy as np
+import cv2
+import einops
+import time
+from PIL import ImageFont
+from cldm.model import create_model, load_state_dict
+from cldm.ddim_hacked import DDIMSampler
+from t3_dataset import draw_glyph, draw_glyph2
+from util import check_channels, resize_image, save_images
+from pytorch_lightning import seed_everything
+from modelscope.pipelines import pipeline
+from modelscope.utils.constant import Tasks
+from modelscope.models.base import TorchModel
+from modelscope.preprocessors.base import Preprocessor
+from modelscope.pipelines.base import Model, Pipeline
+from modelscope.utils.config import Config
+from modelscope.pipelines.builder import PIPELINES
+from modelscope.preprocessors.builder import PREPROCESSORS
+from modelscope.models.builder import MODELS
+from bert_tokenizer import BasicTokenizer
+checker = BasicTokenizer()
+BBOX_MAX_NUM = 8
+PLACE_HOLDER = '*'
+max_chars = 20
+
+
+@MODELS.register_module('my-anytext-task', module_name='my-custom-model')
+class MyCustomModel(TorchModel):
+
+    def __init__(self, model_dir, *args, **kwargs):
+        super().__init__(model_dir, *args, **kwargs)
+        self.init_model(**kwargs)
+
+    '''
+    return:
+        result: list of images in numpy.ndarray format
+        rst_code: 0: normal -1: error 1:warning
+        rst_info: string of error or warning
+        debug_info: string for debug, only valid if show_debug=True
+    '''
+    def forward(self, input_tensor, **forward_params):
+        tic = time.time()
+        str_warning = ''
+        # get inputs
+        seed = input_tensor.get('seed', -1)
+        if seed == -1:
+            seed = random.randint(0, 99999999)
+        seed_everything(seed)
+        prompt = input_tensor.get('prompt')
+        draw_pos = input_tensor.get('draw_pos')
+        ori_image = input_tensor.get('ori_image')
+
+        mode = forward_params.get('mode')
+        sort_priority = forward_params.get('sort_priority', '↕')
+        show_debug = forward_params.get('show_debug', False)
+        revise_pos = forward_params.get('revise_pos', False)
+        img_count = forward_params.get('image_count', 4)
+        ddim_steps = forward_params.get('ddim_steps', 20)
+        w = forward_params.get('image_width', 512)
+        h = forward_params.get('image_height', 512)
+        strength = forward_params.get('strength', 1.0)
+        cfg_scale = forward_params.get('cfg_scale', 9.0)
+        eta = forward_params.get('eta', 0.0)
+        a_prompt = forward_params.get('a_prompt', 'best quality, extremely detailed,4k, HD, supper legible text,  clear text edges,  clear strokes, neat writing, no watermarks')
+        n_prompt = forward_params.get('n_prompt', 'low-res, bad anatomy, extra digit, fewer digits, cropped, worst quality, low quality, watermark, unreadable text, messy words, distorted text, disorganized writing, advertising picture')
+
+        prompt, texts = self.modify_prompt(prompt)
+        n_lines = len(texts)
+        if mode in ['text-generation', 'gen']:
+            edit_image = np.ones((h, w, 3)) * 127.5  # empty mask image
+        elif mode in ['text-editing', 'edit']:
+            if draw_pos is None or ori_image is None:
+                return None, -1, "Reference image and position image are needed for text editing!", ""
+            if isinstance(ori_image, str):
+                ori_image = cv2.imread(ori_image)[..., ::-1]
+                assert ori_image is not None, f"Can't read ori_image image from{ori_image}!"
+            elif isinstance(ori_image, torch.Tensor):
+                ori_image = ori_image.cpu().numpy()
+            else:
+                assert isinstance(ori_image, np.ndarray), f'Unknown format of ori_image: {type(ori_image)}'
+            edit_image = ori_image.clip(1, 255)  # for mask reason
+            edit_image = check_channels(edit_image)
+            edit_image = resize_image(edit_image, max_length=768)  # make w h multiple of 64, resize if w or h > max_length
+            h, w = edit_image.shape[:2]  # change h, w by input ref_img
+        # preprocess pos_imgs(if numpy, make sure it's white pos in black bg)
+        if draw_pos is None:
+            pos_imgs = np.zeros((w, h, 1))
+        if isinstance(draw_pos, str):
+            draw_pos = cv2.imread(draw_pos)[..., ::-1]
+            assert draw_pos is not None, f"Can't read draw_pos image from{draw_pos}!"
+            pos_imgs = 255-draw_pos
+        elif isinstance(draw_pos, torch.Tensor):
+            pos_imgs = draw_pos.cpu().numpy()
+        else:
+            assert isinstance(draw_pos, np.ndarray), f'Unknown format of draw_pos: {type(draw_pos)}'
+        pos_imgs = pos_imgs[..., 0:1]
+        pos_imgs = cv2.convertScaleAbs(pos_imgs)
+        _, pos_imgs = cv2.threshold(pos_imgs, 254, 255, cv2.THRESH_BINARY)
+        # seprate pos_imgs
+        pos_imgs = self.separate_pos_imgs(pos_imgs, sort_priority)
+        if len(pos_imgs) == 0:
+            pos_imgs = [np.zeros((h, w, 1))]
+        if len(pos_imgs) < n_lines:
+            if n_lines == 1 and texts[0] == ' ':
+                pass  # text-to-image without text
+            else:
+                return None, -1, f'Found {len(pos_imgs)} positions that < needed {n_lines} from prompt, check and try again!', ''
+        elif len(pos_imgs) > n_lines:
+            str_warning = f'Warning: found {len(pos_imgs)} positions that > needed {n_lines} from prompt.'
+        # get pre_pos, poly_list, hint that needed for anytext
+        pre_pos = []
+        poly_list = []
+        for input_pos in pos_imgs:
+            if input_pos.mean() != 0:
+                input_pos = input_pos[..., np.newaxis] if len(input_pos.shape) == 2 else input_pos
+                poly, pos_img = self.find_polygon(input_pos)
+                pre_pos += [pos_img/255.]
+                poly_list += [poly]
+            else:
+                pre_pos += [np.zeros((h, w, 1))]
+                poly_list += [None]
+        np_hint = np.sum(pre_pos, axis=0).clip(0, 1)
+        # prepare info dict
+        info = {}
+        info['glyphs'] = []
+        info['gly_line'] = []
+        info['positions'] = []
+        info['n_lines'] = [len(texts)]*img_count
+        gly_pos_imgs = []
+        for i in range(len(texts)):
+            text = texts[i]
+            if len(text) > max_chars:
+                str_warning = f'"{text}" length > max_chars: {max_chars}, will be cut off...'
+                text = text[:max_chars]
+            gly_scale = 2
+            if pre_pos[i].mean() != 0:
+                gly_line = draw_glyph(self.font, text)
+                glyphs = draw_glyph2(self.font, text, poly_list[i], scale=gly_scale, width=w, height=h, add_space=False)
+                gly_pos_img = cv2.drawContours(glyphs*255, [poly_list[i]*gly_scale], 0, (255, 255, 255), 1)
+                if revise_pos:
+                    resize_gly = cv2.resize(glyphs, (pre_pos[i].shape[1], pre_pos[i].shape[0]))
+                    new_pos = cv2.morphologyEx((resize_gly*255).astype(np.uint8), cv2.MORPH_CLOSE, kernel=np.ones((resize_gly.shape[0]//10, resize_gly.shape[1]//10), dtype=np.uint8), iterations=1)
+                    new_pos = new_pos[..., np.newaxis] if len(new_pos.shape) == 2 else new_pos
+                    contours, _ = cv2.findContours(new_pos, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+                    if len(contours) != 1:
+                        str_warning = f'Fail to revise position {i} to bounding rect, remain position unchanged...'
+                    else:
+                        rect = cv2.minAreaRect(contours[0])
+                        poly = np.int0(cv2.boxPoints(rect))
+                        pre_pos[i] = cv2.drawContours(new_pos, [poly], -1, 255, -1) / 255.
+                        gly_pos_img = cv2.drawContours(glyphs*255, [poly*gly_scale], 0, (255, 255, 255), 1)
+                gly_pos_imgs += [gly_pos_img]  # for show
+            else:
+                glyphs = np.zeros((h*gly_scale, w*gly_scale, 1))
+                gly_line = np.zeros((80, 512, 1))
+                gly_pos_imgs += [np.zeros((h*gly_scale, w*gly_scale, 1))]  # for show
+            pos = pre_pos[i]
+            info['glyphs'] += [self.arr2tensor(glyphs, img_count)]
+            info['gly_line'] += [self.arr2tensor(gly_line, img_count)]
+            info['positions'] += [self.arr2tensor(pos, img_count)]
+        # get masked_x
+        masked_img = ((edit_image.astype(np.float32) / 127.5) - 1.0)*(1-np_hint)
+        masked_img = np.transpose(masked_img, (2, 0, 1))
+        masked_img = torch.from_numpy(masked_img.copy()).float().cuda()
+        encoder_posterior = self.model.encode_first_stage(masked_img[None, ...])
+        masked_x = self.model.get_first_stage_encoding(encoder_posterior).detach()
+        info['masked_x'] = torch.cat([masked_x for _ in range(img_count)], dim=0)
+
+        hint = self.arr2tensor(np_hint, img_count)
+
+        cond = self.model.get_learned_conditioning(dict(c_concat=[hint], c_crossattn=[[prompt + ' , ' + a_prompt] * img_count], text_info=info))
+        un_cond = self.model.get_learned_conditioning(dict(c_concat=[hint], c_crossattn=[[n_prompt] * img_count], text_info=info))
+        shape = (4, h // 8, w // 8)
+        self.model.control_scales = ([strength] * 13)
+        samples, intermediates = self.ddim_sampler.sample(ddim_steps, img_count,
+                                                          shape, cond, verbose=False, eta=eta,
+                                                          unconditional_guidance_scale=cfg_scale,
+                                                          unconditional_conditioning=un_cond)
+        x_samples = self.model.decode_first_stage(samples)
+        x_samples = (einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 + 127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
+        results = [x_samples[i] for i in range(img_count)]
+        if mode == 'edit' and False:  # replace backgound in text editing but not ideal yet
+            results = [r*np_hint+edit_image*(1-np_hint) for r in results]
+            results = [r.clip(0, 255).astype(np.uint8) for r in results]
+        if len(gly_pos_imgs) > 0 and show_debug:
+            glyph_bs = np.stack(gly_pos_imgs, axis=2)
+            glyph_img = np.sum(glyph_bs, axis=2) * 255
+            glyph_img = glyph_img.clip(0, 255).astype(np.uint8)
+            results += [np.repeat(glyph_img, 3, axis=2)]
+        # debug_info
+        if not show_debug:
+            debug_info = ''
+        else:
+            input_prompt = prompt
+            for t in texts:
+                input_prompt = input_prompt.replace('*', f'"{t}"', 1)
+            debug_info = f'<span style="color:black;font-size:18px">Prompt: </span>{input_prompt}<br> \
+                           <span style="color:black;font-size:18px">Size: </span>{w}x{h}<br> \
+                           <span style="color:black;font-size:18px">Image Count: </span>{img_count}<br> \
+                           <span style="color:black;font-size:18px">Seed: </span>{seed}<br> \
+                           <span style="color:black;font-size:18px">Cost Time: </span>{(time.time()-tic):.2f}s'
+        rst_code = 1 if str_warning else 0
+        return results, rst_code, str_warning, debug_info
+
+    def init_model(self, **kwargs):
+        font_path = kwargs.get('font_path', 'font/Arial_Unicode.ttf')
+        self.font = ImageFont.truetype(font_path, size=60)
+        cfg_path = kwargs.get('cfg_path', 'models_yaml/anytext_sd15.yaml')
+        ckpt_path = kwargs.get('model_path', os.path.join(self.model_dir, 'anytext_v1.1.ckpt'))
+        clip_path = os.path.join(self.model_dir, 'clip-vit-large-patch14')
+        self.model = create_model(cfg_path, cond_stage_path=clip_path).cuda().eval()
+        self.model.load_state_dict(load_state_dict(ckpt_path, location='cuda'), strict=False)
+        self.ddim_sampler = DDIMSampler(self.model)
+        self.trans_pipe = pipeline(task=Tasks.translation, model=os.path.join(self.model_dir, 'nlp_csanmt_translation_zh2en'))
+
+    def modify_prompt(self, prompt):
+        prompt = prompt.replace('“', '"')
+        prompt = prompt.replace('”', '"')
+        p = '"(.*?)"'
+        strs = re.findall(p, prompt)
+        if len(strs) == 0:
+            strs = [' ']
+        else:
+            for s in strs:
+                prompt = prompt.replace(f'"{s}"', f' {PLACE_HOLDER} ', 1)
+        if self.is_chinese(prompt):
+            old_prompt = prompt
+            prompt = self.trans_pipe(input=prompt + ' .')['translation'][:-1]
+            print(f'Translate: {old_prompt} --> {prompt}')
+        return prompt, strs
+
+    def is_chinese(self, text):
+        text = checker._clean_text(text)
+        for char in text:
+            cp = ord(char)
+            if checker._is_chinese_char(cp):
+                return True
+        return False
+
+    def separate_pos_imgs(self, img, sort_priority, gap=102):
+        num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(img)
+        components = []
+        for label in range(1, num_labels):
+            component = np.zeros_like(img)
+            component[labels == label] = 255
+            components.append((component, centroids[label]))
+        if sort_priority == '↕':
+            fir, sec = 1, 0  # top-down first
+        elif sort_priority == '↔':
+            fir, sec = 0, 1  # left-right first
+        components.sort(key=lambda c: (c[1][fir]//gap, c[1][sec]//gap))
+        sorted_components = [c[0] for c in components]
+        return sorted_components
+
+    def find_polygon(self, image, min_rect=False):
+        contours, hierarchy = cv2.findContours(image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+        max_contour = max(contours, key=cv2.contourArea)  # get contour with max area
+        if min_rect:
+            # get minimum enclosing rectangle
+            rect = cv2.minAreaRect(max_contour)
+            poly = np.int0(cv2.boxPoints(rect))
+        else:
+            # get approximate polygon
+            epsilon = 0.01 * cv2.arcLength(max_contour, True)
+            poly = cv2.approxPolyDP(max_contour, epsilon, True)
+            n, _, xy = poly.shape
+            poly = poly.reshape(n, xy)
+        cv2.drawContours(image, [poly], -1, 255, -1)
+        return poly, image
+
+    def arr2tensor(self, arr, bs):
+        arr = np.transpose(arr, (2, 0, 1))
+        _arr = torch.from_numpy(arr.copy()).float().cuda()
+        _arr = torch.stack([_arr for _ in range(bs)], dim=0)
+        return _arr
+
+
+@PREPROCESSORS.register_module('my-anytext-task', module_name='my-custom-preprocessor')
+class MyCustomPreprocessor(Preprocessor):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.trainsforms = self.init_preprocessor(**kwargs)
+
+    def __call__(self, results):
+        return self.trainsforms(results)
+
+    def init_preprocessor(self, **kwarg):
+        """ Provide default implementation based on preprocess_cfg and user can reimplement it.
+            if nothing to do, then return lambda x: x
+        """
+        return lambda x: x
+
+
+@PIPELINES.register_module('my-anytext-task', module_name='my-custom-pipeline')
+class MyCustomPipeline(Pipeline):
+    """ Give simple introduction to this pipeline.
+
+    Examples:
+
+    >>> from modelscope.pipelines import pipeline
+    >>> input = "Hello, ModelScope!"
+    >>> my_pipeline = pipeline('my-task', 'my-model-id')
+    >>> result = my_pipeline(input)
+
+    """
+
+    def __init__(self, model, preprocessor=None, **kwargs):
+        super().__init__(model=model, auto_collate=False)
+        assert isinstance(model, str) or isinstance(model, Model), \
+            'model must be a single str or Model'
+        pipe_model = self.model
+        pipe_model.eval()
+        if preprocessor is None:
+            preprocessor = MyCustomPreprocessor()
+        super().__init__(model=pipe_model, preprocessor=preprocessor, **kwargs)
+
+    def _sanitize_parameters(self, **pipeline_parameters):
+        return {}, pipeline_parameters, {}
+
+    def _check_input(self, inputs):
+        pass
+
+    def _check_output(self, outputs):
+        pass
+
+    def forward(self, inputs, **forward_params):
+        return super().forward(inputs, **forward_params)
+
+    def postprocess(self, inputs):
+        return inputs
+
+
+usr_config_path = 'models'
+config = Config({
+    "framework": 'pytorch',
+    "task": 'my-anytext-task',
+    "model": {'type': 'my-custom-model'},
+    "pipeline": {"type": "my-custom-pipeline"},
+    "allow_remote": True
+})
+# config.dump('models/' + 'configuration.json')
+
+if __name__ == "__main__":
+    img_save_folder = "SaveImages"
+    inference = pipeline('my-anytext-task', model=usr_config_path)
+    params = {
+        "show_debug": True,
+        "image_count": 2,
+        "ddim_steps": 20,
+    }
+
+    # 1. text generation
+    mode = 'text-generation'
+    input_data = {
+        "prompt": 'photo of caramel macchiato coffee on the table, top-down perspective, with "Any" "Text" written on it using cream',
+        "seed": 66273235,
+        "draw_pos": 'example_images/gen9.png'
+    }
+    results, rtn_code, rtn_warning, debug_info = inference(input_data, mode=mode, **params)
+    if rtn_code >= 0:
+        save_images(results, img_save_folder)
+    # 2. text editing
+    mode = 'text-editing'
+    input_data = {
+        "prompt": 'A cake with colorful characters that reads "EVERYDAY"',
+        "seed": 8943410,
+        "draw_pos": 'example_images/edit7.png',
+        "ori_image": 'example_images/ref7.jpg'
+    }
+    results, rtn_code, rtn_warning, debug_info = inference(input_data, mode=mode, **params)
+    if rtn_code >= 0:
+        save_images(results, img_save_folder)
+    print(f'Done, result images are saved in: {img_save_folder}')

original/nlp_csanmt_translation_zh2en/README.md

@@ -0,0 +1,228 @@
+---
+tasks:
+- translation
+
+widgets:
+- task: translation
+  inputs:
+    - type: text
+      name: input
+      title: 输入文字
+      validator:
+        max_words: 128
+  examples:
+      - name: 1
+        title: 示例1
+        inputs:
+          - name: text
+            data: 阿里巴巴集团的使命是让天下没有难做的生意
+      - name: 2
+        title: 示例2
+        inputs:
+          - name: text
+            data: 今天天气真不错！
+
+model-type:
+- csanmt
+
+domain:
+- nlp
+
+frameworks:
+- tensorflow
+
+backbone:
+- transformer
+
+metrics:
+- bleu
+
+license: Apache License 2.0
+
+finetune-support: True
+
+language: 
+- zh-en
+
+finetune-support: True
+
+tags:
+- CSANMT
+- Neural Machine Translation
+- Continuous Semantic Augmentation
+- ACL2022
+
+datasets:
+  train:
+  - damo/WMT-Chinese-to-English-Machine-Translation-Training-Corpus
+  test:
+  - damo/WMT-Chinese-to-English-Machine-Translation-newstest
+  - damo/IWSLT-Chinese-to-English-Machine-Translation-Spoken
+  - damo/WMT-Chinese-to-English-Machine-Translation-Medical
+---
+# 基于连续语义增强的神经机器翻译模型介绍
+本模型基于邻域最小风险优化策略，backbone选用先进的transformer-large模型，编码器和解码器深度分别为24和6，相关论文已发表于ACL 2022，并获得Outstanding Paper Award。
+
+## 模型描述
+基于连续语义增强的神经机器翻译模型【[论文链接](https://arxiv.org/abs/2204.06812)】由编码器、解码器以及语义编码器三者构成。其中，语义编码器以大规模多语言预训练模型为基底，结合自适应对比学习，构建跨语言连续语义表征空间。此外，设计混合高斯循环采样策略，融合拒绝采样机制和马尔可夫链，提升采样效率的同时兼顾自然语言句子在离散空间中固有的分布特性。最后，结合邻域风险最小化策略优化翻译模型，能够有效提升数据的利用效率，显著改善模型的泛化能力和鲁棒性。模型结构如下图所示。
+
+<center> <img src="./resources/csanmt-model.png" alt="csanmt_translation_model" width="400"/> <br> <div style="color:orange; border-bottom: 1px solid #d9d9d9; display: inline-block; color: #999; padding: 2px;">CSANMT连续语义增强机器翻译</div> </center>
+
+具体来说，我们将双语句子对两个点作为球心，两点之间的欧氏距离作为半径，构造邻接语义区域（即邻域），邻域内的任意一点均与双语句子对语义等价。为了达到这一点，我们引入切线式对比学习，通过线性插值方法构造困难负样例，其中负样本的游走范围介于随机负样本和切点之间。然后，基于混合高斯循环采样策略，从邻接语义分布中采样增强样本，通过对差值向量进行方向变换和尺度缩放，可以将采样目标退化为选择一系列的尺度向量。
+
+<div> <center> <img src="./resources/ctl.png" alt="tangential_ctl" width="300"/> <br> <div style="color:orange; border-bottom: 1px solid #d9d9d9; display: inline-block; color: #999; padding: 2px;">切线式对比学习</div> </center> </div> <div> <center> <img src="./resources/sampling.png" alt="sampling" width="300"/> <br> <div style="color:orange; border-bottom: 1px solid #d9d9d9; display: inline-block; color: #999; padding: 2px;">混合高斯循环采样</div> </center> </div>
+
+## 期望模型使用方式以及适用范围
+本模型适用于具有一定数据规模（百万级以上）的所有翻译语向，同时能够与离散式数据增强方法（如back-translation）结合使用。
+
+### 如何使用
+在ModelScope框架上，提供输入源文，即可通过简单的Pipeline调用来使用。
+
+### 代码范例
+```python
+# Chinese-to-English
+
+from modelscope.pipelines import pipeline
+from modelscope.utils.constant import Tasks
+
+input_sequence = '声明补充说，沃伦的同事都深感震惊，并且希望他能够投案自首。'
+
+pipeline_ins = pipeline(task=Tasks.translation, model="damo/nlp_csanmt_translation_zh2en")
+outputs = pipeline_ins(input=input_sequence)
+
+print(outputs['translation']) # 'The statement added that Warren's colleagues were deeply shocked and expected him to turn himself in.'
+```
+
+## 模型局限性以及可能的偏差
+1. 模型在通用数据集上训练，部分垂直领域有可能产生一些偏差，请用户自行评测后决定如何使用。
+2. 当前版本在tensorflow 2.3和1.14环境测试通过，其他环境下可用性待测试。
+3. 当前版本fine-tune在cpu和单机单gpu环境测试通过，单机多gpu等其他环境待测试。
+
+## 训练数据介绍
+1. [WMT21](https://arxiv.org/abs/2204.06812)数据集，系WMT官方提供的新闻领域双语数据集。
+2. [Opensubtitles2018](https://www.opensubtitles.org)，偏口语化（字幕）的双语数据集。
+3. [OPUS](https://www.opensubtitles.org)，众包数据集。
+
+## 模型训练流程
+
+### 数据准备
+
+使用中英双语语料作为训练数据，准备两个文件：train.zh和train.en，其中每一行一一对应，例如：
+
+```
+#train.zh
+这只是一个例子。
+今天天气怎么样？
+...
+```
+
+```
+# train.en
+This is just an example.
+What's the weather like today?
+...
+```
+
+### 预处理
+训练数据预处理流程如下：
+
+1. Tokenization
+
+英文通过[mosesdecoder](https://github.com/moses-smt/mosesdecoder)进行Tokenization
+```
+perl tokenizer.perl -l en < train.en > train.en.tok
+```
+
+中文通过[jieba](https://github.com/fxsjy/jieba)进行中文分词
+```
+import jieba
+
+fR = open('train.zh', 'r', encoding='UTF-8')
+fW = open('train.zh.tok', 'w', encoding='UTF-8')
+
+for sent in fR: 
+    sent = fR.read()
+    sent_list = jieba.cut(sent)
+    fW.write(' '.join(sent_list))
+
+fR.close()
+fW.close()
+```
+
+2. [Byte-Pair-Encoding](https://github.com/rsennrich/subword-nmt)
+
+```
+subword-nmt apply-bpe -c bpe.en < train.en.tok > train.en.tok.bpe
+
+subword-nmt apply-bpe -c bpe.zh < train.zh.tok > train.zh.tok.bpe
+```
+
+### 参数配置
+
+修改Configuration.json相关训练配置，根据用户定制数据进行微调。参数介绍如下：
+
+```
+"train": {
+        "num_gpus": 0,                                           # 指定GPU数量，0表示CPU运行
+        "warmup_steps": 4000,                                    # 冷启动所需要的迭代步数，默认为4000
+        "update_cycle": 1,                                       # 累积update_cycle个step的梯度进行一次参数更新，默认为1
+        "keep_checkpoint_max": 1,                                # 训练过程中保留的checkpoint数量
+        "confidence": 0.9,                                       # label smoothing权重
+        "optimizer": "adam",
+        "adam_beta1": 0.9,
+        "adam_beta2": 0.98,
+        "adam_epsilon": 1e-9,
+        "gradient_clip_norm": 0.0,
+        "learning_rate_decay": "linear_warmup_rsqrt_decay",      # 学习衰减策略，可选模式包括[none, linear_warmup_rsqrt_decay, piecewise_constant]
+        "initializer": "uniform_unit_scaling",                   # 参数初始化策略，可选模式包括[uniform, normal, normal_unit_scaling, uniform_unit_scaling]
+        "initializer_scale": 0.1,
+        "learning_rate": 1.0,                                    # 学习率的缩放系数，即根据step值确定学习率以后，再根据模型的大小对学习率进行缩放
+        "train_batch_size_words": 1024,                          # 单训练batch所包含的token数量
+        "scale_l1": 0.0,
+        "scale_l2": 0.0,
+        "train_max_len": 100,                                    # 默认情况下，限制训练数据的长度为100，用户可自行调整
+        "max_training_steps": 5,                                 # 最大训练步数
+        "save_checkpoints_steps": 1000,                          # 间隔多少steps保存一次模型
+        "num_of_samples": 4,                                     # 连续语义采样的样本数量
+        "eta": 0.6
+    },
+"dataset": {
+        "train_src": "train.zh",                                 # 指定源语言数据文件
+        "train_trg": "train.en",                                 # 指定目标语言数据文件
+        "src_vocab": {
+            "file": "src_vocab.txt"                              # 指定源语言词典
+        },
+        "trg_vocab": {
+            "file": "trg_vocab.txt"                              # 指定目标语言词典
+        }
+    }
+```
+
+### 模型训练
+```python
+# Chinese-to-English
+
+from modelscope.trainers.nlp import CsanmtTranslationTrainer
+
+trainer = CsanmtTranslationTrainer(model="damo/nlp_csanmt_translation_zh2en")
+trainer.train()
+
+```
+
+## 数据评估及结果
+|  Backbone |#Params|  WMT18-20 (NLTK_BLEU)| IWSLT 16-17 (NLTK_BLEU) |    Remark   |
+|:---------:|:-----:|:--------------------:|:-----------------------:|:-----------:|
+|     -     |   -   |         35.8         |          27.8           |    Google   |
+| 24-6-1024 | 570M  |         34.9         |          28.4           |  ModelScope |
+
+
+## 论文引用
+如果你觉得这个该模型对有所帮助，请考虑引用下面的相关的论文：
+``` bibtex
+@inproceedings{wei-etal-2022-learning,
+  title = {Learning to Generalize to More: Continuous Semantic Augmentation for Neural Machine Translation},
+  author = {Xiangpeng Wei and Heng Yu and Yue Hu and Rongxiang Weng and Weihua Luo and Rong Jin},
+  booktitle = {Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics, ACL 2022},
+  year = {2022},
+}
+```

original/nlp_csanmt_translation_zh2en/configuration.json

@@ -0,0 +1,79 @@
+{
+    "framework": "tensorflow",
+    "task": "translation",
+    "pipeline": {
+       "type": "csanmt-translation"
+    },
+    "model": {
+        "type": "csanmt-translation",
+        "hidden_size": 1024,
+        "filter_size": 4096,
+        "num_heads": 16,
+        "num_encoder_layers": 24,
+        "num_decoder_layers": 6,
+        "attention_dropout": 0.0,
+        "residual_dropout": 0.0,
+        "relu_dropout": 0.0,
+        "layer_preproc": "layer_norm",
+        "layer_postproc": "none",
+        "shared_embedding_and_softmax_weights": true,
+        "shared_source_target_embedding": true,
+        "initializer_scale": 0.1,
+        "position_info_type": "absolute",
+        "max_relative_dis": 16,
+        "num_semantic_encoder_layers": 4,
+        "src_vocab_size": 50000,
+        "trg_vocab_size": 50000,
+        "seed": 1234,
+        "beam_size": 4,
+        "lp_rate": 0.6,
+        "max_decoded_trg_len": 100
+    },
+    "dataset": {
+        "train_src": "train.zh",
+        "train_trg": "train.en",
+        "src_vocab": {
+          "file": "src_vocab.txt"
+        },
+        "trg_vocab": {
+          "file": "trg_vocab.txt"
+        }
+    },
+    "preprocessor": {
+        "src_lang": "zh",
+        "tgt_lang": "en",
+        "src_bpe": {
+          "file": "bpe.zh"
+        }
+    },
+    "train": {
+        "num_gpus": 0,
+        "warmup_steps": 4000,
+        "update_cycle": 1,
+        "keep_checkpoint_max": 1,
+        "confidence": 0.9,
+        "optimizer": "adam",
+        "adam_beta1": 0.9,
+        "adam_beta2": 0.98,
+        "adam_epsilon": 1e-9,
+        "gradient_clip_norm": 0.0,
+        "learning_rate_decay": "linear_warmup_rsqrt_decay",
+        "initializer": "uniform_unit_scaling",
+        "initializer_scale": 0.1,
+        "learning_rate": 1.0,
+        "train_batch_size_words": 1024,
+        "scale_l1": 0.0,
+        "scale_l2": 0.0,
+        "train_max_len": 100,
+        "num_of_epochs": 2,
+        "save_checkpoints_steps": 1000,
+        "num_of_samples": 4,
+        "eta": 0.6
+    },
+    "evaluation": {
+        "beam_size": 4,
+        "lp_rate": 0.6,
+        "max_decoded_trg_len": 100
+    }
+
+}

original/nlp_csanmt_translation_zh2en/tf_ckpts/checkpoint

@@ -0,0 +1,2 @@
+model_checkpoint_path: "ckpt-0"
+all_model_checkpoint_paths: "ckpt-0"

original/nlp_csanmt_translation_zh2en/tf_ckpts/ckpt-0.meta

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