Add files using upload-large-folder tool

pytorch-image-models/hfdocs/source/models/tf-efficientnet-condconv.mdx

@@ -0,0 +1,256 @@
+# (Tensorflow) EfficientNet CondConv
+
+**EfficientNet** is a convolutional neural network architecture and scaling method that uniformly scales all dimensions of depth/width/resolution using a *compound coefficient*. Unlike conventional practice that arbitrary scales  these factors, the EfficientNet scaling method uniformly scales network width, depth, and resolution with a set of fixed scaling coefficients. For example, if we want to use \\( 2^N \\) times more computational resources, then we can simply increase the network depth by \\( \alpha ^ N \\),  width by \\( \beta ^ N \\), and image size by \\( \gamma ^ N \\), where \\( \alpha, \beta, \gamma \\) are constant coefficients determined by a small grid search on the original small model. EfficientNet uses a compound coefficient \\( \phi \\) to uniformly scales network width, depth, and resolution in a  principled way.
+
+The compound scaling method is justified by the intuition that if the input image is bigger, then the network needs more layers to increase the receptive field and more channels to capture more fine-grained patterns on the bigger image.
+
+The base EfficientNet-B0 network is based on the inverted bottleneck residual blocks of [MobileNetV2](https://paperswithcode.com/method/mobilenetv2), in addition to squeeze-and-excitation blocks.
+
+This collection of models amends EfficientNet by adding [CondConv](https://paperswithcode.com/method/condconv) convolutions.
+
+The weights from this model were ported from [Tensorflow/TPU](https://github.com/tensorflow/tpu).
+
+## How do I use this model on an image?
+
+To load a pretrained model:
+
+```py
+>>> import timm
+>>> model = timm.create_model('tf_efficientnet_cc_b0_4e', pretrained=True)
+>>> model.eval()
+```
+
+To load and preprocess the image:
+
+```py
+>>> import urllib
+>>> from PIL import Image
+>>> from timm.data import resolve_data_config
+>>> from timm.data.transforms_factory import create_transform
+
+>>> config = resolve_data_config({}, model=model)
+>>> transform = create_transform(**config)
+
+>>> url, filename = ("https://github.com/pytorch/hub/raw/master/images/dog.jpg", "dog.jpg")
+>>> urllib.request.urlretrieve(url, filename)
+>>> img = Image.open(filename).convert('RGB')
+>>> tensor = transform(img).unsqueeze(0) # transform and add batch dimension
+```
+
+To get the model predictions:
+
+```py
+>>> import torch
+>>> with torch.no_grad():
+...     out = model(tensor)
+>>> probabilities = torch.nn.functional.softmax(out[0], dim=0)
+>>> print(probabilities.shape)
+>>> # prints: torch.Size([1000])
+```
+
+To get the top-5 predictions class names:
+
+```py
+>>> # Get imagenet class mappings
+>>> url, filename = ("https://raw.githubusercontent.com/pytorch/hub/master/imagenet_classes.txt", "imagenet_classes.txt")
+>>> urllib.request.urlretrieve(url, filename)
+>>> with open("imagenet_classes.txt", "r") as f:
+...     categories = [s.strip() for s in f.readlines()]
+
+>>> # Print top categories per image
+>>> top5_prob, top5_catid = torch.topk(probabilities, 5)
+>>> for i in range(top5_prob.size(0)):
+...     print(categories[top5_catid[i]], top5_prob[i].item())
+>>> # prints class names and probabilities like:
+>>> # [('Samoyed', 0.6425196528434753), ('Pomeranian', 0.04062102362513542), ('keeshond', 0.03186424449086189), ('white wolf', 0.01739676296710968), ('Eskimo dog', 0.011717947199940681)]
+```
+
+Replace the model name with the variant you want to use, e.g. `tf_efficientnet_cc_b0_4e`. You can find the IDs in the model summaries at the top of this page.
+
+To extract image features with this model, follow the [timm feature extraction examples](../feature_extraction), just change the name of the model you want to use.
+
+## How do I finetune this model?
+
+You can finetune any of the pre-trained models just by changing the classifier (the last layer).
+
+```py
+>>> model = timm.create_model('tf_efficientnet_cc_b0_4e', pretrained=True, num_classes=NUM_FINETUNE_CLASSES)
+```
+To finetune on your own dataset, you have to write a training loop or adapt [timm's training
+script](https://github.com/rwightman/pytorch-image-models/blob/master/train.py) to use your dataset.
+
+## How do I train this model?
+
+You can follow the [timm recipe scripts](../scripts) for training a new model afresh.
+
+## Citation
+
+```BibTeX
+@article{DBLP:journals/corr/abs-1904-04971,
+  author    = {Brandon Yang and
+               Gabriel Bender and
+               Quoc V. Le and
+               Jiquan Ngiam},
+  title     = {Soft Conditional Computation},
+  journal   = {CoRR},
+  volume    = {abs/1904.04971},
+  year      = {2019},
+  url       = {http://arxiv.org/abs/1904.04971},
+  archivePrefix = {arXiv},
+  eprint    = {1904.04971},
+  timestamp = {Thu, 25 Apr 2019 13:55:01 +0200},
+  biburl    = {https://dblp.org/rec/journals/corr/abs-1904-04971.bib},
+  bibsource = {dblp computer science bibliography, https://dblp.org}
+}
+```
+
+<!--
+Type: model-index
+Collections:
+- Name: TF EfficientNet CondConv
+  Paper:
+    Title: 'CondConv: Conditionally Parameterized Convolutions for Efficient Inference'
+    URL: https://paperswithcode.com/paper/soft-conditional-computation
+Models:
+- Name: tf_efficientnet_cc_b0_4e
+  In Collection: TF EfficientNet CondConv
+  Metadata:
+    FLOPs: 224153788
+    Parameters: 13310000
+    File Size: 53490940
+    Architecture:
+    - 1x1 Convolution
+    - Average Pooling
+    - Batch Normalization
+    - CondConv
+    - Convolution
+    - Dense Connections
+    - Dropout
+    - Inverted Residual Block
+    - Squeeze-and-Excitation Block
+    - Swish
+    Tasks:
+    - Image Classification
+    Training Techniques:
+    - AutoAugment
+    - Label Smoothing
+    - RMSProp
+    - Stochastic Depth
+    - Weight Decay
+    Training Data:
+    - ImageNet
+    ID: tf_efficientnet_cc_b0_4e
+    LR: 0.256
+    Epochs: 350
+    Crop Pct: '0.875'
+    Momentum: 0.9
+    Batch Size: 2048
+    Image Size: '224'
+    Weight Decay: 1.0e-05
+    Interpolation: bicubic
+    RMSProp Decay: 0.9
+    Label Smoothing: 0.1
+    BatchNorm Momentum: 0.99
+  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1561
+  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_cc_b0_4e-4362b6b2.pth
+  Results:
+  - Task: Image Classification
+    Dataset: ImageNet
+    Metrics:
+      Top 1 Accuracy: 77.32%
+      Top 5 Accuracy: 93.32%
+- Name: tf_efficientnet_cc_b0_8e
+  In Collection: TF EfficientNet CondConv
+  Metadata:
+    FLOPs: 224158524
+    Parameters: 24010000
+    File Size: 96287616
+    Architecture:
+    - 1x1 Convolution
+    - Average Pooling
+    - Batch Normalization
+    - CondConv
+    - Convolution
+    - Dense Connections
+    - Dropout
+    - Inverted Residual Block
+    - Squeeze-and-Excitation Block
+    - Swish
+    Tasks:
+    - Image Classification
+    Training Techniques:
+    - AutoAugment
+    - Label Smoothing
+    - RMSProp
+    - Stochastic Depth
+    - Weight Decay
+    Training Data:
+    - ImageNet
+    ID: tf_efficientnet_cc_b0_8e
+    LR: 0.256
+    Epochs: 350
+    Crop Pct: '0.875'
+    Momentum: 0.9
+    Batch Size: 2048
+    Image Size: '224'
+    Weight Decay: 1.0e-05
+    Interpolation: bicubic
+    RMSProp Decay: 0.9
+    Label Smoothing: 0.1
+    BatchNorm Momentum: 0.99
+  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1572
+  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_cc_b0_8e-66184a25.pth
+  Results:
+  - Task: Image Classification
+    Dataset: ImageNet
+    Metrics:
+      Top 1 Accuracy: 77.91%
+      Top 5 Accuracy: 93.65%
+- Name: tf_efficientnet_cc_b1_8e
+  In Collection: TF EfficientNet CondConv
+  Metadata:
+    FLOPs: 370427824
+    Parameters: 39720000
+    File Size: 159206198
+    Architecture:
+    - 1x1 Convolution
+    - Average Pooling
+    - Batch Normalization
+    - CondConv
+    - Convolution
+    - Dense Connections
+    - Dropout
+    - Inverted Residual Block
+    - Squeeze-and-Excitation Block
+    - Swish
+    Tasks:
+    - Image Classification
+    Training Techniques:
+    - AutoAugment
+    - Label Smoothing
+    - RMSProp
+    - Stochastic Depth
+    - Weight Decay
+    Training Data:
+    - ImageNet
+    ID: tf_efficientnet_cc_b1_8e
+    LR: 0.256
+    Epochs: 350
+    Crop Pct: '0.882'
+    Momentum: 0.9
+    Batch Size: 2048
+    Image Size: '240'
+    Weight Decay: 1.0e-05
+    Interpolation: bicubic
+    RMSProp Decay: 0.9
+    Label Smoothing: 0.1
+    BatchNorm Momentum: 0.99
+  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1584
+  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_cc_b1_8e-f7c79ae1.pth
+  Results:
+  - Task: Image Classification
+    Dataset: ImageNet
+    Metrics:
+      Top 1 Accuracy: 79.33%
+      Top 5 Accuracy: 94.37%
+-->

pytorch-image-models/hfdocs/source/models/tf-inception-v3.mdx

@@ -0,0 +1,154 @@
+# (Tensorflow) Inception v3
+
+**Inception v3** is a convolutional neural network architecture from the Inception family that makes several improvements including using [Label Smoothing](https://paperswithcode.com/method/label-smoothing), Factorized 7 x 7 convolutions, and the use of an [auxiliary classifer](https://paperswithcode.com/method/auxiliary-classifier) to propagate label information lower down the network (along with the use of batch normalization for layers in the sidehead). The key building block is an [Inception Module](https://paperswithcode.com/method/inception-v3-module).
+
+The weights from this model were ported from [Tensorflow/Models](https://github.com/tensorflow/models).
+
+## How do I use this model on an image?
+
+To load a pretrained model:
+
+```py
+>>> import timm
+>>> model = timm.create_model('tf_inception_v3', pretrained=True)
+>>> model.eval()
+```
+
+To load and preprocess the image:
+
+```py 
+>>> import urllib
+>>> from PIL import Image
+>>> from timm.data import resolve_data_config
+>>> from timm.data.transforms_factory import create_transform
+
+>>> config = resolve_data_config({}, model=model)
+>>> transform = create_transform(**config)
+
+>>> url, filename = ("https://github.com/pytorch/hub/raw/master/images/dog.jpg", "dog.jpg")
+>>> urllib.request.urlretrieve(url, filename)
+>>> img = Image.open(filename).convert('RGB')
+>>> tensor = transform(img).unsqueeze(0) # transform and add batch dimension
+```
+
+To get the model predictions:
+
+```py
+>>> import torch
+>>> with torch.no_grad():
+...     out = model(tensor)
+>>> probabilities = torch.nn.functional.softmax(out[0], dim=0)
+>>> print(probabilities.shape)
+>>> # prints: torch.Size([1000])
+```
+
+To get the top-5 predictions class names:
+
+```py
+>>> # Get imagenet class mappings
+>>> url, filename = ("https://raw.githubusercontent.com/pytorch/hub/master/imagenet_classes.txt", "imagenet_classes.txt")
+>>> urllib.request.urlretrieve(url, filename) 
+>>> with open("imagenet_classes.txt", "r") as f:
+...     categories = [s.strip() for s in f.readlines()]
+
+>>> # Print top categories per image
+>>> top5_prob, top5_catid = torch.topk(probabilities, 5)
+>>> for i in range(top5_prob.size(0)):
+...     print(categories[top5_catid[i]], top5_prob[i].item())
+>>> # prints class names and probabilities like:
+>>> # [('Samoyed', 0.6425196528434753), ('Pomeranian', 0.04062102362513542), ('keeshond', 0.03186424449086189), ('white wolf', 0.01739676296710968), ('Eskimo dog', 0.011717947199940681)]
+```
+
+Replace the model name with the variant you want to use, e.g. `tf_inception_v3`. You can find the IDs in the model summaries at the top of this page.
+
+To extract image features with this model, follow the [timm feature extraction examples](../feature_extraction), just change the name of the model you want to use.
+
+## How do I finetune this model?
+
+You can finetune any of the pre-trained models just by changing the classifier (the last layer).
+
+```py
+>>> model = timm.create_model('tf_inception_v3', pretrained=True, num_classes=NUM_FINETUNE_CLASSES)
+```
+To finetune on your own dataset, you have to write a training loop or adapt [timm's training
+script](https://github.com/rwightman/pytorch-image-models/blob/master/train.py) to use your dataset.
+
+## How do I train this model?
+
+You can follow the [timm recipe scripts](../scripts) for training a new model afresh.
+
+## Citation
+
+```BibTeX
+@article{DBLP:journals/corr/SzegedyVISW15,
+  author    = {Christian Szegedy and
+               Vincent Vanhoucke and
+               Sergey Ioffe and
+               Jonathon Shlens and
+               Zbigniew Wojna},
+  title     = {Rethinking the Inception Architecture for Computer Vision},
+  journal   = {CoRR},
+  volume    = {abs/1512.00567},
+  year      = {2015},
+  url       = {http://arxiv.org/abs/1512.00567},
+  archivePrefix = {arXiv},
+  eprint    = {1512.00567},
+  timestamp = {Mon, 13 Aug 2018 16:49:07 +0200},
+  biburl    = {https://dblp.org/rec/journals/corr/SzegedyVISW15.bib},
+  bibsource = {dblp computer science bibliography, https://dblp.org}
+}
+```
+
+<!--
+Type: model-index
+Collections:
+- Name: TF Inception v3
+  Paper:
+    Title: Rethinking the Inception Architecture for Computer Vision
+    URL: https://paperswithcode.com/paper/rethinking-the-inception-architecture-for
+Models:
+- Name: tf_inception_v3
+  In Collection: TF Inception v3
+  Metadata:
+    FLOPs: 7352418880
+    Parameters: 23830000
+    File Size: 95549439
+    Architecture:
+    - 1x1 Convolution
+    - Auxiliary Classifier
+    - Average Pooling
+    - Average Pooling
+    - Batch Normalization
+    - Convolution
+    - Dense Connections
+    - Dropout
+    - Inception-v3 Module
+    - Max Pooling
+    - ReLU
+    - Softmax
+    Tasks:
+    - Image Classification
+    Training Techniques:
+    - Gradient Clipping
+    - Label Smoothing
+    - RMSProp
+    - Weight Decay
+    Training Data:
+    - ImageNet
+    Training Resources: 50x NVIDIA Kepler GPUs
+    ID: tf_inception_v3
+    LR: 0.045
+    Dropout: 0.2
+    Crop Pct: '0.875'
+    Momentum: 0.9
+    Image Size: '299'
+    Interpolation: bicubic
+  Code: https://github.com/rwightman/pytorch-image-models/blob/d8e69206be253892b2956341fea09fdebfaae4e3/timm/models/inception_v3.py#L449
+  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_inception_v3-e0069de4.pth
+  Results:
+  - Task: Image Classification
+    Dataset: ImageNet
+    Metrics:
+      Top 1 Accuracy: 77.87%
+      Top 5 Accuracy: 93.65%
+-->

pytorch-image-models/hfdocs/source/models/wide-resnet.mdx

@@ -0,0 +1,169 @@
+# Wide ResNet
+
+**Wide Residual Networks** are a variant on [ResNets](https://paperswithcode.com/method/resnet) where we decrease depth and increase the width of residual networks. This is achieved through the use of [wide residual blocks](https://paperswithcode.com/method/wide-residual-block).
+
+## How do I use this model on an image?
+
+To load a pretrained model:
+
+```py
+>>> import timm
+>>> model = timm.create_model('wide_resnet101_2', pretrained=True)
+>>> model.eval()
+```
+
+To load and preprocess the image:
+
+```py 
+>>> import urllib
+>>> from PIL import Image
+>>> from timm.data import resolve_data_config
+>>> from timm.data.transforms_factory import create_transform
+
+>>> config = resolve_data_config({}, model=model)
+>>> transform = create_transform(**config)
+
+>>> url, filename = ("https://github.com/pytorch/hub/raw/master/images/dog.jpg", "dog.jpg")
+>>> urllib.request.urlretrieve(url, filename)
+>>> img = Image.open(filename).convert('RGB')
+>>> tensor = transform(img).unsqueeze(0) # transform and add batch dimension
+```
+
+To get the model predictions:
+
+```py
+>>> import torch
+>>> with torch.no_grad():
+...     out = model(tensor)
+>>> probabilities = torch.nn.functional.softmax(out[0], dim=0)
+>>> print(probabilities.shape)
+>>> # prints: torch.Size([1000])
+```
+
+To get the top-5 predictions class names:
+
+```py
+>>> # Get imagenet class mappings
+>>> url, filename = ("https://raw.githubusercontent.com/pytorch/hub/master/imagenet_classes.txt", "imagenet_classes.txt")
+>>> urllib.request.urlretrieve(url, filename) 
+>>> with open("imagenet_classes.txt", "r") as f:
+...     categories = [s.strip() for s in f.readlines()]
+
+>>> # Print top categories per image
+>>> top5_prob, top5_catid = torch.topk(probabilities, 5)
+>>> for i in range(top5_prob.size(0)):
+...     print(categories[top5_catid[i]], top5_prob[i].item())
+>>> # prints class names and probabilities like:
+>>> # [('Samoyed', 0.6425196528434753), ('Pomeranian', 0.04062102362513542), ('keeshond', 0.03186424449086189), ('white wolf', 0.01739676296710968), ('Eskimo dog', 0.011717947199940681)]
+```
+
+Replace the model name with the variant you want to use, e.g. `wide_resnet101_2`. You can find the IDs in the model summaries at the top of this page.
+
+To extract image features with this model, follow the [timm feature extraction examples](../feature_extraction), just change the name of the model you want to use.
+
+## How do I finetune this model?
+
+You can finetune any of the pre-trained models just by changing the classifier (the last layer).
+
+```py
+>>> model = timm.create_model('wide_resnet101_2', pretrained=True, num_classes=NUM_FINETUNE_CLASSES)
+```
+To finetune on your own dataset, you have to write a training loop or adapt [timm's training
+script](https://github.com/rwightman/pytorch-image-models/blob/master/train.py) to use your dataset.
+
+## How do I train this model?
+
+You can follow the [timm recipe scripts](../scripts) for training a new model afresh.
+
+## Citation
+
+```BibTeX
+@article{DBLP:journals/corr/ZagoruykoK16,
+  author    = {Sergey Zagoruyko and
+               Nikos Komodakis},
+  title     = {Wide Residual Networks},
+  journal   = {CoRR},
+  volume    = {abs/1605.07146},
+  year      = {2016},
+  url       = {http://arxiv.org/abs/1605.07146},
+  archivePrefix = {arXiv},
+  eprint    = {1605.07146},
+  timestamp = {Mon, 13 Aug 2018 16:46:42 +0200},
+  biburl    = {https://dblp.org/rec/journals/corr/ZagoruykoK16.bib},
+  bibsource = {dblp computer science bibliography, https://dblp.org}
+}
+```
+
+<!--
+Type: model-index
+Collections:
+- Name: Wide ResNet
+  Paper:
+    Title: Wide Residual Networks
+    URL: https://paperswithcode.com/paper/wide-residual-networks
+Models:
+- Name: wide_resnet101_2
+  In Collection: Wide ResNet
+  Metadata:
+    FLOPs: 29304929280
+    Parameters: 126890000
+    File Size: 254695146
+    Architecture:
+    - 1x1 Convolution
+    - Batch Normalization
+    - Convolution
+    - Global Average Pooling
+    - Max Pooling
+    - ReLU
+    - Residual Connection
+    - Softmax
+    - Wide Residual Block
+    Tasks:
+    - Image Classification
+    Training Data:
+    - ImageNet
+    ID: wide_resnet101_2
+    Crop Pct: '0.875'
+    Image Size: '224'
+    Interpolation: bilinear
+  Code: https://github.com/rwightman/pytorch-image-models/blob/5f9aff395c224492e9e44248b15f44b5cc095d9c/timm/models/resnet.py#L802
+  Weights: https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth
+  Results:
+  - Task: Image Classification
+    Dataset: ImageNet
+    Metrics:
+      Top 1 Accuracy: 78.85%
+      Top 5 Accuracy: 94.28%
+- Name: wide_resnet50_2
+  In Collection: Wide ResNet
+  Metadata:
+    FLOPs: 14688058368
+    Parameters: 68880000
+    File Size: 275853271
+    Architecture:
+    - 1x1 Convolution
+    - Batch Normalization
+    - Convolution
+    - Global Average Pooling
+    - Max Pooling
+    - ReLU
+    - Residual Connection
+    - Softmax
+    - Wide Residual Block
+    Tasks:
+    - Image Classification
+    Training Data:
+    - ImageNet
+    ID: wide_resnet50_2
+    Crop Pct: '0.875'
+    Image Size: '224'
+    Interpolation: bicubic
+  Code: https://github.com/rwightman/pytorch-image-models/blob/5f9aff395c224492e9e44248b15f44b5cc095d9c/timm/models/resnet.py#L790
+  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/wide_resnet50_racm-8234f177.pth
+  Results:
+  - Task: Image Classification
+    Dataset: ImageNet
+    Metrics:
+      Top 1 Accuracy: 81.45%
+      Top 5 Accuracy: 95.52%
+-->

pytorch-image-models/hfdocs/source/reference/models.mdx

@@ -0,0 +1,5 @@
+# Models
+
+[[autodoc]] timm.create_model
+
+[[autodoc]] timm.list_models

pytorch-image-models/results/README.md

@@ -0,0 +1,67 @@
+# Validation and Benchmark Results
+
+This folder contains validation and benchmark results for the models in this collection. Validation scores are currently only run for models with pretrained weights and ImageNet-1k heads, benchmark numbers are run for all.
+
+## Datasets
+
+There are currently results for the ImageNet validation set and 5 additional test / label sets.
+
+The test set results include rank and top-1/top-5 differences from clean validation. For the "Real Labels", ImageNetV2, and Sketch test sets, the differences were calculated against the full 1000 class ImageNet-1k validation set. For both the Adversarial and Rendition sets, the differences were calculated against 'clean' runs on the ImageNet-1k validation set with the same 200 classes used in each test set respectively.
+
+### ImageNet Validation - [`results-imagenet.csv`](results-imagenet.csv)
+
+The standard 50,000 image ImageNet-1k validation set. Model selection during training utilizes this validation set, so it is not a true test set. Question: Does anyone have the official ImageNet-1k test set classification labels now that challenges are done?
+
+* Source: http://image-net.org/challenges/LSVRC/2012/index
+* Paper: "ImageNet Large Scale Visual Recognition Challenge" - https://arxiv.org/abs/1409.0575
+
+### ImageNet-"Real Labels" - [`results-imagenet-real.csv`](results-imagenet-real.csv)
+
+The usual ImageNet-1k validation set with a fresh new set of labels intended to improve on mistakes in the original annotation process.
+
+* Source: https://github.com/google-research/reassessed-imagenet
+* Paper: "Are we done with ImageNet?" - https://arxiv.org/abs/2006.07159
+
+### ImageNetV2 Matched Frequency - [`results-imagenetv2-matched-frequency.csv`](results-imagenetv2-matched-frequency.csv)
+
+An ImageNet test set of 10,000 images sampled from new images roughly 10 years after the original. Care was taken to replicate the original ImageNet curation/sampling process.
+
+* Source: https://github.com/modestyachts/ImageNetV2
+* Paper: "Do ImageNet Classifiers Generalize to ImageNet?" - https://arxiv.org/abs/1902.10811
+
+### ImageNet-Sketch - [`results-sketch.csv`](results-sketch.csv)
+
+50,000 non photographic (or photos of such) images (sketches, doodles, mostly monochromatic) covering all 1000 ImageNet classes.
+
+* Source: https://github.com/HaohanWang/ImageNet-Sketch
+* Paper: "Learning Robust Global Representations by Penalizing Local Predictive Power" - https://arxiv.org/abs/1905.13549
+
+### ImageNet-Adversarial - [`results-imagenet-a.csv`](results-imagenet-a.csv)
+
+A collection of 7500 images covering 200 of the 1000 ImageNet classes. Images are naturally occurring adversarial examples that confuse typical ImageNet classifiers. This is a challenging dataset, your typical ResNet-50 will score 0% top-1.
+
+For clean validation with same 200 classes, see [`results-imagenet-a-clean.csv`](results-imagenet-a-clean.csv) 
+
+* Source: https://github.com/hendrycks/natural-adv-examples
+* Paper: "Natural Adversarial Examples" - https://arxiv.org/abs/1907.07174
+
+### ImageNet-Rendition - [`results-imagenet-r.csv`](results-imagenet-r.csv)
+
+Renditions of 200 ImageNet classes resulting in 30,000 images for testing robustness.
+
+For clean validation with same 200 classes, see [`results-imagenet-r-clean.csv`](results-imagenet-r-clean.csv) 
+
+* Source: https://github.com/hendrycks/imagenet-r
+* Paper: "The Many Faces of Robustness" - https://arxiv.org/abs/2006.16241
+
+### TODO
+* Explore adding a reduced version of ImageNet-C (Corruptions) and ImageNet-P (Perturbations) from https://github.com/hendrycks/robustness. The originals are huge and image size specific.
+
+
+## Benchmark
+
+CSV files with a `model_benchmark` prefix include benchmark numbers for models on various accelerators with different precision. Currently only run on RTX 3090 w/ AMP for inference, I intend to add more in the future.
+
+## Metadata
+
+CSV files with `model_metadata` prefix contain extra information about the source training, currently the pretraining dataset and technique (ie distillation, SSL, WSL, etc). Eventually I'd like to have metadata about augmentation, regularization, etc. but that will be a challenge to source consistently. 

pytorch-image-models/tests/test_layers.py

@@ -0,0 +1,121 @@
+import torch
+import torch.nn as nn
+
+from timm.layers import create_act_layer, set_layer_config, get_act_layer, get_act_fn
+
+import importlib
+import os
+
+torch_backend = os.environ.get('TORCH_BACKEND')
+if torch_backend is not None:
+    importlib.import_module(torch_backend)
+torch_device = os.environ.get('TORCH_DEVICE', 'cpu')
+
+class MLP(nn.Module):
+    def __init__(self, act_layer="relu", inplace=True):
+        super(MLP, self).__init__()
+        self.fc1 = nn.Linear(1000, 100)
+        self.act = create_act_layer(act_layer, inplace=inplace)
+        self.fc2 = nn.Linear(100, 10)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.fc2(x)
+        return x
+
+
+def _run_act_layer_grad(act_type, inplace=True):
+    x = torch.rand(10, 1000) * 10
+    m = MLP(act_layer=act_type, inplace=inplace)
+
+    def _run(x, act_layer=''):
+        if act_layer:
+            # replace act layer if set
+            m.act = create_act_layer(act_layer, inplace=inplace)
+        out = m(x)
+        l = (out - 0).pow(2).sum()
+        return l
+
+    x = x.to(device=torch_device)
+    m.to(device=torch_device)
+
+    out_me = _run(x)
+
+    with set_layer_config(scriptable=True):
+        out_jit = _run(x, act_type)
+
+    assert torch.isclose(out_jit, out_me)
+
+    with set_layer_config(no_jit=True):
+        out_basic = _run(x, act_type)
+
+    assert torch.isclose(out_basic, out_jit)
+
+
+def test_swish_grad():
+    for _ in range(100):
+        _run_act_layer_grad('swish')
+
+
+def test_mish_grad():
+    for _ in range(100):
+        _run_act_layer_grad('mish')
+
+
+def test_hard_sigmoid_grad():
+    for _ in range(100):
+        _run_act_layer_grad('hard_sigmoid', inplace=None)
+
+
+def test_hard_swish_grad():
+    for _ in range(100):
+        _run_act_layer_grad('hard_swish')
+
+
+def test_hard_mish_grad():
+    for _ in range(100):
+        _run_act_layer_grad('hard_mish')
+
+def test_get_act_layer_empty_string():
+    # Empty string should return None
+    assert get_act_layer('') is None
+
+
+def test_create_act_layer_inplace_error():
+    class NoInplaceAct(nn.Module):
+        def __init__(self):
+            super().__init__()
+        def forward(self, x):
+            return x
+    
+    # Should recover when inplace arg causes TypeError
+    layer = create_act_layer(NoInplaceAct, inplace=True)
+    assert isinstance(layer, NoInplaceAct)
+
+
+def test_create_act_layer_edge_cases():
+    # Test None input
+    assert create_act_layer(None) is None
+    
+    # Test TypeError handling for inplace
+    class CustomAct(nn.Module):
+        def __init__(self, **kwargs):
+            super().__init__()
+        def forward(self, x):
+            return x
+            
+    result = create_act_layer(CustomAct, inplace=True)
+    assert isinstance(result, CustomAct)
+
+
+def test_get_act_fn_callable():
+    def custom_act(x): 
+        return x
+    assert get_act_fn(custom_act) is custom_act
+
+
+def test_get_act_fn_none():
+    assert get_act_fn(None) is None
+    assert get_act_fn('') is None
+

pytorch-image-models/tests/test_models.py

@@ -0,0 +1,710 @@
+"""Run tests for all models
+
+Tests that run on CI should have a specific marker, e.g. @pytest.mark.base. This
+marker is used to parallelize the CI runs, with one runner for each marker.
+
+If new tests are added, ensure that they use one of the existing markers
+(documented in pyproject.toml > pytest > markers) or that a new marker is added
+for this set of tests. If using a new marker, adjust the test matrix in
+.github/workflows/tests.yml to run tests with this new marker, otherwise the
+tests will be skipped on CI.
+
+"""
+
+import pytest
+import torch
+import platform
+import os
+import fnmatch
+
+_IS_MAC = platform.system() == 'Darwin'
+
+try:
+    from torchvision.models.feature_extraction import create_feature_extractor, get_graph_node_names, NodePathTracer
+    has_fx_feature_extraction = True
+except ImportError:
+    has_fx_feature_extraction = False
+
+import timm
+from timm import list_models, list_pretrained, create_model, set_scriptable, get_pretrained_cfg_value
+from timm.layers import Format, get_spatial_dim, get_channel_dim
+from timm.models import get_notrace_modules, get_notrace_functions
+
+import importlib
+import os
+
+torch_backend = os.environ.get('TORCH_BACKEND')
+if torch_backend is not None:
+    importlib.import_module(torch_backend)
+torch_device = os.environ.get('TORCH_DEVICE', 'cpu')
+timeout = os.environ.get('TIMEOUT')
+timeout120 = int(timeout) if timeout else 120
+timeout240 = int(timeout) if timeout else 240
+timeout360 = int(timeout) if timeout else 360
+
+if hasattr(torch._C, '_jit_set_profiling_executor'):
+    # legacy executor is too slow to compile large models for unit tests
+    # no need for the fusion performance here
+    torch._C._jit_set_profiling_executor(True)
+    torch._C._jit_set_profiling_mode(False)
+
+# models with forward_intermediates() and support for FeatureGetterNet features_only wrapper
+FEAT_INTER_FILTERS = [
+    'vision_transformer', 'vision_transformer_sam', 'vision_transformer_hybrid', 'vision_transformer_relpos',
+    'beit', 'mvitv2', 'eva', 'cait', 'xcit', 'volo', 'twins', 'deit', 'swin_transformer', 'swin_transformer_v2',
+    'swin_transformer_v2_cr', 'maxxvit', 'efficientnet', 'mobilenetv3', 'levit', 'efficientformer', 'resnet',
+    'regnet', 'byobnet', 'byoanet', 'mlp_mixer', 'hiera', 'fastvit', 'hieradet_sam2'
+]
+
+# transformer / hybrid models don't support full set of spatial / feature APIs and/or have spatial output.
+NON_STD_FILTERS = [
+    'vit_*', 'tnt_*', 'pit_*', 'coat_*', 'cait_*', '*mixer_*', 'gmlp_*', 'resmlp_*', 'twins_*',
+    'convit_*', 'levit*', 'visformer*', 'deit*', 'xcit_*', 'crossvit_*', 'beit*',
+    'poolformer_*', 'volo_*', 'sequencer2d_*', 'mvitv2*', 'gcvit*', 'efficientformer*', 'sam_hiera*',
+    'eva_*', 'flexivit*', 'eva02*', 'samvit_*', 'efficientvit_m*', 'tiny_vit_*', 'hiera_*', 'vitamin*', 'test_vit*',
+]
+NUM_NON_STD = len(NON_STD_FILTERS)
+
+# exclude models that cause specific test failures
+if 'GITHUB_ACTIONS' in os.environ:
+    # GitHub Linux runner is slower and hits memory limits sooner than MacOS, exclude bigger models
+    EXCLUDE_FILTERS = [
+        '*efficientnet_l2*', '*resnext101_32x48d', '*in21k', '*152x4_bitm', '*101x3_bitm', '*50x3_bitm',
+        '*nfnet_f3*', '*nfnet_f4*', '*nfnet_f5*', '*nfnet_f6*', '*nfnet_f7*', '*efficientnetv2_xl*',
+        '*resnetrs350*', '*resnetrs420*', 'xcit_large_24_p8*', '*huge*', '*giant*', '*gigantic*',
+        '*enormous*', 'maxvit_xlarge*', 'regnet*1280', 'regnet*2560']
+    NON_STD_EXCLUDE_FILTERS = ['*huge*', '*giant*',  '*gigantic*', '*enormous*']
+else:
+    EXCLUDE_FILTERS = ['*enormous*']
+    NON_STD_EXCLUDE_FILTERS = ['*gigantic*', '*enormous*']
+
+EXCLUDE_JIT_FILTERS = ['hiera_*']
+
+TARGET_FWD_SIZE = MAX_FWD_SIZE = 384
+TARGET_BWD_SIZE = 128
+MAX_BWD_SIZE = 320
+MAX_FWD_OUT_SIZE = 448
+TARGET_JIT_SIZE = 128
+MAX_JIT_SIZE = 320
+TARGET_FFEAT_SIZE = 96
+MAX_FFEAT_SIZE = 256
+TARGET_FWD_FX_SIZE = 128
+MAX_FWD_FX_SIZE = 256
+TARGET_BWD_FX_SIZE = 128
+MAX_BWD_FX_SIZE = 224
+
+
+def _get_input_size(model=None, model_name='', target=None):
+    if model is None:
+        assert model_name, "One of model or model_name must be provided"
+        input_size = get_pretrained_cfg_value(model_name, 'input_size')
+        fixed_input_size = get_pretrained_cfg_value(model_name, 'fixed_input_size')
+        min_input_size = get_pretrained_cfg_value(model_name, 'min_input_size')
+    else:
+        default_cfg = model.default_cfg
+        input_size = default_cfg['input_size']
+        fixed_input_size = default_cfg.get('fixed_input_size', None)
+        min_input_size = default_cfg.get('min_input_size', None)
+    assert input_size is not None
+
+    if fixed_input_size:
+        return input_size
+
+    if min_input_size:
+        if target and max(input_size) > target:
+            input_size = min_input_size
+    else:
+        if target and max(input_size) > target:
+            input_size = tuple([min(x, target) for x in input_size])
+    return input_size
+
+
+@pytest.mark.base
+@pytest.mark.timeout(timeout240)
+@pytest.mark.parametrize('model_name', list_pretrained('test_*'))
+@pytest.mark.parametrize('batch_size', [1])
+def test_model_inference(model_name, batch_size):
+    """Run a single forward pass with each model"""
+    from PIL import Image
+    from huggingface_hub import snapshot_download
+    import tempfile
+    import safetensors
+
+    model = create_model(model_name, pretrained=True)
+    model.eval()
+    pp = timm.data.create_transform(**timm.data.resolve_data_config(model=model))
+
+    with tempfile.TemporaryDirectory()  as temp_dir:
+        snapshot_download(
+            repo_id='timm/' + model_name, repo_type='model', local_dir=temp_dir, allow_patterns='test/*'
+        )
+        rand_tensors = safetensors.torch.load_file(os.path.join(temp_dir, 'test', 'rand_tensors.safetensors'))
+        owl_tensors = safetensors.torch.load_file(os.path.join(temp_dir, 'test', 'owl_tensors.safetensors'))
+        test_owl = Image.open(os.path.join(temp_dir, 'test', 'test_owl.jpg'))
+
+    with torch.no_grad():
+        rand_output = model(rand_tensors['input'])
+        rand_features = model.forward_features(rand_tensors['input'])
+        rand_pre_logits = model.forward_head(rand_features, pre_logits=True)
+        assert torch.allclose(rand_output, rand_tensors['output'], rtol=1e-3, atol=1e-4), 'rand output does not match'
+        assert torch.allclose(rand_features, rand_tensors['features'], rtol=1e-3, atol=1e-4), 'rand features do not match'
+        assert torch.allclose(rand_pre_logits, rand_tensors['pre_logits'], rtol=1e-3, atol=1e-4), 'rand pre_logits do not match'
+
+        def _test_owl(owl_input, tol=(1e-3, 1e-4)):
+            owl_output = model(owl_input)
+            owl_features = model.forward_features(owl_input)
+            owl_pre_logits = model.forward_head(owl_features.clone(), pre_logits=True)
+            assert owl_output.softmax(1).argmax(1) == 24  # owl
+            assert torch.allclose(owl_output, owl_tensors['output'], rtol=tol[0], atol=tol[1]), 'owl output does not match'
+            assert torch.allclose(owl_features, owl_tensors['features'], rtol=tol[0], atol=tol[1]), 'owl output does not match'
+            assert torch.allclose(owl_pre_logits, owl_tensors['pre_logits'], rtol=tol[0], atol=tol[1]), 'owl output does not match'
+
+        _test_owl(owl_tensors['input'])  # test with original pp owl tensor
+        _test_owl(pp(test_owl).unsqueeze(0), tol=(1e-1, 1e-1))  # re-process from original jpg, Pillow output can change a lot btw ver
+
+
+@pytest.mark.base
+@pytest.mark.timeout(timeout120)
+@pytest.mark.parametrize('model_name', list_models(exclude_filters=EXCLUDE_FILTERS))
+@pytest.mark.parametrize('batch_size', [1])
+def test_model_forward(model_name, batch_size):
+    """Run a single forward pass with each model"""
+    model = create_model(model_name, pretrained=False)
+    model.eval()
+
+    input_size = _get_input_size(model=model, target=TARGET_FWD_SIZE)
+    if max(input_size) > MAX_FWD_SIZE:
+        pytest.skip("Fixed input size model > limit.")
+    inputs = torch.randn((batch_size, *input_size))
+    inputs = inputs.to(torch_device)
+    model.to(torch_device)
+    outputs = model(inputs)
+
+    assert outputs.shape[0] == batch_size
+    assert not torch.isnan(outputs).any(), 'Output included NaNs'
+
+
+@pytest.mark.base
+@pytest.mark.timeout(timeout120)
+@pytest.mark.parametrize('model_name', list_models(exclude_filters=EXCLUDE_FILTERS, name_matches_cfg=True))
+@pytest.mark.parametrize('batch_size', [2])
+def test_model_backward(model_name, batch_size):
+    """Run a single forward pass with each model"""
+    input_size = _get_input_size(model_name=model_name, target=TARGET_BWD_SIZE)
+    if max(input_size) > MAX_BWD_SIZE:
+        pytest.skip("Fixed input size model > limit.")
+
+    model = create_model(model_name, pretrained=False, num_classes=42)
+    num_params = sum([x.numel() for x in model.parameters()])
+    model.train()
+
+    inputs = torch.randn((batch_size, *input_size))
+    inputs = inputs.to(torch_device)
+    model.to(torch_device)
+    outputs = model(inputs)
+    if isinstance(outputs, tuple):
+        outputs = torch.cat(outputs)
+    outputs.mean().backward()
+    for n, x in model.named_parameters():
+        assert x.grad is not None, f'No gradient for {n}'
+    num_grad = sum([x.grad.numel() for x in model.parameters() if x.grad is not None])
+
+    assert outputs.shape[-1] == 42
+    assert num_params == num_grad, 'Some parameters are missing gradients'
+    assert not torch.isnan(outputs).any(), 'Output included NaNs'
+
+
+# models with extra conv/linear layers after pooling
+EARLY_POOL_MODELS = (
+    timm.models.EfficientVit,
+    timm.models.EfficientVitLarge,
+    timm.models.HighPerfGpuNet,
+    timm.models.GhostNet,
+    timm.models.MetaNeXt, # InceptionNeXt
+    timm.models.MobileNetV3,
+    timm.models.RepGhostNet,
+    timm.models.VGG,
+)
+
+@pytest.mark.cfg
+@pytest.mark.timeout(timeout360)
+@pytest.mark.parametrize('model_name', list_models(
+    exclude_filters=EXCLUDE_FILTERS + NON_STD_FILTERS, include_tags=True))
+@pytest.mark.parametrize('batch_size', [1])
+def test_model_default_cfgs(model_name, batch_size):
+    """Run a single forward pass with each model"""
+    model = create_model(model_name, pretrained=False)
+    model.eval()
+    model.to(torch_device)
+    assert getattr(model, 'num_classes') >= 0
+    assert getattr(model, 'num_features') > 0
+    assert getattr(model, 'head_hidden_size') > 0
+    state_dict = model.state_dict()
+    cfg = model.default_cfg
+
+    pool_size = cfg['pool_size']
+    input_size = model.default_cfg['input_size']
+    output_fmt = getattr(model, 'output_fmt', 'NCHW')
+    spatial_axis = get_spatial_dim(output_fmt)
+    assert len(spatial_axis) == 2  # TODO add 1D sequence support
+    feat_axis = get_channel_dim(output_fmt)
+
+    if all([x <= MAX_FWD_OUT_SIZE for x in input_size]) and \
+            not any([fnmatch.fnmatch(model_name, x) for x in EXCLUDE_FILTERS]):
+        # output sizes only checked if default res <= 448 * 448 to keep resource down
+        input_size = tuple([min(x, MAX_FWD_OUT_SIZE) for x in input_size])
+        input_tensor = torch.randn((batch_size, *input_size), device=torch_device)
+
+        # test forward_features (always unpooled) & forward_head w/ pre_logits
+        outputs = model.forward_features(input_tensor)
+        outputs_pre = model.forward_head(outputs, pre_logits=True)
+        assert outputs.shape[spatial_axis[0]] == pool_size[0], f'unpooled feature shape {outputs.shape} != config'
+        assert outputs.shape[spatial_axis[1]] == pool_size[1], f'unpooled feature shape {outputs.shape} != config'
+        assert outputs.shape[feat_axis] == model.num_features, f'unpooled feature dim {outputs.shape[feat_axis]} != model.num_features {model.num_features}'
+        assert outputs_pre.shape[1] == model.head_hidden_size, f'pre_logits feature dim {outputs_pre.shape[1]} != model.head_hidden_size {model.head_hidden_size}'
+
+        # test forward after deleting the classifier, output should be poooled, size(-1) == model.num_features
+        model.reset_classifier(0)
+        model.to(torch_device)
+        outputs = model.forward(input_tensor)
+        assert len(outputs.shape) == 2
+        assert outputs.shape[1] == model.head_hidden_size, f'feature dim w/ removed classifier {outputs.shape[1]} != model.head_hidden_size {model.head_hidden_size}'
+        assert outputs.shape == outputs_pre.shape, f'output shape of pre_logits {outputs_pre.shape} does not match reset_head(0) {outputs.shape}'
+
+        # test model forward after removing pooling and classifier
+        if not isinstance(model, EARLY_POOL_MODELS):
+            model.reset_classifier(0, '')  # reset classifier and disable global pooling
+            model.to(torch_device)
+            outputs = model.forward(input_tensor)
+            assert len(outputs.shape) == 4
+            assert outputs.shape[spatial_axis[0]] == pool_size[0] and outputs.shape[spatial_axis[1]] == pool_size[1]
+
+        # test classifier + global pool deletion via __init__
+        if 'pruned' not in model_name and not isinstance(model, EARLY_POOL_MODELS):
+            model = create_model(model_name, pretrained=False, num_classes=0, global_pool='').eval()
+            model.to(torch_device)
+            outputs = model.forward(input_tensor)
+            assert len(outputs.shape) == 4
+            assert outputs.shape[spatial_axis[0]] == pool_size[0] and outputs.shape[spatial_axis[1]] == pool_size[1]
+
+    # check classifier name matches default_cfg
+    if cfg.get('num_classes', None):
+        classifier = cfg['classifier']
+        if not isinstance(classifier, (tuple, list)):
+            classifier = classifier,
+        for c in classifier:
+            assert c + ".weight" in state_dict.keys(), f'{c} not in model params'
+
+    # check first conv(s) names match default_cfg
+    first_conv = cfg['first_conv']
+    if isinstance(first_conv, str):
+        first_conv = (first_conv,)
+    assert isinstance(first_conv, (tuple, list))
+    for fc in first_conv:
+        assert fc + ".weight" in state_dict.keys(), f'{fc} not in model params'
+
+
+@pytest.mark.cfg
+@pytest.mark.timeout(timeout360)
+@pytest.mark.parametrize('model_name', list_models(filter=NON_STD_FILTERS, exclude_filters=NON_STD_EXCLUDE_FILTERS, include_tags=True))
+@pytest.mark.parametrize('batch_size', [1])
+def test_model_default_cfgs_non_std(model_name, batch_size):
+    """Run a single forward pass with each model"""
+    model = create_model(model_name, pretrained=False)
+    model.eval()
+    model.to(torch_device)
+    assert getattr(model, 'num_classes') >= 0
+    assert getattr(model, 'num_features') > 0
+    assert getattr(model, 'head_hidden_size') > 0
+    state_dict = model.state_dict()
+    cfg = model.default_cfg
+
+    input_size = _get_input_size(model=model)
+    if max(input_size) > 320:  # FIXME const
+        pytest.skip("Fixed input size model > limit.")
+
+    input_tensor = torch.randn((batch_size, *input_size), device=torch_device)
+    feat_dim = getattr(model, 'feature_dim', None)
+
+    outputs = model.forward_features(input_tensor)
+    outputs_pre = model.forward_head(outputs, pre_logits=True)
+    if isinstance(outputs, (tuple, list)):
+        # cannot currently verify multi-tensor output.
+        pass
+    else:
+        if feat_dim is None:
+            feat_dim = -1 if outputs.ndim == 3 else 1
+        assert outputs.shape[feat_dim] == model.num_features
+        assert outputs_pre.shape[1] == model.head_hidden_size
+
+    # test forward after deleting the classifier, output should be poooled, size(-1) == model.num_features
+    model.reset_classifier(0)
+    model.to(torch_device)
+    outputs = model.forward(input_tensor)
+    if isinstance(outputs,  (tuple, list)):
+        outputs = outputs[0]
+    if feat_dim is None:
+        feat_dim = -1 if outputs.ndim == 3 else 1
+    assert outputs.shape[feat_dim] == model.head_hidden_size, 'pooled num_features != config'
+    assert outputs.shape == outputs_pre.shape
+
+    model = create_model(model_name, pretrained=False, num_classes=0).eval()
+    model.to(torch_device)
+    outputs = model.forward(input_tensor)
+    if isinstance(outputs, (tuple, list)):
+        outputs = outputs[0]
+    if feat_dim is None:
+        feat_dim = -1 if outputs.ndim == 3 else 1
+    assert outputs.shape[feat_dim] == model.num_features
+
+    # check classifier name matches default_cfg
+    if cfg.get('num_classes', None):
+        classifier = cfg['classifier']
+        if not isinstance(classifier, (tuple, list)):
+            classifier = classifier,
+        for c in classifier:
+            assert c + ".weight" in state_dict.keys(), f'{c} not in model params'
+
+    # check first conv(s) names match default_cfg
+    first_conv = cfg['first_conv']
+    if isinstance(first_conv, str):
+        first_conv = (first_conv,)
+    assert isinstance(first_conv, (tuple, list))
+    for fc in first_conv:
+        assert fc + ".weight" in state_dict.keys(), f'{fc} not in model params'
+
+
+if 'GITHUB_ACTIONS' not in os.environ:
+    @pytest.mark.timeout(240)
+    @pytest.mark.parametrize('model_name', list_models(pretrained=True))
+    @pytest.mark.parametrize('batch_size', [1])
+    def test_model_load_pretrained(model_name, batch_size):
+        """Create that pretrained weights load, verify support for in_chans != 3 while doing so."""
+        in_chans = 3 if 'pruned' in model_name else 1  # pruning not currently supported with in_chans change
+        create_model(model_name, pretrained=True, in_chans=in_chans, num_classes=5)
+        create_model(model_name, pretrained=True, in_chans=in_chans, num_classes=0)
+
+    @pytest.mark.timeout(240)
+    @pytest.mark.parametrize('model_name', list_models(pretrained=True, exclude_filters=NON_STD_FILTERS))
+    @pytest.mark.parametrize('batch_size', [1])
+    def test_model_features_pretrained(model_name, batch_size):
+        """Create that pretrained weights load when features_only==True."""
+        create_model(model_name, pretrained=True, features_only=True)
+
+
+@pytest.mark.torchscript
+@pytest.mark.timeout(timeout120)
+@pytest.mark.parametrize(
+    'model_name', list_models(exclude_filters=EXCLUDE_FILTERS + EXCLUDE_JIT_FILTERS, name_matches_cfg=True))
+@pytest.mark.parametrize('batch_size', [1])
+def test_model_forward_torchscript(model_name, batch_size):
+    """Run a single forward pass with each model"""
+    input_size = _get_input_size(model_name=model_name, target=TARGET_JIT_SIZE)
+    if max(input_size) > MAX_JIT_SIZE:
+        pytest.skip("Fixed input size model > limit.")
+
+    with set_scriptable(True):
+        model = create_model(model_name, pretrained=False)
+    model.eval()
+
+    model = torch.jit.script(model)
+    model.to(torch_device)
+    outputs = model(torch.randn((batch_size, *input_size)))
+
+    assert outputs.shape[0] == batch_size
+    assert not torch.isnan(outputs).any(), 'Output included NaNs'
+
+
+EXCLUDE_FEAT_FILTERS = [
+    '*pruned*',  # hopefully fix at some point
+] + NON_STD_FILTERS
+if 'GITHUB_ACTIONS' in os.environ:  # and 'Linux' in platform.system():
+    # GitHub Linux runner is slower and hits memory limits sooner than MacOS, exclude bigger models
+    EXCLUDE_FEAT_FILTERS += ['*resnext101_32x32d', '*resnext101_32x16d']
+
+
+@pytest.mark.features
+@pytest.mark.timeout(120)
+@pytest.mark.parametrize('model_name', list_models(exclude_filters=EXCLUDE_FILTERS + EXCLUDE_FEAT_FILTERS))
+@pytest.mark.parametrize('batch_size', [1])
+def test_model_forward_features(model_name, batch_size):
+    """Run a single forward pass with each model in feature extraction mode"""
+    model = create_model(model_name, pretrained=False, features_only=True)
+    model.eval()
+    expected_channels = model.feature_info.channels()
+    expected_reduction = model.feature_info.reduction()
+    assert len(expected_channels) >= 3  # all models here should have at least 3 default feat levels
+
+    input_size = _get_input_size(model=model, target=TARGET_FFEAT_SIZE)
+    if max(input_size) > MAX_FFEAT_SIZE:
+        pytest.skip("Fixed input size model > limit.")
+    output_fmt = getattr(model, 'output_fmt', 'NCHW')
+    feat_axis = get_channel_dim(output_fmt)
+    spatial_axis = get_spatial_dim(output_fmt)
+    import math
+
+    outputs = model(torch.randn((batch_size, *input_size)))
+    assert len(expected_channels) == len(outputs)
+    spatial_size = input_size[-2:]
+    for e, r, o in zip(expected_channels, expected_reduction, outputs):
+        assert e == o.shape[feat_axis]
+        assert o.shape[spatial_axis[0]] <= math.ceil(spatial_size[0] / r) + 1
+        assert o.shape[spatial_axis[1]] <= math.ceil(spatial_size[1] / r) + 1
+        assert o.shape[0] == batch_size
+        assert not torch.isnan(o).any()
+
+
+@pytest.mark.features
+@pytest.mark.timeout(120)
+@pytest.mark.parametrize('model_name', list_models(module=FEAT_INTER_FILTERS, exclude_filters=EXCLUDE_FILTERS + ['*pruned*']))
+@pytest.mark.parametrize('batch_size', [1])
+def test_model_forward_intermediates_features(model_name, batch_size):
+    """Run a single forward pass with each model in feature extraction mode"""
+    model = create_model(model_name, pretrained=False, features_only=True, feature_cls='getter')
+    model.eval()
+    expected_channels = model.feature_info.channels()
+    expected_reduction = model.feature_info.reduction()
+
+    input_size = _get_input_size(model=model, target=TARGET_FFEAT_SIZE)
+    if max(input_size) > MAX_FFEAT_SIZE:
+        pytest.skip("Fixed input size model > limit.")
+    output_fmt = getattr(model, 'output_fmt', 'NCHW')
+    feat_axis = get_channel_dim(output_fmt)
+    spatial_axis = get_spatial_dim(output_fmt)
+    import math
+
+    outputs = model(torch.randn((batch_size, *input_size)))
+    assert len(expected_channels) == len(outputs)
+    spatial_size = input_size[-2:]
+    for e, r, o in zip(expected_channels, expected_reduction, outputs):
+        print(o.shape)
+        assert e == o.shape[feat_axis]
+        assert o.shape[spatial_axis[0]] <= math.ceil(spatial_size[0] / r) + 1
+        assert o.shape[spatial_axis[1]] <= math.ceil(spatial_size[1] / r) + 1
+        assert o.shape[0] == batch_size
+        assert not torch.isnan(o).any()
+
+
+@pytest.mark.features
+@pytest.mark.timeout(120)
+@pytest.mark.parametrize('model_name', list_models(module=FEAT_INTER_FILTERS, exclude_filters=EXCLUDE_FILTERS + ['*pruned*']))
+@pytest.mark.parametrize('batch_size', [1])
+def test_model_forward_intermediates(model_name, batch_size):
+    """Run a single forward pass with each model in feature extraction mode"""
+    model = create_model(model_name, pretrained=False)
+    model.eval()
+    feature_info = timm.models.FeatureInfo(model.feature_info, len(model.feature_info))
+    expected_channels = feature_info.channels()
+    expected_reduction = feature_info.reduction()
+    assert len(expected_channels) >= 3  # all models here should have at least 3 feature levels
+
+    input_size = _get_input_size(model=model, target=TARGET_FFEAT_SIZE)
+    if max(input_size) > MAX_FFEAT_SIZE:
+        pytest.skip("Fixed input size model > limit.")
+    output_fmt = 'NCHW'  # NOTE output_fmt determined by forward_intermediates() arg, not model attribute
+    feat_axis = get_channel_dim(output_fmt)
+    spatial_axis = get_spatial_dim(output_fmt)
+    import math
+
+    output, intermediates = model.forward_intermediates(
+        torch.randn((batch_size, *input_size)),
+        output_fmt=output_fmt,
+    )
+    assert len(expected_channels) == len(intermediates)
+    spatial_size = input_size[-2:]
+    for e, r, o in zip(expected_channels, expected_reduction, intermediates):
+        assert e == o.shape[feat_axis]
+        assert o.shape[spatial_axis[0]] <= math.ceil(spatial_size[0] / r) + 1
+        assert o.shape[spatial_axis[1]] <= math.ceil(spatial_size[1] / r) + 1
+        assert o.shape[0] == batch_size
+        assert not torch.isnan(o).any()
+
+
+def _create_fx_model(model, train=False):
+    # This block of code does a bit of juggling to handle any case where there are multiple outputs in train mode
+    # So we trace once and look at the graph, and get the indices of the nodes that lead into the original fx output
+    # node. Then we use those indices to select from train_nodes returned by torchvision get_graph_node_names
+    tracer_kwargs = dict(
+        leaf_modules=get_notrace_modules(),
+        autowrap_functions=get_notrace_functions(),
+        #enable_cpatching=True,
+        param_shapes_constant=True
+    )
+    train_nodes, eval_nodes = get_graph_node_names(model, tracer_kwargs=tracer_kwargs)
+
+    eval_return_nodes = [eval_nodes[-1]]
+    train_return_nodes = [train_nodes[-1]]
+    if train:
+        tracer = NodePathTracer(**tracer_kwargs)
+        graph = tracer.trace(model)
+        graph_nodes = list(reversed(graph.nodes))
+        output_node_names = [n.name for n in graph_nodes[0]._input_nodes.keys()]
+        graph_node_names = [n.name for n in graph_nodes]
+        output_node_indices = [-graph_node_names.index(node_name) for node_name in output_node_names]
+        train_return_nodes = [train_nodes[ix] for ix in output_node_indices]
+
+    fx_model = create_feature_extractor(
+        model,
+        train_return_nodes=train_return_nodes,
+        eval_return_nodes=eval_return_nodes,
+        tracer_kwargs=tracer_kwargs,
+    )
+    return fx_model
+
+
+EXCLUDE_FX_FILTERS = ['vit_gi*', 'hiera*']
+# not enough memory to run fx on more models than other tests
+if 'GITHUB_ACTIONS' in os.environ:
+    EXCLUDE_FX_FILTERS += [
+        'beit_large*',
+        'mixer_l*',
+        '*nfnet_f2*',
+        '*resnext101_32x32d',
+        'resnetv2_152x2*',
+        'resmlp_big*',
+        'resnetrs270',
+        'swin_large*',
+        'vgg*',
+        'vit_large*',
+        'vit_base_patch8*',
+        'xcit_large*',
+    ]
+
+
+@pytest.mark.fxforward
+@pytest.mark.timeout(120)
+@pytest.mark.parametrize('model_name', list_models(exclude_filters=EXCLUDE_FILTERS + EXCLUDE_FX_FILTERS))
+@pytest.mark.parametrize('batch_size', [1])
+def test_model_forward_fx(model_name, batch_size):
+    """
+    Symbolically trace each model and run single forward pass through the resulting GraphModule
+    Also check that the output of a forward pass through the GraphModule is the same as that from the original Module
+    """
+    if not has_fx_feature_extraction:
+        pytest.skip("Can't test FX. Torch >= 1.10 and Torchvision >= 0.11 are required.")
+
+    model = create_model(model_name, pretrained=False)
+    model.eval()
+
+    input_size = _get_input_size(model=model, target=TARGET_FWD_FX_SIZE)
+    if max(input_size) > MAX_FWD_FX_SIZE:
+        pytest.skip("Fixed input size model > limit.")
+    with torch.no_grad():
+        inputs = torch.randn((batch_size, *input_size))
+        outputs = model(inputs)
+        if isinstance(outputs, tuple):
+            outputs = torch.cat(outputs)
+
+        model = _create_fx_model(model)
+        fx_outputs = tuple(model(inputs).values())
+        if isinstance(fx_outputs, tuple):
+            fx_outputs = torch.cat(fx_outputs)
+
+    assert torch.all(fx_outputs == outputs)
+    assert outputs.shape[0] == batch_size
+    assert not torch.isnan(outputs).any(), 'Output included NaNs'
+
+
+@pytest.mark.fxbackward
+@pytest.mark.timeout(120)
+@pytest.mark.parametrize('model_name', list_models(
+    exclude_filters=EXCLUDE_FILTERS + EXCLUDE_FX_FILTERS, name_matches_cfg=True))
+@pytest.mark.parametrize('batch_size', [2])
+def test_model_backward_fx(model_name, batch_size):
+    """Symbolically trace each model and run single backward pass through the resulting GraphModule"""
+    if not has_fx_feature_extraction:
+        pytest.skip("Can't test FX. Torch >= 1.10 and Torchvision >= 0.11 are required.")
+
+    input_size = _get_input_size(model_name=model_name, target=TARGET_BWD_FX_SIZE)
+    if max(input_size) > MAX_BWD_FX_SIZE:
+        pytest.skip("Fixed input size model > limit.")
+
+    model = create_model(model_name, pretrained=False, num_classes=42)
+    model.train()
+    num_params = sum([x.numel() for x in model.parameters()])
+    if 'GITHUB_ACTIONS' in os.environ and num_params > 100e6:
+        pytest.skip("Skipping FX backward test on model with more than 100M params.")
+
+    model = _create_fx_model(model, train=True)
+    outputs = tuple(model(torch.randn((batch_size, *input_size))).values())
+    if isinstance(outputs, tuple):
+        outputs = torch.cat(outputs)
+    outputs.mean().backward()
+    for n, x in model.named_parameters():
+        assert x.grad is not None, f'No gradient for {n}'
+    num_grad = sum([x.grad.numel() for x in model.parameters() if x.grad is not None])
+
+    assert outputs.shape[-1] == 42
+    assert num_params == num_grad, 'Some parameters are missing gradients'
+    assert not torch.isnan(outputs).any(), 'Output included NaNs'
+
+
+if 'GITHUB_ACTIONS' not in os.environ:
+    # FIXME this test is causing GitHub actions to run out of RAM and abruptly kill the test process
+
+    # reason: model is scripted after fx tracing, but beit has torch.jit.is_scripting() control flow
+    EXCLUDE_FX_JIT_FILTERS = [
+        'deit_*_distilled_patch16_224',
+        'levit*',
+        'pit_*_distilled_224',
+    ] + EXCLUDE_FX_FILTERS
+
+
+    @pytest.mark.timeout(120)
+    @pytest.mark.parametrize(
+        'model_name', list_models(
+            exclude_filters=EXCLUDE_FILTERS + EXCLUDE_JIT_FILTERS + EXCLUDE_FX_JIT_FILTERS, name_matches_cfg=True))
+    @pytest.mark.parametrize('batch_size', [1])
+    def test_model_forward_fx_torchscript(model_name, batch_size):
+        """Symbolically trace each model, script it, and run single forward pass"""
+        if not has_fx_feature_extraction:
+            pytest.skip("Can't test FX. Torch >= 1.10 and Torchvision >= 0.11 are required.")
+
+        input_size = _get_input_size(model_name=model_name, target=TARGET_JIT_SIZE)
+        if max(input_size) > MAX_JIT_SIZE:
+            pytest.skip("Fixed input size model > limit.")
+
+        with set_scriptable(True):
+            model = create_model(model_name, pretrained=False)
+        model.eval()
+
+        model = torch.jit.script(_create_fx_model(model))
+        with torch.no_grad():
+            outputs = tuple(model(torch.randn((batch_size, *input_size))).values())
+            if isinstance(outputs, tuple):
+                outputs = torch.cat(outputs)
+
+        assert outputs.shape[0] == batch_size
+        assert not torch.isnan(outputs).any(), 'Output included NaNs'
+
+    @pytest.mark.timeout(120)
+    @pytest.mark.parametrize('model_name', ["regnetx_002"])
+    @pytest.mark.parametrize('batch_size', [1])
+    def test_model_forward_torchscript_with_features_fx(model_name, batch_size):
+        """Create a model with feature extraction based on fx, script it, and run
+        a single forward pass"""
+        if not has_fx_feature_extraction:
+            pytest.skip("Can't test FX. Torch >= 1.10 and Torchvision >= 0.11 are required.")
+
+        allowed_models = list_models(
+            exclude_filters=EXCLUDE_FILTERS + EXCLUDE_JIT_FILTERS + EXCLUDE_FX_JIT_FILTERS,
+            name_matches_cfg=True
+        )
+        assert model_name in allowed_models, f"{model_name=} not supported for this test"
+
+        input_size = _get_input_size(model_name=model_name, target=TARGET_JIT_SIZE)
+        assert max(input_size) <= MAX_JIT_SIZE, "Fixed input size model > limit. Pick a different model to run this test"
+
+        with set_scriptable(True):
+            model = create_model(model_name, pretrained=False, features_only=True, feature_cfg={"feature_cls": "fx"})
+        model.eval()
+
+        model = torch.jit.script(model)
+        with torch.no_grad():
+            outputs = model(torch.randn((batch_size, *input_size)))
+
+        assert isinstance(outputs, list)
+
+        for tensor in outputs:
+            assert tensor.shape[0] == batch_size
+            assert not torch.isnan(tensor).any(), 'Output included NaNs'

pytorch-image-models/timm/__init__.py

@@ -0,0 +1,4 @@
+from .version import __version__
+from .layers import is_scriptable, is_exportable, set_scriptable, set_exportable
+from .models import create_model, list_models, list_pretrained, is_model, list_modules, model_entrypoint, \
+    is_model_pretrained, get_pretrained_cfg, get_pretrained_cfg_value

pytorch-image-models/timm/data/__init__.py

@@ -0,0 +1,15 @@
+from .auto_augment import RandAugment, AutoAugment, rand_augment_ops, auto_augment_policy,\
+    rand_augment_transform, auto_augment_transform
+from .config import resolve_data_config, resolve_model_data_config
+from .constants import *
+from .dataset import ImageDataset, IterableImageDataset, AugMixDataset
+from .dataset_factory import create_dataset
+from .dataset_info import DatasetInfo, CustomDatasetInfo
+from .imagenet_info import ImageNetInfo, infer_imagenet_subset
+from .loader import create_loader
+from .mixup import Mixup, FastCollateMixup
+from .readers import create_reader
+from .readers import get_img_extensions, is_img_extension, set_img_extensions, add_img_extensions, del_img_extensions
+from .real_labels import RealLabelsImagenet
+from .transforms import *
+from .transforms_factory import create_transform

pytorch-image-models/timm/data/_info/imagenet22k_ms_to_12k_indices.txt

@@ -0,0 +1,11821 @@
+1001
+1003
+1004
+1005
+1006
+1007
+1008
+1009
+1010
+1011
+1013
+1014
+1015
+1016
+1017
+1018
+1019
+1020
+1021
+1023
+1024
+1026
+1027
+1028
+1029
+1030
+1031
+1032
+1033
+1034
+1037
+1038
+1041
+1043
+1044
+1045
+1046
+1047
+1048
+1049
+1050
+1051
+1053
+1055
+1056
+1057
+1058
+1060
+1061
+1062
+1063
+1064
+1065
+1066
+1067
+1068
+1069
+1070
+1071
+1072
+1073
+1074
+1075
+1076
+1077
+1078
+1079
+1080
+1081
+1082
+1083
+1084
+1085
+1086
+1089
+1090
+1091
+1093
+1094
+1095
+1096
+1097
+1099
+1100
+1101
+1102
+1103
+1105
+1107
+1108
+1109
+1110
+1111
+1112
+1113
+1114
+1115
+1116
+1117
+1118
+1119
+1120
+1121
+1122
+1123
+1124
+1125
+1126
+1127
+1128
+1129
+1130
+1131
+1132
+1133
+1134
+1135
+1137
+1138
+1140
+1141
+1142
+1143
+1144
+1146
+1147
+1148
+1149
+1151
+1152
+1153
+1154
+1156
+1157
+1158
+1159
+1161
+1162
+1164
+1165
+1166
+1167
+1168
+1169
+1170
+1171
+1172
+1173
+1175
+1176
+1179
+1180
+1181
+1182
+1184
+1188
+1192
+1193
+1195
+1196
+1197
+1199
+1200
+1203
+1206
+1209
+1210
+1211
+1212
+1213
+1214
+1215
+1216
+1217
+1218
+1219
+1220
+1221
+1222
+1223
+1224
+1225
+1226
+1227
+1230
+1231
+1235
+1249
+1250
+1251
+1252
+1253
+1254
+1289
+1292
+1295
+1301
+1306
+1307
+1312
+1313
+1315
+1317
+1320
+1324
+1325
+1326
+1327
+1332
+1341
+1343
+1347
+1352
+1353
+1354
+1356
+0
+1359
+1365
+1366
+1
+1367
+1368
+1375
+1377
+1378
+1380
+1381
+1382
+1383
+1384
+1390
+1393
+1396
+1400
+1403
+1406
+1408
+1409
+1411
+1413
+1414
+1416
+1420
+1421
+1422
+1428
+1429
+1438
+1439
+1449
+1450
+1453
+1454
+1455
+2
+1458
+1461
+1462
+1463
+1465
+1466
+1467
+1468
+1469
+1470
+1471
+3
+1473
+1475
+1478
+4
+1484
+1485
+1486
+5
+1487
+6
+1492
+1493
+1495
+1496
+1498
+1503
+1504
+1505
+1506
+7
+1507
+8
+1511
+1514
+1515
+9
+1516
+1517
+1518
+1519
+1520
+1523
+1526
+1528
+1529
+1530
+1531
+1532
+1533
+1534
+1535
+1536
+10
+11
+1537
+1538
+1540
+1541
+1542
+1543
+12
+1544
+1545
+1546
+1547
+1548
+1549
+13
+1550
+1552
+1553
+1554
+1555
+1556
+1557
+1558
+1559
+1560
+14
+1561
+1562
+1563
+1565
+1566
+1568
+1569
+1570
+1571
+1572
+1573
+1574
+1575
+1576
+1577
+1580
+1581
+1583
+1586
+1587
+1588
+1589
+1590
+1592
+1593
+1594
+1595
+1596
+1597
+1598
+1599
+1600
+1601
+1603
+1604
+1605
+1606
+1608
+1609
+1613
+1614
+1615
+1616
+1617
+1619
+1620
+1621
+1622
+1623
+1624
+1625
+15
+1627
+1628
+1629
+1630
+1631
+16
+1632
+1633
+1634
+1636
+1637
+1638
+1639
+1640
+1641
+1642
+1643
+1644
+1646
+1647
+1648
+1649
+1650
+1651
+1652
+1653
+1654
+1655
+1656
+1657
+1658
+1660
+1661
+1662
+1663
+1664
+1665
+1666
+1667
+1668
+1669
+1670
+1671
+1672
+1674
+1675
+1676
+1677
+1678
+1679
+1680
+1681
+1683
+1684
+1685
+1686
+1687
+1688
+1689
+1690
+1691
+1693
+1694
+1696
+1697
+1698
+1699
+1700
+1701
+1702
+1703
+1704
+1705
+17
+1709
+1710
+1712
+1714
+18
+1715
+1717
+1718
+1719
+1720
+1721
+1722
+1723
+1724
+1725
+1726
+1727
+1728
+1729
+1730
+1732
+1733
+1734
+1736
+1738
+1739
+1740
+1742
+1743
+1744
+1745
+19
+1746
+1747
+1748
+1749
+1750
+1753
+1754
+1755
+1756
+1757
+1758
+1760
+1761
+1762
+1763
+1764
+1765
+1766
+1767
+1769
+1770
+1771
+1772
+1774
+1776
+1778
+1779
+20
+1783
+1784
+1786
+1787
+1788
+1789
+1790
+1791
+1792
+1795
+1796
+1797
+1801
+1802
+1803
+1804
+21
+1805
+1806
+1807
+1808
+1809
+1810
+1811
+1812
+1813
+1814
+1816
+1817
+1818
+1819
+1820
+1821
+1823
+1824
+1825
+1826
+1827
+1828
+1829
+22
+1830
+1831
+1832
+1833
+1834
+23
+1837
+1838
+1839
+1840
+1841
+1842
+1843
+1844
+1845
+1846
+1847
+1848
+1849
+1850
+1851
+1852
+1853
+24
+1854
+1855
+1856
+1857
+1858
+1859
+1860
+1861
+1862
+1863
+1864
+1866
+1867
+1869
+1870
+25
+1871
+1873
+26
+1874
+1876
+1877
+27
+28
+1880
+29
+1882
+1883
+1886
+1889
+1890
+1892
+1895
+1901
+1902
+1903
+1904
+30
+1905
+1908
+1910
+1913
+1914
+31
+32
+1916
+1917
+1918
+1919
+1920
+1921
+1922
+1925
+1927
+1928
+1930
+1931
+1935
+1936
+1937
+1938
+1943
+1946
+1950
+1953
+1957
+1958
+1959
+1960
+33
+1961
+1962
+1963
+1964
+34
+1965
+1966
+1967
+35
+1968
+36
+1969
+1970
+1971
+1972
+37
+1973
+1974
+1975
+1976
+1977
+1978
+1979
+1981
+1984
+1986
+1987
+38
+39
+1990
+1991
+1992
+1995
+1996
+1997
+1998
+1999
+2000
+2001
+2003
+2004
+2005
+2006
+2007
+40
+2009
+2010
+2011
+41
+2014
+2021
+42
+43
+2023
+44
+2025
+2026
+2027
+45
+2030
+2032
+46
+2033
+47
+2035
+2036
+48
+2037
+2038
+49
+2039
+2042
+50
+2043
+2044
+2046
+2048
+51
+2069
+2088
+2089
+52
+53
+54
+55
+2092
+2093
+2094
+2095
+2096
+2099
+2101
+2103
+2104
+2105
+2108
+2109
+2110
+2111
+56
+2112
+2113
+57
+2114
+2115
+58
+2120
+2121
+2122
+2123
+2125
+59
+60
+2130
+2132
+2134
+2135
+61
+2137
+2138
+2139
+2140
+2141
+2142
+62
+2144
+2145
+2146
+2148
+2151
+2152
+63
+2153
+2154
+2155
+2156
+2157
+2158
+64
+2159
+2160
+2162
+2164
+65
+2165
+2166
+2167
+2168
+2169
+66
+2170
+2171
+2172
+2173
+67
+2174
+2176
+68
+2177
+2178
+2180
+2181
+2182
+2183
+2184
+2185
+2187
+69
+2188
+70
+71
+2189
+2191
+2193
+2194
+72
+73
+74
+75
+76
+77
+2196
+78
+2200
+2204
+2208
+2210
+2219
+2220
+79
+2224
+2225
+2228
+2233
+2238
+2240
+2243
+2244
+2245
+2246
+2247
+2248
+2250
+2252
+2253
+2255
+2257
+2259
+2260
+2261
+2262
+2263
+80
+2264
+81
+2268
+2269
+2270
+2271
+2272
+82
+2273
+83
+2274
+2275
+2278
+2280
+2285
+2288
+2289
+2292
+2293
+2294
+2296
+2298
+84
+2300
+2301
+2302
+85
+2303
+2304
+86
+2305
+2306
+2309
+2310
+2311
+2312
+2315
+2317
+2318
+2319
+2320
+2321
+2322
+2324
+2325
+2326
+2329
+2330
+2333
+2337
+2338
+2339
+87
+2340
+88
+2341
+2342
+89
+2343
+2344
+2345
+2346
+90
+2348
+2349
+2351
+2352
+2354
+2355
+2357
+91
+2360
+2362
+2363
+2365
+2366
+2367
+2368
+92
+93
+2369
+2370
+2372
+2375
+2376
+94
+2380
+2381
+2382
+2387
+2390
+2391
+2392
+2393
+2394
+2396
+2398
+2399
+2400
+2401
+2402
+2404
+2405
+95
+96
+2407
+2408
+2409
+2411
+2412
+2414
+97
+2415
+2416
+2417
+2418
+2419
+2420
+2421
+2422
+2423
+2424
+2425
+2426
+2427
+2428
+2429
+2430
+2431
+2432
+2433
+2434
+2435
+2436
+2437
+2438
+2439
+2440
+2441
+2442
+2443
+2444
+2445
+2446
+2447
+2448
+2449
+2450
+2451
+2452
+2453
+98
+2454
+2455
+99
+2456
+2457
+2458
+2459
+2460
+2461
+2462
+2463
+2464
+2465
+2466
+2467
+2468
+2469
+2470
+2471
+2472
+2473
+2474
+2475
+2476
+100
+2477
+2481
+2482
+101
+2484
+102
+2485
+103
+2486
+2487
+2488
+2490
+2491
+2493
+2494
+104
+2495
+2498
+2499
+2500
+2506
+2509
+105
+106
+2515
+2517
+2519
+2520
+2521
+2522
+2523
+2524
+2525
+2526
+2527
+2529
+2536
+2537
+2545
+2549
+2552
+2555
+2556
+2558
+2560
+2561
+2562
+2564
+2565
+2572
+107
+2580
+108
+2584
+2585
+2586
+2587
+2588
+2589
+2591
+109
+2592
+2593
+2594
+2599
+2602
+110
+111
+2627
+2630
+2635
+2636
+2638
+2642
+2643
+112
+2645
+113
+2646
+2647
+2648
+114
+2652
+2655
+2656
+2658
+2659
+115
+2662
+2663
+2666
+2667
+2668
+116
+2670
+2671
+2672
+2673
+2674
+2675
+2676
+2678
+2680
+2681
+2682
+2683
+2686
+2689
+2691
+2692
+2693
+2694
+2697
+2698
+117
+2706
+2707
+2709
+2713
+2715
+2717
+2718
+2719
+118
+119
+2727
+120
+121
+2730
+2731
+2732
+122
+2736
+123
+124
+2737
+125
+2739
+2741
+2748
+126
+2750
+2751
+2754
+2757
+2764
+2765
+2766
+2768
+2769
+127
+128
+2770
+2771
+2772
+2773
+2774
+2775
+2776
+2777
+2778
+2779
+2780
+129
+2781
+2782
+130
+2783
+2784
+2785
+2786
+131
+2787
+2788
+2789
+132
+2790
+2791
+2792
+2793
+2794
+133
+2795
+2796
+2797
+134
+2798
+2799
+135
+2800
+2801
+2802
+2803
+2804
+2806
+2807
+2808
+2809
+2810
+136
+2811
+2812
+2813
+137
+2814
+138
+2815
+2817
+2820
+2822
+2823
+2824
+2825
+2826
+2827
+2828
+2829
+2830
+139
+2831
+2832
+2833
+2834
+2835
+2836
+140
+2837
+141
+2838
+2839
+2840
+2841
+2842
+2843
+2844
+2845
+2846
+2848
+2850
+2851
+2853
+2854
+2855
+2856
+2857
+142
+2859
+2861
+2862
+2864
+2865
+2866
+2867
+2868
+2871
+2873
+143
+2874
+2875
+2877
+2878
+2879
+2882
+2884
+2885
+2886
+2887
+2888
+2889
+2890
+2891
+2892
+2893
+2894
+2895
+2896
+2897
+2898
+2899
+2900
+2901
+2902
+2903
+2904
+2905
+2906
+2907
+2908
+2909
+2910
+2911
+2912
+2914
+2916
+2917
+2918
+2919
+2920
+2921
+144
+2923
+2924
+2925
+2926
+2927
+2928
+2929
+2930
+2931
+2932
+2933
+2934
+2935
+145
+2936
+2937
+2938
+2939
+146
+2941
+2943
+2946
+2947
+2948
+2949
+2953
+2954
+2955
+2956
+2957
+2959
+2960
+2961
+2962
+2963
+147
+2965
+2966
+2970
+2971
+2972
+2973
+2974
+2975
+2976
+148
+2980
+2981
+2983
+2985
+149
+2987
+2988
+2989
+2990
+2991
+2992
+2993
+2994
+2995
+2996
+150
+2997
+2998
+2999
+3000
+3001
+3002
+3003
+3004
+3005
+3007
+3008
+3012
+3013
+3014
+3016
+3017
+3018
+3021
+3022
+151
+153
+154
+155
+3024
+156
+3025
+157
+158
+3026
+159
+3028
+160
+161
+162
+163
+164
+3030
+3032
+3033
+3034
+167
+168
+3038
+169
+170
+3039
+171
+172
+173
+174
+176
+177
+178
+3041
+3042
+179
+180
+181
+182
+183
+184
+185
+186
+187
+3043
+3044
+3045
+3046
+188
+3048
+189
+3049
+190
+191
+192
+193
+194
+195
+3050
+196
+197
+198
+199
+200
+201
+3051
+202
+203
+204
+3053
+3054
+3055
+3056
+205
+206
+207
+208
+209
+3057
+210
+3058
+211
+212
+213
+214
+3059
+215
+216
+3061
+217
+218
+219
+220
+3062
+221
+3065
+3066
+222
+3068
+223
+3069
+3070
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+3071
+3072
+236
+237
+3073
+238
+239
+240
+241
+242
+3074
+243
+244
+3075
+245
+246
+247
+3080
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+3082
+258
+259
+260
+261
+3083
+3084
+263
+264
+3085
+265
+266
+267
+3087
+269
+270
+271
+272
+3089
+3090
+273
+274
+275
+276
+3093
+3095
+3097
+277
+3102
+3103
+278
+279
+280
+3105
+3106
+3107
+3108
+3109
+3110
+3111
+3112
+3114
+3115
+281
+282
+3116
+283
+3117
+284
+3118
+3119
+285
+3121
+3122
+3123
+3124
+3125
+286
+3126
+3129
+3130
+3132
+3133
+287
+3134
+3135
+3136
+3137
+3138
+3139
+288
+3141
+289
+290
+291
+3142
+292
+3144
+3145
+3146
+293
+3150
+294
+3152
+3153
+3154
+295
+3156
+296
+297
+3158
+3161
+3163
+3165
+298
+299
+3170
+3171
+3172
+3173
+3174
+3194
+3195
+3197
+3198
+3199
+3200
+3205
+3209
+3212
+3213
+3215
+3219
+3220
+3222
+3223
+3225
+3226
+3228
+3230
+3231
+300
+301
+3232
+3234
+3235
+302
+3237
+3239
+303
+3241
+304
+3243
+3244
+305
+3252
+3255
+3256
+3257
+306
+3260
+3261
+3262
+3263
+3264
+3265
+3266
+307
+3279
+3280
+3281
+3282
+3287
+3289
+3290
+3301
+308
+3304
+3306
+3307
+3308
+3309
+3316
+3317
+3318
+3319
+3321
+3322
+3326
+3329
+3330
+3332
+3333
+3335
+3336
+3340
+3345
+3346
+3347
+309
+3349
+3350
+3353
+3354
+3355
+3356
+3358
+3359
+3360
+3362
+3364
+3365
+3367
+3369
+3370
+3371
+3372
+3373
+3374
+3376
+3379
+3381
+3382
+3383
+3384
+3386
+3389
+310
+3394
+3395
+3396
+3397
+3401
+3404
+311
+3411
+3412
+3413
+3415
+3416
+3418
+312
+3419
+3421
+3424
+313
+3425
+314
+3427
+3428
+3430
+315
+3432
+3433
+3434
+3436
+3444
+3445
+3446
+3448
+3451
+3454
+3458
+3462
+3464
+3475
+3479
+3480
+3489
+316
+3495
+3497
+3498
+317
+3502
+3510
+3511
+3514
+318
+3516
+3518
+3521
+3524
+319
+320
+3531
+3538
+3539
+3540
+3541
+3542
+3543
+3544
+3545
+321
+3546
+3547
+3548
+3549
+3550
+322
+3552
+3553
+3555
+3556
+3557
+3558
+323
+324
+3560
+3561
+325
+326
+3563
+3564
+3565
+3566
+3567
+3568
+3570
+3572
+3573
+3576
+3577
+3580
+3583
+3586
+3587
+3589
+3596
+3599
+3605
+3606
+3613
+3617
+3618
+3620
+3622
+3623
+3626
+3628
+3629
+3630
+3631
+3632
+3633
+3636
+3637
+3640
+3643
+3647
+3649
+3652
+3653
+3655
+3657
+3658
+3662
+3663
+3664
+3665
+3666
+3667
+3669
+3672
+3673
+3675
+3678
+3680
+327
+3681
+3682
+328
+3684
+3685
+3689
+329
+3690
+3692
+3694
+3695
+3696
+3697
+3698
+330
+3699
+331
+3703
+3704
+3707
+3708
+332
+3710
+3713
+3714
+3715
+3718
+3720
+3722
+3723
+3726
+3727
+3734
+3736
+3741
+3746
+3753
+3755
+333
+3759
+3760
+334
+3776
+3782
+3790
+3794
+3799
+3800
+3801
+3802
+335
+3803
+3804
+3805
+3806
+3807
+3808
+3809
+3810
+3812
+3813
+3814
+3815
+3817
+3818
+336
+3823
+3824
+337
+3827
+3828
+3830
+338
+3831
+3832
+3833
+3834
+3837
+3838
+3843
+3849
+3852
+3853
+3854
+3855
+3856
+3857
+3861
+3862
+3863
+3864
+3865
+3866
+3867
+3868
+3869
+3870
+3871
+3875
+3879
+3880
+3881
+3882
+3883
+3884
+3886
+3887
+3888
+3889
+3890
+3891
+3892
+3893
+3895
+3896
+3897
+3898
+3899
+3900
+3901
+3902
+3903
+3904
+3905
+3906
+3907
+3908
+3909
+3914
+3919
+3920
+3921
+3922
+3923
+3925
+3926
+3927
+3928
+3929
+3931
+3932
+3934
+3935
+3938
+3939
+3940
+339
+3941
+3942
+3943
+3944
+3945
+3948
+3949
+3951
+3952
+340
+3956
+3957
+3958
+3960
+3961
+3963
+3964
+3965
+3966
+3967
+3968
+3969
+341
+3970
+3973
+3974
+342
+343
+3977
+3978
+344
+3980
+3982
+3983
+3984
+345
+3986
+3987
+3988
+3989
+3991
+3993
+3994
+3995
+3996
+3997
+3998
+3999
+4002
+4003
+4005
+4006
+4007
+4008
+4009
+4010
+4012
+4014
+4015
+4016
+4017
+4019
+346
+4021
+4024
+4026
+347
+4028
+4029
+4030
+4031
+4032
+348
+4033
+4034
+4035
+4040
+4041
+4043
+4048
+4049
+4051
+4052
+4055
+4056
+349
+4057
+4058
+4059
+4060
+4061
+4062
+4063
+4065
+4066
+4067
+350
+4070
+4073
+4074
+4075
+4076
+4077
+4078
+4079
+4080
+351
+4081
+352
+353
+4082
+4084
+4085
+4086
+4087
+4090
+4092
+4094
+4096
+4097
+4098
+4100
+4101
+4102
+4104
+4105
+4107
+4108
+4109
+4112
+4113
+4114
+4115
+4117
+4118
+4119
+4120
+4121
+4122
+4123
+4124
+4125
+4127
+4128
+4131
+4138
+354
+4139
+355
+4141
+4142
+4143
+4144
+4145
+4146
+356
+4148
+357
+4152
+358
+4153
+359
+360
+4157
+4158
+4159
+361
+4160
+362
+4164
+4165
+4170
+4173
+4181
+363
+4183
+4189
+364
+4190
+4191
+4194
+4195
+4197
+4198
+4200
+4201
+4202
+4203
+4204
+4209
+4210
+4211
+4219
+4220
+4222
+4234
+365
+366
+4235
+4236
+4237
+4238
+367
+4240
+4241
+4242
+368
+369
+4244
+4245
+370
+4248
+371
+372
+4251
+4252
+373
+4254
+4255
+4256
+374
+4258
+375
+4259
+376
+377
+4262
+4263
+378
+379
+380
+381
+382
+4272
+383
+4275
+4276
+4278
+384
+4280
+4286
+385
+386
+4296
+4297
+4299
+4300
+4301
+387
+388
+4303
+4305
+4306
+389
+4315
+4317
+4319
+4321
+4324
+4325
+4326
+4330
+4335
+4337
+4341
+390
+4345
+4346
+4347
+4353
+4355
+4356
+4359
+4362
+4365
+4367
+4370
+4372
+4373
+4374
+4375
+4376
+4377
+391
+4378
+4379
+4380
+4381
+4382
+4383
+4390
+4393
+4395
+4398
+4406
+4409
+4411
+4420
+4422
+4423
+4424
+4425
+4426
+4427
+4433
+4434
+4435
+4436
+4437
+4440
+4441
+4444
+4445
+4446
+4448
+4450
+4452
+4453
+4454
+4460
+4461
+4462
+4463
+4466
+4468
+4472
+4473
+4475
+4476
+4481
+4482
+4485
+4490
+4491
+4492
+4495
+4496
+4497
+4498
+4502
+4507
+4508
+4509
+4510
+4512
+4516
+4518
+4524
+4526
+4528
+4533
+4536
+4544
+4545
+4547
+4551
+4555
+4556
+4557
+4558
+4559
+4564
+4570
+4571
+4576
+4577
+4578
+392
+4579
+393
+4581
+4582
+4583
+4590
+4592
+4594
+4597
+4607
+4611
+4612
+4613
+4615
+4624
+4625
+4626
+4627
+4628
+4629
+4630
+4632
+4634
+4636
+4637
+4638
+4639
+4642
+4644
+4645
+4646
+4647
+4648
+4649
+4668
+4669
+394
+4671
+4672
+395
+4675
+396
+4677
+4678
+4692
+4693
+4697
+4699
+4700
+4702
+4703
+4704
+397
+4706
+4707
+4709
+4711
+4712
+4714
+4720
+4722
+4731
+398
+4738
+4739
+4740
+399
+4741
+4742
+4743
+4744
+4748
+4750
+400
+4751
+4752
+4753
+4754
+4757
+401
+4759
+402
+4764
+4768
+4771
+4773
+4775
+4776
+4778
+4779
+4780
+4782
+4784
+4786
+4787
+4788
+4789
+4795
+4799
+4800
+4801
+4802
+4803
+403
+4804
+4806
+4807
+4808
+4809
+4810
+4811
+4812
+4813
+404
+4816
+4817
+4818
+405
+4821
+4824
+4826
+4827
+4829
+4831
+4836
+4838
+4842
+406
+4843
+4844
+4845
+4846
+4847
+4848
+407
+4851
+4853
+4854
+408
+4855
+4856
+4857
+4858
+4860
+409
+4862
+4863
+4864
+4866
+4867
+4868
+4870
+4871
+4872
+4873
+4874
+4875
+4880
+4882
+4886
+4887
+4888
+4889
+4891
+4894
+4896
+4897
+4898
+4899
+4900
+4901
+4902
+410
+4904
+4906
+4907
+411
+4911
+4912
+4913
+4914
+4915
+4916
+4917
+4918
+4919
+4920
+4922
+4923
+4924
+4926
+4928
+4929
+4932
+4933
+4934
+4937
+4938
+4939
+4940
+4942
+4943
+4944
+4946
+4949
+4950
+4951
+4953
+4954
+4957
+4961
+4962
+412
+4966
+4967
+413
+4975
+4976
+4977
+4981
+4982
+4985
+4986
+4987
+4989
+4990
+4992
+4993
+4994
+4996
+4998
+5000
+5002
+5003
+5004
+5005
+5006
+5007
+5009
+5011
+5012
+5013
+5014
+5016
+5017
+5018
+5020
+5021
+5022
+5024
+5025
+5026
+5027
+5028
+5030
+5031
+5036
+5037
+5039
+5040
+5041
+5042
+5044
+5045
+5048
+5049
+5050
+5051
+5052
+5053
+5054
+5055
+5056
+5057
+5059
+5060
+5061
+5062
+5063
+414
+5064
+5066
+5068
+5069
+5070
+5071
+5072
+5074
+5075
+5076
+5078
+5079
+5080
+5081
+5082
+5083
+5084
+5085
+5086
+5089
+5090
+5091
+415
+5093
+5094
+5095
+416
+5098
+5101
+5102
+5104
+5105
+5112
+5113
+5114
+5116
+417
+5120
+5121
+5122
+418
+5124
+5125
+5126
+5127
+5128
+5130
+419
+5131
+5132
+5135
+5136
+5139
+420
+5140
+421
+5143
+5145
+5146
+5147
+422
+423
+424
+5149
+5151
+5152
+5154
+5155
+425
+5159
+5161
+426
+5164
+427
+5167
+5168
+5171
+5172
+5175
+428
+5176
+5177
+429
+5179
+5180
+5181
+5182
+5183
+5184
+5187
+5188
+5189
+5190
+5191
+5192
+430
+5193
+5194
+5195
+5196
+5197
+5198
+5200
+5201
+5202
+431
+5203
+432
+5206
+5207
+5208
+5209
+433
+5213
+5214
+5215
+5216
+434
+435
+5219
+5220
+5226
+5227
+5228
+5229
+5230
+5231
+5232
+5233
+5234
+5235
+5236
+5240
+5241
+5242
+5243
+5244
+5245
+5247
+5249
+436
+5250
+437
+5252
+438
+5253
+5255
+5256
+5257
+439
+5262
+5265
+5268
+5269
+5270
+5271
+5272
+5274
+5275
+5276
+5277
+5279
+5282
+5283
+440
+5284
+5285
+441
+5286
+5287
+5288
+5290
+5291
+5292
+5294
+442
+5296
+5297
+5300
+5303
+5305
+5307
+5308
+5309
+5313
+5315
+5316
+5317
+5318
+5319
+5325
+443
+5327
+5329
+444
+5330
+5332
+5333
+5334
+5335
+5336
+5338
+445
+5344
+5347
+5349
+5351
+5352
+5353
+5354
+5355
+446
+5357
+5359
+447
+5360
+5364
+5365
+5366
+5367
+5368
+5370
+448
+5375
+5380
+5382
+5384
+5387
+5388
+5390
+5391
+5393
+5394
+5395
+5398
+5399
+5400
+5402
+5403
+5404
+5405
+5406
+5411
+5412
+5414
+5415
+5416
+5417
+5418
+5420
+5422
+5425
+5426
+5428
+5429
+5430
+449
+5433
+5434
+5435
+450
+5436
+5437
+5439
+5443
+5444
+5445
+5446
+5449
+5450
+5452
+5454
+5455
+451
+5457
+5458
+5460
+5461
+5464
+5465
+5469
+5470
+5471
+5472
+5473
+5474
+452
+5475
+5476
+453
+5478
+5479
+5480
+5481
+454
+5483
+5484
+5485
+5486
+5487
+5488
+5490
+5491
+5492
+5495
+5496
+5498
+5502
+5503
+5505
+5506
+455
+5509
+5511
+5512
+5514
+5516
+5517
+456
+5520
+5521
+5522
+5523
+5524
+5525
+5527
+5528
+5529
+5530
+5532
+5533
+5534
+457
+5536
+5540
+5541
+5543
+5544
+5545
+5546
+5547
+5549
+5550
+5551
+5553
+5554
+5558
+5559
+5562
+5563
+5564
+5565
+5567
+5568
+5569
+458
+5570
+5572
+459
+5574
+5577
+5578
+5579
+5581
+5582
+460
+461
+5585
+5586
+5589
+5593
+5595
+5598
+5599
+5600
+5601
+5602
+5603
+5606
+5609
+5610
+5611
+5614
+5616
+5617
+5619
+5621
+5622
+5624
+5626
+5628
+5629
+5630
+5631
+5632
+462
+5635
+5637
+5638
+5639
+5641
+5642
+5646
+463
+5648
+464
+5650
+5652
+5654
+5655
+5656
+5657
+5658
+5659
+5660
+5661
+5662
+5664
+5665
+465
+466
+5666
+5667
+5668
+5670
+5671
+5672
+5674
+5675
+5676
+5677
+5679
+5681
+5682
+5684
+5686
+5687
+5689
+5690
+5691
+5695
+5696
+5698
+5700
+5701
+5705
+5707
+5708
+5709
+5711
+5712
+5713
+5714
+467
+5716
+5717
+5718
+5719
+5721
+5723
+5725
+5727
+5728
+5730
+468
+5732
+5733
+5734
+5735
+5736
+5737
+5738
+5739
+5740
+5741
+5742
+5743
+5744
+5746
+5747
+5748
+5749
+5750
+5752
+5753
+5754
+5755
+5756
+5757
+5758
+5762
+5765
+469
+5767
+5769
+5770
+5777
+5778
+5779
+5780
+5783
+5784
+5785
+5786
+5788
+5789
+5794
+5795
+5796
+5797
+5799
+5800
+5802
+5803
+470
+5806
+5807
+5811
+5813
+5817
+5819
+471
+5820
+472
+473
+5821
+5822
+5823
+5824
+5825
+5826
+5827
+5828
+5832
+5833
+5837
+5838
+5839
+5840
+5841
+5842
+5843
+5845
+5846
+5847
+5848
+5849
+5852
+5854
+5855
+5856
+5857
+5858
+5859
+5860
+5861
+5862
+5864
+5865
+5866
+5867
+474
+5869
+5870
+5871
+5872
+5873
+5878
+5882
+5883
+475
+476
+5886
+477
+5891
+5894
+5895
+5897
+5899
+5900
+5901
+5903
+5907
+5908
+5909
+5910
+5911
+478
+5912
+5913
+5914
+5916
+5919
+5920
+5921
+5922
+479
+5923
+5926
+5927
+5930
+5931
+5932
+5933
+5937
+480
+5938
+5939
+5940
+5941
+5942
+5944
+5945
+5946
+481
+5947
+482
+5948
+5949
+5951
+5952
+483
+5955
+5957
+484
+5959
+5960
+5961
+5962
+5963
+5965
+5966
+5969
+5970
+5971
+5976
+5978
+5981
+5982
+5986
+5987
+485
+5988
+5989
+5990
+5991
+5992
+5995
+5996
+5997
+486
+5998
+487
+5999
+6000
+6001
+6003
+6005
+6006
+6007
+6008
+6009
+6010
+6011
+6013
+6015
+6016
+488
+6017
+489
+490
+491
+6019
+6022
+6023
+6025
+6027
+6028
+6029
+6030
+6032
+6037
+6038
+6039
+6040
+6043
+6046
+6048
+6049
+6050
+6052
+6055
+6056
+6057
+6058
+6059
+6060
+6061
+6062
+6063
+6065
+6069
+6071
+6072
+6073
+6074
+492
+6075
+6076
+6077
+6079
+6081
+6082
+6083
+6084
+493
+6085
+494
+6088
+495
+6090
+6094
+6095
+6096
+6097
+6098
+6099
+6100
+6101
+6102
+6107
+6108
+496
+6110
+6111
+6112
+6113
+6115
+497
+6116
+6117
+6119
+6121
+6122
+6123
+6124
+6125
+6126
+6127
+6128
+6129
+498
+6131
+6132
+6134
+6135
+6136
+6137
+6139
+6140
+6143
+6144
+6148
+6153
+6155
+6157
+6158
+6159
+6160
+6161
+6162
+6164
+6165
+6166
+6168
+6170
+6172
+499
+6173
+6174
+500
+6176
+6181
+6182
+6184
+6187
+6189
+6190
+501
+6192
+6193
+6194
+6195
+6196
+6197
+502
+6199
+6200
+6201
+6202
+6205
+6206
+6208
+6209
+6210
+6211
+6212
+6213
+6214
+6215
+6222
+6224
+6226
+6233
+6234
+6235
+6238
+6239
+6240
+6245
+6249
+6250
+6251
+6252
+6254
+6255
+6256
+503
+6257
+6260
+6261
+6262
+6263
+6264
+504
+505
+6266
+6267
+6268
+6270
+6271
+6272
+506
+6275
+6277
+6278
+6279
+6280
+6281
+6282
+6283
+6284
+6285
+6286
+6290
+6291
+6295
+6296
+6297
+6298
+6300
+6301
+6302
+6303
+6304
+6305
+507
+6308
+6309
+6310
+6315
+6316
+6317
+6320
+6321
+6322
+6323
+6324
+6328
+6329
+6333
+6335
+6337
+6338
+6339
+6340
+6341
+508
+6342
+6344
+6346
+6348
+6349
+6350
+6351
+6352
+6353
+6354
+6357
+6358
+6359
+509
+6362
+6363
+6364
+6365
+6369
+6371
+6374
+6375
+6377
+6378
+6381
+6382
+510
+6385
+6386
+6387
+6388
+6389
+6391
+6393
+6394
+6395
+6396
+6399
+511
+6400
+6401
+6402
+6403
+6406
+6407
+6408
+6409
+6410
+6412
+6415
+6416
+6419
+6420
+6422
+6423
+6428
+6429
+6430
+6432
+6435
+512
+6437
+6438
+6439
+513
+6441
+6442
+6443
+6446
+6447
+6448
+6450
+6451
+6453
+6454
+6455
+6459
+6460
+6462
+6463
+6466
+6467
+6471
+6472
+6473
+6474
+6476
+6477
+6480
+6481
+6482
+6483
+6484
+6485
+6487
+6489
+6490
+514
+515
+6492
+6493
+6494
+516
+6496
+6498
+6499
+517
+6502
+6503
+518
+519
+6505
+6506
+6507
+6508
+6509
+6510
+6512
+6513
+6517
+520
+6520
+6521
+6522
+6523
+6525
+6526
+6527
+6528
+521
+522
+6532
+6533
+6534
+6540
+6542
+6546
+6547
+6549
+6552
+6553
+6554
+6556
+6559
+6560
+6561
+6563
+523
+6568
+6575
+6578
+6579
+524
+6584
+6585
+6586
+6589
+6590
+6591
+6593
+6595
+6597
+6599
+6600
+6603
+6604
+6609
+6614
+6615
+6619
+6621
+6622
+6623
+6627
+6628
+6629
+525
+6632
+6634
+6641
+6642
+6647
+6648
+6649
+6651
+6653
+6654
+6658
+6664
+6665
+6666
+6672
+6675
+6676
+6677
+6678
+6679
+6681
+6684
+6685
+6686
+6688
+6689
+6690
+6691
+6693
+6698
+6699
+6700
+6701
+6702
+6704
+6706
+6708
+526
+6709
+527
+6710
+6711
+6713
+6714
+6715
+6720
+6723
+6724
+6725
+6727
+528
+529
+6730
+6732
+6736
+6740
+6742
+6743
+6744
+6745
+6751
+6754
+6755
+530
+6757
+6758
+6759
+531
+6762
+6765
+6766
+6767
+6768
+6769
+6770
+6771
+6772
+6773
+532
+6774
+6775
+6776
+6779
+6782
+6786
+6788
+6792
+6793
+6794
+6797
+6798
+6801
+6802
+6803
+6805
+533
+6806
+534
+6807
+535
+6808
+6809
+6811
+6812
+6813
+6814
+6816
+6819
+6820
+6823
+6826
+6827
+6828
+6829
+6831
+6836
+6840
+6842
+536
+537
+6847
+6848
+6849
+6850
+6851
+6852
+6854
+538
+6855
+6856
+6857
+6858
+6859
+6860
+6861
+6862
+6865
+539
+6867
+6868
+6871
+6872
+6874
+6877
+6878
+6880
+6881
+6882
+6883
+6885
+6886
+6890
+6891
+6893
+6895
+6897
+6899
+6900
+6901
+6902
+6904
+6907
+6908
+6909
+6910
+6911
+6912
+6913
+6914
+6915
+6916
+6918
+6919
+6920
+6922
+6924
+6925
+6927
+6928
+6929
+6930
+6931
+6934
+6935
+6937
+6938
+540
+6939
+6940
+6941
+6942
+6947
+6949
+6951
+6952
+6954
+6955
+6958
+6959
+6962
+6964
+6965
+6969
+541
+6971
+6972
+6973
+542
+6975
+6978
+6979
+6980
+6984
+6988
+6990
+6991
+6992
+6993
+6994
+6997
+543
+7001
+7002
+7003
+7006
+7007
+7009
+7010
+7012
+7014
+7015
+7016
+544
+7017
+7018
+7022
+7023
+7026
+7027
+7028
+7029
+7030
+7031
+7032
+7033
+7034
+7038
+7042
+7044
+7045
+7046
+7048
+7049
+7050
+7051
+7052
+7053
+7055
+7056
+7057
+7059
+7060
+545
+546
+7065
+7066
+7067
+547
+7068
+7069
+7070
+7071
+7072
+7073
+7074
+7075
+7081
+7084
+7088
+7090
+7091
+7092
+7095
+7100
+7101
+7103
+7105
+7106
+7107
+7110
+7112
+7113
+7114
+7115
+7117
+7119
+7120
+7121
+7122
+7125
+7126
+7127
+7128
+7129
+548
+7130
+7132
+549
+7133
+7136
+7137
+7141
+7142
+7143
+7144
+7145
+7146
+7148
+7150
+7152
+7153
+7155
+7156
+550
+7157
+7158
+7159
+7161
+7162
+7164
+7165
+7167
+7169
+7170
+7171
+7172
+7174
+7175
+7177
+7184
+7186
+7188
+7189
+7190
+7192
+7193
+7194
+7195
+7196
+7197
+7198
+7200
+551
+7201
+7202
+7205
+7206
+7211
+7212
+7213
+7214
+7215
+7216
+7218
+7220
+7221
+7222
+7223
+7224
+7226
+7227
+7229
+7231
+7232
+7233
+7234
+7235
+7236
+7239
+7242
+7243
+7245
+552
+7246
+7247
+7251
+7252
+7253
+7254
+7255
+7256
+7257
+7260
+7261
+7262
+7267
+7269
+7270
+7272
+7273
+7276
+7277
+7278
+7280
+7281
+7284
+7285
+7287
+7288
+7293
+7294
+553
+7297
+7301
+7303
+7304
+7306
+7309
+7310
+7311
+7312
+7313
+7314
+7316
+7321
+7322
+7323
+7324
+7325
+554
+7327
+555
+7330
+7331
+7333
+556
+7335
+7337
+7341
+7343
+7344
+7345
+7348
+7351
+7352
+7355
+7358
+7359
+7360
+7362
+557
+7367
+7368
+7370
+7371
+7372
+7373
+7374
+7376
+7377
+7378
+7379
+7381
+7382
+7383
+7386
+7387
+7388
+7392
+7393
+7394
+7395
+7396
+7398
+7400
+7401
+7402
+7403
+7406
+7407
+7408
+7410
+7411
+7415
+7416
+7420
+7422
+558
+7423
+7426
+7427
+7428
+7431
+7432
+7434
+7435
+7436
+7437
+7438
+7439
+7440
+559
+7442
+7443
+7444
+560
+7449
+7450
+7452
+7456
+7457
+7458
+7464
+7465
+7468
+7470
+561
+7477
+7479
+7480
+7482
+7483
+7484
+7486
+562
+563
+7487
+564
+7490
+7491
+7492
+7494
+7497
+7498
+7499
+7501
+7503
+7504
+7507
+565
+7509
+7510
+7511
+566
+7512
+7514
+7515
+7516
+7517
+7518
+7520
+7521
+7523
+7524
+7525
+7526
+7528
+7529
+7530
+567
+7531
+7532
+7533
+7535
+7536
+7539
+7540
+7542
+568
+7543
+7544
+7546
+7547
+7548
+7549
+7551
+7552
+7553
+7554
+7557
+7558
+7559
+7560
+7565
+7566
+7567
+7568
+7569
+7573
+7581
+7583
+7584
+7585
+7586
+7587
+7589
+7591
+7592
+7593
+7594
+7595
+569
+7596
+7597
+7598
+7599
+7600
+7601
+7602
+7603
+7605
+7606
+7607
+7608
+7610
+7611
+7612
+7613
+7616
+7619
+7622
+7623
+7624
+7625
+7626
+570
+7628
+7629
+7630
+7631
+7632
+571
+7633
+7634
+7635
+7636
+7640
+7641
+7642
+7643
+7644
+7645
+7646
+7647
+7648
+7650
+7651
+7652
+7653
+7654
+7656
+7658
+7659
+7660
+7665
+7666
+7667
+7669
+7670
+7671
+7672
+7673
+7674
+7675
+7678
+7682
+7684
+7685
+7686
+7687
+7688
+7689
+7691
+7692
+7694
+7695
+7696
+7698
+7699
+7701
+7704
+7705
+7706
+7707
+572
+7709
+573
+7710
+7711
+574
+575
+7712
+7713
+7714
+7715
+7716
+576
+577
+7719
+7721
+7723
+7724
+578
+7727
+7728
+7730
+7731
+7734
+7735
+7736
+7737
+7738
+579
+7739
+7741
+7742
+7743
+7744
+7745
+7746
+7747
+7749
+7752
+7753
+7754
+7755
+7756
+7757
+7758
+7760
+580
+7761
+7763
+581
+7766
+7767
+7768
+7771
+582
+7774
+7775
+7780
+7781
+7782
+7787
+7789
+7790
+7792
+7795
+7796
+7797
+583
+7801
+7802
+7804
+7806
+7807
+7809
+7810
+7812
+7816
+7819
+7822
+7828
+7834
+7835
+7836
+7838
+7840
+7841
+584
+585
+7846
+586
+7849
+7850
+7851
+7853
+7854
+7855
+7856
+587
+7861
+588
+7862
+7863
+7865
+589
+7868
+7869
+7870
+7871
+7872
+7873
+7874
+7875
+7876
+590
+591
+7878
+7879
+7880
+7881
+7882
+7883
+7884
+7886
+7887
+7890
+7892
+7893
+7894
+7899
+7900
+7902
+7904
+592
+7905
+593
+7909
+7910
+7911
+594
+7912
+7916
+7918
+595
+7920
+7921
+7922
+7924
+7925
+596
+7927
+7928
+7929
+7931
+7933
+7936
+7939
+7942
+7943
+7944
+7945
+7949
+7951
+7954
+7955
+7957
+7959
+7960
+7961
+7962
+7964
+7965
+7966
+7967
+7968
+7969
+7970
+7971
+7973
+7974
+7976
+7977
+7978
+7981
+7987
+7988
+7990
+7993
+7994
+7995
+7998
+7999
+8000
+8004
+8006
+8007
+8009
+8010
+8011
+8013
+8015
+8016
+8019
+8020
+8022
+8025
+8026
+8028
+8029
+8031
+8032
+8033
+8034
+8037
+8040
+8041
+8044
+8045
+8047
+8049
+8053
+597
+8054
+8057
+8058
+8059
+8060
+8061
+8062
+598
+8064
+599
+8065
+8066
+8071
+600
+8072
+8073
+601
+8079
+8080
+602
+8083
+8085
+8087
+8088
+8090
+8091
+603
+8094
+8099
+8100
+8101
+8103
+8104
+8106
+8107
+8108
+8109
+8111
+8112
+8113
+8114
+8115
+8117
+8118
+8119
+8120
+8121
+8123
+8124
+8125
+604
+8126
+8127
+8128
+8129
+8131
+8133
+8134
+8135
+8136
+8137
+8141
+8144
+8146
+8148
+8150
+8151
+8152
+8153
+8154
+8155
+8158
+8159
+8163
+8164
+8165
+8168
+8170
+8172
+8173
+8174
+8178
+8180
+8181
+8182
+8183
+8184
+8187
+8188
+8189
+8190
+8193
+8194
+8196
+8200
+8201
+8205
+8208
+8210
+8213
+8215
+8219
+8223
+8225
+8227
+8229
+8230
+8232
+8236
+8238
+8239
+8244
+8247
+8249
+8250
+8251
+8253
+8255
+8257
+8259
+8262
+8263
+605
+8266
+606
+8267
+8269
+8271
+8274
+8275
+8277
+8279
+8280
+8282
+8284
+8285
+8287
+607
+8288
+8294
+8295
+8296
+8297
+8298
+8300
+8303
+8305
+608
+609
+8307
+8308
+8309
+610
+8310
+8312
+8313
+8316
+8317
+8318
+8320
+611
+612
+8324
+8325
+8326
+8327
+8328
+8329
+8330
+8331
+613
+8336
+8337
+8338
+8339
+8340
+8341
+8345
+8348
+8349
+8350
+8352
+8355
+8358
+8359
+8362
+8363
+8367
+8368
+8369
+8370
+8373
+8374
+8375
+8376
+8377
+8378
+8380
+8381
+8383
+8384
+8385
+8386
+8387
+8390
+8391
+8392
+8393
+8394
+614
+8397
+8402
+8404
+8405
+8406
+8407
+8408
+8409
+8410
+8412
+8413
+8414
+8416
+8418
+8419
+8420
+615
+8421
+8422
+8423
+8424
+8426
+8427
+8428
+8429
+8430
+8434
+616
+8435
+8437
+8439
+8443
+8444
+8445
+8447
+617
+8448
+8450
+8452
+8453
+8454
+618
+8458
+8459
+8461
+8462
+8463
+8465
+8467
+8468
+8470
+619
+8473
+8478
+8479
+8481
+8484
+8485
+8486
+8490
+620
+8492
+8493
+8494
+8495
+8498
+8499
+8500
+8503
+8504
+8505
+8506
+8508
+8510
+8512
+8515
+8517
+8518
+621
+8519
+8520
+8522
+8523
+8525
+8527
+8528
+8529
+8531
+8532
+8533
+8534
+8535
+8537
+8539
+8540
+8541
+622
+8543
+623
+8546
+8547
+8548
+8549
+8550
+8551
+8553
+624
+8554
+625
+8557
+8558
+8560
+8565
+8567
+8569
+8571
+626
+8572
+8574
+8575
+8576
+8577
+8578
+8579
+8580
+8581
+8583
+8584
+627
+8585
+8587
+628
+8589
+8591
+8592
+8593
+8596
+8600
+629
+8601
+8602
+8603
+8606
+8607
+8609
+8610
+630
+8612
+8613
+8614
+8615
+8619
+8620
+8621
+8623
+8624
+8625
+8626
+8627
+8628
+8630
+8632
+8633
+8636
+8637
+8640
+8641
+8642
+8644
+8645
+8647
+8650
+8651
+8654
+8655
+631
+632
+8657
+8661
+633
+8663
+8664
+8665
+8666
+8669
+8673
+8675
+8676
+8678
+8679
+8681
+634
+8685
+8687
+8690
+8691
+8692
+8693
+8694
+8695
+8697
+8698
+8700
+8702
+8710
+8711
+8712
+8713
+635
+8718
+8724
+8726
+8728
+8729
+636
+637
+638
+639
+8738
+8740
+8741
+8742
+8746
+8748
+8749
+8750
+8752
+8753
+8754
+8756
+8757
+8758
+8759
+8760
+640
+8761
+8762
+8763
+8764
+8766
+8767
+8768
+8769
+8771
+8773
+641
+8775
+8776
+642
+8777
+8778
+8779
+8783
+8785
+8787
+8789
+8790
+8791
+8792
+643
+8793
+8795
+8796
+8802
+8803
+8804
+8805
+8806
+8807
+8808
+8809
+8810
+8812
+644
+8817
+8818
+8819
+8822
+8823
+8824
+8825
+8827
+8828
+8829
+645
+646
+8834
+647
+8835
+8836
+8837
+8838
+8842
+8843
+8844
+8845
+8846
+8847
+8848
+8849
+648
+649
+8851
+8852
+8853
+8855
+8856
+8858
+8859
+8860
+8861
+8862
+8863
+8866
+8871
+8872
+8874
+8876
+8879
+8881
+8882
+8886
+8888
+650
+8889
+8890
+8891
+651
+8895
+8896
+8897
+652
+8900
+653
+8902
+8903
+8906
+8907
+8908
+8910
+8911
+8914
+8915
+8916
+8917
+8918
+8919
+8923
+8924
+654
+8926
+8928
+655
+656
+8931
+8932
+8933
+8934
+8936
+657
+8938
+8939
+658
+8940
+8941
+659
+8942
+8943
+8944
+660
+8946
+661
+662
+8950
+8952
+663
+8961
+8962
+664
+8963
+8964
+8967
+8971
+8973
+665
+8975
+8977
+8979
+8980
+8981
+8982
+666
+667
+8983
+8984
+668
+669
+8985
+8986
+8987
+8988
+8992
+8993
+8994
+8995
+8996
+670
+8997
+8998
+8999
+9000
+671
+672
+673
+9001
+674
+9002
+9003
+9004
+9005
+9006
+9007
+675
+9009
+9010
+9014
+9015
+9016
+9017
+9018
+9019
+9026
+9031
+9032
+9033
+9034
+9035
+9036
+9037
+9039
+9040
+676
+677
+9046
+9047
+9050
+9054
+9055
+9059
+9060
+9061
+9062
+9063
+9067
+9068
+678
+9073
+679
+9074
+9076
+9077
+9078
+9079
+9081
+9082
+9083
+9086
+9088
+9090
+9091
+9092
+9093
+9095
+9096
+9100
+9101
+9103
+9104
+9105
+9106
+9107
+9108
+9113
+9115
+9117
+9118
+680
+9122
+9123
+9125
+9126
+9129
+9131
+9133
+681
+9135
+9138
+9141
+9142
+9144
+9145
+9146
+9147
+9148
+682
+9150
+683
+9154
+9155
+684
+9158
+685
+9160
+9161
+9162
+9163
+9165
+9168
+9170
+9171
+686
+9173
+9174
+9176
+9177
+9180
+9182
+9183
+9184
+9185
+9188
+9189
+9191
+9192
+9196
+9197
+9199
+9200
+9201
+9203
+9204
+9205
+9207
+9209
+687
+9210
+9211
+9212
+9213
+9214
+9215
+9217
+9218
+9220
+9222
+9226
+9227
+688
+9228
+9229
+9230
+9233
+9234
+9235
+9236
+9237
+9238
+9240
+9242
+9243
+9245
+9247
+9248
+9249
+9250
+9253
+9254
+9255
+9256
+9258
+9259
+9261
+689
+690
+9265
+9266
+691
+9270
+9273
+9274
+9275
+9276
+9277
+692
+9278
+693
+9283
+9286
+694
+9287
+695
+9288
+9289
+9290
+9291
+696
+9293
+697
+9294
+698
+9295
+9296
+9301
+9302
+9304
+9307
+9308
+9312
+9313
+9314
+9315
+9316
+699
+9322
+9323
+9324
+9325
+9326
+9328
+9329
+9330
+9331
+9332
+9333
+9334
+9336
+9337
+700
+701
+702
+9344
+9346
+9347
+9348
+9349
+9351
+9352
+703
+704
+9353
+9354
+9355
+9356
+9357
+9359
+9360
+9361
+705
+9365
+9366
+9367
+9368
+9373
+9374
+9375
+9376
+9377
+706
+9381
+9385
+9386
+9387
+9389
+9390
+707
+9392
+9393
+9396
+9397
+708
+9398
+9399
+9400
+9401
+9402
+9403
+9407
+9409
+9410
+9414
+9419
+709
+710
+9421
+9422
+9423
+9427
+9428
+9429
+9430
+9431
+9433
+9435
+9436
+9437
+9438
+9439
+9440
+9442
+9443
+711
+9446
+9447
+9449
+9451
+9453
+9454
+9455
+9456
+9457
+712
+9460
+9461
+9462
+9463
+9466
+9467
+713
+9470
+9473
+9474
+9475
+9477
+9479
+714
+715
+716
+717
+9487
+9488
+718
+9493
+9494
+9495
+9496
+9497
+9499
+9500
+719
+9503
+720
+9504
+9505
+9506
+721
+9507
+9508
+9509
+9511
+9515
+9516
+9517
+9519
+9520
+9521
+9523
+722
+9527
+9528
+9529
+9531
+9533
+9534
+9535
+723
+9540
+9541
+9544
+9545
+724
+9546
+9547
+9548
+9549
+9550
+9551
+725
+9554
+9556
+9563
+9566
+9567
+726
+9568
+9569
+727
+9574
+9575
+9576
+9577
+9578
+9579
+9580
+728
+9583
+9584
+9587
+9588
+9589
+729
+9593
+9596
+9599
+9600
+9602
+9603
+9604
+9605
+9606
+9607
+9611
+9612
+9613
+730
+9614
+9615
+9617
+9618
+731
+9621
+9622
+9629
+9630
+9632
+9633
+9634
+9635
+9636
+9637
+9638
+9639
+732
+733
+9646
+734
+9647
+9649
+9650
+9651
+9654
+9655
+735
+9658
+9659
+9660
+9661
+9662
+9663
+736
+9664
+9666
+737
+9668
+9672
+9673
+9674
+9675
+9676
+9677
+9678
+9679
+9681
+9682
+9683
+9684
+9686
+9687
+9688
+9691
+9692
+9698
+9701
+738
+9702
+9705
+9706
+9707
+9708
+739
+9709
+9711
+9712
+9713
+9714
+9716
+9719
+9722
+740
+9723
+9725
+9727
+9728
+9729
+741
+9733
+9736
+9738
+9739
+9741
+9743
+9745
+9747
+9749
+9750
+9753
+9755
+9757
+9758
+742
+9759
+9760
+743
+9768
+744
+745
+9769
+9774
+9775
+9776
+9781
+9785
+9786
+9788
+9789
+9790
+9793
+9795
+9796
+746
+9798
+9800
+9801
+9803
+9804
+9809
+9810
+9818
+747
+9820
+9821
+9822
+9823
+9825
+9826
+748
+9827
+9828
+9829
+9831
+9834
+9835
+9836
+9837
+9838
+9840
+9841
+9845
+9847
+9852
+9855
+749
+750
+9858
+9863
+9864
+9866
+9870
+751
+9873
+9874
+9875
+9876
+9877
+752
+9880
+9881
+9882
+9883
+753
+9885
+9886
+9887
+754
+9888
+9891
+9896
+9897
+9898
+9899
+755
+9902
+9903
+9904
+9907
+9908
+9909
+9910
+9911
+9913
+9916
+756
+9917
+9918
+9919
+9920
+9921
+9923
+9926
+9928
+9931
+9932
+9933
+9934
+9935
+9937
+9939
+9940
+9945
+9946
+9947
+9948
+9949
+9953
+9954
+9955
+9957
+9959
+9962
+9963
+9966
+9968
+9969
+9970
+9972
+9975
+9976
+9977
+9979
+9980
+9981
+757
+9982
+9983
+9986
+758
+9993
+9994
+9995
+9996
+9997
+9999
+759
+10002
+10003
+10004
+760
+10008
+10009
+10010
+10011
+10012
+10014
+10015
+761
+10016
+10017
+10018
+10020
+10022
+10023
+10024
+10029
+10032
+10034
+10035
+10036
+10037
+10038
+762
+10039
+10042
+10043
+10044
+10046
+10048
+10051
+763
+10056
+10061
+10062
+10063
+10070
+10071
+10072
+10073
+764
+10076
+10079
+10083
+10084
+10090
+10092
+10093
+10094
+10095
+10097
+10101
+10103
+10104
+10108
+10110
+10111
+10112
+765
+10114
+10117
+10119
+10120
+10121
+10122
+10123
+10125
+10127
+10128
+10129
+10130
+10131
+10132
+10133
+10134
+10135
+10136
+10138
+10140
+10141
+10143
+10145
+10146
+10149
+10154
+10155
+10156
+766
+10157
+10159
+10160
+10161
+10162
+10163
+10164
+10167
+10168
+10169
+10170
+10171
+10173
+10177
+10179
+10180
+10181
+10183
+10184
+10185
+10186
+767
+10189
+10191
+768
+10192
+769
+10193
+10194
+10195
+10196
+10198
+770
+10200
+10203
+10204
+10205
+10207
+10208
+10209
+10210
+10211
+10212
+10216
+10217
+10218
+10219
+10220
+10221
+10222
+771
+10226
+10229
+10230
+772
+10237
+10238
+10239
+10240
+10241
+10242
+10243
+10244
+10248
+10249
+10251
+10254
+10255
+773
+10258
+10259
+10261
+10263
+774
+10265
+10266
+10267
+10268
+10269
+10270
+10271
+10272
+10274
+10275
+775
+10276
+10277
+10278
+10279
+10280
+10281
+10282
+10283
+10285
+10287
+10288
+10289
+10290
+10291
+10293
+776
+10296
+777
+10297
+10298
+778
+10301
+10302
+10303
+10304
+10306
+10307
+10308
+10310
+10311
+10312
+10313
+779
+10314
+780
+10318
+10320
+10323
+10324
+10325
+10326
+781
+10327
+10330
+10334
+782
+10335
+783
+10337
+10338
+784
+10341
+10342
+10348
+10349
+10354
+10355
+10356
+10361
+10362
+10365
+10366
+10367
+10369
+10370
+10371
+785
+10372
+10373
+10375
+10376
+10377
+10378
+10382
+10384
+10388
+10392
+10394
+10398
+10399
+10400
+10401
+10402
+10403
+10404
+10405
+10408
+10409
+10410
+10412
+10413
+10415
+10419
+10420
+10422
+10423
+10424
+10426
+10430
+10431
+10432
+10433
+10434
+10436
+10437
+10438
+786
+10439
+10440
+10441
+10443
+10444
+10446
+10447
+10448
+10449
+10452
+10453
+10455
+10456
+10457
+10458
+10459
+10460
+10461
+10462
+10464
+10465
+10466
+10467
+10470
+10472
+10474
+10475
+10476
+10477
+10478
+10481
+10483
+10484
+10485
+787
+10488
+10490
+10494
+10495
+10497
+10500
+10501
+10502
+10506
+10507
+10508
+10509
+10510
+10511
+10512
+10513
+10514
+788
+10515
+10516
+789
+10517
+10520
+10522
+790
+791
+10525
+10526
+10529
+10530
+10531
+10532
+10533
+10534
+10535
+10536
+10537
+10538
+792
+10539
+10541
+10542
+793
+794
+10543
+10544
+10547
+10548
+10549
+10550
+10553
+10554
+10555
+10556
+10557
+10558
+10559
+10560
+10564
+10566
+10567
+10570
+10571
+10575
+10576
+10577
+10579
+10581
+10582
+10584
+10585
+10587
+10591
+10592
+10593
+10594
+10595
+10598
+10599
+10601
+10602
+10603
+10605
+10606
+10608
+10610
+10613
+10616
+795
+10617
+10619
+10620
+10621
+10622
+10623
+10625
+796
+10626
+10627
+10629
+10631
+10632
+10633
+10634
+10635
+10638
+10640
+10642
+10646
+10649
+10650
+797
+10654
+10656
+10657
+10660
+10661
+10662
+10663
+798
+799
+10667
+10669
+10672
+10675
+10677
+10678
+10680
+10682
+800
+10686
+10687
+10689
+10692
+10694
+10695
+10697
+10698
+10699
+10702
+10703
+10704
+10706
+10707
+10708
+10709
+10710
+10711
+10712
+10713
+10715
+10716
+801
+10717
+10718
+802
+803
+10719
+10720
+10721
+10722
+10723
+10725
+10726
+804
+805
+806
+10728
+10731
+10734
+10736
+10738
+10739
+10740
+10741
+10742
+807
+10743
+10744
+10745
+10746
+10747
+808
+10751
+10753
+10754
+10757
+10760
+809
+10764
+10765
+810
+10772
+10773
+811
+10775
+812
+10776
+10777
+10778
+10780
+10784
+10793
+10796
+10797
+813
+10798
+10800
+10802
+10805
+10806
+10808
+10810
+814
+10811
+10812
+10813
+10815
+10817
+815
+10819
+816
+10821
+10823
+10824
+10825
+10826
+10830
+10831
+10832
+10840
+10841
+10844
+10845
+10846
+10847
+10848
+10849
+10850
+10851
+10853
+10854
+10855
+10856
+10857
+10858
+817
+10859
+10861
+10862
+818
+10866
+10867
+10868
+10871
+10872
+10874
+10875
+10877
+10878
+10879
+10880
+10881
+10882
+10883
+10888
+10889
+10891
+10892
+10893
+10894
+10898
+10899
+10900
+10901
+10903
+10905
+819
+10906
+10907
+10908
+10909
+10910
+10912
+10913
+10914
+10917
+10918
+10921
+10927
+10928
+10929
+10930
+10931
+10933
+10934
+10936
+10938
+10939
+10940
+10942
+10944
+10945
+10946
+10947
+10951
+10952
+10953
+10954
+820
+10955
+10958
+10959
+821
+822
+10960
+10962
+10963
+10967
+10968
+10969
+10972
+10974
+10975
+10976
+10978
+10979
+10982
+823
+10983
+10984
+10985
+10986
+10988
+10989
+10993
+10997
+10999
+11000
+11003
+11005
+11007
+11008
+11010
+824
+825
+11014
+11015
+11016
+11017
+11019
+826
+11021
+11024
+11027
+11028
+827
+11031
+11033
+11035
+11036
+11038
+11041
+828
+11042
+11044
+11045
+11046
+11047
+11049
+11050
+829
+11051
+11052
+830
+11054
+11057
+11058
+11062
+11064
+11065
+11066
+11067
+11070
+11074
+11075
+831
+11076
+11077
+11079
+11080
+832
+11081
+11085
+11086
+833
+11089
+11092
+11093
+11097
+11098
+11100
+834
+11102
+11103
+11104
+11105
+11107
+11108
+11109
+11110
+835
+11111
+836
+837
+11114
+11116
+11117
+838
+11118
+11120
+11122
+11123
+11124
+11128
+11129
+11132
+11133
+11134
+11135
+11140
+11144
+11146
+11147
+11149
+11154
+11157
+11158
+839
+11160
+11161
+840
+11162
+11163
+11167
+11170
+11171
+11174
+11175
+841
+11177
+11179
+842
+11180
+843
+844
+11182
+11183
+11185
+11186
+11187
+11188
+11190
+11193
+11194
+11195
+11198
+845
+11199
+11202
+11204
+11205
+11206
+11207
+846
+11208
+11209
+11211
+11212
+11213
+11214
+11216
+11218
+11219
+11220
+11221
+11223
+11225
+11226
+11229
+11230
+11231
+11233
+11234
+11235
+11236
+11237
+11238
+11240
+11241
+11246
+847
+11247
+11248
+11249
+11250
+11253
+11254
+11255
+11256
+11257
+11258
+11259
+11260
+848
+11261
+11263
+11264
+11265
+11269
+11270
+11271
+11273
+11276
+11278
+11279
+11280
+11283
+11284
+11285
+849
+11287
+11288
+11289
+11290
+11292
+11293
+11294
+11295
+11296
+11298
+11300
+11301
+11302
+11303
+11304
+11305
+11307
+11308
+11309
+11310
+11311
+11312
+11313
+11314
+851
+11317
+11318
+11319
+11320
+11321
+11322
+11325
+11327
+11328
+11329
+11330
+11331
+11333
+852
+11334
+11335
+11337
+11345
+11348
+11350
+11353
+11355
+11356
+11357
+11358
+11359
+11361
+11363
+11365
+11366
+11367
+853
+11368
+854
+11370
+11371
+11372
+11380
+11381
+11383
+11384
+855
+11387
+11388
+11391
+11392
+11396
+856
+11400
+857
+11402
+11404
+11405
+11408
+11411
+11412
+11415
+11416
+11417
+11418
+11419
+858
+11423
+11424
+11425
+11433
+11434
+11435
+11437
+11439
+11440
+11442
+11445
+11446
+859
+11447
+11449
+11450
+860
+11452
+11455
+11457
+11458
+11459
+11462
+11464
+11465
+11466
+11468
+11469
+861
+11470
+11472
+11473
+11477
+11478
+11479
+11481
+11482
+11483
+11485
+11487
+11488
+11489
+11490
+11492
+11493
+11494
+11495
+11499
+11501
+11503
+862
+11507
+11509
+11511
+11512
+863
+11514
+11515
+11518
+11519
+11520
+11521
+11522
+11523
+11524
+864
+11525
+11526
+865
+11528
+11530
+11531
+11532
+11534
+866
+11535
+11536
+11537
+11538
+867
+11541
+11542
+11544
+11546
+11548
+11550
+11553
+11556
+11559
+11560
+11561
+11563
+11565
+11568
+868
+11570
+11571
+11572
+11573
+11574
+11578
+869
+11584
+11585
+11586
+11590
+11594
+11595
+870
+11597
+871
+11598
+11600
+872
+11601
+11604
+873
+11605
+11608
+874
+875
+11609
+11611
+11612
+11613
+11614
+11615
+11616
+11617
+11618
+11619
+11621
+11622
+11623
+11625
+11627
+11628
+876
+11631
+11637
+11638
+11639
+11640
+11641
+11643
+11644
+11645
+11647
+11650
+11652
+11655
+877
+11659
+11660
+11661
+11662
+11663
+11664
+11665
+11666
+11671
+11673
+11676
+11678
+11679
+878
+11681
+11683
+11684
+879
+11690
+11691
+11692
+11693
+11694
+880
+11696
+11697
+11698
+11699
+11701
+881
+11706
+11707
+11708
+11709
+11710
+11711
+882
+11713
+11714
+11715
+11716
+11717
+11721
+11722
+11723
+11726
+883
+884
+11728
+11729
+11730
+11733
+885
+11734
+886
+11735
+11736
+11737
+11740
+11741
+11742
+11743
+11744
+11745
+11746
+11747
+11749
+11750
+11751
+887
+11753
+888
+11755
+11757
+11758
+11759
+11760
+11761
+11762
+11763
+11764
+11765
+11766
+11767
+11768
+11769
+11770
+11771
+11773
+889
+11778
+11780
+11781
+11783
+890
+11784
+11788
+11791
+11792
+11796
+11797
+891
+11798
+11800
+11801
+11803
+11804
+11805
+11806
+11808
+11809
+11812
+11813
+11816
+892
+893
+11817
+11818
+11819
+11821
+894
+11823
+895
+11827
+11829
+896
+11830
+11831
+897
+11832
+11834
+11835
+11836
+11837
+11838
+11839
+11840
+11842
+898
+11845
+11848
+11851
+11852
+11854
+11855
+11857
+11858
+899
+11861
+11863
+11864
+11865
+11869
+11870
+900
+11872
+11873
+11876
+11877
+11879
+11880
+11881
+11882
+11886
+11887
+11889
+11890
+11892
+11894
+11897
+11898
+11899
+11900
+11901
+11903
+11908
+11909
+11910
+11913
+11914
+11918
+11919
+11920
+11921
+11922
+11926
+11928
+11934
+11935
+901
+11936
+902
+11937
+11938
+11939
+11940
+11942
+11943
+11944
+11945
+11946
+11948
+11949
+903
+11953
+11954
+11958
+11959
+11960
+11961
+11962
+11963
+11964
+11965
+11966
+11967
+11968
+11969
+11971
+904
+11972
+905
+11973
+11974
+11975
+11976
+11977
+906
+11980
+907
+11982
+11983
+11984
+11986
+908
+11988
+11989
+11990
+11991
+11993
+11994
+11995
+11996
+11998
+12000
+12001
+12005
+909
+12008
+12010
+12011
+12012
+910
+12014
+12016
+12017
+12018
+911
+12019
+12021
+12025
+12027
+12028
+12029
+12030
+912
+12034
+12035
+12037
+12038
+913
+12039
+12040
+12041
+12044
+12046
+12047
+12048
+12050
+12051
+12052
+12054
+12056
+12057
+12058
+12061
+12062
+12065
+914
+12067
+915
+12069
+12071
+12074
+12075
+12078
+12079
+12080
+12084
+12086
+12093
+12094
+12095
+12096
+12097
+12098
+12099
+12100
+12102
+12103
+12104
+12105
+12106
+12107
+12108
+12109
+12110
+12111
+12112
+12113
+12115
+12116
+12117
+12118
+12119
+12120
+12121
+12122
+12123
+12124
+12125
+12126
+12128
+12129
+12131
+12132
+12133
+12134
+12135
+12136
+12138
+12139
+12140
+12142
+12145
+12147
+12148
+12149
+12151
+12153
+12155
+12158
+12159
+12165
+12168
+12169
+12172
+12174
+12175
+12176
+12177
+12178
+12179
+12180
+12181
+12183
+12189
+12191
+12193
+12194
+12196
+12205
+12207
+12209
+12215
+12229
+12231
+12232
+12238
+12239
+12241
+12243
+12247
+12254
+12258
+12261
+12262
+12263
+12264
+12265
+12266
+12267
+12268
+12269
+12270
+12271
+12274
+12275
+12276
+12278
+12282
+12284
+12285
+12286
+12287
+12288
+12291
+12292
+12293
+12294
+12295
+916
+12298
+12300
+12301
+12305
+12308
+12310
+917
+12312
+12313
+12314
+918
+12321
+919
+920
+12322
+12323
+12324
+12325
+921
+12326
+12327
+12328
+12329
+12331
+12333
+12334
+12335
+12337
+12338
+12339
+12340
+12341
+12342
+12346
+12350
+12354
+12359
+12360
+922
+12361
+12362
+12368
+12374
+12375
+12379
+12381
+12383
+12386
+12390
+12392
+12394
+12396
+12399
+12400
+12401
+12402
+12403
+12404
+12405
+12406
+12408
+12409
+12410
+12411
+12412
+12413
+12415
+12417
+12418
+12419
+12423
+12424
+12425
+923
+12426
+12427
+12428
+12429
+12430
+12431
+12432
+12433
+12435
+12436
+12438
+12439
+12441
+12443
+924
+925
+12449
+12450
+12451
+12455
+12456
+12458
+12460
+12461
+12463
+12465
+12467
+12468
+12469
+12470
+12471
+12473
+12474
+12475
+12476
+12478
+12479
+12480
+12481
+12482
+12483
+12485
+12486
+12487
+12488
+12494
+12495
+926
+12496
+12499
+12503
+12504
+12506
+12507
+12509
+12510
+12511
+12512
+12514
+12516
+12517
+12520
+12526
+12528
+12530
+12536
+12537
+12538
+12540
+12541
+12544
+12547
+12554
+12555
+12556
+12557
+12560
+12564
+12566
+12567
+12568
+12570
+12571
+12574
+12575
+12576
+12578
+12579
+12584
+12585
+12586
+12589
+12592
+12595
+12596
+12598
+12599
+12603
+12606
+12608
+12610
+12612
+12615
+12618
+12619
+12620
+12621
+12623
+12624
+12625
+12627
+12629
+12630
+12632
+927
+12634
+12636
+928
+12638
+12639
+12641
+12642
+12643
+12644
+12645
+929
+12647
+12650
+12651
+12652
+12653
+12655
+12660
+12661
+12663
+12664
+12665
+12667
+12671
+12672
+12674
+12681
+12684
+12685
+12686
+12687
+12689
+12690
+12692
+12693
+12695
+12696
+12697
+12698
+12699
+12700
+12702
+12703
+12704
+12705
+12706
+12710
+12711
+12713
+12714
+12716
+12717
+12718
+12719
+12721
+12723
+12724
+12727
+12729
+12731
+12733
+12735
+12737
+12738
+12741
+12742
+12744
+12745
+12746
+12747
+12748
+12749
+12750
+12751
+12754
+12755
+12756
+12757
+930
+12758
+12759
+12761
+12762
+12763
+12764
+12766
+12768
+12769
+12770
+12771
+12772
+12773
+12777
+12778
+12779
+12780
+12781
+12782
+12783
+12784
+12786
+12789
+12791
+12792
+12798
+12799
+12800
+12801
+12802
+12803
+12804
+12805
+12806
+12807
+12808
+12809
+12810
+12811
+12812
+12813
+12818
+12820
+12821
+12823
+931
+12825
+12827
+12828
+12829
+12830
+12835
+932
+12836
+12837
+12838
+12839
+12840
+12841
+12842
+12843
+12844
+933
+934
+12846
+12847
+12848
+12849
+12850
+12851
+12852
+12853
+12855
+12856
+12858
+12859
+12860
+12861
+12863
+12865
+12866
+12867
+12869
+12871
+12872
+12873
+12874
+12875
+12876
+935
+12880
+12881
+12882
+12883
+12884
+12885
+12886
+12887
+12888
+12889
+12890
+12891
+12892
+12893
+12894
+12895
+936
+12896
+12897
+937
+938
+12898
+12899
+12900
+12901
+12902
+12903
+939
+12904
+940
+12907
+941
+942
+943
+944
+12916
+12919
+12921
+12925
+12926
+12927
+945
+12928
+12930
+12931
+12932
+12933
+12935
+12936
+12937
+12939
+12941
+12942
+12943
+12944
+12945
+12946
+12948
+12951
+12952
+12953
+12955
+12957
+12958
+12959
+12961
+12962
+12964
+12967
+12968
+12969
+12970
+12974
+12975
+12977
+12978
+12979
+12981
+12982
+12983
+12988
+12989
+12990
+12991
+946
+12992
+12993
+12994
+12996
+12997
+12998
+13000
+13002
+13003
+13004
+13005
+13009
+13010
+13011
+13015
+13016
+13017
+13019
+13020
+13021
+13022
+13023
+947
+13024
+13028
+13029
+13030
+13031
+13033
+13034
+13035
+13037
+13038
+13042
+13046
+13047
+13048
+13050
+13052
+13053
+13054
+13055
+13058
+13059
+13062
+13067
+948
+13072
+13073
+13075
+13077
+13078
+13079
+13080
+13082
+13083
+13084
+13087
+949
+13090
+13091
+13092
+13095
+950
+13097
+13098
+13099
+13100
+13101
+13102
+13103
+13105
+13106
+13107
+951
+13108
+13109
+13110
+13111
+13113
+13115
+13116
+13117
+13118
+13119
+13120
+13122
+13124
+13126
+13127
+13129
+13132
+952
+953
+954
+13134
+13135
+13138
+955
+13139
+13140
+13142
+13144
+13145
+13147
+13149
+13151
+13152
+13153
+13154
+13158
+13163
+13165
+13170
+13172
+956
+13178
+13179
+13180
+13183
+13184
+13187
+13188
+13189
+13192
+13193
+13194
+13195
+13196
+13198
+13199
+13200
+13201
+13202
+13206
+13207
+13208
+13212
+13213
+13214
+13215
+13216
+13217
+13218
+13219
+13221
+13223
+957
+13225
+13229
+13230
+13232
+13236
+13239
+13242
+13245
+13246
+13248
+13249
+13254
+13255
+13256
+13257
+13258
+13264
+13266
+13267
+13268
+13270
+13271
+958
+13274
+13276
+13277
+13278
+13282
+13287
+13288
+13289
+13290
+13291
+13296
+13297
+13298
+13300
+13301
+13302
+13303
+13305
+13306
+13307
+13308
+13309
+13310
+13311
+13312
+13313
+13318
+13321
+13322
+13325
+13327
+13328
+13339
+13340
+13341
+13342
+13343
+13347
+13348
+13349
+13351
+13352
+13353
+13354
+13355
+13357
+13358
+13359
+13360
+13364
+13366
+13367
+13369
+13370
+13371
+13372
+13373
+13375
+13377
+13378
+13380
+13381
+13382
+13383
+13385
+13387
+13389
+13390
+13391
+13393
+13394
+13395
+13397
+13398
+13399
+13401
+13403
+13405
+13406
+13410
+13413
+13417
+13419
+13420
+13422
+13423
+13426
+13427
+13428
+13429
+13431
+13432
+13437
+13439
+13440
+13441
+13443
+959
+13447
+13455
+13458
+13464
+13467
+13468
+13470
+13473
+13474
+13478
+960
+13484
+13487
+13491
+13492
+13493
+13494
+13495
+13506
+13511
+13513
+13515
+13516
+13517
+13518
+13519
+13520
+13521
+13522
+13523
+13524
+13525
+13526
+13528
+13531
+13532
+13533
+13534
+13535
+13537
+13538
+13544
+13546
+13548
+13557
+13558
+13561
+13562
+13563
+13564
+13565
+13570
+13572
+13573
+13574
+13575
+13577
+13579
+13580
+13581
+13582
+13583
+13585
+13586
+13587
+13591
+13593
+13594
+13599
+13605
+13612
+13617
+13621
+13629
+13632
+13634
+13640
+13642
+13643
+13644
+13646
+13648
+13649
+13652
+961
+13653
+13656
+13658
+13659
+13660
+13661
+13662
+13663
+13664
+13669
+13670
+13672
+13674
+13679
+13680
+13681
+13682
+13683
+13687
+13688
+13689
+13690
+13692
+13693
+13694
+13695
+13696
+13697
+13698
+13699
+13702
+13703
+13704
+13706
+13707
+13709
+13710
+13711
+13712
+13713
+13715
+13716
+13717
+13721
+13723
+13725
+13727
+962
+13728
+13730
+13732
+13733
+963
+13735
+13736
+13737
+13738
+13739
+13742
+964
+13746
+13747
+13748
+13752
+13756
+13759
+13760
+13761
+13762
+13763
+13767
+13768
+13769
+13770
+13771
+13772
+13773
+13775
+13777
+13778
+13779
+13780
+13781
+13782
+13783
+965
+13785
+13786
+13789
+13790
+13791
+13793
+13795
+13799
+13800
+13801
+13802
+13804
+13805
+13806
+13807
+13808
+13809
+13810
+13811
+13812
+13814
+13816
+13817
+13820
+13821
+13822
+13824
+13825
+13826
+13827
+13829
+13833
+13834
+13835
+13836
+13837
+966
+13838
+13839
+13841
+13842
+13844
+13845
+13846
+13847
+13848
+13849
+13850
+13851
+13852
+13853
+13854
+13855
+13856
+13857
+13858
+13859
+13860
+13861
+13864
+13865
+13866
+13867
+13868
+13870
+13871
+13872
+13873
+13874
+13875
+13876
+13877
+13878
+13879
+13880
+13882
+13883
+13884
+13885
+13886
+13887
+13888
+13889
+13891
+13892
+13893
+13894
+13895
+13896
+13897
+13898
+13899
+13900
+13901
+13902
+13905
+13906
+13907
+13908
+13909
+13910
+13911
+13912
+13913
+13915
+13916
+13917
+13918
+13919
+13920
+13921
+13922
+13923
+13924
+13927
+13928
+13929
+13930
+13931
+13932
+13933
+13934
+13935
+13936
+13937
+13938
+13939
+13940
+13941
+13942
+13943
+13945
+13949
+13953
+13954
+13956
+13957
+13958
+13962
+13963
+13964
+13966
+13969
+13973
+13974
+13975
+13976
+13977
+13978
+13980
+13982
+13983
+13986
+13987
+13989
+13990
+13991
+13992
+13993
+13995
+13996
+13997
+13998
+13999
+14003
+14004
+14005
+14007
+14009
+14010
+14011
+967
+14015
+14016
+14017
+14018
+14019
+14020
+14022
+14024
+14025
+14026
+14028
+14029
+14030
+14032
+14034
+14035
+14036
+14038
+14039
+14041
+14042
+14043
+14044
+14045
+14048
+14049
+14052
+14053
+14054
+14057
+14058
+14060
+14061
+14063
+14064
+14065
+14067
+14068
+14070
+14071
+14072
+14074
+14075
+14076
+14078
+14080
+14081
+14082
+968
+14083
+14086
+14087
+14089
+969
+14094
+14095
+14096
+14099
+14103
+14109
+14112
+14113
+14114
+14115
+14118
+14120
+14121
+14125
+14127
+14128
+14129
+14130
+14131
+14132
+14133
+14134
+14136
+14138
+14139
+14141
+14142
+14145
+14146
+14147
+14152
+14156
+14157
+14159
+14161
+14162
+14165
+14166
+14167
+14170
+14174
+14178
+14180
+14181
+14183
+14184
+14185
+14186
+14189
+14192
+14194
+14195
+14198
+14201
+14202
+14206
+14207
+14208
+14209
+14210
+14213
+14214
+14218
+14221
+14225
+14226
+14230
+14232
+14235
+14243
+14246
+14247
+970
+14249
+14250
+14253
+14254
+14255
+14256
+14258
+14266
+14267
+14268
+14269
+14270
+14272
+14274
+971
+14275
+14276
+14277
+14278
+14280
+14281
+14282
+14283
+972
+14284
+14286
+14287
+14289
+973
+14291
+14292
+14293
+14294
+14296
+14298
+14300
+14302
+14303
+14307
+14308
+14310
+14312
+14313
+14314
+14316
+14317
+14319
+974
+14320
+14323
+14324
+14326
+14328
+14329
+14330
+14331
+14332
+14334
+14335
+14336
+14338
+14339
+14344
+14348
+975
+14350
+14351
+14353
+14357
+14359
+14360
+14367
+14368
+14370
+14372
+14374
+14375
+14376
+14377
+14378
+14379
+14384
+14386
+14387
+14388
+14389
+14390
+976
+14392
+14395
+14396
+14397
+14398
+14400
+14401
+14402
+14403
+14404
+14406
+14407
+14408
+14409
+14411
+977
+978
+14416
+14418
+14421
+14422
+14423
+14424
+14425
+14426
+14427
+14428
+14430
+14431
+14432
+14433
+14434
+14435
+14436
+14437
+14438
+14439
+14440
+14442
+14443
+14444
+14445
+14446
+14449
+14452
+14453
+14457
+979
+14461
+980
+14465
+14466
+14467
+14471
+14474
+14479
+14480
+14482
+14483
+14485
+14493
+14498
+14499
+14500
+14501
+14503
+14504
+14505
+14506
+14507
+14508
+14509
+14512
+14514
+14517
+14520
+14522
+14525
+14526
+14527
+14528
+14530
+14532
+14533
+14535
+14536
+14538
+14541
+14544
+14546
+14550
+14554
+14561
+14562
+14565
+14578
+14586
+14598
+14599
+14600
+14601
+14605
+14609
+14612
+14613
+14615
+14619
+14621
+14622
+14623
+14627
+14630
+14631
+14633
+14635
+14636
+14637
+14640
+14641
+14642
+14643
+14644
+14645
+14646
+14648
+14652
+14653
+14654
+14659
+14660
+14667
+14669
+14671
+14673
+14675
+14676
+14679
+14683
+14684
+14685
+14686
+14688
+14690
+14693
+14696
+14697
+14698
+14699
+14700
+14701
+14702
+14703
+14704
+14706
+14710
+14712
+14716
+14717
+14718
+14719
+14722
+14723
+14725
+14727
+14728
+14729
+14730
+14733
+14734
+14735
+14736
+14737
+14739
+14741
+14742
+14743
+14744
+14745
+14749
+14750
+14754
+14756
+14760
+14763
+14764
+14766
+14768
+14769
+14773
+14779
+14780
+14785
+14786
+14787
+14788
+14789
+14791
+14793
+14794
+14795
+14797
+14799
+14803
+14807
+14810
+14812
+14813
+14815
+14817
+14822
+14824
+14826
+14827
+14829
+14833
+14834
+14838
+14841
+14843
+14854
+14861
+14862
+14871
+14872
+14874
+14875
+14879
+14883
+14884
+14885
+14887
+14888
+14889
+14897
+14900
+14904
+14907
+14912
+14913
+14920
+14921
+14922
+14926
+14927
+14932
+14936
+14939
+14942
+14944
+14947
+14948
+14949
+14950
+14956
+14957
+14958
+14961
+14962
+14963
+14967
+14972
+14973
+14977
+14978
+14982
+14983
+981
+14984
+14985
+14986
+14987
+14992
+14993
+14994
+14996
+14997
+14999
+15000
+15002
+15003
+15005
+15008
+15009
+15011
+15014
+15016
+15017
+15020
+15025
+15027
+15028
+15032
+15033
+15035
+15037
+15040
+15043
+15047
+15048
+15049
+15051
+15052
+15067
+15080
+15081
+15082
+15084
+15086
+15087
+15089
+15090
+15091
+15092
+15096
+15098
+15099
+15104
+15106
+15112
+15115
+15116
+15118
+15120
+15125
+15126
+15127
+15129
+15130
+15131
+15133
+15135
+15138
+15140
+15141
+15145
+15146
+15147
+15148
+15152
+15155
+15157
+15158
+15159
+15162
+15163
+15165
+15168
+15178
+15184
+15185
+15186
+15187
+15188
+15189
+15190
+15192
+15193
+15194
+15198
+15201
+15205
+15206
+15207
+15208
+15210
+15211
+15214
+15216
+15217
+15221
+15222
+15223
+15225
+15226
+15228
+15229
+15230
+15231
+15234
+15237
+15239
+15242
+15249
+15253
+15255
+15256
+15258
+15259
+15260
+15261
+15263
+15268
+15269
+15274
+15276
+15279
+15282
+15291
+15300
+15310
+15318
+15319
+15322
+15323
+15325
+15326
+15328
+15329
+15337
+15339
+15340
+15341
+15357
+15359
+15360
+15361
+15362
+15363
+15364
+15366
+15369
+15372
+15385
+15386
+15389
+15391
+15393
+15396
+15402
+15413
+15415
+15418
+15422
+15424
+15427
+15429
+15435
+15440
+15441
+15442
+15449
+15451
+15453
+15454
+15458
+15459
+15461
+15463
+15465
+15467
+15468
+15471
+15475
+15477
+15478
+15485
+15487
+15495
+15496
+15497
+15499
+15508
+15512
+15525
+15538
+15539
+15540
+15544
+15553
+15554
+15556
+15557
+15559
+15561
+15562
+15563
+15564
+15568
+15569
+15571
+15575
+15576
+15580
+15582
+15583
+15585
+15590
+15591
+15592
+15595
+15596
+15597
+15598
+15600
+15601
+15607
+15608
+15616
+15618
+15619
+15620
+15621
+15627
+15631
+15636
+15642
+15643
+15656
+15663
+15667
+15671
+15672
+15677
+15678
+15685
+15686
+15691
+15695
+15698
+15701
+15702
+15704
+15707
+15708
+15713
+15719
+15722
+15723
+15724
+15726
+15728
+15730
+15733
+15734
+15735
+15736
+15737
+15738
+15739
+15740
+15741
+15742
+15743
+15745
+15746
+15748
+982
+15753
+15755
+15760
+15763
+15765
+15766
+15773
+15777
+15780
+15782
+15784
+15791
+15792
+15793
+15796
+15799
+15803
+15804
+15815
+15818
+15820
+15821
+15825
+15830
+15839
+15842
+15845
+15846
+15847
+15849
+15854
+15855
+15858
+15859
+15863
+15866
+15868
+15873
+15877
+15881
+15883
+15885
+15888
+15890
+15896
+15897
+15899
+15900
+15901
+15905
+15909
+15910
+15916
+15917
+15928
+15930
+15935
+15938
+15939
+15940
+15947
+15952
+15954
+15955
+15957
+15958
+15961
+15962
+15963
+15965
+15975
+15976
+15977
+15978
+15980
+15993
+15994
+15999
+16000
+16007
+16010
+16011
+16012
+16014
+16018
+16019
+16020
+16021
+16023
+16024
+16027
+16030
+16031
+16032
+16035
+16036
+16044
+16045
+16055
+16057
+16060
+16062
+16067
+16072
+16076
+16077
+16078
+16087
+16088
+16090
+16095
+16098
+16101
+16108
+16109
+16110
+16112
+16113
+16116
+16117
+16119
+16123
+16124
+16125
+16132
+16133
+16135
+16137
+16145
+16149
+16156
+16157
+16159
+16160
+16162
+16163
+16165
+16166
+16168
+16171
+16172
+16174
+16175
+16179
+16181
+16185
+16188
+16190
+16193
+16194
+16195
+16203
+16208
+16209
+16214
+16215
+16216
+16217
+16230
+16231
+16233
+16235
+16241
+16243
+16252
+16257
+16259
+16260
+16267
+16272
+16274
+16275
+16278
+16280
+16287
+16290
+16296
+16297
+16300
+16304
+16305
+16306
+16307
+16308
+16312
+16318
+16323
+16328
+16329
+16330
+16331
+16333
+16334
+16335
+16338
+16344
+16350
+16351
+16357
+16358
+16359
+16363
+16364
+16365
+16373
+16376
+16379
+16380
+16389
+16391
+16392
+16395
+16396
+16400
+16404
+16405
+16406
+16407
+16408
+16409
+16413
+16416
+16421
+16430
+16432
+16434
+16437
+16439
+16440
+16441
+16442
+16448
+16451
+16452
+16453
+16460
+16463
+16471
+16472
+16475
+16476
+16479
+16490
+16492
+16493
+16494
+16497
+16510
+16514
+16519
+16520
+16524
+16525
+16528
+16529
+16533
+16538
+16542
+16545
+16546
+16556
+16558
+16561
+16563
+16567
+16568
+16571
+16576
+16584
+16592
+16600
+16601
+16603
+16604
+16607
+16608
+16609
+16615
+16619
+16621
+16626
+16632
+16634
+16635
+16638
+16642
+16646
+16651
+16664
+16665
+16667
+16669
+16670
+16671
+16675
+16676
+16681
+16684
+16685
+16686
+16688
+16696
+16705
+16709
+16710
+16711
+16720
+16721
+16724
+16729
+16742
+16743
+16745
+16746
+16751
+16752
+16755
+16756
+983
+16760
+16765
+16767
+16770
+16774
+16775
+16778
+16779
+16780
+16789
+16792
+16794
+16798
+16802
+16804
+16805
+16806
+16807
+16815
+16816
+16818
+16820
+16827
+16828
+16832
+16833
+16840
+16844
+16848
+16849
+16851
+16853
+16856
+16859
+16860
+16863
+16864
+16865
+16866
+16870
+16880
+16888
+16889
+16893
+16894
+16895
+16896
+16897
+16900
+16902
+16905
+16907
+16909
+16913
+16915
+16917
+16920
+16922
+16923
+16926
+16931
+16932
+16935
+16943
+16946
+16955
+16963
+16972
+16977
+16978
+16980
+16982
+16985
+16987
+16988
+16990
+16992
+16996
+16997
+17003
+17004
+17008
+17009
+17013
+17018
+17019
+17022
+17023
+17025
+17028
+17032
+17036
+17037
+17041
+17044
+17047
+17052
+17053
+17054
+17055
+17067
+17068
+17072
+17078
+17096
+17102
+17109
+17122
+17125
+17126
+17129
+17133
+17136
+17141
+17143
+17148
+17150
+17156
+17159
+17161
+17170
+17171
+17173
+17174
+17180
+17182
+17184
+17186
+17193
+17195
+17198
+17201
+17203
+17207
+17208
+17218
+17223
+17225
+17226
+17232
+17243
+17246
+17263
+17264
+17268
+17269
+17270
+17279
+17283
+17284
+17287
+17289
+17290
+17295
+17301
+17305
+17312
+17313
+17314
+17316
+17320
+17321
+17324
+17325
+17327
+17328
+17329
+17331
+17332
+17334
+17341
+17344
+17345
+17353
+17354
+17355
+17356
+17357
+17360
+17361
+17363
+17365
+17366
+17368
+17369
+17370
+17371
+17374
+17375
+17376
+17377
+17378
+17379
+17381
+17382
+17384
+17385
+17388
+17389
+17390
+17391
+17392
+17394
+17395
+17397
+17399
+17400
+17402
+17403
+17404
+17407
+17408
+17409
+17410
+17411
+17415
+17416
+17417
+17418
+17419
+17420
+17421
+17422
+17423
+17424
+17425
+17426
+17427
+17428
+17429
+17430
+17431
+17432
+17434
+17435
+17437
+17438
+17439
+17440
+17441
+17442
+17444
+17445
+17446
+17447
+17450
+17455
+17457
+17459
+17462
+17463
+17464
+17465
+17466
+17467
+17470
+17471
+17472
+17473
+17474
+17475
+17478
+17479
+17480
+17481
+17483
+17485
+17486
+17497
+17501
+17507
+17508
+17513
+17514
+17518
+17519
+17523
+17524
+17525
+17527
+17531
+17532
+17533
+17535
+17536
+17537
+17538
+17541
+17544
+17549
+17554
+17555
+17566
+17575
+17580
+17581
+17582
+17583
+17584
+17585
+17586
+17589
+17593
+17594
+17599
+17601
+17603
+17606
+17609
+17610
+17611
+17613
+17614
+17616
+17618
+17620
+17621
+17625
+17626
+17627
+17628
+17630
+17633
+17634
+17636
+17640
+17641
+17642
+17645
+17648
+17649
+17650
+17651
+17652
+17656
+17658
+17659
+17661
+17663
+17665
+17666
+17667
+17669
+17670
+17672
+17674
+17675
+17676
+17677
+17678
+17679
+17681
+17687
+17691
+17693
+17694
+17695
+17696
+17699
+17703
+17704
+17707
+17726
+17736
+17737
+17738
+17740
+17741
+17742
+17744
+17745
+17748
+17749
+17750
+17751
+17752
+17753
+17754
+17755
+17757
+17758
+17759
+17760
+17763
+17777
+17778
+17779
+17780
+17785
+17786
+17789
+17790
+17795
+17797
+17798
+17799
+17801
+17802
+17804
+17807
+17808
+17809
+17811
+17813
+17814
+17818
+17819
+17821
+17826
+17827
+17828
+17829
+17830
+17832
+17833
+17835
+17836
+17841
+17850
+17854
+17856
+17857
+17860
+17861
+17862
+17865
+17867
+17868
+17870
+17871
+17872
+17873
+17874
+17875
+17876
+17877
+17878
+17879
+17881
+17883
+17884
+17885
+17886
+17887
+17888
+17889
+17891
+17892
+17893
+17894
+17895
+17896
+17897
+17900
+17901
+17903
+17904
+17905
+17906
+17910
+17912
+17915
+17917
+17920
+17929
+17933
+17934
+17940
+17944
+17949
+17951
+17953
+17954
+17955
+17961
+17962
+17963
+17964
+17965
+17968
+17969
+17970
+17973
+17974
+17975
+17976
+17978
+17979
+17980
+17981
+17985
+17986
+17987
+17988
+17990
+17991
+17994
+17995
+17998
+17999
+18000
+18002
+18005
+18006
+18007
+18014
+18015
+18020
+18022
+18023
+18027
+18032
+18035
+18036
+18037
+18038
+18039
+18040
+18041
+18042
+18043
+18045
+18047
+18050
+18051
+984
+18052
+18053
+18055
+18059
+18064
+18065
+18071
+18073
+18075
+18077
+18078
+18080
+18081
+18082
+18084
+18085
+18086
+18087
+18091
+18092
+18095
+18099
+18100
+18102
+18103
+18104
+18105
+18106
+18107
+18108
+18110
+18111
+18113
+18114
+18117
+18118
+18120
+18121
+18122
+18124
+18125
+18127
+18128
+18129
+18130
+18131
+18134
+18135
+18137
+18139
+18140
+18144
+18150
+18151
+18152
+18154
+18155
+18156
+18158
+18159
+18160
+18162
+18164
+18165
+18166
+18174
+18175
+18181
+18182
+18187
+18188
+18191
+18192
+18218
+985
+18219
+18220
+18222
+18226
+18229
+18230
+18231
+18232
+18234
+18235
+18236
+18237
+18240
+18241
+18243
+18244
+18246
+18248
+18249
+18250
+18252
+18253
+18254
+18256
+18259
+18260
+18262
+18263
+18264
+18265
+18267
+18270
+18272
+18273
+18274
+18277
+18278
+18282
+18283
+18284
+18286
+18287
+18288
+18289
+18290
+18293
+18296
+18297
+18299
+18300
+18302
+18303
+18309
+18310
+18311
+18312
+18316
+18317
+18318
+18319
+18320
+18321
+18322
+18324
+18335
+18338
+18339
+18340
+18341
+18344
+18345
+18346
+18347
+18348
+18349
+18351
+18356
+18357
+18362
+18364
+18368
+18370
+18371
+18372
+18373
+18374
+18377
+18381
+18386
+18394
+18399
+18401
+18404
+18405
+18407
+18409
+18411
+18412
+18413
+18414
+18416
+18417
+18418
+18420
+18425
+18426
+18432
+18435
+18436
+18437
+18439
+18454
+18455
+18456
+18457
+18458
+18459
+18460
+18461
+18464
+18465
+18466
+18468
+18469
+18472
+18473
+18474
+18475
+18476
+18479
+18482
+18483
+18486
+18491
+18492
+18493
+18495
+18499
+18500
+18501
+18502
+18504
+18505
+18507
+18508
+18509
+18510
+18511
+18512
+18514
+18519
+18520
+18521
+18522
+18523
+18524
+18525
+18527
+18528
+18529
+18530
+18531
+18535
+18536
+18537
+18538
+18542
+18544
+18545
+18546
+986
+18548
+18549
+18551
+18552
+18553
+18554
+18555
+18558
+18559
+18561
+18562
+18563
+18565
+18566
+18567
+18568
+18570
+18571
+18572
+18574
+18577
+18582
+18585
+18586
+18587
+18588
+18589
+18590
+18593
+18595
+18597
+18598
+18599
+18600
+18601
+18602
+18603
+18604
+18605
+18606
+18607
+18609
+18610
+18613
+18615
+18616
+18618
+18619
+18622
+18623
+18624
+18625
+18627
+18628
+18629
+18630
+18631
+18632
+18633
+18634
+18635
+18636
+18643
+18644
+18645
+18646
+18648
+18649
+18650
+18653
+18654
+18658
+18659
+18663
+18669
+18671
+18672
+18674
+18676
+18677
+18681
+18682
+18683
+18684
+18692
+18693
+18696
+18697
+18699
+18703
+18706
+18708
+18709
+18710
+18715
+18717
+18727
+18735
+18737
+18740
+18742
+18743
+18747
+18750
+18752
+18753
+18756
+18765
+18766
+18767
+18771
+18775
+18778
+18779
+18787
+18792
+18793
+18794
+18796
+18803
+987
+18806
+18807
+18809
+18812
+18813
+18816
+18819
+18820
+18827
+18828
+18833
+18836
+18837
+18839
+18840
+18845
+18846
+18847
+18848
+18852
+18853
+18854
+18858
+18859
+18860
+18861
+18863
+18864
+18865
+18866
+18868
+18869
+18870
+18871
+18874
+18875
+18876
+18877
+18878
+18879
+18880
+18881
+18882
+18883
+18884
+18885
+18896
+18897
+18899
+18901
+18911
+18913
+18917
+18919
+18922
+18924
+18925
+18926
+18932
+18935
+18938
+18939
+18940
+18944
+18948
+18950
+18953
+18954
+18956
+18957
+18959
+18960
+18961
+18964
+18965
+18966
+18968
+18973
+18990
+18991
+18992
+18995
+18997
+18999
+19000
+19007
+19023
+19024
+19027
+19032
+19038
+19040
+19042
+19044
+19045
+19046
+19050
+19063
+19067
+19080
+19081
+19084
+19086
+19088
+19089
+19090
+19091
+19093
+19094
+19097
+19098
+19099
+19103
+19104
+19107
+19111
+988
+19114
+19115
+19116
+19118
+19121
+19122
+19126
+19127
+19130
+19131
+19132
+19134
+19135
+19137
+19139
+19140
+19143
+19144
+19145
+19147
+19148
+19149
+19150
+19152
+19153
+19154
+19155
+19156
+19157
+19160
+19161
+19162
+19164
+19165
+19166
+19167
+19168
+19169
+19170
+19171
+19173
+19175
+19176
+19179
+19182
+19185
+19186
+19189
+19190
+19191
+19193
+19195
+19197
+19200
+19203
+19204
+19205
+19207
+19208
+19209
+19211
+19212
+19214
+19223
+19224
+19225
+19228
+19229
+19230
+19231
+19232
+19233
+19236
+19237
+19238
+19239
+19240
+19242
+19243
+19244
+19246
+19248
+19249
+19250
+19254
+19262
+19264
+19267
+19268
+19269
+19270
+19271
+19272
+19274
+19275
+19276
+19277
+19280
+19281
+19285
+19286
+19287
+19294
+19299
+19300
+19302
+19303
+19305
+19306
+19307
+19310
+19312
+19314
+19315
+19316
+19317
+19320
+19321
+19326
+19327
+19328
+19330
+19331
+19334
+19335
+19340
+19341
+19342
+19343
+19346
+19347
+19349
+19352
+19353
+19354
+19355
+19357
+19358
+19359
+19360
+19361
+19362
+19364
+19366
+19370
+19373
+19374
+19375
+19376
+19377
+19379
+19381
+19383
+19384
+19387
+19389
+19391
+19392
+19395
+19396
+19398
+19412
+19413
+19414
+19415
+19417
+19424
+19427
+19429
+19431
+19433
+19444
+19445
+19446
+19447
+19450
+19451
+19452
+19456
+19457
+19458
+19460
+19461
+19462
+19463
+19466
+19467
+19469
+19471
+19481
+19482
+19483
+19487
+19488
+19491
+19493
+19494
+19495
+19496
+19500
+19502
+19504
+19505
+19506
+19507
+19508
+19511
+19512
+19513
+19516
+19518
+19519
+19521
+19523
+19524
+19526
+19527
+19528
+19529
+19530
+19531
+19532
+19534
+19535
+19536
+19537
+19538
+19540
+19542
+19548
+19549
+19551
+19552
+19553
+19556
+19557
+19558
+19559
+19560
+19561
+19563
+19565
+19566
+19567
+19573
+19576
+19577
+19578
+19585
+19587
+19588
+19592
+19593
+19594
+19597
+19598
+19600
+19602
+19607
+19616
+19617
+19618
+19621
+19623
+19624
+19625
+19626
+19628
+19632
+19634
+19637
+19638
+19639
+19640
+19642
+19643
+19644
+19645
+19648
+19650
+19651
+19652
+19653
+19654
+19658
+19659
+19665
+19666
+19673
+19677
+19678
+19679
+19680
+19682
+19683
+19685
+19686
+19687
+19688
+19689
+19691
+19692
+19693
+19694
+19697
+19698
+19699
+19700
+19702
+19703
+19704
+19706
+19707
+19708
+19709
+19715
+19717
+19719
+19720
+19724
+19727
+19728
+19730
+19731
+19732
+19734
+19738
+19742
+19743
+19744
+19747
+19748
+19751
+19755
+19756
+19766
+19767
+19768
+19769
+19773
+19774
+19777
+19779
+19780
+19783
+19784
+19787
+19792
+19802
+19805
+19807
+19808
+19811
+19812
+19815
+19823
+19827
+19829
+19841
+19843
+19845
+19847
+19848
+19849
+19850
+19851
+19855
+19862
+19868
+19871
+19872
+19873
+19874
+19875
+19876
+19877
+19881
+19882
+19883
+19884
+19889
+19892
+19897
+19899
+19904
+19905
+19906
+19907
+19912
+19915
+19917
+19918
+19919
+19920
+19924
+19926
+19927
+19928
+19932
+19934
+19936
+19937
+19938
+19939
+19940
+19943
+19945
+19948
+19953
+19955
+19956
+19957
+19962
+19963
+19966
+19967
+19974
+19977
+19978
+19979
+19980
+19981
+19982
+19983
+19984
+19985
+19986
+19988
+19995
+19998
+20000
+20002
+20007
+20008
+20009
+20011
+20018
+20020
+20028
+989
+20029
+20030
+20033
+20034
+20035
+20038
+20039
+20041
+20046
+20051
+20052
+20053
+20054
+20056
+20058
+20059
+20062
+20063
+20064
+20065
+20066
+20067
+20070
+20071
+20072
+20073
+20075
+20077
+20079
+20080
+20083
+20090
+20091
+20093
+20095
+20096
+20101
+20102
+20106
+20107
+20109
+20111
+20112
+20113
+20117
+20119
+20120
+20124
+20125
+20126
+20127
+20131
+20132
+20135
+20136
+20137
+20138
+20149
+20150
+20152
+20154
+20156
+20157
+20158
+20162
+20163
+20164
+20171
+20172
+20174
+20180
+20181
+20183
+20187
+20194
+20196
+20201
+20202
+20204
+20207
+20208
+20216
+20218
+20220
+20223
+20224
+20225
+20227
+20228
+20229
+20230
+20231
+20232
+20233
+20234
+20235
+20237
+20239
+20240
+20241
+20242
+20245
+20248
+20249
+20257
+20259
+20260
+20266
+20271
+20274
+20275
+20276
+20278
+20280
+20287
+20289
+20290
+20291
+20292
+20293
+20295
+20296
+20297
+20298
+20299
+20300
+20304
+20305
+20306
+20309
+20312
+20314
+20320
+20321
+20326
+20327
+20328
+20334
+20335
+20336
+20337
+20339
+20342
+20344
+20346
+20356
+20357
+20358
+20364
+20365
+20366
+20367
+20369
+20371
+20372
+20373
+20374
+20375
+20376
+20377
+20382
+20383
+20385
+20388
+20390
+20394
+20395
+20399
+20401
+20403
+20406
+20407
+20408
+20409
+20414
+20415
+20416
+20417
+20418
+20419
+20422
+20423
+20424
+20425
+20426
+20427
+20429
+20431
+20433
+20434
+20436
+20446
+20450
+20453
+20455
+20458
+20461
+20465
+20466
+20469
+990
+20479
+20480
+20481
+20483
+20484
+20486
+20488
+20489
+20493
+20497
+20500
+20501
+20502
+20503
+20506
+20507
+20508
+20512
+20513
+20514
+20519
+20520
+20523
+20524
+20525
+20526
+20527
+20528
+20531
+20532
+20534
+20536
+20537
+20538
+20542
+20546
+20550
+20551
+20554
+20557
+20558
+20560
+20561
+20562
+20563
+20565
+20566
+20570
+20571
+20574
+20576
+20577
+20580
+20583
+20585
+20586
+20589
+20591
+20594
+20597
+20598
+20599
+20600
+20602
+20603
+20604
+20605
+20606
+20609
+20611
+20612
+20614
+20615
+20617
+20621
+20622
+20625
+20626
+20627
+20629
+20630
+20632
+20634
+20636
+20637
+20638
+20639
+20643
+20647
+20649
+20650
+20651
+20652
+20659
+20660
+20662
+20664
+20668
+20669
+20670
+20671
+20672
+20673
+20674
+20675
+20676
+20677
+20678
+20680
+20687
+20688
+20690
+20692
+20695
+20696
+20697
+20698
+20700
+20701
+20702
+20703
+20704
+20709
+20710
+20712
+20713
+20714
+20715
+20718
+20719
+20720
+20721
+20722
+20723
+20724
+20725
+20727
+20728
+20732
+20733
+20735
+20736
+20740
+20741
+20742
+20746
+20750
+20757
+20762
+20763
+20764
+20765
+20771
+20772
+20775
+20776
+20785
+20791
+20794
+20795
+20796
+20797
+20798
+20799
+20800
+20801
+20802
+20805
+20806
+20808
+20814
+20816
+20817
+20820
+20822
+20827
+20831
+20832
+20833
+20838
+20839
+20841
+20844
+20845
+20847
+20848
+20851
+20855
+20856
+20858
+20859
+20860
+20861
+20862
+20863
+20867
+20868
+20869
+20871
+20874
+20878
+20881
+20884
+20885
+20888
+20889
+20890
+20892
+20894
+20898
+20903
+20905
+20906
+20908
+20910
+20911
+20912
+20914
+20916
+20919
+20921
+20925
+20927
+20928
+20929
+20934
+20935
+20944
+20945
+20946
+20948
+20949
+20950
+20951
+20954
+20955
+20957
+20958
+20963
+20964
+20967
+20971
+20976
+20987
+20988
+20989
+20990
+20993
+20996
+20997
+21006
+21009
+21010
+21015
+21017
+21020
+21022
+21025
+21032
+21033
+991
+21034
+21035
+21038
+21042
+21044
+21045
+21046
+21047
+21049
+21050
+21051
+992
+21052
+21053
+21054
+21055
+21056
+21057
+21059
+21060
+21061
+21062
+21063
+21064
+21065
+21069
+21070
+21071
+21072
+21073
+21074
+21075
+21078
+21082
+21084
+21089
+21090
+21092
+21093
+21094
+21098
+21100
+21106
+21107
+21118
+21119
+21121
+21125
+21127
+21128
+21130
+21131
+21134
+21139
+21142
+21144
+21151
+21152
+21153
+21154
+21155
+21157
+21159
+21162
+21164
+21165
+993
+21171
+21174
+21175
+994
+21176
+21178
+21183
+21184
+995
+21189
+21192
+21193
+996
+21199
+21200
+21201
+997
+21202
+21203
+21205
+21220
+21222
+21225
+21230
+21233
+21239
+21253
+21258
+21269
+21270
+21272
+21280
+21282
+21283
+21285
+21287
+21288
+21298
+21304
+21306
+21308
+21312
+21313
+21314
+21316
+21317
+21318
+21319
+21320
+21322
+21328
+21337
+21338
+21340
+21344
+21346
+21350
+21353
+21357
+21358
+21359
+21362
+21364
+998
+21370
+21374
+21376
+21377
+21378
+21382
+21386
+21388
+21389
+21397
+21398
+21402
+21407
+21408
+21411
+21414
+21415
+21419
+21425
+21428
+21429
+21431
+21432
+21433
+21438
+21441
+21451
+21459
+21464
+21467
+21469
+21476
+21479
+21484
+21485
+21486
+21489
+21494
+21495
+21497
+21501
+21502
+21507
+21511
+21515
+21516
+21517
+21519
+21522
+21524
+21528
+21529
+21532
+21533
+21534
+21537
+21541
+21545
+21547
+21548
+21549
+21550
+21554
+21560
+21563
+21569
+21573
+21576
+21578
+21579
+21580
+21581
+21585
+21589
+21590
+21591
+21598
+21601
+21604
+21606
+21611
+21615
+21618
+21620
+21623
+21625
+21627
+21635
+21637
+21638
+21641
+21644
+21645
+21648
+21649
+21650
+21659
+21661
+21662
+21663
+21665
+21666
+21668
+21669
+21672
+21673
+21675
+21678
+21679
+21680
+21686
+21688
+21689
+21690
+21692
+21702
+21711
+21712
+21713
+21716
+21717
+21721
+21722
+21723
+21724
+21727
+21728
+21729
+21734
+21739
+21740
+21741
+21743
+21744
+21747
+21748
+21749
+21754
+21757
+21758
+21760
+21761
+21762
+21763
+21765
+21772
+21773
+21774
+21777
+21778
+21781
+21782
+21784
+21786
+21791
+21792
+21795
+21796
+21800
+21801
+21803
+21804
+21806
+21811
+21815
+21816
+999
+21817
+21818
+21822
+21825
+21826
+21827
+21828
+21829
+21830
+21831
+21833
+21835
+21837
+21838
+21840
+21841

pytorch-image-models/timm/data/_info/imagenet_a_synsets.txt

@@ -0,0 +1,200 @@
+n01498041
+n01531178
+n01534433
+n01558993
+n01580077
+n01614925
+n01616318
+n01631663
+n01641577
+n01669191
+n01677366
+n01687978
+n01694178
+n01698640
+n01735189
+n01770081
+n01770393
+n01774750
+n01784675
+n01819313
+n01820546
+n01833805
+n01843383
+n01847000
+n01855672
+n01882714
+n01910747
+n01914609
+n01924916
+n01944390
+n01985128
+n01986214
+n02007558
+n02009912
+n02037110
+n02051845
+n02077923
+n02085620
+n02099601
+n02106550
+n02106662
+n02110958
+n02119022
+n02123394
+n02127052
+n02129165
+n02133161
+n02137549
+n02165456
+n02174001
+n02177972
+n02190166
+n02206856
+n02219486
+n02226429
+n02231487
+n02233338
+n02236044
+n02259212
+n02268443
+n02279972
+n02280649
+n02281787
+n02317335
+n02325366
+n02346627
+n02356798
+n02361337
+n02410509
+n02445715
+n02454379
+n02486410
+n02492035
+n02504458
+n02655020
+n02669723
+n02672831
+n02676566
+n02690373
+n02701002
+n02730930
+n02777292
+n02782093
+n02787622
+n02793495
+n02797295
+n02802426
+n02814860
+n02815834
+n02837789
+n02879718
+n02883205
+n02895154
+n02906734
+n02948072
+n02951358
+n02980441
+n02992211
+n02999410
+n03014705
+n03026506
+n03124043
+n03125729
+n03187595
+n03196217
+n03223299
+n03250847
+n03255030
+n03291819
+n03325584
+n03355925
+n03384352
+n03388043
+n03417042
+n03443371
+n03444034
+n03445924
+n03452741
+n03483316
+n03584829
+n03590841
+n03594945
+n03617480
+n03666591
+n03670208
+n03717622
+n03720891
+n03721384
+n03724870
+n03775071
+n03788195
+n03804744
+n03837869
+n03840681
+n03854065
+n03888257
+n03891332
+n03935335
+n03982430
+n04019541
+n04033901
+n04039381
+n04067472
+n04086273
+n04099969
+n04118538
+n04131690
+n04133789
+n04141076
+n04146614
+n04147183
+n04179913
+n04208210
+n04235860
+n04252077
+n04252225
+n04254120
+n04270147
+n04275548
+n04310018
+n04317175
+n04344873
+n04347754
+n04355338
+n04366367
+n04376876
+n04389033
+n04399382
+n04442312
+n04456115
+n04482393
+n04507155
+n04509417
+n04532670
+n04540053
+n04554684
+n04562935
+n04591713
+n04606251
+n07583066
+n07695742
+n07697313
+n07697537
+n07714990
+n07718472
+n07720875
+n07734744
+n07749582
+n07753592
+n07760859
+n07768694
+n07831146
+n09229709
+n09246464
+n09472597
+n09835506
+n11879895
+n12057211
+n12144580
+n12267677

pytorch-image-models/timm/data/_info/imagenet_r_indices.txt

@@ -0,0 +1,200 @@
+1
+2
+4
+6
+8
+9
+11
+13
+22
+23
+26
+29
+31
+39
+47
+63
+71
+76
+79
+84
+90
+94
+96
+97
+99
+100
+105
+107
+113
+122
+125
+130
+132
+144
+145
+147
+148
+150
+151
+155
+160
+161
+162
+163
+171
+172
+178
+187
+195
+199
+203
+207
+208
+219
+231
+232
+234
+235
+242
+245
+247
+250
+251
+254
+259
+260
+263
+265
+267
+269
+276
+277
+281
+288
+289
+291
+292
+293
+296
+299
+301
+308
+309
+310
+311
+314
+315
+319
+323
+327
+330
+334
+335
+337
+338
+340
+341
+344
+347
+353
+355
+361
+362
+365
+366
+367
+368
+372
+388
+390
+393
+397
+401
+407
+413
+414
+425
+428
+430
+435
+437
+441
+447
+448
+457
+462
+463
+469
+470
+471
+472
+476
+483
+487
+515
+546
+555
+558
+570
+579
+583
+587
+593
+594
+596
+609
+613
+617
+621
+629
+637
+657
+658
+701
+717
+724
+763
+768
+774
+776
+779
+780
+787
+805
+812
+815
+820
+824
+833
+847
+852
+866
+875
+883
+889
+895
+907
+928
+931
+932
+933
+934
+936
+937
+943
+945
+947
+948
+949
+951
+953
+954
+957
+963
+965
+967
+980
+981
+983
+988

pytorch-image-models/timm/data/_info/imagenet_r_synsets.txt

@@ -0,0 +1,200 @@
+n01443537
+n01484850
+n01494475
+n01498041
+n01514859
+n01518878
+n01531178
+n01534433
+n01614925
+n01616318
+n01630670
+n01632777
+n01644373
+n01677366
+n01694178
+n01748264
+n01770393
+n01774750
+n01784675
+n01806143
+n01820546
+n01833805
+n01843383
+n01847000
+n01855672
+n01860187
+n01882714
+n01910747
+n01944390
+n01983481
+n01986214
+n02007558
+n02009912
+n02051845
+n02056570
+n02066245
+n02071294
+n02077923
+n02085620
+n02086240
+n02088094
+n02088238
+n02088364
+n02088466
+n02091032
+n02091134
+n02092339
+n02094433
+n02096585
+n02097298
+n02098286
+n02099601
+n02099712
+n02102318
+n02106030
+n02106166
+n02106550
+n02106662
+n02108089
+n02108915
+n02109525
+n02110185
+n02110341
+n02110958
+n02112018
+n02112137
+n02113023
+n02113624
+n02113799
+n02114367
+n02117135
+n02119022
+n02123045
+n02128385
+n02128757
+n02129165
+n02129604
+n02130308
+n02134084
+n02138441
+n02165456
+n02190166
+n02206856
+n02219486
+n02226429
+n02233338
+n02236044
+n02268443
+n02279972
+n02317335
+n02325366
+n02346627
+n02356798
+n02363005
+n02364673
+n02391049
+n02395406
+n02398521
+n02410509
+n02423022
+n02437616
+n02445715
+n02447366
+n02480495
+n02480855
+n02481823
+n02483362
+n02486410
+n02510455
+n02526121
+n02607072
+n02655020
+n02672831
+n02701002
+n02749479
+n02769748
+n02793495
+n02797295
+n02802426
+n02808440
+n02814860
+n02823750
+n02841315
+n02843684
+n02883205
+n02906734
+n02909870
+n02939185
+n02948072
+n02950826
+n02951358
+n02966193
+n02980441
+n02992529
+n03124170
+n03272010
+n03345487
+n03372029
+n03424325
+n03452741
+n03467068
+n03481172
+n03494278
+n03495258
+n03498962
+n03594945
+n03602883
+n03630383
+n03649909
+n03676483
+n03710193
+n03773504
+n03775071
+n03888257
+n03930630
+n03947888
+n04086273
+n04118538
+n04133789
+n04141076
+n04146614
+n04147183
+n04192698
+n04254680
+n04266014
+n04275548
+n04310018
+n04325704
+n04347754
+n04389033
+n04409515
+n04465501
+n04487394
+n04522168
+n04536866
+n04552348
+n04591713
+n07614500
+n07693725
+n07695742
+n07697313
+n07697537
+n07714571
+n07714990
+n07718472
+n07720875
+n07734744
+n07742313
+n07745940
+n07749582
+n07753275
+n07753592
+n07768694
+n07873807
+n07880968
+n07920052
+n09472597
+n09835506
+n10565667
+n12267677

pytorch-image-models/timm/data/_info/imagenet_synsets.txt

@@ -0,0 +1,1000 @@
+n01440764
+n01443537
+n01484850
+n01491361
+n01494475
+n01496331
+n01498041
+n01514668
+n01514859
+n01518878
+n01530575
+n01531178
+n01532829
+n01534433
+n01537544
+n01558993
+n01560419
+n01580077
+n01582220
+n01592084
+n01601694
+n01608432
+n01614925
+n01616318
+n01622779
+n01629819
+n01630670
+n01631663
+n01632458
+n01632777
+n01641577
+n01644373
+n01644900
+n01664065
+n01665541
+n01667114
+n01667778
+n01669191
+n01675722
+n01677366
+n01682714
+n01685808
+n01687978
+n01688243
+n01689811
+n01692333
+n01693334
+n01694178
+n01695060
+n01697457
+n01698640
+n01704323
+n01728572
+n01728920
+n01729322
+n01729977
+n01734418
+n01735189
+n01737021
+n01739381
+n01740131
+n01742172
+n01744401
+n01748264
+n01749939
+n01751748
+n01753488
+n01755581
+n01756291
+n01768244
+n01770081
+n01770393
+n01773157
+n01773549
+n01773797
+n01774384
+n01774750
+n01775062
+n01776313
+n01784675
+n01795545
+n01796340
+n01797886
+n01798484
+n01806143
+n01806567
+n01807496
+n01817953
+n01818515
+n01819313
+n01820546
+n01824575
+n01828970
+n01829413
+n01833805
+n01843065
+n01843383
+n01847000
+n01855032
+n01855672
+n01860187
+n01871265
+n01872401
+n01873310
+n01877812
+n01882714
+n01883070
+n01910747
+n01914609
+n01917289
+n01924916
+n01930112
+n01943899
+n01944390
+n01945685
+n01950731
+n01955084
+n01968897
+n01978287
+n01978455
+n01980166
+n01981276
+n01983481
+n01984695
+n01985128
+n01986214
+n01990800
+n02002556
+n02002724
+n02006656
+n02007558
+n02009229
+n02009912
+n02011460
+n02012849
+n02013706
+n02017213
+n02018207
+n02018795
+n02025239
+n02027492
+n02028035
+n02033041
+n02037110
+n02051845
+n02056570
+n02058221
+n02066245
+n02071294
+n02074367
+n02077923
+n02085620
+n02085782
+n02085936
+n02086079
+n02086240
+n02086646
+n02086910
+n02087046
+n02087394
+n02088094
+n02088238
+n02088364
+n02088466
+n02088632
+n02089078
+n02089867
+n02089973
+n02090379
+n02090622
+n02090721
+n02091032
+n02091134
+n02091244
+n02091467
+n02091635
+n02091831
+n02092002
+n02092339
+n02093256
+n02093428
+n02093647
+n02093754
+n02093859
+n02093991
+n02094114
+n02094258
+n02094433
+n02095314
+n02095570
+n02095889
+n02096051
+n02096177
+n02096294
+n02096437
+n02096585
+n02097047
+n02097130
+n02097209
+n02097298
+n02097474
+n02097658
+n02098105
+n02098286
+n02098413
+n02099267
+n02099429
+n02099601
+n02099712
+n02099849
+n02100236
+n02100583
+n02100735
+n02100877
+n02101006
+n02101388
+n02101556
+n02102040
+n02102177
+n02102318
+n02102480
+n02102973
+n02104029
+n02104365
+n02105056
+n02105162
+n02105251
+n02105412
+n02105505
+n02105641
+n02105855
+n02106030
+n02106166
+n02106382
+n02106550
+n02106662
+n02107142
+n02107312
+n02107574
+n02107683
+n02107908
+n02108000
+n02108089
+n02108422
+n02108551
+n02108915
+n02109047
+n02109525
+n02109961
+n02110063
+n02110185
+n02110341
+n02110627
+n02110806
+n02110958
+n02111129
+n02111277
+n02111500
+n02111889
+n02112018
+n02112137
+n02112350
+n02112706
+n02113023
+n02113186
+n02113624
+n02113712
+n02113799
+n02113978
+n02114367
+n02114548
+n02114712
+n02114855
+n02115641
+n02115913
+n02116738
+n02117135
+n02119022
+n02119789
+n02120079
+n02120505
+n02123045
+n02123159
+n02123394
+n02123597
+n02124075
+n02125311
+n02127052
+n02128385
+n02128757
+n02128925
+n02129165
+n02129604
+n02130308
+n02132136
+n02133161
+n02134084
+n02134418
+n02137549
+n02138441
+n02165105
+n02165456
+n02167151
+n02168699
+n02169497
+n02172182
+n02174001
+n02177972
+n02190166
+n02206856
+n02219486
+n02226429
+n02229544
+n02231487
+n02233338
+n02236044
+n02256656
+n02259212
+n02264363
+n02268443
+n02268853
+n02276258
+n02277742
+n02279972
+n02280649
+n02281406
+n02281787
+n02317335
+n02319095
+n02321529
+n02325366
+n02326432
+n02328150
+n02342885
+n02346627
+n02356798
+n02361337
+n02363005
+n02364673
+n02389026
+n02391049
+n02395406
+n02396427
+n02397096
+n02398521
+n02403003
+n02408429
+n02410509
+n02412080
+n02415577
+n02417914
+n02422106
+n02422699
+n02423022
+n02437312
+n02437616
+n02441942
+n02442845
+n02443114
+n02443484
+n02444819
+n02445715
+n02447366
+n02454379
+n02457408
+n02480495
+n02480855
+n02481823
+n02483362
+n02483708
+n02484975
+n02486261
+n02486410
+n02487347
+n02488291
+n02488702
+n02489166
+n02490219
+n02492035
+n02492660
+n02493509
+n02493793
+n02494079
+n02497673
+n02500267
+n02504013
+n02504458
+n02509815
+n02510455
+n02514041
+n02526121
+n02536864
+n02606052
+n02607072
+n02640242
+n02641379
+n02643566
+n02655020
+n02666196
+n02667093
+n02669723
+n02672831
+n02676566
+n02687172
+n02690373
+n02692877
+n02699494
+n02701002
+n02704792
+n02708093
+n02727426
+n02730930
+n02747177
+n02749479
+n02769748
+n02776631
+n02777292
+n02782093
+n02783161
+n02786058
+n02787622
+n02788148
+n02790996
+n02791124
+n02791270
+n02793495
+n02794156
+n02795169
+n02797295
+n02799071
+n02802426
+n02804414
+n02804610
+n02807133
+n02808304
+n02808440
+n02814533
+n02814860
+n02815834
+n02817516
+n02823428
+n02823750
+n02825657
+n02834397
+n02835271
+n02837789
+n02840245
+n02841315
+n02843684
+n02859443
+n02860847
+n02865351
+n02869837
+n02870880
+n02871525
+n02877765
+n02879718
+n02883205
+n02892201
+n02892767
+n02894605
+n02895154
+n02906734
+n02909870
+n02910353
+n02916936
+n02917067
+n02927161
+n02930766
+n02939185
+n02948072
+n02950826
+n02951358
+n02951585
+n02963159
+n02965783
+n02966193
+n02966687
+n02971356
+n02974003
+n02977058
+n02978881
+n02979186
+n02980441
+n02981792
+n02988304
+n02992211
+n02992529
+n02999410
+n03000134
+n03000247
+n03000684
+n03014705
+n03016953
+n03017168
+n03018349
+n03026506
+n03028079
+n03032252
+n03041632
+n03042490
+n03045698
+n03047690
+n03062245
+n03063599
+n03063689
+n03065424
+n03075370
+n03085013
+n03089624
+n03095699
+n03100240
+n03109150
+n03110669
+n03124043
+n03124170
+n03125729
+n03126707
+n03127747
+n03127925
+n03131574
+n03133878
+n03134739
+n03141823
+n03146219
+n03160309
+n03179701
+n03180011
+n03187595
+n03188531
+n03196217
+n03197337
+n03201208
+n03207743
+n03207941
+n03208938
+n03216828
+n03218198
+n03220513
+n03223299
+n03240683
+n03249569
+n03250847
+n03255030
+n03259280
+n03271574
+n03272010
+n03272562
+n03290653
+n03291819
+n03297495
+n03314780
+n03325584
+n03337140
+n03344393
+n03345487
+n03347037
+n03355925
+n03372029
+n03376595
+n03379051
+n03384352
+n03388043
+n03388183
+n03388549
+n03393912
+n03394916
+n03400231
+n03404251
+n03417042
+n03424325
+n03425413
+n03443371
+n03444034
+n03445777
+n03445924
+n03447447
+n03447721
+n03450230
+n03452741
+n03457902
+n03459775
+n03461385
+n03467068
+n03476684
+n03476991
+n03478589
+n03481172
+n03482405
+n03483316
+n03485407
+n03485794
+n03492542
+n03494278
+n03495258
+n03496892
+n03498962
+n03527444
+n03529860
+n03530642
+n03532672
+n03534580
+n03535780
+n03538406
+n03544143
+n03584254
+n03584829
+n03590841
+n03594734
+n03594945
+n03595614
+n03598930
+n03599486
+n03602883
+n03617480
+n03623198
+n03627232
+n03630383
+n03633091
+n03637318
+n03642806
+n03649909
+n03657121
+n03658185
+n03661043
+n03662601
+n03666591
+n03670208
+n03673027
+n03676483
+n03680355
+n03690938
+n03691459
+n03692522
+n03697007
+n03706229
+n03709823
+n03710193
+n03710637
+n03710721
+n03717622
+n03720891
+n03721384
+n03724870
+n03729826
+n03733131
+n03733281
+n03733805
+n03742115
+n03743016
+n03759954
+n03761084
+n03763968
+n03764736
+n03769881
+n03770439
+n03770679
+n03773504
+n03775071
+n03775546
+n03776460
+n03777568
+n03777754
+n03781244
+n03782006
+n03785016
+n03786901
+n03787032
+n03788195
+n03788365
+n03791053
+n03792782
+n03792972
+n03793489
+n03794056
+n03796401
+n03803284
+n03804744
+n03814639
+n03814906
+n03825788
+n03832673
+n03837869
+n03838899
+n03840681
+n03841143
+n03843555
+n03854065
+n03857828
+n03866082
+n03868242
+n03868863
+n03871628
+n03873416
+n03874293
+n03874599
+n03876231
+n03877472
+n03877845
+n03884397
+n03887697
+n03888257
+n03888605
+n03891251
+n03891332
+n03895866
+n03899768
+n03902125
+n03903868
+n03908618
+n03908714
+n03916031
+n03920288
+n03924679
+n03929660
+n03929855
+n03930313
+n03930630
+n03933933
+n03935335
+n03937543
+n03938244
+n03942813
+n03944341
+n03947888
+n03950228
+n03954731
+n03956157
+n03958227
+n03961711
+n03967562
+n03970156
+n03976467
+n03976657
+n03977966
+n03980874
+n03982430
+n03983396
+n03991062
+n03992509
+n03995372
+n03998194
+n04004767
+n04005630
+n04008634
+n04009552
+n04019541
+n04023962
+n04026417
+n04033901
+n04033995
+n04037443
+n04039381
+n04040759
+n04041544
+n04044716
+n04049303
+n04065272
+n04067472
+n04069434
+n04070727
+n04074963
+n04081281
+n04086273
+n04090263
+n04099969
+n04111531
+n04116512
+n04118538
+n04118776
+n04120489
+n04125021
+n04127249
+n04131690
+n04133789
+n04136333
+n04141076
+n04141327
+n04141975
+n04146614
+n04147183
+n04149813
+n04152593
+n04153751
+n04154565
+n04162706
+n04179913
+n04192698
+n04200800
+n04201297
+n04204238
+n04204347
+n04208210
+n04209133
+n04209239
+n04228054
+n04229816
+n04235860
+n04238763
+n04239074
+n04243546
+n04251144
+n04252077
+n04252225
+n04254120
+n04254680
+n04254777
+n04258138
+n04259630
+n04263257
+n04264628
+n04265275
+n04266014
+n04270147
+n04273569
+n04275548
+n04277352
+n04285008
+n04286575
+n04296562
+n04310018
+n04311004
+n04311174
+n04317175
+n04325704
+n04326547
+n04328186
+n04330267
+n04332243
+n04335435
+n04336792
+n04344873
+n04346328
+n04347754
+n04350905
+n04355338
+n04355933
+n04356056
+n04357314
+n04366367
+n04367480
+n04370456
+n04371430
+n04371774
+n04372370
+n04376876
+n04380533
+n04389033
+n04392985
+n04398044
+n04399382
+n04404412
+n04409515
+n04417672
+n04418357
+n04423845
+n04428191
+n04429376
+n04435653
+n04442312
+n04443257
+n04447861
+n04456115
+n04458633
+n04461696
+n04462240
+n04465501
+n04467665
+n04476259
+n04479046
+n04482393
+n04483307
+n04485082
+n04486054
+n04487081
+n04487394
+n04493381
+n04501370
+n04505470
+n04507155
+n04509417
+n04515003
+n04517823
+n04522168
+n04523525
+n04525038
+n04525305
+n04532106
+n04532670
+n04536866
+n04540053
+n04542943
+n04548280
+n04548362
+n04550184
+n04552348
+n04553703
+n04554684
+n04557648
+n04560804
+n04562935
+n04579145
+n04579432
+n04584207
+n04589890
+n04590129
+n04591157
+n04591713
+n04592741
+n04596742
+n04597913
+n04599235
+n04604644
+n04606251
+n04612504
+n04613696
+n06359193
+n06596364
+n06785654
+n06794110
+n06874185
+n07248320
+n07565083
+n07579787
+n07583066
+n07584110
+n07590611
+n07613480
+n07614500
+n07615774
+n07684084
+n07693725
+n07695742
+n07697313
+n07697537
+n07711569
+n07714571
+n07714990
+n07715103
+n07716358
+n07716906
+n07717410
+n07717556
+n07718472
+n07718747
+n07720875
+n07730033
+n07734744
+n07742313
+n07745940
+n07747607
+n07749582
+n07753113
+n07753275
+n07753592
+n07754684
+n07760859
+n07768694
+n07802026
+n07831146
+n07836838
+n07860988
+n07871810
+n07873807
+n07875152
+n07880968
+n07892512
+n07920052
+n07930864
+n07932039
+n09193705
+n09229709
+n09246464
+n09256479
+n09288635
+n09332890
+n09399592
+n09421951
+n09428293
+n09468604
+n09472597
+n09835506
+n10148035
+n10565667
+n11879895
+n11939491
+n12057211
+n12144580
+n12267677
+n12620546
+n12768682
+n12985857
+n12998815
+n13037406
+n13040303
+n13044778
+n13052670
+n13054560
+n13133613
+n15075141

pytorch-image-models/timm/data/_info/mini_imagenet_indices.txt

@@ -0,0 +1,100 @@
+12
+15
+51
+64
+70
+96
+99
+107
+111
+121
+149
+166
+173
+176
+207
+214
+228
+242
+244
+245
+249
+251
+256
+266
+270
+275
+279
+291
+299
+301
+306
+310
+359
+364
+392
+403
+412
+427
+440
+454
+471
+476
+478
+484
+494
+502
+503
+507
+519
+524
+533
+538
+546
+553
+556
+567
+569
+584
+597
+602
+604
+605
+629
+655
+657
+659
+683
+687
+702
+709
+713
+735
+741
+758
+779
+781
+800
+801
+807
+815
+819
+847
+854
+858
+860
+880
+881
+883
+909
+912
+914
+919
+925
+927
+934
+950
+972
+973
+997
+998

pytorch-image-models/timm/data/_info/mini_imagenet_synsets.txt

@@ -0,0 +1,100 @@
+n01532829
+n01558993
+n01704323
+n01749939
+n01770081
+n01843383
+n01855672
+n01910747
+n01930112
+n01981276
+n02074367
+n02089867
+n02091244
+n02091831
+n02099601
+n02101006
+n02105505
+n02108089
+n02108551
+n02108915
+n02110063
+n02110341
+n02111277
+n02113712
+n02114548
+n02116738
+n02120079
+n02129165
+n02138441
+n02165456
+n02174001
+n02219486
+n02443484
+n02457408
+n02606052
+n02687172
+n02747177
+n02795169
+n02823428
+n02871525
+n02950826
+n02966193
+n02971356
+n02981792
+n03017168
+n03047690
+n03062245
+n03075370
+n03127925
+n03146219
+n03207743
+n03220513
+n03272010
+n03337140
+n03347037
+n03400231
+n03417042
+n03476684
+n03527444
+n03535780
+n03544143
+n03584254
+n03676483
+n03770439
+n03773504
+n03775546
+n03838899
+n03854065
+n03888605
+n03908618
+n03924679
+n03980874
+n03998194
+n04067472
+n04146614
+n04149813
+n04243546
+n04251144
+n04258138
+n04275548
+n04296562
+n04389033
+n04418357
+n04435653
+n04443257
+n04509417
+n04515003
+n04522168
+n04596742
+n04604644
+n04612504
+n06794110
+n07584110
+n07613480
+n07697537
+n07747607
+n09246464
+n09256479
+n13054560
+n13133613

pytorch-image-models/timm/data/auto_augment.py

@@ -0,0 +1,1000 @@
+""" AutoAugment, RandAugment, AugMix, and 3-Augment for PyTorch
+
+This code implements the searched ImageNet policies with various tweaks and improvements and
+does not include any of the search code.
+
+AA and RA Implementation adapted from:
+    https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/autoaugment.py
+
+AugMix adapted from:
+    https://github.com/google-research/augmix
+
+3-Augment based on: https://github.com/facebookresearch/deit/blob/main/README_revenge.md
+
+Papers:
+    AutoAugment: Learning Augmentation Policies from Data - https://arxiv.org/abs/1805.09501
+    Learning Data Augmentation Strategies for Object Detection - https://arxiv.org/abs/1906.11172
+    RandAugment: Practical automated data augmentation... - https://arxiv.org/abs/1909.13719
+    AugMix: A Simple Data Processing Method to Improve Robustness and Uncertainty - https://arxiv.org/abs/1912.02781
+    3-Augment: DeiT III: Revenge of the ViT - https://arxiv.org/abs/2204.07118
+
+Hacked together by / Copyright 2019, Ross Wightman
+"""
+import random
+import math
+import re
+from functools import partial
+from typing import Dict, List, Optional, Union
+
+from PIL import Image, ImageOps, ImageEnhance, ImageChops, ImageFilter
+import PIL
+import numpy as np
+
+
+_PIL_VER = tuple([int(x) for x in PIL.__version__.split('.')[:2]])
+
+_FILL = (128, 128, 128)
+
+_LEVEL_DENOM = 10.  # denominator for conversion from 'Mx' magnitude scale to fractional aug level for op arguments
+
+_HPARAMS_DEFAULT = dict(
+    translate_const=250,
+    img_mean=_FILL,
+)
+
+if hasattr(Image, "Resampling"):
+    _RANDOM_INTERPOLATION = (Image.Resampling.BILINEAR, Image.Resampling.BICUBIC)
+    _DEFAULT_INTERPOLATION = Image.Resampling.BICUBIC
+else:
+    _RANDOM_INTERPOLATION = (Image.BILINEAR, Image.BICUBIC)
+    _DEFAULT_INTERPOLATION = Image.BICUBIC
+
+
+def _interpolation(kwargs):
+    interpolation = kwargs.pop('resample', _DEFAULT_INTERPOLATION)
+    if isinstance(interpolation, (list, tuple)):
+        return random.choice(interpolation)
+    return interpolation
+
+
+def _check_args_tf(kwargs):
+    if 'fillcolor' in kwargs and _PIL_VER < (5, 0):
+        kwargs.pop('fillcolor')
+    kwargs['resample'] = _interpolation(kwargs)
+
+
+def shear_x(img, factor, **kwargs):
+    _check_args_tf(kwargs)
+    return img.transform(img.size, Image.AFFINE, (1, factor, 0, 0, 1, 0), **kwargs)
+
+
+def shear_y(img, factor, **kwargs):
+    _check_args_tf(kwargs)
+    return img.transform(img.size, Image.AFFINE, (1, 0, 0, factor, 1, 0), **kwargs)
+
+
+def translate_x_rel(img, pct, **kwargs):
+    pixels = pct * img.size[0]
+    _check_args_tf(kwargs)
+    return img.transform(img.size, Image.AFFINE, (1, 0, pixels, 0, 1, 0), **kwargs)
+
+
+def translate_y_rel(img, pct, **kwargs):
+    pixels = pct * img.size[1]
+    _check_args_tf(kwargs)
+    return img.transform(img.size, Image.AFFINE, (1, 0, 0, 0, 1, pixels), **kwargs)
+
+
+def translate_x_abs(img, pixels, **kwargs):
+    _check_args_tf(kwargs)
+    return img.transform(img.size, Image.AFFINE, (1, 0, pixels, 0, 1, 0), **kwargs)
+
+
+def translate_y_abs(img, pixels, **kwargs):
+    _check_args_tf(kwargs)
+    return img.transform(img.size, Image.AFFINE, (1, 0, 0, 0, 1, pixels), **kwargs)
+
+
+def rotate(img, degrees, **kwargs):
+    _check_args_tf(kwargs)
+    if _PIL_VER >= (5, 2):
+        return img.rotate(degrees, **kwargs)
+    if _PIL_VER >= (5, 0):
+        w, h = img.size
+        post_trans = (0, 0)
+        rotn_center = (w / 2.0, h / 2.0)
+        angle = -math.radians(degrees)
+        matrix = [
+            round(math.cos(angle), 15),
+            round(math.sin(angle), 15),
+            0.0,
+            round(-math.sin(angle), 15),
+            round(math.cos(angle), 15),
+            0.0,
+        ]
+
+        def transform(x, y, matrix):
+            (a, b, c, d, e, f) = matrix
+            return a * x + b * y + c, d * x + e * y + f
+
+        matrix[2], matrix[5] = transform(
+            -rotn_center[0] - post_trans[0], -rotn_center[1] - post_trans[1], matrix
+        )
+        matrix[2] += rotn_center[0]
+        matrix[5] += rotn_center[1]
+        return img.transform(img.size, Image.AFFINE, matrix, **kwargs)
+    return img.rotate(degrees, resample=kwargs['resample'])
+
+
+def auto_contrast(img, **__):
+    return ImageOps.autocontrast(img)
+
+
+def invert(img, **__):
+    return ImageOps.invert(img)
+
+
+def equalize(img, **__):
+    return ImageOps.equalize(img)
+
+
+def solarize(img, thresh, **__):
+    return ImageOps.solarize(img, thresh)
+
+
+def solarize_add(img, add, thresh=128, **__):
+    lut = []
+    for i in range(256):
+        if i < thresh:
+            lut.append(min(255, i + add))
+        else:
+            lut.append(i)
+
+    if img.mode in ("L", "RGB"):
+        if img.mode == "RGB" and len(lut) == 256:
+            lut = lut + lut + lut
+        return img.point(lut)
+
+    return img
+
+
+def posterize(img, bits_to_keep, **__):
+    if bits_to_keep >= 8:
+        return img
+    return ImageOps.posterize(img, bits_to_keep)
+
+
+def contrast(img, factor, **__):
+    return ImageEnhance.Contrast(img).enhance(factor)
+
+
+def color(img, factor, **__):
+    return ImageEnhance.Color(img).enhance(factor)
+
+
+def brightness(img, factor, **__):
+    return ImageEnhance.Brightness(img).enhance(factor)
+
+
+def sharpness(img, factor, **__):
+    return ImageEnhance.Sharpness(img).enhance(factor)
+
+
+def gaussian_blur(img, factor, **__):
+    img = img.filter(ImageFilter.GaussianBlur(radius=factor))
+    return img
+
+
+def gaussian_blur_rand(img, factor, **__):
+    radius_min = 0.1
+    radius_max = 2.0
+    img = img.filter(ImageFilter.GaussianBlur(radius=random.uniform(radius_min, radius_max * factor)))
+    return img
+
+
+def desaturate(img, factor, **_):
+    factor = min(1., max(0., 1. - factor))
+    # enhance factor 0 = grayscale, 1.0 = no-change
+    return ImageEnhance.Color(img).enhance(factor)
+
+
+def _randomly_negate(v):
+    """With 50% prob, negate the value"""
+    return -v if random.random() > 0.5 else v
+
+
+def _rotate_level_to_arg(level, _hparams):
+    # range [-30, 30]
+    level = (level / _LEVEL_DENOM) * 30.
+    level = _randomly_negate(level)
+    return level,
+
+
+def _enhance_level_to_arg(level, _hparams):
+    # range [0.1, 1.9]
+    return (level / _LEVEL_DENOM) * 1.8 + 0.1,
+
+
+def _enhance_increasing_level_to_arg(level, _hparams):
+    # the 'no change' level is 1.0, moving away from that towards 0. or 2.0 increases the enhancement blend
+    # range [0.1, 1.9] if level <= _LEVEL_DENOM
+    level = (level / _LEVEL_DENOM) * .9
+    level = max(0.1, 1.0 + _randomly_negate(level))  # keep it >= 0.1
+    return level,
+
+
+def _minmax_level_to_arg(level, _hparams, min_val=0., max_val=1.0, clamp=True):
+    level = (level / _LEVEL_DENOM)
+    level = min_val + (max_val - min_val) * level
+    if clamp:
+        level = max(min_val, min(max_val, level))
+    return level,
+
+
+def _shear_level_to_arg(level, _hparams):
+    # range [-0.3, 0.3]
+    level = (level / _LEVEL_DENOM) * 0.3
+    level = _randomly_negate(level)
+    return level,
+
+
+def _translate_abs_level_to_arg(level, hparams):
+    translate_const = hparams['translate_const']
+    level = (level / _LEVEL_DENOM) * float(translate_const)
+    level = _randomly_negate(level)
+    return level,
+
+
+def _translate_rel_level_to_arg(level, hparams):
+    # default range [-0.45, 0.45]
+    translate_pct = hparams.get('translate_pct', 0.45)
+    level = (level / _LEVEL_DENOM) * translate_pct
+    level = _randomly_negate(level)
+    return level,
+
+
+def _posterize_level_to_arg(level, _hparams):
+    # As per Tensorflow TPU EfficientNet impl
+    # range [0, 4], 'keep 0 up to 4 MSB of original image'
+    # intensity/severity of augmentation decreases with level
+    return int((level / _LEVEL_DENOM) * 4),
+
+
+def _posterize_increasing_level_to_arg(level, hparams):
+    # As per Tensorflow models research and UDA impl
+    # range [4, 0], 'keep 4 down to 0 MSB of original image',
+    # intensity/severity of augmentation increases with level
+    return 4 - _posterize_level_to_arg(level, hparams)[0],
+
+
+def _posterize_original_level_to_arg(level, _hparams):
+    # As per original AutoAugment paper description
+    # range [4, 8], 'keep 4 up to 8 MSB of image'
+    # intensity/severity of augmentation decreases with level
+    return int((level / _LEVEL_DENOM) * 4) + 4,
+
+
+def _solarize_level_to_arg(level, _hparams):
+    # range [0, 256]
+    # intensity/severity of augmentation decreases with level
+    return min(256, int((level / _LEVEL_DENOM) * 256)),
+
+
+def _solarize_increasing_level_to_arg(level, _hparams):
+    # range [0, 256]
+    # intensity/severity of augmentation increases with level
+    return 256 - _solarize_level_to_arg(level, _hparams)[0],
+
+
+def _solarize_add_level_to_arg(level, _hparams):
+    # range [0, 110]
+    return min(128, int((level / _LEVEL_DENOM) * 110)),
+
+
+LEVEL_TO_ARG = {
+    'AutoContrast': None,
+    'Equalize': None,
+    'Invert': None,
+    'Rotate': _rotate_level_to_arg,
+    # There are several variations of the posterize level scaling in various Tensorflow/Google repositories/papers
+    'Posterize': _posterize_level_to_arg,
+    'PosterizeIncreasing': _posterize_increasing_level_to_arg,
+    'PosterizeOriginal': _posterize_original_level_to_arg,
+    'Solarize': _solarize_level_to_arg,
+    'SolarizeIncreasing': _solarize_increasing_level_to_arg,
+    'SolarizeAdd': _solarize_add_level_to_arg,
+    'Color': _enhance_level_to_arg,
+    'ColorIncreasing': _enhance_increasing_level_to_arg,
+    'Contrast': _enhance_level_to_arg,
+    'ContrastIncreasing': _enhance_increasing_level_to_arg,
+    'Brightness': _enhance_level_to_arg,
+    'BrightnessIncreasing': _enhance_increasing_level_to_arg,
+    'Sharpness': _enhance_level_to_arg,
+    'SharpnessIncreasing': _enhance_increasing_level_to_arg,
+    'ShearX': _shear_level_to_arg,
+    'ShearY': _shear_level_to_arg,
+    'TranslateX': _translate_abs_level_to_arg,
+    'TranslateY': _translate_abs_level_to_arg,
+    'TranslateXRel': _translate_rel_level_to_arg,
+    'TranslateYRel': _translate_rel_level_to_arg,
+    'Desaturate': partial(_minmax_level_to_arg, min_val=0.5, max_val=1.0),
+    'GaussianBlur': partial(_minmax_level_to_arg, min_val=0.1, max_val=2.0),
+    'GaussianBlurRand': _minmax_level_to_arg,
+}
+
+
+NAME_TO_OP = {
+    'AutoContrast': auto_contrast,
+    'Equalize': equalize,
+    'Invert': invert,
+    'Rotate': rotate,
+    'Posterize': posterize,
+    'PosterizeIncreasing': posterize,
+    'PosterizeOriginal': posterize,
+    'Solarize': solarize,
+    'SolarizeIncreasing': solarize,
+    'SolarizeAdd': solarize_add,
+    'Color': color,
+    'ColorIncreasing': color,
+    'Contrast': contrast,
+    'ContrastIncreasing': contrast,
+    'Brightness': brightness,
+    'BrightnessIncreasing': brightness,
+    'Sharpness': sharpness,
+    'SharpnessIncreasing': sharpness,
+    'ShearX': shear_x,
+    'ShearY': shear_y,
+    'TranslateX': translate_x_abs,
+    'TranslateY': translate_y_abs,
+    'TranslateXRel': translate_x_rel,
+    'TranslateYRel': translate_y_rel,
+    'Desaturate': desaturate,
+    'GaussianBlur': gaussian_blur,
+    'GaussianBlurRand': gaussian_blur_rand,
+}
+
+
+class AugmentOp:
+
+    def __init__(self, name, prob=0.5, magnitude=10, hparams=None):
+        hparams = hparams or _HPARAMS_DEFAULT
+        self.name = name
+        self.aug_fn = NAME_TO_OP[name]
+        self.level_fn = LEVEL_TO_ARG[name]
+        self.prob = prob
+        self.magnitude = magnitude
+        self.hparams = hparams.copy()
+        self.kwargs = dict(
+            fillcolor=hparams['img_mean'] if 'img_mean' in hparams else _FILL,
+            resample=hparams['interpolation'] if 'interpolation' in hparams else _RANDOM_INTERPOLATION,
+        )
+
+        # If magnitude_std is > 0, we introduce some randomness
+        # in the usually fixed policy and sample magnitude from a normal distribution
+        # with mean `magnitude` and std-dev of `magnitude_std`.
+        # NOTE This is my own hack, being tested, not in papers or reference impls.
+        # If magnitude_std is inf, we sample magnitude from a uniform distribution
+        self.magnitude_std = self.hparams.get('magnitude_std', 0)
+        self.magnitude_max = self.hparams.get('magnitude_max', None)
+
+    def __call__(self, img):
+        if self.prob < 1.0 and random.random() > self.prob:
+            return img
+        magnitude = self.magnitude
+        if self.magnitude_std > 0:
+            # magnitude randomization enabled
+            if self.magnitude_std == float('inf'):
+                # inf == uniform sampling
+                magnitude = random.uniform(0, magnitude)
+            elif self.magnitude_std > 0:
+                magnitude = random.gauss(magnitude, self.magnitude_std)
+        # default upper_bound for the timm RA impl is _LEVEL_DENOM (10)
+        # setting magnitude_max overrides this to allow M > 10 (behaviour closer to Google TF RA impl)
+        upper_bound = self.magnitude_max or _LEVEL_DENOM
+        magnitude = max(0., min(magnitude, upper_bound))
+        level_args = self.level_fn(magnitude, self.hparams) if self.level_fn is not None else tuple()
+        return self.aug_fn(img, *level_args, **self.kwargs)
+
+    def __repr__(self):
+        fs = self.__class__.__name__ + f'(name={self.name}, p={self.prob}'
+        fs += f', m={self.magnitude}, mstd={self.magnitude_std}'
+        if self.magnitude_max is not None:
+            fs += f', mmax={self.magnitude_max}'
+        fs += ')'
+        return fs
+
+
+def auto_augment_policy_v0(hparams):
+    # ImageNet v0 policy from TPU EfficientNet impl, cannot find a paper reference.
+    policy = [
+        [('Equalize', 0.8, 1), ('ShearY', 0.8, 4)],
+        [('Color', 0.4, 9), ('Equalize', 0.6, 3)],
+        [('Color', 0.4, 1), ('Rotate', 0.6, 8)],
+        [('Solarize', 0.8, 3), ('Equalize', 0.4, 7)],
+        [('Solarize', 0.4, 2), ('Solarize', 0.6, 2)],
+        [('Color', 0.2, 0), ('Equalize', 0.8, 8)],
+        [('Equalize', 0.4, 8), ('SolarizeAdd', 0.8, 3)],
+        [('ShearX', 0.2, 9), ('Rotate', 0.6, 8)],
+        [('Color', 0.6, 1), ('Equalize', 1.0, 2)],
+        [('Invert', 0.4, 9), ('Rotate', 0.6, 0)],
+        [('Equalize', 1.0, 9), ('ShearY', 0.6, 3)],
+        [('Color', 0.4, 7), ('Equalize', 0.6, 0)],
+        [('Posterize', 0.4, 6), ('AutoContrast', 0.4, 7)],
+        [('Solarize', 0.6, 8), ('Color', 0.6, 9)],
+        [('Solarize', 0.2, 4), ('Rotate', 0.8, 9)],
+        [('Rotate', 1.0, 7), ('TranslateYRel', 0.8, 9)],
+        [('ShearX', 0.0, 0), ('Solarize', 0.8, 4)],
+        [('ShearY', 0.8, 0), ('Color', 0.6, 4)],
+        [('Color', 1.0, 0), ('Rotate', 0.6, 2)],
+        [('Equalize', 0.8, 4), ('Equalize', 0.0, 8)],
+        [('Equalize', 1.0, 4), ('AutoContrast', 0.6, 2)],
+        [('ShearY', 0.4, 7), ('SolarizeAdd', 0.6, 7)],
+        [('Posterize', 0.8, 2), ('Solarize', 0.6, 10)],  # This results in black image with Tpu posterize
+        [('Solarize', 0.6, 8), ('Equalize', 0.6, 1)],
+        [('Color', 0.8, 6), ('Rotate', 0.4, 5)],
+    ]
+    pc = [[AugmentOp(*a, hparams=hparams) for a in sp] for sp in policy]
+    return pc
+
+
+def auto_augment_policy_v0r(hparams):
+    # ImageNet v0 policy from TPU EfficientNet impl, with variation of Posterize used
+    # in Google research implementation (number of bits discarded increases with magnitude)
+    policy = [
+        [('Equalize', 0.8, 1), ('ShearY', 0.8, 4)],
+        [('Color', 0.4, 9), ('Equalize', 0.6, 3)],
+        [('Color', 0.4, 1), ('Rotate', 0.6, 8)],
+        [('Solarize', 0.8, 3), ('Equalize', 0.4, 7)],
+        [('Solarize', 0.4, 2), ('Solarize', 0.6, 2)],
+        [('Color', 0.2, 0), ('Equalize', 0.8, 8)],
+        [('Equalize', 0.4, 8), ('SolarizeAdd', 0.8, 3)],
+        [('ShearX', 0.2, 9), ('Rotate', 0.6, 8)],
+        [('Color', 0.6, 1), ('Equalize', 1.0, 2)],
+        [('Invert', 0.4, 9), ('Rotate', 0.6, 0)],
+        [('Equalize', 1.0, 9), ('ShearY', 0.6, 3)],
+        [('Color', 0.4, 7), ('Equalize', 0.6, 0)],
+        [('PosterizeIncreasing', 0.4, 6), ('AutoContrast', 0.4, 7)],
+        [('Solarize', 0.6, 8), ('Color', 0.6, 9)],
+        [('Solarize', 0.2, 4), ('Rotate', 0.8, 9)],
+        [('Rotate', 1.0, 7), ('TranslateYRel', 0.8, 9)],
+        [('ShearX', 0.0, 0), ('Solarize', 0.8, 4)],
+        [('ShearY', 0.8, 0), ('Color', 0.6, 4)],
+        [('Color', 1.0, 0), ('Rotate', 0.6, 2)],
+        [('Equalize', 0.8, 4), ('Equalize', 0.0, 8)],
+        [('Equalize', 1.0, 4), ('AutoContrast', 0.6, 2)],
+        [('ShearY', 0.4, 7), ('SolarizeAdd', 0.6, 7)],
+        [('PosterizeIncreasing', 0.8, 2), ('Solarize', 0.6, 10)],
+        [('Solarize', 0.6, 8), ('Equalize', 0.6, 1)],
+        [('Color', 0.8, 6), ('Rotate', 0.4, 5)],
+    ]
+    pc = [[AugmentOp(*a, hparams=hparams) for a in sp] for sp in policy]
+    return pc
+
+
+def auto_augment_policy_original(hparams):
+    # ImageNet policy from https://arxiv.org/abs/1805.09501
+    policy = [
+        [('PosterizeOriginal', 0.4, 8), ('Rotate', 0.6, 9)],
+        [('Solarize', 0.6, 5), ('AutoContrast', 0.6, 5)],
+        [('Equalize', 0.8, 8), ('Equalize', 0.6, 3)],
+        [('PosterizeOriginal', 0.6, 7), ('PosterizeOriginal', 0.6, 6)],
+        [('Equalize', 0.4, 7), ('Solarize', 0.2, 4)],
+        [('Equalize', 0.4, 4), ('Rotate', 0.8, 8)],
+        [('Solarize', 0.6, 3), ('Equalize', 0.6, 7)],
+        [('PosterizeOriginal', 0.8, 5), ('Equalize', 1.0, 2)],
+        [('Rotate', 0.2, 3), ('Solarize', 0.6, 8)],
+        [('Equalize', 0.6, 8), ('PosterizeOriginal', 0.4, 6)],
+        [('Rotate', 0.8, 8), ('Color', 0.4, 0)],
+        [('Rotate', 0.4, 9), ('Equalize', 0.6, 2)],
+        [('Equalize', 0.0, 7), ('Equalize', 0.8, 8)],
+        [('Invert', 0.6, 4), ('Equalize', 1.0, 8)],
+        [('Color', 0.6, 4), ('Contrast', 1.0, 8)],
+        [('Rotate', 0.8, 8), ('Color', 1.0, 2)],
+        [('Color', 0.8, 8), ('Solarize', 0.8, 7)],
+        [('Sharpness', 0.4, 7), ('Invert', 0.6, 8)],
+        [('ShearX', 0.6, 5), ('Equalize', 1.0, 9)],
+        [('Color', 0.4, 0), ('Equalize', 0.6, 3)],
+        [('Equalize', 0.4, 7), ('Solarize', 0.2, 4)],
+        [('Solarize', 0.6, 5), ('AutoContrast', 0.6, 5)],
+        [('Invert', 0.6, 4), ('Equalize', 1.0, 8)],
+        [('Color', 0.6, 4), ('Contrast', 1.0, 8)],
+        [('Equalize', 0.8, 8), ('Equalize', 0.6, 3)],
+    ]
+    pc = [[AugmentOp(*a, hparams=hparams) for a in sp] for sp in policy]
+    return pc
+
+
+def auto_augment_policy_originalr(hparams):
+    # ImageNet policy from https://arxiv.org/abs/1805.09501 with research posterize variation
+    policy = [
+        [('PosterizeIncreasing', 0.4, 8), ('Rotate', 0.6, 9)],
+        [('Solarize', 0.6, 5), ('AutoContrast', 0.6, 5)],
+        [('Equalize', 0.8, 8), ('Equalize', 0.6, 3)],
+        [('PosterizeIncreasing', 0.6, 7), ('PosterizeIncreasing', 0.6, 6)],
+        [('Equalize', 0.4, 7), ('Solarize', 0.2, 4)],
+        [('Equalize', 0.4, 4), ('Rotate', 0.8, 8)],
+        [('Solarize', 0.6, 3), ('Equalize', 0.6, 7)],
+        [('PosterizeIncreasing', 0.8, 5), ('Equalize', 1.0, 2)],
+        [('Rotate', 0.2, 3), ('Solarize', 0.6, 8)],
+        [('Equalize', 0.6, 8), ('PosterizeIncreasing', 0.4, 6)],
+        [('Rotate', 0.8, 8), ('Color', 0.4, 0)],
+        [('Rotate', 0.4, 9), ('Equalize', 0.6, 2)],
+        [('Equalize', 0.0, 7), ('Equalize', 0.8, 8)],
+        [('Invert', 0.6, 4), ('Equalize', 1.0, 8)],
+        [('Color', 0.6, 4), ('Contrast', 1.0, 8)],
+        [('Rotate', 0.8, 8), ('Color', 1.0, 2)],
+        [('Color', 0.8, 8), ('Solarize', 0.8, 7)],
+        [('Sharpness', 0.4, 7), ('Invert', 0.6, 8)],
+        [('ShearX', 0.6, 5), ('Equalize', 1.0, 9)],
+        [('Color', 0.4, 0), ('Equalize', 0.6, 3)],
+        [('Equalize', 0.4, 7), ('Solarize', 0.2, 4)],
+        [('Solarize', 0.6, 5), ('AutoContrast', 0.6, 5)],
+        [('Invert', 0.6, 4), ('Equalize', 1.0, 8)],
+        [('Color', 0.6, 4), ('Contrast', 1.0, 8)],
+        [('Equalize', 0.8, 8), ('Equalize', 0.6, 3)],
+    ]
+    pc = [[AugmentOp(*a, hparams=hparams) for a in sp] for sp in policy]
+    return pc
+
+
+def auto_augment_policy_3a(hparams):
+    policy = [
+        [('Solarize', 1.0, 5)],  # 128 solarize threshold @ 5 magnitude
+        [('Desaturate', 1.0, 10)],  # grayscale at 10 magnitude
+        [('GaussianBlurRand', 1.0, 10)],
+    ]
+    pc = [[AugmentOp(*a, hparams=hparams) for a in sp] for sp in policy]
+    return pc
+
+
+def auto_augment_policy(name='v0', hparams=None):
+    hparams = hparams or _HPARAMS_DEFAULT
+    if name == 'original':
+        return auto_augment_policy_original(hparams)
+    if name == 'originalr':
+        return auto_augment_policy_originalr(hparams)
+    if name == 'v0':
+        return auto_augment_policy_v0(hparams)
+    if name == 'v0r':
+        return auto_augment_policy_v0r(hparams)
+    if name == '3a':
+        return auto_augment_policy_3a(hparams)
+    assert False, f'Unknown AA policy {name}'
+
+
+class AutoAugment:
+
+    def __init__(self, policy):
+        self.policy = policy
+
+    def __call__(self, img):
+        sub_policy = random.choice(self.policy)
+        for op in sub_policy:
+            img = op(img)
+        return img
+
+    def __repr__(self):
+        fs = self.__class__.__name__ + '(policy='
+        for p in self.policy:
+            fs += '\n\t['
+            fs += ', '.join([str(op) for op in p])
+            fs += ']'
+        fs += ')'
+        return fs
+
+
+def auto_augment_transform(config_str: str, hparams: Optional[Dict] = None):
+    """ Create a AutoAugment transform
+
+    Args:
+        config_str: String defining configuration of auto augmentation. Consists of multiple sections separated by
+            dashes ('-').
+            The first section defines the AutoAugment policy (one of 'v0', 'v0r', 'original', 'originalr').
+            While the remaining sections define other arguments
+                * 'mstd' -  float std deviation of magnitude noise applied
+        hparams: Other hparams (kwargs) for the AutoAugmentation scheme
+
+    Returns:
+         A PyTorch compatible Transform
+
+    Examples::
+
+        'original-mstd0.5' results in AutoAugment with original policy, magnitude_std 0.5
+    """
+    config = config_str.split('-')
+    policy_name = config[0]
+    config = config[1:]
+    for c in config:
+        cs = re.split(r'(\d.*)', c)
+        if len(cs) < 2:
+            continue
+        key, val = cs[:2]
+        if key == 'mstd':
+            # noise param injected via hparams for now
+            hparams.setdefault('magnitude_std', float(val))
+        else:
+            assert False, 'Unknown AutoAugment config section'
+    aa_policy = auto_augment_policy(policy_name, hparams=hparams)
+    return AutoAugment(aa_policy)
+
+
+_RAND_TRANSFORMS = [
+    'AutoContrast',
+    'Equalize',
+    'Invert',
+    'Rotate',
+    'Posterize',
+    'Solarize',
+    'SolarizeAdd',
+    'Color',
+    'Contrast',
+    'Brightness',
+    'Sharpness',
+    'ShearX',
+    'ShearY',
+    'TranslateXRel',
+    'TranslateYRel',
+    # 'Cutout'  # NOTE I've implement this as random erasing separately
+]
+
+
+_RAND_INCREASING_TRANSFORMS = [
+    'AutoContrast',
+    'Equalize',
+    'Invert',
+    'Rotate',
+    'PosterizeIncreasing',
+    'SolarizeIncreasing',
+    'SolarizeAdd',
+    'ColorIncreasing',
+    'ContrastIncreasing',
+    'BrightnessIncreasing',
+    'SharpnessIncreasing',
+    'ShearX',
+    'ShearY',
+    'TranslateXRel',
+    'TranslateYRel',
+    # 'Cutout'  # NOTE I've implement this as random erasing separately
+]
+
+
+_RAND_3A = [
+    'SolarizeIncreasing',
+    'Desaturate',
+    'GaussianBlur',
+]
+
+
+_RAND_WEIGHTED_3A = {
+    'SolarizeIncreasing': 6,
+    'Desaturate': 6,
+    'GaussianBlur': 6,
+    'Rotate': 3,
+    'ShearX': 2,
+    'ShearY': 2,
+    'PosterizeIncreasing': 1,
+    'AutoContrast': 1,
+    'ColorIncreasing': 1,
+    'SharpnessIncreasing': 1,
+    'ContrastIncreasing': 1,
+    'BrightnessIncreasing': 1,
+    'Equalize': 1,
+    'Invert': 1,
+}
+
+
+# These experimental weights are based loosely on the relative improvements mentioned in paper.
+# They may not result in increased performance, but could likely be tuned to so.
+_RAND_WEIGHTED_0 = {
+    'Rotate': 3,
+    'ShearX': 2,
+    'ShearY': 2,
+    'TranslateXRel': 1,
+    'TranslateYRel': 1,
+    'ColorIncreasing': .25,
+    'SharpnessIncreasing': 0.25,
+    'AutoContrast': 0.25,
+    'SolarizeIncreasing': .05,
+    'SolarizeAdd': .05,
+    'ContrastIncreasing': .05,
+    'BrightnessIncreasing': .05,
+    'Equalize': .05,
+    'PosterizeIncreasing': 0.05,
+    'Invert': 0.05,
+}
+
+
+def _get_weighted_transforms(transforms: Dict):
+    transforms, probs = list(zip(*transforms.items()))
+    probs = np.array(probs)
+    probs = probs / np.sum(probs)
+    return transforms, probs
+
+
+def rand_augment_choices(name: str, increasing=True):
+    if name == 'weights':
+        return _RAND_WEIGHTED_0
+    if name == '3aw':
+        return _RAND_WEIGHTED_3A
+    if name == '3a':
+        return _RAND_3A
+    return _RAND_INCREASING_TRANSFORMS if increasing else _RAND_TRANSFORMS
+
+
+def rand_augment_ops(
+        magnitude: Union[int, float] = 10,
+        prob: float = 0.5,
+        hparams: Optional[Dict] = None,
+        transforms: Optional[Union[Dict, List]] = None,
+):
+    hparams = hparams or _HPARAMS_DEFAULT
+    transforms = transforms or _RAND_TRANSFORMS
+    return [AugmentOp(
+        name, prob=prob, magnitude=magnitude, hparams=hparams) for name in transforms]
+
+
+class RandAugment:
+    def __init__(self, ops, num_layers=2, choice_weights=None):
+        self.ops = ops
+        self.num_layers = num_layers
+        self.choice_weights = choice_weights
+
+    def __call__(self, img):
+        # no replacement when using weighted choice
+        ops = np.random.choice(
+            self.ops,
+            self.num_layers,
+            replace=self.choice_weights is None,
+            p=self.choice_weights,
+        )
+        for op in ops:
+            img = op(img)
+        return img
+
+    def __repr__(self):
+        fs = self.__class__.__name__ + f'(n={self.num_layers}, ops='
+        for op in self.ops:
+            fs += f'\n\t{op}'
+        fs += ')'
+        return fs
+
+
+def rand_augment_transform(
+        config_str: str,
+        hparams: Optional[Dict] = None,
+        transforms: Optional[Union[str, Dict, List]] = None,
+):
+    """ Create a RandAugment transform
+
+    Args:
+        config_str (str): String defining configuration of random augmentation. Consists of multiple sections separated
+            by dashes ('-'). The first section defines the specific variant of rand augment (currently only 'rand').
+            The remaining sections, not order specific determine
+                * 'm' - integer magnitude of rand augment
+                * 'n' - integer num layers (number of transform ops selected per image)
+                * 'p' - float probability of applying each layer (default 0.5)
+                * 'mstd' -  float std deviation of magnitude noise applied, or uniform sampling if infinity (or > 100)
+                * 'mmax' - set upper bound for magnitude to something other than default of  _LEVEL_DENOM (10)
+                * 'inc' - integer (bool), use augmentations that increase in severity with magnitude (default: 0)
+                * 't' - str name of transform set to use
+        hparams (dict): Other hparams (kwargs) for the RandAugmentation scheme
+
+    Returns:
+         A PyTorch compatible Transform
+
+    Examples::
+
+        'rand-m9-n3-mstd0.5' results in RandAugment with magnitude 9, num_layers 3, magnitude_std 0.5
+
+        'rand-mstd1-tweights' results in mag std 1.0, weighted transforms, default mag of 10 and num_layers 2
+
+    """
+    magnitude = _LEVEL_DENOM  # default to _LEVEL_DENOM for magnitude (currently 10)
+    num_layers = 2  # default to 2 ops per image
+    increasing = False
+    prob = 0.5
+    config = config_str.split('-')
+    assert config[0] == 'rand'
+    config = config[1:]
+    for c in config:
+        if c.startswith('t'):
+            # NOTE old 'w' key was removed, 'w0' is not equivalent to 'tweights'
+            val = str(c[1:])
+            if transforms is None:
+                transforms = val
+        else:
+            # numeric options
+            cs = re.split(r'(\d.*)', c)
+            if len(cs) < 2:
+                continue
+            key, val = cs[:2]
+            if key == 'mstd':
+                # noise param / randomization of magnitude values
+                mstd = float(val)
+                if mstd > 100:
+                    # use uniform sampling in 0 to magnitude if mstd is > 100
+                    mstd = float('inf')
+                hparams.setdefault('magnitude_std', mstd)
+            elif key == 'mmax':
+                # clip magnitude between [0, mmax] instead of default [0, _LEVEL_DENOM]
+                hparams.setdefault('magnitude_max', int(val))
+            elif key == 'inc':
+                if bool(val):
+                    increasing = True
+            elif key == 'm':
+                magnitude = int(val)
+            elif key == 'n':
+                num_layers = int(val)
+            elif key == 'p':
+                prob = float(val)
+            else:
+                assert False, 'Unknown RandAugment config section'
+
+    if isinstance(transforms, str):
+        transforms = rand_augment_choices(transforms, increasing=increasing)
+    elif transforms is None:
+        transforms = _RAND_INCREASING_TRANSFORMS if increasing else _RAND_TRANSFORMS
+
+    choice_weights = None
+    if isinstance(transforms, Dict):
+        transforms, choice_weights = _get_weighted_transforms(transforms)
+
+    ra_ops = rand_augment_ops(magnitude=magnitude, prob=prob, hparams=hparams, transforms=transforms)
+    return RandAugment(ra_ops, num_layers, choice_weights=choice_weights)
+
+
+_AUGMIX_TRANSFORMS = [
+    'AutoContrast',
+    'ColorIncreasing',  # not in paper
+    'ContrastIncreasing',  # not in paper
+    'BrightnessIncreasing',  # not in paper
+    'SharpnessIncreasing',  # not in paper
+    'Equalize',
+    'Rotate',
+    'PosterizeIncreasing',
+    'SolarizeIncreasing',
+    'ShearX',
+    'ShearY',
+    'TranslateXRel',
+    'TranslateYRel',
+]
+
+
+def augmix_ops(
+        magnitude: Union[int, float] = 10,
+        hparams: Optional[Dict] = None,
+        transforms: Optional[Union[str, Dict, List]] = None,
+):
+    hparams = hparams or _HPARAMS_DEFAULT
+    transforms = transforms or _AUGMIX_TRANSFORMS
+    return [AugmentOp(
+        name,
+        prob=1.0,
+        magnitude=magnitude,
+        hparams=hparams
+    ) for name in transforms]
+
+
+class AugMixAugment:
+    """ AugMix Transform
+    Adapted and improved from impl here: https://github.com/google-research/augmix/blob/master/imagenet.py
+    From paper: 'AugMix: A Simple Data Processing Method to Improve Robustness and Uncertainty -
+    https://arxiv.org/abs/1912.02781
+    """
+    def __init__(self, ops, alpha=1., width=3, depth=-1, blended=False):
+        self.ops = ops
+        self.alpha = alpha
+        self.width = width
+        self.depth = depth
+        self.blended = blended  # blended mode is faster but not well tested
+
+    def _calc_blended_weights(self, ws, m):
+        ws = ws * m
+        cump = 1.
+        rws = []
+        for w in ws[::-1]:
+            alpha = w / cump
+            cump *= (1 - alpha)
+            rws.append(alpha)
+        return np.array(rws[::-1], dtype=np.float32)
+
+    def _apply_blended(self, img, mixing_weights, m):
+        # This is my first crack and implementing a slightly faster mixed augmentation. Instead
+        # of accumulating the mix for each chain in a Numpy array and then blending with original,
+        # it recomputes the blending coefficients and applies one PIL image blend per chain.
+        # TODO the results appear in the right ballpark but they differ by more than rounding.
+        img_orig = img.copy()
+        ws = self._calc_blended_weights(mixing_weights, m)
+        for w in ws:
+            depth = self.depth if self.depth > 0 else np.random.randint(1, 4)
+            ops = np.random.choice(self.ops, depth, replace=True)
+            img_aug = img_orig  # no ops are in-place, deep copy not necessary
+            for op in ops:
+                img_aug = op(img_aug)
+            img = Image.blend(img, img_aug, w)
+        return img
+
+    def _apply_basic(self, img, mixing_weights, m):
+        # This is a literal adaptation of the paper/official implementation without normalizations and
+        # PIL <-> Numpy conversions between every op. It is still quite CPU compute heavy compared to the
+        # typical augmentation transforms, could use a GPU / Kornia implementation.
+        img_shape = img.size[0], img.size[1], len(img.getbands())
+        mixed = np.zeros(img_shape, dtype=np.float32)
+        for mw in mixing_weights:
+            depth = self.depth if self.depth > 0 else np.random.randint(1, 4)
+            ops = np.random.choice(self.ops, depth, replace=True)
+            img_aug = img  # no ops are in-place, deep copy not necessary
+            for op in ops:
+                img_aug = op(img_aug)
+            mixed += mw * np.asarray(img_aug, dtype=np.float32)
+        np.clip(mixed, 0, 255., out=mixed)
+        mixed = Image.fromarray(mixed.astype(np.uint8))
+        return Image.blend(img, mixed, m)
+
+    def __call__(self, img):
+        mixing_weights = np.float32(np.random.dirichlet([self.alpha] * self.width))
+        m = np.float32(np.random.beta(self.alpha, self.alpha))
+        if self.blended:
+            mixed = self._apply_blended(img, mixing_weights, m)
+        else:
+            mixed = self._apply_basic(img, mixing_weights, m)
+        return mixed
+
+    def __repr__(self):
+        fs = self.__class__.__name__ + f'(alpha={self.alpha}, width={self.width}, depth={self.depth}, ops='
+        for op in self.ops:
+            fs += f'\n\t{op}'
+        fs += ')'
+        return fs
+
+
+def augment_and_mix_transform(config_str: str, hparams: Optional[Dict] = None):
+    """ Create AugMix PyTorch transform
+
+    Args:
+        config_str (str): String defining configuration of random augmentation. Consists of multiple sections separated
+            by dashes ('-'). The first section defines the specific variant of rand augment (currently only 'rand').
+            The remaining sections, not order sepecific determine
+                'm' - integer magnitude (severity) of augmentation mix (default: 3)
+                'w' - integer width of augmentation chain (default: 3)
+                'd' - integer depth of augmentation chain (-1 is random [1, 3], default: -1)
+                'b' - integer (bool), blend each branch of chain into end result without a final blend, less CPU (default: 0)
+                'mstd' -  float std deviation of magnitude noise applied (default: 0)
+            Ex 'augmix-m5-w4-d2' results in AugMix with severity 5, chain width 4, chain depth 2
+
+        hparams: Other hparams (kwargs) for the Augmentation transforms
+
+    Returns:
+         A PyTorch compatible Transform
+    """
+    magnitude = 3
+    width = 3
+    depth = -1
+    alpha = 1.
+    blended = False
+    config = config_str.split('-')
+    assert config[0] == 'augmix'
+    config = config[1:]
+    for c in config:
+        cs = re.split(r'(\d.*)', c)
+        if len(cs) < 2:
+            continue
+        key, val = cs[:2]
+        if key == 'mstd':
+            # noise param injected via hparams for now
+            hparams.setdefault('magnitude_std', float(val))
+        elif key == 'm':
+            magnitude = int(val)
+        elif key == 'w':
+            width = int(val)
+        elif key == 'd':
+            depth = int(val)
+        elif key == 'a':
+            alpha = float(val)
+        elif key == 'b':
+            blended = bool(val)
+        else:
+            assert False, 'Unknown AugMix config section'
+    hparams.setdefault('magnitude_std', float('inf'))  # default to uniform sampling (if not set via mstd arg)
+    ops = augmix_ops(magnitude=magnitude, hparams=hparams)
+    return AugMixAugment(ops, alpha=alpha, width=width, depth=depth, blended=blended)

pytorch-image-models/timm/data/config.py

@@ -0,0 +1,129 @@
+import logging
+from .constants import *
+
+
+_logger = logging.getLogger(__name__)
+
+
+def resolve_data_config(
+        args=None,
+        pretrained_cfg=None,
+        model=None,
+        use_test_size=False,
+        verbose=False
+):
+    assert model or args or pretrained_cfg, "At least one of model, args, or pretrained_cfg required for data config."
+    args = args or {}
+    pretrained_cfg = pretrained_cfg or {}
+    if not pretrained_cfg and model is not None and hasattr(model, 'pretrained_cfg'):
+        pretrained_cfg = model.pretrained_cfg
+    data_config = {}
+
+    # Resolve input/image size
+    in_chans = 3
+    if args.get('in_chans', None) is not None:
+        in_chans = args['in_chans']
+    elif args.get('chans', None) is not None:
+        in_chans = args['chans']
+
+    input_size = (in_chans, 224, 224)
+    if args.get('input_size', None) is not None:
+        assert isinstance(args['input_size'], (tuple, list))
+        assert len(args['input_size']) == 3
+        input_size = tuple(args['input_size'])
+        in_chans = input_size[0]  # input_size overrides in_chans
+    elif args.get('img_size', None) is not None:
+        assert isinstance(args['img_size'], int)
+        input_size = (in_chans, args['img_size'], args['img_size'])
+    else:
+        if use_test_size and pretrained_cfg.get('test_input_size', None) is not None:
+            input_size = pretrained_cfg['test_input_size']
+        elif pretrained_cfg.get('input_size', None) is not None:
+            input_size = pretrained_cfg['input_size']
+    data_config['input_size'] = input_size
+
+    # resolve interpolation method
+    data_config['interpolation'] = 'bicubic'
+    if args.get('interpolation', None):
+        data_config['interpolation'] = args['interpolation']
+    elif pretrained_cfg.get('interpolation', None):
+        data_config['interpolation'] = pretrained_cfg['interpolation']
+
+    # resolve dataset + model mean for normalization
+    data_config['mean'] = IMAGENET_DEFAULT_MEAN
+    if args.get('mean', None) is not None:
+        mean = tuple(args['mean'])
+        if len(mean) == 1:
+            mean = tuple(list(mean) * in_chans)
+        else:
+            assert len(mean) == in_chans
+        data_config['mean'] = mean
+    elif pretrained_cfg.get('mean', None):
+        data_config['mean'] = pretrained_cfg['mean']
+
+    # resolve dataset + model std deviation for normalization
+    data_config['std'] = IMAGENET_DEFAULT_STD
+    if args.get('std', None) is not None:
+        std = tuple(args['std'])
+        if len(std) == 1:
+            std = tuple(list(std) * in_chans)
+        else:
+            assert len(std) == in_chans
+        data_config['std'] = std
+    elif pretrained_cfg.get('std', None):
+        data_config['std'] = pretrained_cfg['std']
+
+    # resolve default inference crop
+    crop_pct = DEFAULT_CROP_PCT
+    if args.get('crop_pct', None):
+        crop_pct = args['crop_pct']
+    else:
+        if use_test_size and pretrained_cfg.get('test_crop_pct', None):
+            crop_pct = pretrained_cfg['test_crop_pct']
+        elif pretrained_cfg.get('crop_pct', None):
+            crop_pct = pretrained_cfg['crop_pct']
+    data_config['crop_pct'] = crop_pct
+
+    # resolve default crop percentage
+    crop_mode = DEFAULT_CROP_MODE
+    if args.get('crop_mode', None):
+        crop_mode = args['crop_mode']
+    elif pretrained_cfg.get('crop_mode', None):
+        crop_mode = pretrained_cfg['crop_mode']
+    data_config['crop_mode'] = crop_mode
+
+    if verbose:
+        _logger.info('Data processing configuration for current model + dataset:')
+        for n, v in data_config.items():
+            _logger.info('\t%s: %s' % (n, str(v)))
+
+    return data_config
+
+
+def resolve_model_data_config(
+        model,
+        args=None,
+        pretrained_cfg=None,
+        use_test_size=False,
+        verbose=False,
+):
+    """ Resolve Model Data Config
+    This is equivalent to resolve_data_config() but with arguments re-ordered to put model first.
+
+    Args:
+        model (nn.Module): the model instance
+        args (dict): command line arguments / configuration in dict form (overrides pretrained_cfg)
+        pretrained_cfg (dict): pretrained model config (overrides pretrained_cfg attached to model)
+        use_test_size (bool): use the test time input resolution (if one exists) instead of default train resolution
+        verbose (bool): enable extra logging of resolved values
+
+    Returns:
+        dictionary of config
+    """
+    return resolve_data_config(
+        args=args,
+        pretrained_cfg=pretrained_cfg,
+        model=model,
+        use_test_size=use_test_size,
+        verbose=verbose,
+    )

pytorch-image-models/timm/data/constants.py

@@ -0,0 +1,10 @@
+DEFAULT_CROP_PCT = 0.875
+DEFAULT_CROP_MODE = 'center'
+IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225)
+IMAGENET_INCEPTION_MEAN = (0.5, 0.5, 0.5)
+IMAGENET_INCEPTION_STD = (0.5, 0.5, 0.5)
+IMAGENET_DPN_MEAN = (124 / 255, 117 / 255, 104 / 255)
+IMAGENET_DPN_STD = tuple([1 / (.0167 * 255)] * 3)
+OPENAI_CLIP_MEAN = (0.48145466, 0.4578275, 0.40821073)
+OPENAI_CLIP_STD = (0.26862954, 0.26130258, 0.27577711)

pytorch-image-models/timm/data/dataset.py

@@ -0,0 +1,204 @@
+""" Quick n Simple Image Folder, Tarfile based DataSet
+
+Hacked together by / Copyright 2019, Ross Wightman
+"""
+import io
+import logging
+from typing import Optional
+
+import torch
+import torch.utils.data as data
+from PIL import Image
+
+from .readers import create_reader
+
+_logger = logging.getLogger(__name__)
+
+
+_ERROR_RETRY = 50
+
+
+class ImageDataset(data.Dataset):
+
+    def __init__(
+            self,
+            root,
+            reader=None,
+            split='train',
+            class_map=None,
+            load_bytes=False,
+            input_img_mode='RGB',
+            transform=None,
+            target_transform=None,
+            **kwargs,
+    ):
+        if reader is None or isinstance(reader, str):
+            reader = create_reader(
+                reader or '',
+                root=root,
+                split=split,
+                class_map=class_map,
+                **kwargs,
+            )
+        self.reader = reader
+        self.load_bytes = load_bytes
+        self.input_img_mode = input_img_mode
+        self.transform = transform
+        self.target_transform = target_transform
+        self._consecutive_errors = 0
+
+    def __getitem__(self, index):
+        img, target = self.reader[index]
+
+        try:
+            img = img.read() if self.load_bytes else Image.open(img)
+        except Exception as e:
+            _logger.warning(f'Skipped sample (index {index}, file {self.reader.filename(index)}). {str(e)}')
+            self._consecutive_errors += 1
+            if self._consecutive_errors < _ERROR_RETRY:
+                return self.__getitem__((index + 1) % len(self.reader))
+            else:
+                raise e
+        self._consecutive_errors = 0
+
+        if self.input_img_mode and not self.load_bytes:
+            img = img.convert(self.input_img_mode)
+        if self.transform is not None:
+            img = self.transform(img)
+
+        if target is None:
+            target = -1
+        elif self.target_transform is not None:
+            target = self.target_transform(target)
+
+        return img, target
+
+    def __len__(self):
+        return len(self.reader)
+
+    def filename(self, index, basename=False, absolute=False):
+        return self.reader.filename(index, basename, absolute)
+
+    def filenames(self, basename=False, absolute=False):
+        return self.reader.filenames(basename, absolute)
+
+
+class IterableImageDataset(data.IterableDataset):
+
+    def __init__(
+            self,
+            root,
+            reader=None,
+            split='train',
+            class_map=None,
+            is_training=False,
+            batch_size=1,
+            num_samples=None,
+            seed=42,
+            repeats=0,
+            download=False,
+            input_img_mode='RGB',
+            input_key=None,
+            target_key=None,
+            transform=None,
+            target_transform=None,
+            max_steps=None,
+            **kwargs,
+    ):
+        assert reader is not None
+        if isinstance(reader, str):
+            self.reader = create_reader(
+                reader,
+                root=root,
+                split=split,
+                class_map=class_map,
+                is_training=is_training,
+                batch_size=batch_size,
+                num_samples=num_samples,
+                seed=seed,
+                repeats=repeats,
+                download=download,
+                input_img_mode=input_img_mode,
+                input_key=input_key,
+                target_key=target_key,
+                max_steps=max_steps,
+                **kwargs,
+            )
+        else:
+            self.reader = reader
+        self.transform = transform
+        self.target_transform = target_transform
+        self._consecutive_errors = 0
+
+    def __iter__(self):
+        for img, target in self.reader:
+            if self.transform is not None:
+                img = self.transform(img)
+            if self.target_transform is not None:
+                target = self.target_transform(target)
+            yield img, target
+
+    def __len__(self):
+        if hasattr(self.reader, '__len__'):
+            return len(self.reader)
+        else:
+            return 0
+
+    def set_epoch(self, count):
+        # TFDS and WDS need external epoch count for deterministic cross process shuffle
+        if hasattr(self.reader, 'set_epoch'):
+            self.reader.set_epoch(count)
+
+    def set_loader_cfg(
+            self,
+            num_workers: Optional[int] = None,
+    ):
+        # TFDS and WDS readers need # workers for correct # samples estimate before loader processes created
+        if hasattr(self.reader, 'set_loader_cfg'):
+            self.reader.set_loader_cfg(num_workers=num_workers)
+
+    def filename(self, index, basename=False, absolute=False):
+        assert False, 'Filename lookup by index not supported, use filenames().'
+
+    def filenames(self, basename=False, absolute=False):
+        return self.reader.filenames(basename, absolute)
+
+
+class AugMixDataset(torch.utils.data.Dataset):
+    """Dataset wrapper to perform AugMix or other clean/augmentation mixes"""
+
+    def __init__(self, dataset, num_splits=2):
+        self.augmentation = None
+        self.normalize = None
+        self.dataset = dataset
+        if self.dataset.transform is not None:
+            self._set_transforms(self.dataset.transform)
+        self.num_splits = num_splits
+
+    def _set_transforms(self, x):
+        assert isinstance(x, (list, tuple)) and len(x) == 3, 'Expecting a tuple/list of 3 transforms'
+        self.dataset.transform = x[0]
+        self.augmentation = x[1]
+        self.normalize = x[2]
+
+    @property
+    def transform(self):
+        return self.dataset.transform
+
+    @transform.setter
+    def transform(self, x):
+        self._set_transforms(x)
+
+    def _normalize(self, x):
+        return x if self.normalize is None else self.normalize(x)
+
+    def __getitem__(self, i):
+        x, y = self.dataset[i]  # all splits share the same dataset base transform
+        x_list = [self._normalize(x)]  # first split only normalizes (this is the 'clean' split)
+        # run the full augmentation on the remaining splits
+        for _ in range(self.num_splits - 1):
+            x_list.append(self._normalize(self.augmentation(x)))
+        return tuple(x_list), y
+
+    def __len__(self):
+        return len(self.dataset)

pytorch-image-models/timm/data/dataset_factory.py

@@ -0,0 +1,229 @@
+""" Dataset Factory
+
+Hacked together by / Copyright 2021, Ross Wightman
+"""
+import os
+from typing import Optional
+
+from torchvision.datasets import CIFAR100, CIFAR10, MNIST, KMNIST, FashionMNIST, ImageFolder
+try:
+    from torchvision.datasets import Places365
+    has_places365 = True
+except ImportError:
+    has_places365 = False
+try:
+    from torchvision.datasets import INaturalist
+    has_inaturalist = True
+except ImportError:
+    has_inaturalist = False
+try:
+    from torchvision.datasets import QMNIST
+    has_qmnist = True
+except ImportError:
+    has_qmnist = False
+try:
+    from torchvision.datasets import ImageNet
+    has_imagenet = True
+except ImportError:
+    has_imagenet = False
+
+from .dataset import IterableImageDataset, ImageDataset
+
+_TORCH_BASIC_DS = dict(
+    cifar10=CIFAR10,
+    cifar100=CIFAR100,
+    mnist=MNIST,
+    kmnist=KMNIST,
+    fashion_mnist=FashionMNIST,
+)
+_TRAIN_SYNONYM = dict(train=None, training=None)
+_EVAL_SYNONYM = dict(val=None, valid=None, validation=None, eval=None, evaluation=None)
+
+
+def _search_split(root, split):
+    # look for sub-folder with name of split in root and use that if it exists
+    split_name = split.split('[')[0]
+    try_root = os.path.join(root, split_name)
+    if os.path.exists(try_root):
+        return try_root
+
+    def _try(syn):
+        for s in syn:
+            try_root = os.path.join(root, s)
+            if os.path.exists(try_root):
+                return try_root
+        return root
+    if split_name in _TRAIN_SYNONYM:
+        root = _try(_TRAIN_SYNONYM)
+    elif split_name in _EVAL_SYNONYM:
+        root = _try(_EVAL_SYNONYM)
+    return root
+
+
+def create_dataset(
+        name: str,
+        root: Optional[str] = None,
+        split: str = 'validation',
+        search_split: bool = True,
+        class_map: dict = None,
+        load_bytes: bool = False,
+        is_training: bool = False,
+        download: bool = False,
+        batch_size: int = 1,
+        num_samples: Optional[int] = None,
+        seed: int = 42,
+        repeats: int = 0,
+        input_img_mode: str = 'RGB',
+        trust_remote_code: bool = False,
+        **kwargs,
+):
+    """ Dataset factory method
+
+    In parentheses after each arg are the type of dataset supported for each arg, one of:
+      * Folder - default, timm folder (or tar) based ImageDataset
+      * Torch - torchvision based datasets
+      * HFDS - Hugging Face Datasets
+      * HFIDS - Hugging Face Datasets Iterable (streaming mode, with IterableDataset)
+      * TFDS - Tensorflow-datasets wrapper in IterabeDataset interface via IterableImageDataset
+      * WDS - Webdataset
+      * All - any of the above
+
+    Args:
+        name: Dataset name, empty is okay for folder based datasets
+        root: Root folder of dataset (All)
+        split: Dataset split (All)
+        search_split: Search for split specific child fold from root so one can specify
+            `imagenet/` instead of `/imagenet/val`, etc on cmd line / config. (Folder, Torch)
+        class_map: Specify class -> index mapping via text file or dict (Folder)
+        load_bytes: Load data, return images as undecoded bytes (Folder)
+        download: Download dataset if not present and supported (HFIDS, TFDS, Torch)
+        is_training: Create dataset in train mode, this is different from the split.
+            For Iterable / TDFS it enables shuffle, ignored for other datasets. (TFDS, WDS, HFIDS)
+        batch_size: Batch size hint for iterable datasets (TFDS, WDS, HFIDS)
+        seed: Seed for iterable datasets (TFDS, WDS, HFIDS)
+        repeats: Dataset repeats per iteration i.e. epoch (TFDS, WDS, HFIDS)
+        input_img_mode: Input image color conversion mode e.g. 'RGB', 'L' (folder, TFDS, WDS, HFDS, HFIDS)
+        trust_remote_code: Trust remote code in Hugging Face Datasets if True (HFDS, HFIDS)
+        **kwargs: Other args to pass through to underlying Dataset and/or Reader classes
+
+    Returns:
+        Dataset object
+    """
+    kwargs = {k: v for k, v in kwargs.items() if v is not None}
+    name = name.lower()
+    if name.startswith('torch/'):
+        name = name.split('/', 2)[-1]
+        torch_kwargs = dict(root=root, download=download, **kwargs)
+        if name in _TORCH_BASIC_DS:
+            ds_class = _TORCH_BASIC_DS[name]
+            use_train = split in _TRAIN_SYNONYM
+            ds = ds_class(train=use_train, **torch_kwargs)
+        elif name == 'inaturalist' or name == 'inat':
+            assert has_inaturalist, 'Please update to PyTorch 1.10, torchvision 0.11+ for Inaturalist'
+            target_type = 'full'
+            split_split = split.split('/')
+            if len(split_split) > 1:
+                target_type = split_split[0].split('_')
+                if len(target_type) == 1:
+                    target_type = target_type[0]
+                split = split_split[-1]
+            if split in _TRAIN_SYNONYM:
+                split = '2021_train'
+            elif split in _EVAL_SYNONYM:
+                split = '2021_valid'
+            ds = INaturalist(version=split, target_type=target_type, **torch_kwargs)
+        elif name == 'places365':
+            assert has_places365, 'Please update to a newer PyTorch and torchvision for Places365 dataset.'
+            if split in _TRAIN_SYNONYM:
+                split = 'train-standard'
+            elif split in _EVAL_SYNONYM:
+                split = 'val'
+            ds = Places365(split=split, **torch_kwargs)
+        elif name == 'qmnist':
+            assert has_qmnist, 'Please update to a newer PyTorch and torchvision for QMNIST dataset.'
+            use_train = split in _TRAIN_SYNONYM
+            ds = QMNIST(train=use_train, **torch_kwargs)
+        elif name == 'imagenet':
+            assert has_imagenet, 'Please update to a newer PyTorch and torchvision for ImageNet dataset.'
+            if split in _EVAL_SYNONYM:
+                split = 'val'
+            ds = ImageNet(split=split, **torch_kwargs)
+        elif name == 'image_folder' or name == 'folder':
+            # in case torchvision ImageFolder is preferred over timm ImageDataset for some reason
+            if search_split and os.path.isdir(root):
+                # look for split specific sub-folder in root
+                root = _search_split(root, split)
+            ds = ImageFolder(root, **kwargs)
+        else:
+            assert False, f"Unknown torchvision dataset {name}"
+    elif name.startswith('hfds/'):
+        # NOTE right now, HF datasets default arrow format is a random-access Dataset,
+        # There will be a IterableDataset variant too, TBD
+        ds = ImageDataset(
+            root,
+            reader=name,
+            split=split,
+            class_map=class_map,
+            input_img_mode=input_img_mode,
+            trust_remote_code=trust_remote_code,
+            **kwargs,
+        )
+    elif name.startswith('hfids/'):
+        ds = IterableImageDataset(
+            root,
+            reader=name,
+            split=split,
+            class_map=class_map,
+            is_training=is_training,
+            download=download,
+            batch_size=batch_size,
+            num_samples=num_samples,
+            repeats=repeats,
+            seed=seed,
+            input_img_mode=input_img_mode,
+            trust_remote_code=trust_remote_code,
+            **kwargs,
+        )
+    elif name.startswith('tfds/'):
+        ds = IterableImageDataset(
+            root,
+            reader=name,
+            split=split,
+            class_map=class_map,
+            is_training=is_training,
+            download=download,
+            batch_size=batch_size,
+            num_samples=num_samples,
+            repeats=repeats,
+            seed=seed,
+            input_img_mode=input_img_mode,
+            **kwargs
+        )
+    elif name.startswith('wds/'):
+        ds = IterableImageDataset(
+            root,
+            reader=name,
+            split=split,
+            class_map=class_map,
+            is_training=is_training,
+            batch_size=batch_size,
+            num_samples=num_samples,
+            repeats=repeats,
+            seed=seed,
+            input_img_mode=input_img_mode,
+            **kwargs
+        )
+    else:
+        # FIXME support more advance split cfg for ImageFolder/Tar datasets in the future
+        if search_split and os.path.isdir(root):
+            # look for split specific sub-folder in root
+            root = _search_split(root, split)
+        ds = ImageDataset(
+            root,
+            reader=name,
+            class_map=class_map,
+            load_bytes=load_bytes,
+            input_img_mode=input_img_mode,
+            **kwargs,
+        )
+    return ds

pytorch-image-models/timm/data/dataset_info.py

@@ -0,0 +1,73 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Union
+
+
+class DatasetInfo(ABC):
+
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def num_classes(self):
+        pass
+
+    @abstractmethod
+    def label_names(self):
+        pass
+
+    @abstractmethod
+    def label_descriptions(self, detailed: bool = False, as_dict: bool = False) -> Union[List[str], Dict[str, str]]:
+        pass
+
+    @abstractmethod
+    def index_to_label_name(self, index) -> str:
+        pass
+
+    @abstractmethod
+    def index_to_description(self, index: int, detailed: bool = False) -> str:
+        pass
+
+    @abstractmethod
+    def label_name_to_description(self, label: str, detailed: bool = False) -> str:
+        pass
+
+
+class CustomDatasetInfo(DatasetInfo):
+    """ DatasetInfo that wraps passed values for custom datasets."""
+
+    def __init__(
+            self,
+            label_names: Union[List[str], Dict[int, str]],
+            label_descriptions: Optional[Dict[str, str]] = None
+    ):
+        super().__init__()
+        assert len(label_names) > 0
+        self._label_names = label_names  # label index => label name mapping
+        self._label_descriptions = label_descriptions  # label name => label description mapping
+        if self._label_descriptions is not None:
+            # validate descriptions (label names required)
+            assert isinstance(self._label_descriptions, dict)
+            for n in self._label_names:
+                assert n in self._label_descriptions
+
+    def num_classes(self):
+        return len(self._label_names)
+
+    def label_names(self):
+        return self._label_names
+
+    def label_descriptions(self, detailed: bool = False, as_dict: bool = False) -> Union[List[str], Dict[str, str]]:
+        return self._label_descriptions
+
+    def label_name_to_description(self, label: str, detailed: bool = False) -> str:
+        if self._label_descriptions:
+            return self._label_descriptions[label]
+        return label  # return label name itself if a descriptions is not present
+
+    def index_to_label_name(self, index) -> str:
+        assert 0 <= index < len(self._label_names)
+        return self._label_names[index]
+
+    def index_to_description(self, index: int, detailed: bool = False) -> str:
+        label = self.index_to_label_name(index)
+        return self.label_name_to_description(label, detailed=detailed)

pytorch-image-models/timm/data/distributed_sampler.py

@@ -0,0 +1,135 @@
+import math
+import torch
+from torch.utils.data import Sampler
+import torch.distributed as dist
+
+
+class OrderedDistributedSampler(Sampler):
+    """Sampler that restricts data loading to a subset of the dataset.
+    It is especially useful in conjunction with
+    :class:`torch.nn.parallel.DistributedDataParallel`. In such case, each
+    process can pass a DistributedSampler instance as a DataLoader sampler,
+    and load a subset of the original dataset that is exclusive to it.
+    .. note::
+        Dataset is assumed to be of constant size.
+    Arguments:
+        dataset: Dataset used for sampling.
+        num_replicas (optional): Number of processes participating in
+            distributed training.
+        rank (optional): Rank of the current process within num_replicas.
+    """
+
+    def __init__(self, dataset, num_replicas=None, rank=None):
+        if num_replicas is None:
+            if not dist.is_available():
+                raise RuntimeError("Requires distributed package to be available")
+            num_replicas = dist.get_world_size()
+        if rank is None:
+            if not dist.is_available():
+                raise RuntimeError("Requires distributed package to be available")
+            rank = dist.get_rank()
+        self.dataset = dataset
+        self.num_replicas = num_replicas
+        self.rank = rank
+        self.num_samples = int(math.ceil(len(self.dataset) * 1.0 / self.num_replicas))
+        self.total_size = self.num_samples * self.num_replicas
+
+    def __iter__(self):
+        indices = list(range(len(self.dataset)))
+
+        # add extra samples to make it evenly divisible
+        indices += indices[:(self.total_size - len(indices))]
+        assert len(indices) == self.total_size
+
+        # subsample
+        indices = indices[self.rank:self.total_size:self.num_replicas]
+        assert len(indices) == self.num_samples
+
+        return iter(indices)
+
+    def __len__(self):
+        return self.num_samples
+
+
+class RepeatAugSampler(Sampler):
+    """Sampler that restricts data loading to a subset of the dataset for distributed,
+    with repeated augmentation.
+    It ensures that different each augmented version of a sample will be visible to a
+    different process (GPU). Heavily based on torch.utils.data.DistributedSampler
+
+    This sampler was taken from https://github.com/facebookresearch/deit/blob/0c4b8f60/samplers.py
+    Used in
+    Copyright (c) 2015-present, Facebook, Inc.
+    """
+
+    def __init__(
+            self,
+            dataset,
+            num_replicas=None,
+            rank=None,
+            shuffle=True,
+            num_repeats=3,
+            selected_round=256,
+            selected_ratio=0,
+    ):
+        if num_replicas is None:
+            if not dist.is_available():
+                raise RuntimeError("Requires distributed package to be available")
+            num_replicas = dist.get_world_size()
+        if rank is None:
+            if not dist.is_available():
+                raise RuntimeError("Requires distributed package to be available")
+            rank = dist.get_rank()
+        self.dataset = dataset
+        self.num_replicas = num_replicas
+        self.rank = rank
+        self.shuffle = shuffle
+        self.num_repeats = num_repeats
+        self.epoch = 0
+        self.num_samples = int(math.ceil(len(self.dataset) * num_repeats / self.num_replicas))
+        self.total_size = self.num_samples * self.num_replicas
+        # Determine the number of samples to select per epoch for each rank.
+        # num_selected logic defaults to be the same as original RASampler impl, but this one can be tweaked
+        # via selected_ratio and selected_round args.
+        selected_ratio = selected_ratio or num_replicas  # ratio to reduce selected samples by, num_replicas if 0
+        if selected_round:
+            self.num_selected_samples = int(math.floor(
+                 len(self.dataset) // selected_round * selected_round / selected_ratio))
+        else:
+            self.num_selected_samples = int(math.ceil(len(self.dataset) / selected_ratio))
+
+    def __iter__(self):
+        # deterministically shuffle based on epoch
+        g = torch.Generator()
+        g.manual_seed(self.epoch)
+        if self.shuffle:
+            indices = torch.randperm(len(self.dataset), generator=g)
+        else:
+            indices = torch.arange(start=0, end=len(self.dataset))
+
+        # produce repeats e.g. [0, 0, 0, 1, 1, 1, 2, 2, 2....]
+        if isinstance(self.num_repeats, float) and not self.num_repeats.is_integer():
+            # resample for repeats w/ non-integer ratio
+            repeat_size = math.ceil(self.num_repeats * len(self.dataset))
+            indices = indices[torch.tensor([int(i // self.num_repeats) for i in range(repeat_size)])]
+        else:
+            indices = torch.repeat_interleave(indices, repeats=int(self.num_repeats), dim=0)
+        indices = indices.tolist()  # leaving as tensor thrashes dataloader memory
+        # add extra samples to make it evenly divisible
+        padding_size = self.total_size - len(indices)
+        if padding_size > 0:
+            indices += indices[:padding_size]
+        assert len(indices) == self.total_size
+
+        # subsample per rank
+        indices = indices[self.rank:self.total_size:self.num_replicas]
+        assert len(indices) == self.num_samples
+
+        # return up to num selected samples
+        return iter(indices[:self.num_selected_samples])
+
+    def __len__(self):
+        return self.num_selected_samples
+
+    def set_epoch(self, epoch):
+        self.epoch = epoch

pytorch-image-models/timm/data/imagenet_info.py

@@ -0,0 +1,95 @@
+import csv
+import os
+import pkgutil
+import re
+from typing import Dict, List, Optional, Union
+
+from .dataset_info import DatasetInfo
+
+
+# NOTE no ambiguity wrt to mapping from # classes to ImageNet subset so far, but likely to change
+_NUM_CLASSES_TO_SUBSET = {
+    1000: 'imagenet-1k',
+    11221: 'imagenet-21k-miil',  # miil subset of fall11
+    11821: 'imagenet-12k',  # timm specific 12k subset of fall11
+    21841: 'imagenet-22k',  # as in fall11.tar
+    21842: 'imagenet-22k-ms',  # a Microsoft (for FocalNet) remapping of 22k w/ moves ImageNet-1k classes to first 1000
+    21843: 'imagenet-21k-goog',  # Google's ImageNet full has two classes not in fall11
+}
+
+_SUBSETS = {
+    'imagenet1k': 'imagenet_synsets.txt',
+    'imagenet12k': 'imagenet12k_synsets.txt',
+    'imagenet22k': 'imagenet22k_synsets.txt',
+    'imagenet21k': 'imagenet21k_goog_synsets.txt',
+    'imagenet21kgoog': 'imagenet21k_goog_synsets.txt',
+    'imagenet21kmiil': 'imagenet21k_miil_synsets.txt',
+    'imagenet22kms': 'imagenet22k_ms_synsets.txt',
+}
+_LEMMA_FILE = 'imagenet_synset_to_lemma.txt'
+_DEFINITION_FILE = 'imagenet_synset_to_definition.txt'
+
+
+def infer_imagenet_subset(model_or_cfg) -> Optional[str]:
+    if isinstance(model_or_cfg, dict):
+        num_classes = model_or_cfg.get('num_classes', None)
+    else:
+        num_classes = getattr(model_or_cfg, 'num_classes', None)
+        if not num_classes:
+            pretrained_cfg = getattr(model_or_cfg, 'pretrained_cfg', {})
+            # FIXME at some point pretrained_cfg should include dataset-tag,
+            # which will be more robust than a guess based on num_classes
+            num_classes = pretrained_cfg.get('num_classes', None)
+    if not num_classes or num_classes not in _NUM_CLASSES_TO_SUBSET:
+        return None
+    return _NUM_CLASSES_TO_SUBSET[num_classes]
+
+
+class ImageNetInfo(DatasetInfo):
+
+    def __init__(self, subset: str = 'imagenet-1k'):
+        super().__init__()
+        subset = re.sub(r'[-_\s]', '', subset.lower())
+        assert subset in _SUBSETS, f'Unknown imagenet subset {subset}.'
+
+        # WordNet synsets (part-of-speach + offset) are the unique class label names for ImageNet classifiers
+        synset_file = _SUBSETS[subset]
+        synset_data = pkgutil.get_data(__name__, os.path.join('_info', synset_file))
+        self._synsets = synset_data.decode('utf-8').splitlines()
+
+        # WordNet lemmas (canonical dictionary form of word) and definitions are used to build
+        # the class descriptions. If detailed=True both are used, otherwise just the lemmas.
+        lemma_data = pkgutil.get_data(__name__, os.path.join('_info', _LEMMA_FILE))
+        reader = csv.reader(lemma_data.decode('utf-8').splitlines(), delimiter='\t')
+        self._lemmas = dict(reader)
+        definition_data = pkgutil.get_data(__name__, os.path.join('_info', _DEFINITION_FILE))
+        reader = csv.reader(definition_data.decode('utf-8').splitlines(), delimiter='\t')
+        self._definitions = dict(reader)
+
+    def num_classes(self):
+        return len(self._synsets)
+
+    def label_names(self):
+        return self._synsets
+
+    def label_descriptions(self, detailed: bool = False, as_dict: bool = False) -> Union[List[str], Dict[str, str]]:
+        if as_dict:
+            return {label: self.label_name_to_description(label, detailed=detailed) for label in self._synsets}
+        else:
+            return [self.label_name_to_description(label, detailed=detailed) for label in self._synsets]
+
+    def index_to_label_name(self, index) -> str:
+        assert 0 <= index < len(self._synsets), \
+            f'Index ({index}) out of range for dataset with {len(self._synsets)} classes.'
+        return self._synsets[index]
+
+    def index_to_description(self, index: int, detailed: bool = False) -> str:
+        label = self.index_to_label_name(index)
+        return self.label_name_to_description(label, detailed=detailed)
+
+    def label_name_to_description(self, label: str, detailed: bool = False) -> str:
+        if detailed:
+            description = f'{self._lemmas[label]}: {self._definitions[label]}'
+        else:
+            description = f'{self._lemmas[label]}'
+        return description

pytorch-image-models/timm/data/loader.py

@@ -0,0 +1,409 @@
+""" Loader Factory, Fast Collate, CUDA Prefetcher
+
+Prefetcher and Fast Collate inspired by NVIDIA APEX example at
+https://github.com/NVIDIA/apex/commit/d5e2bb4bdeedd27b1dfaf5bb2b24d6c000dee9be#diff-cf86c282ff7fba81fad27a559379d5bf
+
+Hacked together by / Copyright 2019, Ross Wightman
+"""
+import logging
+import random
+from contextlib import suppress
+from functools import partial
+from itertools import repeat
+from typing import Callable, Optional, Tuple, Union
+
+import torch
+import torch.utils.data
+import numpy as np
+
+from .constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
+from .dataset import IterableImageDataset, ImageDataset
+from .distributed_sampler import OrderedDistributedSampler, RepeatAugSampler
+from .random_erasing import RandomErasing
+from .mixup import FastCollateMixup
+from .transforms_factory import create_transform
+
+_logger = logging.getLogger(__name__)
+
+
+def fast_collate(batch):
+    """ A fast collation function optimized for uint8 images (np array or torch) and int64 targets (labels)"""
+    assert isinstance(batch[0], tuple)
+    batch_size = len(batch)
+    if isinstance(batch[0][0], tuple):
+        # This branch 'deinterleaves' and flattens tuples of input tensors into one tensor ordered by position
+        # such that all tuple of position n will end up in a torch.split(tensor, batch_size) in nth position
+        inner_tuple_size = len(batch[0][0])
+        flattened_batch_size = batch_size * inner_tuple_size
+        targets = torch.zeros(flattened_batch_size, dtype=torch.int64)
+        tensor = torch.zeros((flattened_batch_size, *batch[0][0][0].shape), dtype=torch.uint8)
+        for i in range(batch_size):
+            assert len(batch[i][0]) == inner_tuple_size  # all input tensor tuples must be same length
+            for j in range(inner_tuple_size):
+                targets[i + j * batch_size] = batch[i][1]
+                tensor[i + j * batch_size] += torch.from_numpy(batch[i][0][j])
+        return tensor, targets
+    elif isinstance(batch[0][0], np.ndarray):
+        targets = torch.tensor([b[1] for b in batch], dtype=torch.int64)
+        assert len(targets) == batch_size
+        tensor = torch.zeros((batch_size, *batch[0][0].shape), dtype=torch.uint8)
+        for i in range(batch_size):
+            tensor[i] += torch.from_numpy(batch[i][0])
+        return tensor, targets
+    elif isinstance(batch[0][0], torch.Tensor):
+        targets = torch.tensor([b[1] for b in batch], dtype=torch.int64)
+        assert len(targets) == batch_size
+        tensor = torch.zeros((batch_size, *batch[0][0].shape), dtype=torch.uint8)
+        for i in range(batch_size):
+            tensor[i].copy_(batch[i][0])
+        return tensor, targets
+    else:
+        assert False
+
+
+def adapt_to_chs(x, n):
+    if not isinstance(x, (tuple, list)):
+        x = tuple(repeat(x, n))
+    elif len(x) != n:
+        x_mean = np.mean(x).item()
+        x = (x_mean,) * n
+        _logger.warning(f'Pretrained mean/std different shape than model, using avg value {x}.')
+    else:
+        assert len(x) == n, 'normalization stats must match image channels'
+    return x
+
+
+class PrefetchLoader:
+
+    def __init__(
+            self,
+            loader,
+            mean=IMAGENET_DEFAULT_MEAN,
+            std=IMAGENET_DEFAULT_STD,
+            channels=3,
+            device=torch.device('cuda'),
+            img_dtype=torch.float32,
+            fp16=False,
+            re_prob=0.,
+            re_mode='const',
+            re_count=1,
+            re_num_splits=0):
+
+        mean = adapt_to_chs(mean, channels)
+        std = adapt_to_chs(std, channels)
+        normalization_shape = (1, channels, 1, 1)
+
+        self.loader = loader
+        self.device = device
+        if fp16:
+            # fp16 arg is deprecated, but will override dtype arg if set for bwd compat
+            img_dtype = torch.float16
+        self.img_dtype = img_dtype
+        self.mean = torch.tensor(
+            [x * 255 for x in mean], device=device, dtype=img_dtype).view(normalization_shape)
+        self.std = torch.tensor(
+            [x * 255 for x in std], device=device, dtype=img_dtype).view(normalization_shape)
+        if re_prob > 0.:
+            self.random_erasing = RandomErasing(
+                probability=re_prob,
+                mode=re_mode,
+                max_count=re_count,
+                num_splits=re_num_splits,
+                device=device,
+            )
+        else:
+            self.random_erasing = None
+        self.is_cuda = device.type == 'cuda' and torch.cuda.is_available()
+        self.is_npu = device.type == 'npu' and torch.npu.is_available()
+
+    def __iter__(self):
+        first = True
+        if self.is_cuda:
+            stream = torch.cuda.Stream()
+            stream_context = partial(torch.cuda.stream, stream=stream)
+        elif self.is_npu:
+            stream = torch.npu.Stream()
+            stream_context = partial(torch.npu.stream, stream=stream)
+        else:
+            stream = None
+            stream_context = suppress
+
+        for next_input, next_target in self.loader:
+
+            with stream_context():
+                next_input = next_input.to(device=self.device, non_blocking=True)
+                next_target = next_target.to(device=self.device, non_blocking=True)
+                next_input = next_input.to(self.img_dtype).sub_(self.mean).div_(self.std)
+                if self.random_erasing is not None:
+                    next_input = self.random_erasing(next_input)
+
+            if not first:
+                yield input, target
+            else:
+                first = False
+
+            if stream is not None:
+                if self.is_cuda:
+                    torch.cuda.current_stream().wait_stream(stream)
+                elif self.is_npu:
+                    torch.npu.current_stream().wait_stream(stream)
+
+            input = next_input
+            target = next_target
+
+        yield input, target
+
+    def __len__(self):
+        return len(self.loader)
+
+    @property
+    def sampler(self):
+        return self.loader.sampler
+
+    @property
+    def dataset(self):
+        return self.loader.dataset
+
+    @property
+    def mixup_enabled(self):
+        if isinstance(self.loader.collate_fn, FastCollateMixup):
+            return self.loader.collate_fn.mixup_enabled
+        else:
+            return False
+
+    @mixup_enabled.setter
+    def mixup_enabled(self, x):
+        if isinstance(self.loader.collate_fn, FastCollateMixup):
+            self.loader.collate_fn.mixup_enabled = x
+
+
+def _worker_init(worker_id, worker_seeding='all'):
+    worker_info = torch.utils.data.get_worker_info()
+    assert worker_info.id == worker_id
+    if isinstance(worker_seeding, Callable):
+        seed = worker_seeding(worker_info)
+        random.seed(seed)
+        torch.manual_seed(seed)
+        np.random.seed(seed % (2 ** 32 - 1))
+    else:
+        assert worker_seeding in ('all', 'part')
+        # random / torch seed already called in dataloader iter class w/ worker_info.seed
+        # to reproduce some old results (same seed + hparam combo), partial seeding is required (skip numpy re-seed)
+        if worker_seeding == 'all':
+            np.random.seed(worker_info.seed % (2 ** 32 - 1))
+
+
+def create_loader(
+        dataset: Union[ImageDataset, IterableImageDataset],
+        input_size: Union[int, Tuple[int, int], Tuple[int, int, int]],
+        batch_size: int,
+        is_training: bool = False,
+        no_aug: bool = False,
+        re_prob: float = 0.,
+        re_mode: str = 'const',
+        re_count: int = 1,
+        re_split: bool = False,
+        train_crop_mode: Optional[str] = None,
+        scale: Optional[Tuple[float, float]] = None,
+        ratio: Optional[Tuple[float, float]] = None,
+        hflip: float = 0.5,
+        vflip: float = 0.,
+        color_jitter: float = 0.4,
+        color_jitter_prob: Optional[float] = None,
+        grayscale_prob: float = 0.,
+        gaussian_blur_prob: float = 0.,
+        auto_augment: Optional[str] = None,
+        num_aug_repeats: int = 0,
+        num_aug_splits: int = 0,
+        interpolation: str = 'bilinear',
+        mean: Tuple[float, ...] = IMAGENET_DEFAULT_MEAN,
+        std: Tuple[float, ...] = IMAGENET_DEFAULT_STD,
+        num_workers: int = 1,
+        distributed: bool = False,
+        crop_pct: Optional[float] = None,
+        crop_mode: Optional[str] = None,
+        crop_border_pixels: Optional[int] = None,
+        collate_fn: Optional[Callable] = None,
+        pin_memory: bool = False,
+        fp16: bool = False,  # deprecated, use img_dtype
+        img_dtype: torch.dtype = torch.float32,
+        device: torch.device = torch.device('cuda'),
+        use_prefetcher: bool = True,
+        use_multi_epochs_loader: bool = False,
+        persistent_workers: bool = True,
+        worker_seeding: str = 'all',
+        tf_preprocessing: bool = False,
+):
+    """
+
+    Args:
+        dataset: The image dataset to load.
+        input_size: Target input size (channels, height, width) tuple or size scalar.
+        batch_size: Number of samples in a batch.
+        is_training: Return training (random) transforms.
+        no_aug: Disable augmentation for training (useful for debug).
+        re_prob: Random erasing probability.
+        re_mode: Random erasing fill mode.
+        re_count: Number of random erasing regions.
+        re_split: Control split of random erasing across batch size.
+        scale: Random resize scale range (crop area, < 1.0 => zoom in).
+        ratio: Random aspect ratio range (crop ratio for RRC, ratio adjustment factor for RKR).
+        hflip: Horizontal flip probability.
+        vflip: Vertical flip probability.
+        color_jitter: Random color jitter component factors (brightness, contrast, saturation, hue).
+            Scalar is applied as (scalar,) * 3 (no hue).
+        color_jitter_prob: Apply color jitter with this probability if not None (for SimlCLR-like aug
+        grayscale_prob: Probability of converting image to grayscale (for SimCLR-like aug).
+        gaussian_blur_prob: Probability of applying gaussian blur (for SimCLR-like aug).
+        auto_augment: Auto augment configuration string (see auto_augment.py).
+        num_aug_repeats: Enable special sampler to repeat same augmentation across distributed GPUs.
+        num_aug_splits: Enable mode where augmentations can be split across the batch.
+        interpolation: Image interpolation mode.
+        mean: Image normalization mean.
+        std: Image normalization standard deviation.
+        num_workers: Num worker processes per DataLoader.
+        distributed: Enable dataloading for distributed training.
+        crop_pct: Inference crop percentage (output size / resize size).
+        crop_mode: Inference crop mode. One of ['squash', 'border', 'center']. Defaults to 'center' when None.
+        crop_border_pixels: Inference crop border of specified # pixels around edge of original image.
+        collate_fn: Override default collate_fn.
+        pin_memory: Pin memory for device transfer.
+        fp16: Deprecated argument for half-precision input dtype. Use img_dtype.
+        img_dtype: Data type for input image.
+        device: Device to transfer inputs and targets to.
+        use_prefetcher: Use efficient pre-fetcher to load samples onto device.
+        use_multi_epochs_loader:
+        persistent_workers: Enable persistent worker processes.
+        worker_seeding: Control worker random seeding at init.
+        tf_preprocessing: Use TF 1.0 inference preprocessing for testing model ports.
+
+    Returns:
+        DataLoader
+    """
+    re_num_splits = 0
+    if re_split:
+        # apply RE to second half of batch if no aug split otherwise line up with aug split
+        re_num_splits = num_aug_splits or 2
+    dataset.transform = create_transform(
+        input_size,
+        is_training=is_training,
+        no_aug=no_aug,
+        train_crop_mode=train_crop_mode,
+        scale=scale,
+        ratio=ratio,
+        hflip=hflip,
+        vflip=vflip,
+        color_jitter=color_jitter,
+        color_jitter_prob=color_jitter_prob,
+        grayscale_prob=grayscale_prob,
+        gaussian_blur_prob=gaussian_blur_prob,
+        auto_augment=auto_augment,
+        interpolation=interpolation,
+        mean=mean,
+        std=std,
+        crop_pct=crop_pct,
+        crop_mode=crop_mode,
+        crop_border_pixels=crop_border_pixels,
+        re_prob=re_prob,
+        re_mode=re_mode,
+        re_count=re_count,
+        re_num_splits=re_num_splits,
+        tf_preprocessing=tf_preprocessing,
+        use_prefetcher=use_prefetcher,
+        separate=num_aug_splits > 0,
+    )
+
+    if isinstance(dataset, IterableImageDataset):
+        # give Iterable datasets early knowledge of num_workers so that sample estimates
+        # are correct before worker processes are launched
+        dataset.set_loader_cfg(num_workers=num_workers)
+
+    sampler = None
+    if distributed and not isinstance(dataset, torch.utils.data.IterableDataset):
+        if is_training:
+            if num_aug_repeats:
+                sampler = RepeatAugSampler(dataset, num_repeats=num_aug_repeats)
+            else:
+                sampler = torch.utils.data.distributed.DistributedSampler(dataset)
+        else:
+            # This will add extra duplicate entries to result in equal num
+            # of samples per-process, will slightly alter validation results
+            sampler = OrderedDistributedSampler(dataset)
+    else:
+        assert num_aug_repeats == 0, "RepeatAugment not currently supported in non-distributed or IterableDataset use"
+
+    if collate_fn is None:
+        collate_fn = fast_collate if use_prefetcher else torch.utils.data.dataloader.default_collate
+
+    loader_class = torch.utils.data.DataLoader
+    if use_multi_epochs_loader:
+        loader_class = MultiEpochsDataLoader
+
+    loader_args = dict(
+        batch_size=batch_size,
+        shuffle=not isinstance(dataset, torch.utils.data.IterableDataset) and sampler is None and is_training,
+        num_workers=num_workers,
+        sampler=sampler,
+        collate_fn=collate_fn,
+        pin_memory=pin_memory,
+        drop_last=is_training,
+        worker_init_fn=partial(_worker_init, worker_seeding=worker_seeding),
+        persistent_workers=persistent_workers
+    )
+    try:
+        loader = loader_class(dataset, **loader_args)
+    except TypeError as e:
+        loader_args.pop('persistent_workers')  # only in Pytorch 1.7+
+        loader = loader_class(dataset, **loader_args)
+    if use_prefetcher:
+        prefetch_re_prob = re_prob if is_training and not no_aug else 0.
+        loader = PrefetchLoader(
+            loader,
+            mean=mean,
+            std=std,
+            channels=input_size[0],
+            device=device,
+            fp16=fp16,  # deprecated, use img_dtype
+            img_dtype=img_dtype,
+            re_prob=prefetch_re_prob,
+            re_mode=re_mode,
+            re_count=re_count,
+            re_num_splits=re_num_splits
+        )
+
+    return loader
+
+
+class MultiEpochsDataLoader(torch.utils.data.DataLoader):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._DataLoader__initialized = False
+        if self.batch_sampler is None:
+            self.sampler = _RepeatSampler(self.sampler)
+        else:
+            self.batch_sampler = _RepeatSampler(self.batch_sampler)
+        self._DataLoader__initialized = True
+        self.iterator = super().__iter__()
+
+    def __len__(self):
+        return len(self.sampler) if self.batch_sampler is None else len(self.batch_sampler.sampler)
+
+    def __iter__(self):
+        for i in range(len(self)):
+            yield next(self.iterator)
+
+
+class _RepeatSampler(object):
+    """ Sampler that repeats forever.
+
+    Args:
+        sampler (Sampler)
+    """
+
+    def __init__(self, sampler):
+        self.sampler = sampler
+
+    def __iter__(self):
+        while True:
+            yield from iter(self.sampler)