From 0e7bdf467137076ab5b7d65550311daa85c2750c Mon Sep 17 00:00:00 2001 From: root Date: Thu, 9 Nov 2023 14:40:33 +0800 Subject: [PATCH] init commit --- .gitattributes | 16 ++++++ README.md | 111 +++++++++++++++++++++++++++++++++++++++ config.json | 21 ++++++++ flax_model.msgpack | 3 ++ preprocessor_config.json | 15 ++++++ pytorch_model.bin | 3 ++ tf_model.h5 | 3 ++ 7 files changed, 172 insertions(+) create mode 100644 .gitattributes create mode 100644 README.md create mode 100644 config.json create mode 100644 flax_model.msgpack create mode 100644 preprocessor_config.json create mode 100644 pytorch_model.bin create mode 100644 tf_model.h5 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..07f0db3 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,16 @@ +*.bin.* filter=lfs diff=lfs merge=lfs -text +*.lfs.* filter=lfs diff=lfs merge=lfs -text +*.bin filter=lfs diff=lfs merge=lfs -text +*.h5 filter=lfs diff=lfs merge=lfs -text +*.tflite filter=lfs diff=lfs merge=lfs -text +*.tar.gz filter=lfs diff=lfs merge=lfs -text +*.ot filter=lfs diff=lfs merge=lfs -text +*.onnx filter=lfs diff=lfs merge=lfs -text +*.arrow filter=lfs diff=lfs merge=lfs -text +*.ftz filter=lfs diff=lfs merge=lfs -text +*.joblib filter=lfs diff=lfs merge=lfs -text +*.model filter=lfs diff=lfs merge=lfs -text +*.msgpack 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 diff --git a/README.md b/README.md new file mode 100644 index 0000000..1da3073 --- /dev/null +++ b/README.md @@ -0,0 +1,111 @@ +--- +license: apache-2.0 +tags: +- vision +datasets: +- imagenet-21k +inference: false +--- + +# Vision Transformer (base-sized model) + +Vision Transformer (ViT) model pre-trained on ImageNet-21k (14 million images, 21,843 classes) at resolution 224x224. It was introduced in the paper [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https://arxiv.org/abs/2010.11929) by Dosovitskiy et al. and first released in [this repository](https://github.com/google-research/vision_transformer). However, the weights were converted from the [timm repository](https://github.com/rwightman/pytorch-image-models) by Ross Wightman, who already converted the weights from JAX to PyTorch. Credits go to him. + +Disclaimer: The team releasing ViT did not write a model card for this model so this model card has been written by the Hugging Face team. + +## Model description + +The Vision Transformer (ViT) is a transformer encoder model (BERT-like) pretrained on a large collection of images in a supervised fashion, namely ImageNet-21k, at a resolution of 224x224 pixels. + +Images are presented to the model as a sequence of fixed-size patches (resolution 16x16), which are linearly embedded. One also adds a [CLS] token to the beginning of a sequence to use it for classification tasks. One also adds absolute position embeddings before feeding the sequence to the layers of the Transformer encoder. + +Note that this model does not provide any fine-tuned heads, as these were zero'd by Google researchers. However, the model does include the pre-trained pooler, which can be used for downstream tasks (such as image classification). + +By pre-training the model, it learns an inner representation of images that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled images for instance, you can train a standard classifier by placing a linear layer on top of the pre-trained encoder. One typically places a linear layer on top of the [CLS] token, as the last hidden state of this token can be seen as a representation of an entire image. + +## Intended uses & limitations + +You can use the raw model for image classification. See the [model hub](https://huggingface.co/models?search=google/vit) to look for +fine-tuned versions on a task that interests you. + +### How to use + +Here is how to use this model in PyTorch: + +```python +from transformers import ViTImageProcessor, ViTModel +from PIL import Image +import requests + +url = 'http://images.cocodataset.org/val2017/000000039769.jpg' +image = Image.open(requests.get(url, stream=True).raw) + +processor = ViTImageProcessor.from_pretrained('google/vit-base-patch16-224-in21k') +model = ViTModel.from_pretrained('google/vit-base-patch16-224-in21k') +inputs = processor(images=image, return_tensors="pt") + +outputs = model(**inputs) +last_hidden_states = outputs.last_hidden_state +``` + +Here is how to use this model in JAX/Flax: + +```python +from transformers import ViTImageProcessor, FlaxViTModel +from PIL import Image +import requests + +url = 'http://images.cocodataset.org/val2017/000000039769.jpg' +image = Image.open(requests.get(url, stream=True).raw) + +processor = ViTImageProcessor.from_pretrained('google/vit-base-patch16-224-in21k') +model = FlaxViTModel.from_pretrained('google/vit-base-patch16-224-in21k') + +inputs = processor(images=image, return_tensors="np") +outputs = model(**inputs) +last_hidden_states = outputs.last_hidden_state +``` + +## Training data + +The ViT model was pretrained on [ImageNet-21k](http://www.image-net.org/), a dataset consisting of 14 million images and 21k classes. + +## Training procedure + +### Preprocessing + +The exact details of preprocessing of images during training/validation can be found [here](https://github.com/google-research/vision_transformer/blob/master/vit_jax/input_pipeline.py). + +Images are resized/rescaled to the same resolution (224x224) and normalized across the RGB channels with mean (0.5, 0.5, 0.5) and standard deviation (0.5, 0.5, 0.5). + +### Pretraining + +The model was trained on TPUv3 hardware (8 cores). All model variants are trained with a batch size of 4096 and learning rate warmup of 10k steps. For ImageNet, the authors found it beneficial to additionally apply gradient clipping at global norm 1. Pre-training resolution is 224. + +## Evaluation results + +For evaluation results on several image classification benchmarks, we refer to tables 2 and 5 of the original paper. Note that for fine-tuning, the best results are obtained with a higher resolution (384x384). Of course, increasing the model size will result in better performance. + +### BibTeX entry and citation info + +```bibtex +@misc{wu2020visual, + title={Visual Transformers: Token-based Image Representation and Processing for Computer Vision}, + author={Bichen Wu and Chenfeng Xu and Xiaoliang Dai and Alvin Wan and Peizhao Zhang and Zhicheng Yan and Masayoshi Tomizuka and Joseph Gonzalez and Kurt Keutzer and Peter Vajda}, + year={2020}, + eprint={2006.03677}, + archivePrefix={arXiv}, + primaryClass={cs.CV} +} +``` + +```bibtex +@inproceedings{deng2009imagenet, + title={Imagenet: A large-scale hierarchical image database}, + author={Deng, Jia and Dong, Wei and Socher, Richard and Li, Li-Jia and Li, Kai and Fei-Fei, Li}, + booktitle={2009 IEEE conference on computer vision and pattern recognition}, + pages={248--255}, + year={2009}, + organization={Ieee} +} +``` \ No newline at end of file diff --git a/config.json b/config.json new file mode 100644 index 0000000..254071b --- /dev/null +++ b/config.json @@ -0,0 +1,21 @@ +{ + "_name_or_path": "google/vit-base-patch16-224-in21k", + "architectures": [ + "ViTModel" + ], + "attention_probs_dropout_prob": 0.0, + "hidden_act": "gelu", + "hidden_dropout_prob": 0.0, + "hidden_size": 768, + "image_size": 224, + "initializer_range": 0.02, + "intermediate_size": 3072, + "layer_norm_eps": 1e-12, + "model_type": "vit", + "num_attention_heads": 12, + "num_channels": 3, + "num_hidden_layers": 12, + "patch_size": 16, + "qkv_bias": true, + "transformers_version": "4.13.0.dev0" +} diff --git a/flax_model.msgpack b/flax_model.msgpack new file mode 100644 index 0000000..3391fae --- /dev/null +++ b/flax_model.msgpack @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aa00da5f7abb687576e6f9138d48cbb0fe7489f2bc9768793d262c3987b3db32 +size 345564359 diff --git a/preprocessor_config.json b/preprocessor_config.json new file mode 100644 index 0000000..70fbc14 --- /dev/null +++ b/preprocessor_config.json @@ -0,0 +1,15 @@ +{ + "do_normalize": true, + "do_resize": true, + "image_mean": [ + 0.5, + 0.5, + 0.5 + ], + "image_std": [ + 0.5, + 0.5, + 0.5 + ], + "size": 224 +} diff --git a/pytorch_model.bin b/pytorch_model.bin new file mode 100644 index 0000000..5212c04 --- /dev/null +++ b/pytorch_model.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:84066da0f5d8ff1cc494c660d4693141fae2e356535bf18a14d9fc00a055a6a1 +size 345636463 diff --git a/tf_model.h5 b/tf_model.h5 new file mode 100644 index 0000000..c819b72 --- /dev/null +++ b/tf_model.h5 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1f76b72dc4a8408733ccdbecfd90ff136176f35cf1897795f428311c6970109e +size 345823776