Showing preview only (2,414K chars total). Download the full file or copy to clipboard to get everything.
Repository: lukemelas/EfficientNet-PyTorch
Branch: master
Commit: 7e8b0d312162
Files: 31
Total size: 2.3 MB
Directory structure:
gitextract_b4i7h7bn/
├── .github/
│ └── workflows/
│ └── main.yml
├── .gitignore
├── LICENSE
├── README.md
├── efficientnet_pytorch/
│ ├── __init__.py
│ ├── model.py
│ └── utils.py
├── examples/
│ ├── imagenet/
│ │ ├── README.md
│ │ ├── data/
│ │ │ └── README.md
│ │ └── main.py
│ └── simple/
│ ├── check.ipynb
│ ├── example.ipynb
│ └── labels_map.txt
├── hubconf.py
├── setup.py
├── sotabench.py
├── sotabench_setup.sh
├── tests/
│ └── test_model.py
└── tf_to_pytorch/
├── README.md
└── convert_tf_to_pt/
├── download.sh
├── load_tf_weights.py
├── load_tf_weights_tf1.py
├── original_tf/
│ ├── __init__.py
│ ├── efficientnet_builder.py
│ ├── efficientnet_model.py
│ ├── eval_ckpt_main.py
│ ├── eval_ckpt_main_tf1.py
│ ├── preprocessing.py
│ └── utils.py
├── rename.sh
└── run.sh
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/workflows/main.yml
================================================
name: Workflow
on:
push:
branches:
- master
jobs:
pypi-job:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Install twine
run: pip install twine
- name: Build package
run: python setup.py sdist
- name: Publish a Python distribution to PyPI
uses: pypa/gh-action-pypi-publish@release/v1
with:
user: __token__
password: ${{ secrets.PYPI_API_TOKEN }}
================================================
FILE: .gitignore
================================================
# Custom
tmp
*.pkl
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
target/
# Jupyter Notebook
.ipynb_checkpoints
# pyenv
.python-version
# celery beat schedule file
celerybeat-schedule
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
.DS_STORE
# PyCharm
.idea*
*.xml
# Custom
tensorflow/
example/test*
*.pth*
examples/imagenet/data/
!examples/imagenet/data/README.md
tmp
tf_to_pytorch/pretrained_tensorflow
!tf_to_pytorch/pretrained_tensorflow/download.sh
examples/imagenet/run.sh
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: README.md
================================================
# EfficientNet PyTorch
### Quickstart
Install with `pip install efficientnet_pytorch` and load a pretrained EfficientNet with:
```python
from efficientnet_pytorch import EfficientNet
model = EfficientNet.from_pretrained('efficientnet-b0')
```
### Updates
#### Update (April 2, 2021)
The [EfficientNetV2 paper](https://arxiv.org/abs/2104.00298) has been released! I am working on implementing it as you read this :)
About EfficientNetV2:
> EfficientNetV2 is a new family of convolutional networks that have faster training speed and better parameter efficiency than previous models. To develop this family of models, we use a combination of training-aware neural architecture search and scaling, to jointly optimize training speed and parameter efficiency. The models were searched from the search space enriched with new ops such as Fused-MBConv.
Here is a comparison:
> <img src="https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnetv2-image.png" width="100%" />
#### Update (Aug 25, 2020)
This update adds:
* A new `include_top` (default: `True`) option ([#208](https://github.com/lukemelas/EfficientNet-PyTorch/pull/208))
* Continuous testing with [sotabench](https://sotabench.com/)
* Code quality improvements and fixes ([#215](https://github.com/lukemelas/EfficientNet-PyTorch/pull/215) [#223](https://github.com/lukemelas/EfficientNet-PyTorch/pull/223))
#### Update (May 14, 2020)
This update adds comprehensive comments and documentation (thanks to @workingcoder).
#### Update (January 23, 2020)
This update adds a new category of pre-trained model based on adversarial training, called _advprop_. It is important to note that the preprocessing required for the advprop pretrained models is slightly different from normal ImageNet preprocessing. As a result, by default, advprop models are not used. To load a model with advprop, use:
```python
model = EfficientNet.from_pretrained("efficientnet-b0", advprop=True)
```
There is also a new, large `efficientnet-b8` pretrained model that is only available in advprop form. When using these models, replace ImageNet preprocessing code as follows:
```python
if advprop: # for models using advprop pretrained weights
normalize = transforms.Lambda(lambda img: img * 2.0 - 1.0)
else:
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
```
This update also addresses multiple other issues ([#115](https://github.com/lukemelas/EfficientNet-PyTorch/issues/115), [#128](https://github.com/lukemelas/EfficientNet-PyTorch/issues/128)).
#### Update (October 15, 2019)
This update allows you to choose whether to use a memory-efficient Swish activation. The memory-efficient version is chosen by default, but it cannot be used when exporting using PyTorch JIT. For this purpose, we have also included a standard (export-friendly) swish activation function. To switch to the export-friendly version, simply call `model.set_swish(memory_efficient=False)` after loading your desired model. This update addresses issues [#88](https://github.com/lukemelas/EfficientNet-PyTorch/pull/88) and [#89](https://github.com/lukemelas/EfficientNet-PyTorch/pull/89).
#### Update (October 12, 2019)
This update makes the Swish activation function more memory-efficient. It also addresses pull requests [#72](https://github.com/lukemelas/EfficientNet-PyTorch/pull/72), [#73](https://github.com/lukemelas/EfficientNet-PyTorch/pull/73), [#85](https://github.com/lukemelas/EfficientNet-PyTorch/pull/85), and [#86](https://github.com/lukemelas/EfficientNet-PyTorch/pull/86). Thanks to the authors of all the pull requests!
#### Update (July 31, 2019)
_Upgrade the pip package with_ `pip install --upgrade efficientnet-pytorch`
The B6 and B7 models are now available. Additionally, _all_ pretrained models have been updated to use AutoAugment preprocessing, which translates to better performance across the board. Usage is the same as before:
```python
from efficientnet_pytorch import EfficientNet
model = EfficientNet.from_pretrained('efficientnet-b7')
```
#### Update (June 29, 2019)
This update adds easy model exporting ([#20](https://github.com/lukemelas/EfficientNet-PyTorch/issues/20)) and feature extraction ([#38](https://github.com/lukemelas/EfficientNet-PyTorch/issues/38)).
* [Example: Export to ONNX](#example-export)
* [Example: Extract features](#example-feature-extraction)
* Also: fixed a CUDA/CPU bug ([#32](https://github.com/lukemelas/EfficientNet-PyTorch/issues/32))
It is also now incredibly simple to load a pretrained model with a new number of classes for transfer learning:
```python
model = EfficientNet.from_pretrained('efficientnet-b1', num_classes=23)
```
#### Update (June 23, 2019)
The B4 and B5 models are now available. Their usage is identical to the other models:
```python
from efficientnet_pytorch import EfficientNet
model = EfficientNet.from_pretrained('efficientnet-b4')
```
### Overview
This repository contains an op-for-op PyTorch reimplementation of [EfficientNet](https://arxiv.org/abs/1905.11946), along with pre-trained models and examples.
The goal of this implementation is to be simple, highly extensible, and easy to integrate into your own projects. This implementation is a work in progress -- new features are currently being implemented.
At the moment, you can easily:
* Load pretrained EfficientNet models
* Use EfficientNet models for classification or feature extraction
* Evaluate EfficientNet models on ImageNet or your own images
_Upcoming features_: In the next few days, you will be able to:
* Train new models from scratch on ImageNet with a simple command
* Quickly finetune an EfficientNet on your own dataset
* Export EfficientNet models for production
### Table of contents
1. [About EfficientNet](#about-efficientnet)
2. [About EfficientNet-PyTorch](#about-efficientnet-pytorch)
3. [Installation](#installation)
4. [Usage](#usage)
* [Load pretrained models](#loading-pretrained-models)
* [Example: Classify](#example-classification)
* [Example: Extract features](#example-feature-extraction)
* [Example: Export to ONNX](#example-export)
6. [Contributing](#contributing)
### About EfficientNet
If you're new to EfficientNets, here is an explanation straight from the official TensorFlow implementation:
EfficientNets are a family of image classification models, which achieve state-of-the-art accuracy, yet being an order-of-magnitude smaller and faster than previous models. We develop EfficientNets based on AutoML and Compound Scaling. In particular, we first use [AutoML Mobile framework](https://ai.googleblog.com/2018/08/mnasnet-towards-automating-design-of.html) to develop a mobile-size baseline network, named as EfficientNet-B0; Then, we use the compound scaling method to scale up this baseline to obtain EfficientNet-B1 to B7.
<table border="0">
<tr>
<td>
<img src="https://raw.githubusercontent.com/tensorflow/tpu/master/models/official/efficientnet/g3doc/params.png" width="100%" />
</td>
<td>
<img src="https://raw.githubusercontent.com/tensorflow/tpu/master/models/official/efficientnet/g3doc/flops.png", width="90%" />
</td>
</tr>
</table>
EfficientNets achieve state-of-the-art accuracy on ImageNet with an order of magnitude better efficiency:
* In high-accuracy regime, our EfficientNet-B7 achieves state-of-the-art 84.4% top-1 / 97.1% top-5 accuracy on ImageNet with 66M parameters and 37B FLOPS, being 8.4x smaller and 6.1x faster on CPU inference than previous best [Gpipe](https://arxiv.org/abs/1811.06965).
* In middle-accuracy regime, our EfficientNet-B1 is 7.6x smaller and 5.7x faster on CPU inference than [ResNet-152](https://arxiv.org/abs/1512.03385), with similar ImageNet accuracy.
* Compared with the widely used [ResNet-50](https://arxiv.org/abs/1512.03385), our EfficientNet-B4 improves the top-1 accuracy from 76.3% of ResNet-50 to 82.6% (+6.3%), under similar FLOPS constraint.
### About EfficientNet PyTorch
EfficientNet PyTorch is a PyTorch re-implementation of EfficientNet. It is consistent with the [original TensorFlow implementation](https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet), such that it is easy to load weights from a TensorFlow checkpoint. At the same time, we aim to make our PyTorch implementation as simple, flexible, and extensible as possible.
If you have any feature requests or questions, feel free to leave them as GitHub issues!
### Installation
Install via pip:
```bash
pip install efficientnet_pytorch
```
Or install from source:
```bash
git clone https://github.com/lukemelas/EfficientNet-PyTorch
cd EfficientNet-Pytorch
pip install -e .
```
### Usage
#### Loading pretrained models
Load an EfficientNet:
```python
from efficientnet_pytorch import EfficientNet
model = EfficientNet.from_name('efficientnet-b0')
```
Load a pretrained EfficientNet:
```python
from efficientnet_pytorch import EfficientNet
model = EfficientNet.from_pretrained('efficientnet-b0')
```
Details about the models are below:
| *Name* |*# Params*|*Top-1 Acc.*|*Pretrained?*|
|:-----------------:|:--------:|:----------:|:-----------:|
| `efficientnet-b0` | 5.3M | 76.3 | ✓ |
| `efficientnet-b1` | 7.8M | 78.8 | ✓ |
| `efficientnet-b2` | 9.2M | 79.8 | ✓ |
| `efficientnet-b3` | 12M | 81.1 | ✓ |
| `efficientnet-b4` | 19M | 82.6 | ✓ |
| `efficientnet-b5` | 30M | 83.3 | ✓ |
| `efficientnet-b6` | 43M | 84.0 | ✓ |
| `efficientnet-b7` | 66M | 84.4 | ✓ |
#### Example: Classification
Below is a simple, complete example. It may also be found as a jupyter notebook in `examples/simple` or as a [Colab Notebook](https://colab.research.google.com/drive/1Jw28xZ1NJq4Cja4jLe6tJ6_F5lCzElb4).
We assume that in your current directory, there is a `img.jpg` file and a `labels_map.txt` file (ImageNet class names). These are both included in `examples/simple`.
```python
import json
from PIL import Image
import torch
from torchvision import transforms
from efficientnet_pytorch import EfficientNet
model = EfficientNet.from_pretrained('efficientnet-b0')
# Preprocess image
tfms = transforms.Compose([transforms.Resize(224), transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),])
img = tfms(Image.open('img.jpg')).unsqueeze(0)
print(img.shape) # torch.Size([1, 3, 224, 224])
# Load ImageNet class names
labels_map = json.load(open('labels_map.txt'))
labels_map = [labels_map[str(i)] for i in range(1000)]
# Classify
model.eval()
with torch.no_grad():
outputs = model(img)
# Print predictions
print('-----')
for idx in torch.topk(outputs, k=5).indices.squeeze(0).tolist():
prob = torch.softmax(outputs, dim=1)[0, idx].item()
print('{label:<75} ({p:.2f}%)'.format(label=labels_map[idx], p=prob*100))
```
#### Example: Feature Extraction
You can easily extract features with `model.extract_features`:
```python
from efficientnet_pytorch import EfficientNet
model = EfficientNet.from_pretrained('efficientnet-b0')
# ... image preprocessing as in the classification example ...
print(img.shape) # torch.Size([1, 3, 224, 224])
features = model.extract_features(img)
print(features.shape) # torch.Size([1, 1280, 7, 7])
```
#### Example: Export to ONNX
Exporting to ONNX for deploying to production is now simple:
```python
import torch
from efficientnet_pytorch import EfficientNet
model = EfficientNet.from_pretrained('efficientnet-b1')
dummy_input = torch.randn(10, 3, 240, 240)
model.set_swish(memory_efficient=False)
torch.onnx.export(model, dummy_input, "test-b1.onnx", verbose=True)
```
[Here](https://colab.research.google.com/drive/1rOAEXeXHaA8uo3aG2YcFDHItlRJMV0VP) is a Colab example.
#### ImageNet
See `examples/imagenet` for details about evaluating on ImageNet.
### Contributing
If you find a bug, create a GitHub issue, or even better, submit a pull request. Similarly, if you have questions, simply post them as GitHub issues.
I look forward to seeing what the community does with these models!
================================================
FILE: efficientnet_pytorch/__init__.py
================================================
__version__ = "0.7.1"
from .model import EfficientNet, VALID_MODELS
from .utils import (
GlobalParams,
BlockArgs,
BlockDecoder,
efficientnet,
get_model_params,
)
================================================
FILE: efficientnet_pytorch/model.py
================================================
"""model.py - Model and module class for EfficientNet.
They are built to mirror those in the official TensorFlow implementation.
"""
# Author: lukemelas (github username)
# Github repo: https://github.com/lukemelas/EfficientNet-PyTorch
# With adjustments and added comments by workingcoder (github username).
import torch
from torch import nn
from torch.nn import functional as F
from .utils import (
round_filters,
round_repeats,
drop_connect,
get_same_padding_conv2d,
get_model_params,
efficientnet_params,
load_pretrained_weights,
Swish,
MemoryEfficientSwish,
calculate_output_image_size
)
VALID_MODELS = (
'efficientnet-b0', 'efficientnet-b1', 'efficientnet-b2', 'efficientnet-b3',
'efficientnet-b4', 'efficientnet-b5', 'efficientnet-b6', 'efficientnet-b7',
'efficientnet-b8',
# Support the construction of 'efficientnet-l2' without pretrained weights
'efficientnet-l2'
)
class MBConvBlock(nn.Module):
"""Mobile Inverted Residual Bottleneck Block.
Args:
block_args (namedtuple): BlockArgs, defined in utils.py.
global_params (namedtuple): GlobalParam, defined in utils.py.
image_size (tuple or list): [image_height, image_width].
References:
[1] https://arxiv.org/abs/1704.04861 (MobileNet v1)
[2] https://arxiv.org/abs/1801.04381 (MobileNet v2)
[3] https://arxiv.org/abs/1905.02244 (MobileNet v3)
"""
def __init__(self, block_args, global_params, image_size=None):
super().__init__()
self._block_args = block_args
self._bn_mom = 1 - global_params.batch_norm_momentum # pytorch's difference from tensorflow
self._bn_eps = global_params.batch_norm_epsilon
self.has_se = (self._block_args.se_ratio is not None) and (0 < self._block_args.se_ratio <= 1)
self.id_skip = block_args.id_skip # whether to use skip connection and drop connect
# Expansion phase (Inverted Bottleneck)
inp = self._block_args.input_filters # number of input channels
oup = self._block_args.input_filters * self._block_args.expand_ratio # number of output channels
if self._block_args.expand_ratio != 1:
Conv2d = get_same_padding_conv2d(image_size=image_size)
self._expand_conv = Conv2d(in_channels=inp, out_channels=oup, kernel_size=1, bias=False)
self._bn0 = nn.BatchNorm2d(num_features=oup, momentum=self._bn_mom, eps=self._bn_eps)
# image_size = calculate_output_image_size(image_size, 1) <-- this wouldn't modify image_size
# Depthwise convolution phase
k = self._block_args.kernel_size
s = self._block_args.stride
Conv2d = get_same_padding_conv2d(image_size=image_size)
self._depthwise_conv = Conv2d(
in_channels=oup, out_channels=oup, groups=oup, # groups makes it depthwise
kernel_size=k, stride=s, bias=False)
self._bn1 = nn.BatchNorm2d(num_features=oup, momentum=self._bn_mom, eps=self._bn_eps)
image_size = calculate_output_image_size(image_size, s)
# Squeeze and Excitation layer, if desired
if self.has_se:
Conv2d = get_same_padding_conv2d(image_size=(1, 1))
num_squeezed_channels = max(1, int(self._block_args.input_filters * self._block_args.se_ratio))
self._se_reduce = Conv2d(in_channels=oup, out_channels=num_squeezed_channels, kernel_size=1)
self._se_expand = Conv2d(in_channels=num_squeezed_channels, out_channels=oup, kernel_size=1)
# Pointwise convolution phase
final_oup = self._block_args.output_filters
Conv2d = get_same_padding_conv2d(image_size=image_size)
self._project_conv = Conv2d(in_channels=oup, out_channels=final_oup, kernel_size=1, bias=False)
self._bn2 = nn.BatchNorm2d(num_features=final_oup, momentum=self._bn_mom, eps=self._bn_eps)
self._swish = MemoryEfficientSwish()
def forward(self, inputs, drop_connect_rate=None):
"""MBConvBlock's forward function.
Args:
inputs (tensor): Input tensor.
drop_connect_rate (bool): Drop connect rate (float, between 0 and 1).
Returns:
Output of this block after processing.
"""
# Expansion and Depthwise Convolution
x = inputs
if self._block_args.expand_ratio != 1:
x = self._expand_conv(inputs)
x = self._bn0(x)
x = self._swish(x)
x = self._depthwise_conv(x)
x = self._bn1(x)
x = self._swish(x)
# Squeeze and Excitation
if self.has_se:
x_squeezed = F.adaptive_avg_pool2d(x, 1)
x_squeezed = self._se_reduce(x_squeezed)
x_squeezed = self._swish(x_squeezed)
x_squeezed = self._se_expand(x_squeezed)
x = torch.sigmoid(x_squeezed) * x
# Pointwise Convolution
x = self._project_conv(x)
x = self._bn2(x)
# Skip connection and drop connect
input_filters, output_filters = self._block_args.input_filters, self._block_args.output_filters
if self.id_skip and self._block_args.stride == 1 and input_filters == output_filters:
# The combination of skip connection and drop connect brings about stochastic depth.
if drop_connect_rate:
x = drop_connect(x, p=drop_connect_rate, training=self.training)
x = x + inputs # skip connection
return x
def set_swish(self, memory_efficient=True):
"""Sets swish function as memory efficient (for training) or standard (for export).
Args:
memory_efficient (bool): Whether to use memory-efficient version of swish.
"""
self._swish = MemoryEfficientSwish() if memory_efficient else Swish()
class EfficientNet(nn.Module):
"""EfficientNet model.
Most easily loaded with the .from_name or .from_pretrained methods.
Args:
blocks_args (list[namedtuple]): A list of BlockArgs to construct blocks.
global_params (namedtuple): A set of GlobalParams shared between blocks.
References:
[1] https://arxiv.org/abs/1905.11946 (EfficientNet)
Example:
>>> import torch
>>> from efficientnet.model import EfficientNet
>>> inputs = torch.rand(1, 3, 224, 224)
>>> model = EfficientNet.from_pretrained('efficientnet-b0')
>>> model.eval()
>>> outputs = model(inputs)
"""
def __init__(self, blocks_args=None, global_params=None):
super().__init__()
assert isinstance(blocks_args, list), 'blocks_args should be a list'
assert len(blocks_args) > 0, 'block args must be greater than 0'
self._global_params = global_params
self._blocks_args = blocks_args
# Batch norm parameters
bn_mom = 1 - self._global_params.batch_norm_momentum
bn_eps = self._global_params.batch_norm_epsilon
# Get stem static or dynamic convolution depending on image size
image_size = global_params.image_size
Conv2d = get_same_padding_conv2d(image_size=image_size)
# Stem
in_channels = 3 # rgb
out_channels = round_filters(32, self._global_params) # number of output channels
self._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False)
self._bn0 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps)
image_size = calculate_output_image_size(image_size, 2)
# Build blocks
self._blocks = nn.ModuleList([])
for block_args in self._blocks_args:
# Update block input and output filters based on depth multiplier.
block_args = block_args._replace(
input_filters=round_filters(block_args.input_filters, self._global_params),
output_filters=round_filters(block_args.output_filters, self._global_params),
num_repeat=round_repeats(block_args.num_repeat, self._global_params)
)
# The first block needs to take care of stride and filter size increase.
self._blocks.append(MBConvBlock(block_args, self._global_params, image_size=image_size))
image_size = calculate_output_image_size(image_size, block_args.stride)
if block_args.num_repeat > 1: # modify block_args to keep same output size
block_args = block_args._replace(input_filters=block_args.output_filters, stride=1)
for _ in range(block_args.num_repeat - 1):
self._blocks.append(MBConvBlock(block_args, self._global_params, image_size=image_size))
# image_size = calculate_output_image_size(image_size, block_args.stride) # stride = 1
# Head
in_channels = block_args.output_filters # output of final block
out_channels = round_filters(1280, self._global_params)
Conv2d = get_same_padding_conv2d(image_size=image_size)
self._conv_head = Conv2d(in_channels, out_channels, kernel_size=1, bias=False)
self._bn1 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps)
# Final linear layer
self._avg_pooling = nn.AdaptiveAvgPool2d(1)
if self._global_params.include_top:
self._dropout = nn.Dropout(self._global_params.dropout_rate)
self._fc = nn.Linear(out_channels, self._global_params.num_classes)
# set activation to memory efficient swish by default
self._swish = MemoryEfficientSwish()
def set_swish(self, memory_efficient=True):
"""Sets swish function as memory efficient (for training) or standard (for export).
Args:
memory_efficient (bool): Whether to use memory-efficient version of swish.
"""
self._swish = MemoryEfficientSwish() if memory_efficient else Swish()
for block in self._blocks:
block.set_swish(memory_efficient)
def extract_endpoints(self, inputs):
"""Use convolution layer to extract features
from reduction levels i in [1, 2, 3, 4, 5].
Args:
inputs (tensor): Input tensor.
Returns:
Dictionary of last intermediate features
with reduction levels i in [1, 2, 3, 4, 5].
Example:
>>> import torch
>>> from efficientnet.model import EfficientNet
>>> inputs = torch.rand(1, 3, 224, 224)
>>> model = EfficientNet.from_pretrained('efficientnet-b0')
>>> endpoints = model.extract_endpoints(inputs)
>>> print(endpoints['reduction_1'].shape) # torch.Size([1, 16, 112, 112])
>>> print(endpoints['reduction_2'].shape) # torch.Size([1, 24, 56, 56])
>>> print(endpoints['reduction_3'].shape) # torch.Size([1, 40, 28, 28])
>>> print(endpoints['reduction_4'].shape) # torch.Size([1, 112, 14, 14])
>>> print(endpoints['reduction_5'].shape) # torch.Size([1, 320, 7, 7])
>>> print(endpoints['reduction_6'].shape) # torch.Size([1, 1280, 7, 7])
"""
endpoints = dict()
# Stem
x = self._swish(self._bn0(self._conv_stem(inputs)))
prev_x = x
# Blocks
for idx, block in enumerate(self._blocks):
drop_connect_rate = self._global_params.drop_connect_rate
if drop_connect_rate:
drop_connect_rate *= float(idx) / len(self._blocks) # scale drop connect_rate
x = block(x, drop_connect_rate=drop_connect_rate)
if prev_x.size(2) > x.size(2):
endpoints['reduction_{}'.format(len(endpoints) + 1)] = prev_x
elif idx == len(self._blocks) - 1:
endpoints['reduction_{}'.format(len(endpoints) + 1)] = x
prev_x = x
# Head
x = self._swish(self._bn1(self._conv_head(x)))
endpoints['reduction_{}'.format(len(endpoints) + 1)] = x
return endpoints
def extract_features(self, inputs):
"""use convolution layer to extract feature .
Args:
inputs (tensor): Input tensor.
Returns:
Output of the final convolution
layer in the efficientnet model.
"""
# Stem
x = self._swish(self._bn0(self._conv_stem(inputs)))
# Blocks
for idx, block in enumerate(self._blocks):
drop_connect_rate = self._global_params.drop_connect_rate
if drop_connect_rate:
drop_connect_rate *= float(idx) / len(self._blocks) # scale drop connect_rate
x = block(x, drop_connect_rate=drop_connect_rate)
# Head
x = self._swish(self._bn1(self._conv_head(x)))
return x
def forward(self, inputs):
"""EfficientNet's forward function.
Calls extract_features to extract features, applies final linear layer, and returns logits.
Args:
inputs (tensor): Input tensor.
Returns:
Output of this model after processing.
"""
# Convolution layers
x = self.extract_features(inputs)
# Pooling and final linear layer
x = self._avg_pooling(x)
if self._global_params.include_top:
x = x.flatten(start_dim=1)
x = self._dropout(x)
x = self._fc(x)
return x
@classmethod
def from_name(cls, model_name, in_channels=3, **override_params):
"""Create an efficientnet model according to name.
Args:
model_name (str): Name for efficientnet.
in_channels (int): Input data's channel number.
override_params (other key word params):
Params to override model's global_params.
Optional key:
'width_coefficient', 'depth_coefficient',
'image_size', 'dropout_rate',
'num_classes', 'batch_norm_momentum',
'batch_norm_epsilon', 'drop_connect_rate',
'depth_divisor', 'min_depth'
Returns:
An efficientnet model.
"""
cls._check_model_name_is_valid(model_name)
blocks_args, global_params = get_model_params(model_name, override_params)
model = cls(blocks_args, global_params)
model._change_in_channels(in_channels)
return model
@classmethod
def from_pretrained(cls, model_name, weights_path=None, advprop=False,
in_channels=3, num_classes=1000, **override_params):
"""Create an efficientnet model according to name.
Args:
model_name (str): Name for efficientnet.
weights_path (None or str):
str: path to pretrained weights file on the local disk.
None: use pretrained weights downloaded from the Internet.
advprop (bool):
Whether to load pretrained weights
trained with advprop (valid when weights_path is None).
in_channels (int): Input data's channel number.
num_classes (int):
Number of categories for classification.
It controls the output size for final linear layer.
override_params (other key word params):
Params to override model's global_params.
Optional key:
'width_coefficient', 'depth_coefficient',
'image_size', 'dropout_rate',
'batch_norm_momentum',
'batch_norm_epsilon', 'drop_connect_rate',
'depth_divisor', 'min_depth'
Returns:
A pretrained efficientnet model.
"""
model = cls.from_name(model_name, num_classes=num_classes, **override_params)
load_pretrained_weights(model, model_name, weights_path=weights_path,
load_fc=(num_classes == 1000), advprop=advprop)
model._change_in_channels(in_channels)
return model
@classmethod
def get_image_size(cls, model_name):
"""Get the input image size for a given efficientnet model.
Args:
model_name (str): Name for efficientnet.
Returns:
Input image size (resolution).
"""
cls._check_model_name_is_valid(model_name)
_, _, res, _ = efficientnet_params(model_name)
return res
@classmethod
def _check_model_name_is_valid(cls, model_name):
"""Validates model name.
Args:
model_name (str): Name for efficientnet.
Returns:
bool: Is a valid name or not.
"""
if model_name not in VALID_MODELS:
raise ValueError('model_name should be one of: ' + ', '.join(VALID_MODELS))
def _change_in_channels(self, in_channels):
"""Adjust model's first convolution layer to in_channels, if in_channels not equals 3.
Args:
in_channels (int): Input data's channel number.
"""
if in_channels != 3:
Conv2d = get_same_padding_conv2d(image_size=self._global_params.image_size)
out_channels = round_filters(32, self._global_params)
self._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False)
================================================
FILE: efficientnet_pytorch/utils.py
================================================
"""utils.py - Helper functions for building the model and for loading model parameters.
These helper functions are built to mirror those in the official TensorFlow implementation.
"""
# Author: lukemelas (github username)
# Github repo: https://github.com/lukemelas/EfficientNet-PyTorch
# With adjustments and added comments by workingcoder (github username).
import re
import math
import collections
from functools import partial
import torch
from torch import nn
from torch.nn import functional as F
from torch.utils import model_zoo
################################################################################
# Help functions for model architecture
################################################################################
# GlobalParams and BlockArgs: Two namedtuples
# Swish and MemoryEfficientSwish: Two implementations of the method
# round_filters and round_repeats:
# Functions to calculate params for scaling model width and depth ! ! !
# get_width_and_height_from_size and calculate_output_image_size
# drop_connect: A structural design
# get_same_padding_conv2d:
# Conv2dDynamicSamePadding
# Conv2dStaticSamePadding
# get_same_padding_maxPool2d:
# MaxPool2dDynamicSamePadding
# MaxPool2dStaticSamePadding
# It's an additional function, not used in EfficientNet,
# but can be used in other model (such as EfficientDet).
# Parameters for the entire model (stem, all blocks, and head)
GlobalParams = collections.namedtuple('GlobalParams', [
'width_coefficient', 'depth_coefficient', 'image_size', 'dropout_rate',
'num_classes', 'batch_norm_momentum', 'batch_norm_epsilon',
'drop_connect_rate', 'depth_divisor', 'min_depth', 'include_top'])
# Parameters for an individual model block
BlockArgs = collections.namedtuple('BlockArgs', [
'num_repeat', 'kernel_size', 'stride', 'expand_ratio',
'input_filters', 'output_filters', 'se_ratio', 'id_skip'])
# Set GlobalParams and BlockArgs's defaults
GlobalParams.__new__.__defaults__ = (None,) * len(GlobalParams._fields)
BlockArgs.__new__.__defaults__ = (None,) * len(BlockArgs._fields)
# Swish activation function
if hasattr(nn, 'SiLU'):
Swish = nn.SiLU
else:
# For compatibility with old PyTorch versions
class Swish(nn.Module):
def forward(self, x):
return x * torch.sigmoid(x)
# A memory-efficient implementation of Swish function
class SwishImplementation(torch.autograd.Function):
@staticmethod
def forward(ctx, i):
result = i * torch.sigmoid(i)
ctx.save_for_backward(i)
return result
@staticmethod
def backward(ctx, grad_output):
i = ctx.saved_tensors[0]
sigmoid_i = torch.sigmoid(i)
return grad_output * (sigmoid_i * (1 + i * (1 - sigmoid_i)))
class MemoryEfficientSwish(nn.Module):
def forward(self, x):
return SwishImplementation.apply(x)
def round_filters(filters, global_params):
"""Calculate and round number of filters based on width multiplier.
Use width_coefficient, depth_divisor and min_depth of global_params.
Args:
filters (int): Filters number to be calculated.
global_params (namedtuple): Global params of the model.
Returns:
new_filters: New filters number after calculating.
"""
multiplier = global_params.width_coefficient
if not multiplier:
return filters
# TODO: modify the params names.
# maybe the names (width_divisor,min_width)
# are more suitable than (depth_divisor,min_depth).
divisor = global_params.depth_divisor
min_depth = global_params.min_depth
filters *= multiplier
min_depth = min_depth or divisor # pay attention to this line when using min_depth
# follow the formula transferred from official TensorFlow implementation
new_filters = max(min_depth, int(filters + divisor / 2) // divisor * divisor)
if new_filters < 0.9 * filters: # prevent rounding by more than 10%
new_filters += divisor
return int(new_filters)
def round_repeats(repeats, global_params):
"""Calculate module's repeat number of a block based on depth multiplier.
Use depth_coefficient of global_params.
Args:
repeats (int): num_repeat to be calculated.
global_params (namedtuple): Global params of the model.
Returns:
new repeat: New repeat number after calculating.
"""
multiplier = global_params.depth_coefficient
if not multiplier:
return repeats
# follow the formula transferred from official TensorFlow implementation
return int(math.ceil(multiplier * repeats))
def drop_connect(inputs, p, training):
"""Drop connect.
Args:
input (tensor: BCWH): Input of this structure.
p (float: 0.0~1.0): Probability of drop connection.
training (bool): The running mode.
Returns:
output: Output after drop connection.
"""
assert 0 <= p <= 1, 'p must be in range of [0,1]'
if not training:
return inputs
batch_size = inputs.shape[0]
keep_prob = 1 - p
# generate binary_tensor mask according to probability (p for 0, 1-p for 1)
random_tensor = keep_prob
random_tensor += torch.rand([batch_size, 1, 1, 1], dtype=inputs.dtype, device=inputs.device)
binary_tensor = torch.floor(random_tensor)
output = inputs / keep_prob * binary_tensor
return output
def get_width_and_height_from_size(x):
"""Obtain height and width from x.
Args:
x (int, tuple or list): Data size.
Returns:
size: A tuple or list (H,W).
"""
if isinstance(x, int):
return x, x
if isinstance(x, list) or isinstance(x, tuple):
return x
else:
raise TypeError()
def calculate_output_image_size(input_image_size, stride):
"""Calculates the output image size when using Conv2dSamePadding with a stride.
Necessary for static padding. Thanks to mannatsingh for pointing this out.
Args:
input_image_size (int, tuple or list): Size of input image.
stride (int, tuple or list): Conv2d operation's stride.
Returns:
output_image_size: A list [H,W].
"""
if input_image_size is None:
return None
image_height, image_width = get_width_and_height_from_size(input_image_size)
stride = stride if isinstance(stride, int) else stride[0]
image_height = int(math.ceil(image_height / stride))
image_width = int(math.ceil(image_width / stride))
return [image_height, image_width]
# Note:
# The following 'SamePadding' functions make output size equal ceil(input size/stride).
# Only when stride equals 1, can the output size be the same as input size.
# Don't be confused by their function names ! ! !
def get_same_padding_conv2d(image_size=None):
"""Chooses static padding if you have specified an image size, and dynamic padding otherwise.
Static padding is necessary for ONNX exporting of models.
Args:
image_size (int or tuple): Size of the image.
Returns:
Conv2dDynamicSamePadding or Conv2dStaticSamePadding.
"""
if image_size is None:
return Conv2dDynamicSamePadding
else:
return partial(Conv2dStaticSamePadding, image_size=image_size)
class Conv2dDynamicSamePadding(nn.Conv2d):
"""2D Convolutions like TensorFlow, for a dynamic image size.
The padding is operated in forward function by calculating dynamically.
"""
# Tips for 'SAME' mode padding.
# Given the following:
# i: width or height
# s: stride
# k: kernel size
# d: dilation
# p: padding
# Output after Conv2d:
# o = floor((i+p-((k-1)*d+1))/s+1)
# If o equals i, i = floor((i+p-((k-1)*d+1))/s+1),
# => p = (i-1)*s+((k-1)*d+1)-i
def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, groups=1, bias=True):
super().__init__(in_channels, out_channels, kernel_size, stride, 0, dilation, groups, bias)
self.stride = self.stride if len(self.stride) == 2 else [self.stride[0]] * 2
def forward(self, x):
ih, iw = x.size()[-2:]
kh, kw = self.weight.size()[-2:]
sh, sw = self.stride
oh, ow = math.ceil(ih / sh), math.ceil(iw / sw) # change the output size according to stride ! ! !
pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0)
pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0)
if pad_h > 0 or pad_w > 0:
x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
return F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
class Conv2dStaticSamePadding(nn.Conv2d):
"""2D Convolutions like TensorFlow's 'SAME' mode, with the given input image size.
The padding mudule is calculated in construction function, then used in forward.
"""
# With the same calculation as Conv2dDynamicSamePadding
def __init__(self, in_channels, out_channels, kernel_size, stride=1, image_size=None, **kwargs):
super().__init__(in_channels, out_channels, kernel_size, stride, **kwargs)
self.stride = self.stride if len(self.stride) == 2 else [self.stride[0]] * 2
# Calculate padding based on image size and save it
assert image_size is not None
ih, iw = (image_size, image_size) if isinstance(image_size, int) else image_size
kh, kw = self.weight.size()[-2:]
sh, sw = self.stride
oh, ow = math.ceil(ih / sh), math.ceil(iw / sw)
pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0)
pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0)
if pad_h > 0 or pad_w > 0:
self.static_padding = nn.ZeroPad2d((pad_w // 2, pad_w - pad_w // 2,
pad_h // 2, pad_h - pad_h // 2))
else:
self.static_padding = nn.Identity()
def forward(self, x):
x = self.static_padding(x)
x = F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
return x
def get_same_padding_maxPool2d(image_size=None):
"""Chooses static padding if you have specified an image size, and dynamic padding otherwise.
Static padding is necessary for ONNX exporting of models.
Args:
image_size (int or tuple): Size of the image.
Returns:
MaxPool2dDynamicSamePadding or MaxPool2dStaticSamePadding.
"""
if image_size is None:
return MaxPool2dDynamicSamePadding
else:
return partial(MaxPool2dStaticSamePadding, image_size=image_size)
class MaxPool2dDynamicSamePadding(nn.MaxPool2d):
"""2D MaxPooling like TensorFlow's 'SAME' mode, with a dynamic image size.
The padding is operated in forward function by calculating dynamically.
"""
def __init__(self, kernel_size, stride, padding=0, dilation=1, return_indices=False, ceil_mode=False):
super().__init__(kernel_size, stride, padding, dilation, return_indices, ceil_mode)
self.stride = [self.stride] * 2 if isinstance(self.stride, int) else self.stride
self.kernel_size = [self.kernel_size] * 2 if isinstance(self.kernel_size, int) else self.kernel_size
self.dilation = [self.dilation] * 2 if isinstance(self.dilation, int) else self.dilation
def forward(self, x):
ih, iw = x.size()[-2:]
kh, kw = self.kernel_size
sh, sw = self.stride
oh, ow = math.ceil(ih / sh), math.ceil(iw / sw)
pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0)
pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0)
if pad_h > 0 or pad_w > 0:
x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
return F.max_pool2d(x, self.kernel_size, self.stride, self.padding,
self.dilation, self.ceil_mode, self.return_indices)
class MaxPool2dStaticSamePadding(nn.MaxPool2d):
"""2D MaxPooling like TensorFlow's 'SAME' mode, with the given input image size.
The padding mudule is calculated in construction function, then used in forward.
"""
def __init__(self, kernel_size, stride, image_size=None, **kwargs):
super().__init__(kernel_size, stride, **kwargs)
self.stride = [self.stride] * 2 if isinstance(self.stride, int) else self.stride
self.kernel_size = [self.kernel_size] * 2 if isinstance(self.kernel_size, int) else self.kernel_size
self.dilation = [self.dilation] * 2 if isinstance(self.dilation, int) else self.dilation
# Calculate padding based on image size and save it
assert image_size is not None
ih, iw = (image_size, image_size) if isinstance(image_size, int) else image_size
kh, kw = self.kernel_size
sh, sw = self.stride
oh, ow = math.ceil(ih / sh), math.ceil(iw / sw)
pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0)
pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0)
if pad_h > 0 or pad_w > 0:
self.static_padding = nn.ZeroPad2d((pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2))
else:
self.static_padding = nn.Identity()
def forward(self, x):
x = self.static_padding(x)
x = F.max_pool2d(x, self.kernel_size, self.stride, self.padding,
self.dilation, self.ceil_mode, self.return_indices)
return x
################################################################################
# Helper functions for loading model params
################################################################################
# BlockDecoder: A Class for encoding and decoding BlockArgs
# efficientnet_params: A function to query compound coefficient
# get_model_params and efficientnet:
# Functions to get BlockArgs and GlobalParams for efficientnet
# url_map and url_map_advprop: Dicts of url_map for pretrained weights
# load_pretrained_weights: A function to load pretrained weights
class BlockDecoder(object):
"""Block Decoder for readability,
straight from the official TensorFlow repository.
"""
@staticmethod
def _decode_block_string(block_string):
"""Get a block through a string notation of arguments.
Args:
block_string (str): A string notation of arguments.
Examples: 'r1_k3_s11_e1_i32_o16_se0.25_noskip'.
Returns:
BlockArgs: The namedtuple defined at the top of this file.
"""
assert isinstance(block_string, str)
ops = block_string.split('_')
options = {}
for op in ops:
splits = re.split(r'(\d.*)', op)
if len(splits) >= 2:
key, value = splits[:2]
options[key] = value
# Check stride
assert (('s' in options and len(options['s']) == 1) or
(len(options['s']) == 2 and options['s'][0] == options['s'][1]))
return BlockArgs(
num_repeat=int(options['r']),
kernel_size=int(options['k']),
stride=[int(options['s'][0])],
expand_ratio=int(options['e']),
input_filters=int(options['i']),
output_filters=int(options['o']),
se_ratio=float(options['se']) if 'se' in options else None,
id_skip=('noskip' not in block_string))
@staticmethod
def _encode_block_string(block):
"""Encode a block to a string.
Args:
block (namedtuple): A BlockArgs type argument.
Returns:
block_string: A String form of BlockArgs.
"""
args = [
'r%d' % block.num_repeat,
'k%d' % block.kernel_size,
's%d%d' % (block.strides[0], block.strides[1]),
'e%s' % block.expand_ratio,
'i%d' % block.input_filters,
'o%d' % block.output_filters
]
if 0 < block.se_ratio <= 1:
args.append('se%s' % block.se_ratio)
if block.id_skip is False:
args.append('noskip')
return '_'.join(args)
@staticmethod
def decode(string_list):
"""Decode a list of string notations to specify blocks inside the network.
Args:
string_list (list[str]): A list of strings, each string is a notation of block.
Returns:
blocks_args: A list of BlockArgs namedtuples of block args.
"""
assert isinstance(string_list, list)
blocks_args = []
for block_string in string_list:
blocks_args.append(BlockDecoder._decode_block_string(block_string))
return blocks_args
@staticmethod
def encode(blocks_args):
"""Encode a list of BlockArgs to a list of strings.
Args:
blocks_args (list[namedtuples]): A list of BlockArgs namedtuples of block args.
Returns:
block_strings: A list of strings, each string is a notation of block.
"""
block_strings = []
for block in blocks_args:
block_strings.append(BlockDecoder._encode_block_string(block))
return block_strings
def efficientnet_params(model_name):
"""Map EfficientNet model name to parameter coefficients.
Args:
model_name (str): Model name to be queried.
Returns:
params_dict[model_name]: A (width,depth,res,dropout) tuple.
"""
params_dict = {
# Coefficients: width,depth,res,dropout
'efficientnet-b0': (1.0, 1.0, 224, 0.2),
'efficientnet-b1': (1.0, 1.1, 240, 0.2),
'efficientnet-b2': (1.1, 1.2, 260, 0.3),
'efficientnet-b3': (1.2, 1.4, 300, 0.3),
'efficientnet-b4': (1.4, 1.8, 380, 0.4),
'efficientnet-b5': (1.6, 2.2, 456, 0.4),
'efficientnet-b6': (1.8, 2.6, 528, 0.5),
'efficientnet-b7': (2.0, 3.1, 600, 0.5),
'efficientnet-b8': (2.2, 3.6, 672, 0.5),
'efficientnet-l2': (4.3, 5.3, 800, 0.5),
}
return params_dict[model_name]
def efficientnet(width_coefficient=None, depth_coefficient=None, image_size=None,
dropout_rate=0.2, drop_connect_rate=0.2, num_classes=1000, include_top=True):
"""Create BlockArgs and GlobalParams for efficientnet model.
Args:
width_coefficient (float)
depth_coefficient (float)
image_size (int)
dropout_rate (float)
drop_connect_rate (float)
num_classes (int)
Meaning as the name suggests.
Returns:
blocks_args, global_params.
"""
# Blocks args for the whole model(efficientnet-b0 by default)
# It will be modified in the construction of EfficientNet Class according to model
blocks_args = [
'r1_k3_s11_e1_i32_o16_se0.25',
'r2_k3_s22_e6_i16_o24_se0.25',
'r2_k5_s22_e6_i24_o40_se0.25',
'r3_k3_s22_e6_i40_o80_se0.25',
'r3_k5_s11_e6_i80_o112_se0.25',
'r4_k5_s22_e6_i112_o192_se0.25',
'r1_k3_s11_e6_i192_o320_se0.25',
]
blocks_args = BlockDecoder.decode(blocks_args)
global_params = GlobalParams(
width_coefficient=width_coefficient,
depth_coefficient=depth_coefficient,
image_size=image_size,
dropout_rate=dropout_rate,
num_classes=num_classes,
batch_norm_momentum=0.99,
batch_norm_epsilon=1e-3,
drop_connect_rate=drop_connect_rate,
depth_divisor=8,
min_depth=None,
include_top=include_top,
)
return blocks_args, global_params
def get_model_params(model_name, override_params):
"""Get the block args and global params for a given model name.
Args:
model_name (str): Model's name.
override_params (dict): A dict to modify global_params.
Returns:
blocks_args, global_params
"""
if model_name.startswith('efficientnet'):
w, d, s, p = efficientnet_params(model_name)
# note: all models have drop connect rate = 0.2
blocks_args, global_params = efficientnet(
width_coefficient=w, depth_coefficient=d, dropout_rate=p, image_size=s)
else:
raise NotImplementedError('model name is not pre-defined: {}'.format(model_name))
if override_params:
# ValueError will be raised here if override_params has fields not included in global_params.
global_params = global_params._replace(**override_params)
return blocks_args, global_params
# train with Standard methods
# check more details in paper(EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks)
url_map = {
'efficientnet-b0': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b0-355c32eb.pth',
'efficientnet-b1': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b1-f1951068.pth',
'efficientnet-b2': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b2-8bb594d6.pth',
'efficientnet-b3': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b3-5fb5a3c3.pth',
'efficientnet-b4': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b4-6ed6700e.pth',
'efficientnet-b5': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b5-b6417697.pth',
'efficientnet-b6': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b6-c76e70fd.pth',
'efficientnet-b7': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b7-dcc49843.pth',
}
# train with Adversarial Examples(AdvProp)
# check more details in paper(Adversarial Examples Improve Image Recognition)
url_map_advprop = {
'efficientnet-b0': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b0-b64d5a18.pth',
'efficientnet-b1': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b1-0f3ce85a.pth',
'efficientnet-b2': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b2-6e9d97e5.pth',
'efficientnet-b3': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b3-cdd7c0f4.pth',
'efficientnet-b4': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b4-44fb3a87.pth',
'efficientnet-b5': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b5-86493f6b.pth',
'efficientnet-b6': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b6-ac80338e.pth',
'efficientnet-b7': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b7-4652b6dd.pth',
'efficientnet-b8': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b8-22a8fe65.pth',
}
# TODO: add the petrained weights url map of 'efficientnet-l2'
def load_pretrained_weights(model, model_name, weights_path=None, load_fc=True, advprop=False, verbose=True):
"""Loads pretrained weights from weights path or download using url.
Args:
model (Module): The whole model of efficientnet.
model_name (str): Model name of efficientnet.
weights_path (None or str):
str: path to pretrained weights file on the local disk.
None: use pretrained weights downloaded from the Internet.
load_fc (bool): Whether to load pretrained weights for fc layer at the end of the model.
advprop (bool): Whether to load pretrained weights
trained with advprop (valid when weights_path is None).
"""
if isinstance(weights_path, str):
state_dict = torch.load(weights_path)
else:
# AutoAugment or Advprop (different preprocessing)
url_map_ = url_map_advprop if advprop else url_map
state_dict = model_zoo.load_url(url_map_[model_name])
if load_fc:
ret = model.load_state_dict(state_dict, strict=False)
assert not ret.missing_keys, 'Missing keys when loading pretrained weights: {}'.format(ret.missing_keys)
else:
state_dict.pop('_fc.weight')
state_dict.pop('_fc.bias')
ret = model.load_state_dict(state_dict, strict=False)
assert set(ret.missing_keys) == set(
['_fc.weight', '_fc.bias']), 'Missing keys when loading pretrained weights: {}'.format(ret.missing_keys)
assert not ret.unexpected_keys, 'Missing keys when loading pretrained weights: {}'.format(ret.unexpected_keys)
if verbose:
print('Loaded pretrained weights for {}'.format(model_name))
================================================
FILE: examples/imagenet/README.md
================================================
### Imagenet
This is a preliminary directory for evaluating the model on ImageNet. It is adapted from the standard PyTorch Imagenet script.
For now, only evaluation is supported, but I am currently building scripts to assist with training new models on Imagenet.
The evaluation results are slightly different from the original TensorFlow repository, due to differences in data preprocessing. For example, with the current preprocessing, `efficientnet-b3` gives a top-1 accuracy of `80.8`, rather than `81.1` in the paper. I am working on porting the TensorFlow preprocessing into PyTorch to address this issue.
To run on Imagenet, place your `train` and `val` directories in `data`.
Example commands:
```bash
# Evaluate small EfficientNet on CPU
python main.py data -e -a 'efficientnet-b0' --pretrained
```
```bash
# Evaluate medium EfficientNet on GPU
python main.py data -e -a 'efficientnet-b3' --pretrained --gpu 0 --batch-size 128
```
```bash
# Evaluate ResNet-50 for comparison
python main.py data -e -a 'resnet50' --pretrained --gpu 0
```
================================================
FILE: examples/imagenet/data/README.md
================================================
### ImageNet
Download ImageNet and place it into `train` and `val` folders here.
More details may be found with the official PyTorch ImageNet example [here](https://github.com/pytorch/examples/blob/master/imagenet).
================================================
FILE: examples/imagenet/main.py
================================================
"""
Evaluate on ImageNet. Note that at the moment, training is not implemented (I am working on it).
that being said, evaluation is working.
"""
import argparse
import os
import random
import shutil
import time
import warnings
import PIL
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.optim
import torch.multiprocessing as mp
import torch.utils.data
import torch.utils.data.distributed
import torchvision.transforms as transforms
import torchvision.datasets as datasets
import torchvision.models as models
from efficientnet_pytorch import EfficientNet
parser = argparse.ArgumentParser(description='PyTorch ImageNet Training')
parser.add_argument('data', metavar='DIR',
help='path to dataset')
parser.add_argument('-a', '--arch', metavar='ARCH', default='resnet18',
help='model architecture (default: resnet18)')
parser.add_argument('-j', '--workers', default=4, type=int, metavar='N',
help='number of data loading workers (default: 4)')
parser.add_argument('--epochs', default=90, type=int, metavar='N',
help='number of total epochs to run')
parser.add_argument('--start-epoch', default=0, type=int, metavar='N',
help='manual epoch number (useful on restarts)')
parser.add_argument('-b', '--batch-size', default=256, type=int,
metavar='N',
help='mini-batch size (default: 256), this is the total '
'batch size of all GPUs on the current node when '
'using Data Parallel or Distributed Data Parallel')
parser.add_argument('--lr', '--learning-rate', default=0.1, type=float,
metavar='LR', help='initial learning rate', dest='lr')
parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
help='momentum')
parser.add_argument('--wd', '--weight-decay', default=1e-4, type=float,
metavar='W', help='weight decay (default: 1e-4)',
dest='weight_decay')
parser.add_argument('-p', '--print-freq', default=10, type=int,
metavar='N', help='print frequency (default: 10)')
parser.add_argument('--resume', default='', type=str, metavar='PATH',
help='path to latest checkpoint (default: none)')
parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',
help='evaluate model on validation set')
parser.add_argument('--pretrained', dest='pretrained', action='store_true',
help='use pre-trained model')
parser.add_argument('--world-size', default=-1, type=int,
help='number of nodes for distributed training')
parser.add_argument('--rank', default=-1, type=int,
help='node rank for distributed training')
parser.add_argument('--dist-url', default='tcp://224.66.41.62:23456', type=str,
help='url used to set up distributed training')
parser.add_argument('--dist-backend', default='nccl', type=str,
help='distributed backend')
parser.add_argument('--seed', default=None, type=int,
help='seed for initializing training. ')
parser.add_argument('--gpu', default=None, type=int,
help='GPU id to use.')
parser.add_argument('--image_size', default=224, type=int,
help='image size')
parser.add_argument('--advprop', default=False, action='store_true',
help='use advprop or not')
parser.add_argument('--multiprocessing-distributed', action='store_true',
help='Use multi-processing distributed training to launch '
'N processes per node, which has N GPUs. This is the '
'fastest way to use PyTorch for either single node or '
'multi node data parallel training')
best_acc1 = 0
def main():
args = parser.parse_args()
if args.seed is not None:
random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.deterministic = True
warnings.warn('You have chosen to seed training. '
'This will turn on the CUDNN deterministic setting, '
'which can slow down your training considerably! '
'You may see unexpected behavior when restarting '
'from checkpoints.')
if args.gpu is not None:
warnings.warn('You have chosen a specific GPU. This will completely '
'disable data parallelism.')
if args.dist_url == "env://" and args.world_size == -1:
args.world_size = int(os.environ["WORLD_SIZE"])
args.distributed = args.world_size > 1 or args.multiprocessing_distributed
ngpus_per_node = torch.cuda.device_count()
if args.multiprocessing_distributed:
# Since we have ngpus_per_node processes per node, the total world_size
# needs to be adjusted accordingly
args.world_size = ngpus_per_node * args.world_size
# Use torch.multiprocessing.spawn to launch distributed processes: the
# main_worker process function
mp.spawn(main_worker, nprocs=ngpus_per_node, args=(ngpus_per_node, args))
else:
# Simply call main_worker function
main_worker(args.gpu, ngpus_per_node, args)
def main_worker(gpu, ngpus_per_node, args):
global best_acc1
args.gpu = gpu
if args.gpu is not None:
print("Use GPU: {} for training".format(args.gpu))
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
# For multiprocessing distributed training, rank needs to be the
# global rank among all the processes
args.rank = args.rank * ngpus_per_node + gpu
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# create model
if 'efficientnet' in args.arch: # NEW
if args.pretrained:
model = EfficientNet.from_pretrained(args.arch, advprop=args.advprop)
print("=> using pre-trained model '{}'".format(args.arch))
else:
print("=> creating model '{}'".format(args.arch))
model = EfficientNet.from_name(args.arch)
else:
if args.pretrained:
print("=> using pre-trained model '{}'".format(args.arch))
model = models.__dict__[args.arch](pretrained=True)
else:
print("=> creating model '{}'".format(args.arch))
model = models.__dict__[args.arch]()
if args.distributed:
# For multiprocessing distributed, DistributedDataParallel constructor
# should always set the single device scope, otherwise,
# DistributedDataParallel will use all available devices.
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.cuda(args.gpu)
# When using a single GPU per process and per
# DistributedDataParallel, we need to divide the batch size
# ourselves based on the total number of GPUs we have
args.batch_size = int(args.batch_size / ngpus_per_node)
args.workers = int(args.workers / ngpus_per_node)
model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])
else:
model.cuda()
# DistributedDataParallel will divide and allocate batch_size to all
# available GPUs if device_ids are not set
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model = model.cuda(args.gpu)
else:
# DataParallel will divide and allocate batch_size to all available GPUs
if args.arch.startswith('alexnet') or args.arch.startswith('vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda(args.gpu)
optimizer = torch.optim.SGD(model.parameters(), args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
if args.gpu is not None:
# best_acc1 may be from a checkpoint from a different GPU
best_acc1 = best_acc1.to(args.gpu)
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
if args.advprop:
normalize = transforms.Lambda(lambda img: img * 2.0 - 1.0)
else:
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if 'efficientnet' in args.arch:
image_size = EfficientNet.get_image_size(args.arch)
else:
image_size = args.image_size
train_dataset = datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(image_size),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]))
if args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
else:
train_sampler = None
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None),
num_workers=args.workers, pin_memory=True, sampler=train_sampler)
val_transforms = transforms.Compose([
transforms.Resize(image_size, interpolation=PIL.Image.BICUBIC),
transforms.CenterCrop(image_size),
transforms.ToTensor(),
normalize,
])
print('Using image size', image_size)
val_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(valdir, val_transforms),
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
if args.evaluate:
res = validate(val_loader, model, criterion, args)
with open('res.txt', 'w') as f:
print(res, file=f)
return
for epoch in range(args.start_epoch, args.epochs):
if args.distributed:
train_sampler.set_epoch(epoch)
adjust_learning_rate(optimizer, epoch, args)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, args)
# evaluate on validation set
acc1 = validate(val_loader, model, criterion, args)
# remember best acc@1 and save checkpoint
is_best = acc1 > best_acc1
best_acc1 = max(acc1, best_acc1)
if not args.multiprocessing_distributed or (args.multiprocessing_distributed
and args.rank % ngpus_per_node == 0):
save_checkpoint({
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer' : optimizer.state_dict(),
}, is_best)
def train(train_loader, model, criterion, optimizer, epoch, args):
batch_time = AverageMeter('Time', ':6.3f')
data_time = AverageMeter('Data', ':6.3f')
losses = AverageMeter('Loss', ':.4e')
top1 = AverageMeter('Acc@1', ':6.2f')
top5 = AverageMeter('Acc@5', ':6.2f')
progress = ProgressMeter(len(train_loader), batch_time, data_time, losses, top1,
top5, prefix="Epoch: [{}]".format(epoch))
# switch to train mode
model.train()
end = time.time()
for i, (images, target) in enumerate(train_loader):
# measure data loading time
data_time.update(time.time() - end)
if args.gpu is not None:
images = images.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
# compute output
output = model(images)
loss = criterion(output, target)
# measure accuracy and record loss
acc1, acc5 = accuracy(output, target, topk=(1, 5))
losses.update(loss.item(), images.size(0))
top1.update(acc1[0], images.size(0))
top5.update(acc5[0], images.size(0))
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
progress.print(i)
def validate(val_loader, model, criterion, args):
batch_time = AverageMeter('Time', ':6.3f')
losses = AverageMeter('Loss', ':.4e')
top1 = AverageMeter('Acc@1', ':6.2f')
top5 = AverageMeter('Acc@5', ':6.2f')
progress = ProgressMeter(len(val_loader), batch_time, losses, top1, top5,
prefix='Test: ')
# switch to evaluate mode
model.eval()
with torch.no_grad():
end = time.time()
for i, (images, target) in enumerate(val_loader):
if args.gpu is not None:
images = images.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
# compute output
output = model(images)
loss = criterion(output, target)
# measure accuracy and record loss
acc1, acc5 = accuracy(output, target, topk=(1, 5))
losses.update(loss.item(), images.size(0))
top1.update(acc1[0], images.size(0))
top5.update(acc5[0], images.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
progress.print(i)
# TODO: this should also be done with the ProgressMeter
print(' * Acc@1 {top1.avg:.3f} Acc@5 {top5.avg:.3f}'
.format(top1=top1, top5=top5))
return top1.avg
def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
torch.save(state, filename)
if is_best:
shutil.copyfile(filename, 'model_best.pth.tar')
class AverageMeter(object):
"""Computes and stores the average and current value"""
def __init__(self, name, fmt=':f'):
self.name = name
self.fmt = fmt
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def __str__(self):
fmtstr = '{name} {val' + self.fmt + '} ({avg' + self.fmt + '})'
return fmtstr.format(**self.__dict__)
class ProgressMeter(object):
def __init__(self, num_batches, *meters, prefix=""):
self.batch_fmtstr = self._get_batch_fmtstr(num_batches)
self.meters = meters
self.prefix = prefix
def print(self, batch):
entries = [self.prefix + self.batch_fmtstr.format(batch)]
entries += [str(meter) for meter in self.meters]
print('\t'.join(entries))
def _get_batch_fmtstr(self, num_batches):
num_digits = len(str(num_batches // 1))
fmt = '{:' + str(num_digits) + 'd}'
return '[' + fmt + '/' + fmt.format(num_batches) + ']'
def adjust_learning_rate(optimizer, epoch, args):
"""Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
lr = args.lr * (0.1 ** (epoch // 30))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
def accuracy(output, target, topk=(1,)):
"""Computes the accuracy over the k top predictions for the specified values of k"""
with torch.no_grad():
maxk = max(topk)
batch_size = target.size(0)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)
res.append(correct_k.mul_(100.0 / batch_size))
return res
if __name__ == '__main__':
main()
================================================
FILE: examples/simple/check.ipynb
================================================
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## TensorFlow Consistency Check\n",
"\n",
"In this example, we demonstrate that our model gives the same output as the original TensorFlow implementation, when using the same image pre-processing. Note that this notebook requires TensorFlow in order to do the pre-processing. "
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"import json\n",
"from PIL import Image\n",
"\n",
"import torch\n",
"import tensorflow as tf\n",
"\n",
"from efficientnet_pytorch import EfficientNet"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"model_name = 'efficientnet-b0'\n",
"image_size = EfficientNet.get_image_size(model_name) # 224"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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
gitextract_b4i7h7bn/
├── .github/
│ └── workflows/
│ └── main.yml
├── .gitignore
├── LICENSE
├── README.md
├── efficientnet_pytorch/
│ ├── __init__.py
│ ├── model.py
│ └── utils.py
├── examples/
│ ├── imagenet/
│ │ ├── README.md
│ │ ├── data/
│ │ │ └── README.md
│ │ └── main.py
│ └── simple/
│ ├── check.ipynb
│ ├── example.ipynb
│ └── labels_map.txt
├── hubconf.py
├── setup.py
├── sotabench.py
├── sotabench_setup.sh
├── tests/
│ └── test_model.py
└── tf_to_pytorch/
├── README.md
└── convert_tf_to_pt/
├── download.sh
├── load_tf_weights.py
├── load_tf_weights_tf1.py
├── original_tf/
│ ├── __init__.py
│ ├── efficientnet_builder.py
│ ├── efficientnet_model.py
│ ├── eval_ckpt_main.py
│ ├── eval_ckpt_main_tf1.py
│ ├── preprocessing.py
│ └── utils.py
├── rename.sh
└── run.sh
SYMBOL INDEX (166 symbols across 15 files)
FILE: efficientnet_pytorch/model.py
class MBConvBlock (line 36) | class MBConvBlock(nn.Module):
method __init__ (line 50) | def __init__(self, block_args, global_params, image_size=None):
method forward (line 91) | def forward(self, inputs, drop_connect_rate=None):
method set_swish (line 134) | def set_swish(self, memory_efficient=True):
class EfficientNet (line 143) | class EfficientNet(nn.Module):
method __init__ (line 163) | def __init__(self, blocks_args=None, global_params=None):
method set_swish (line 221) | def set_swish(self, memory_efficient=True):
method extract_endpoints (line 231) | def extract_endpoints(self, inputs):
method extract_features (line 278) | def extract_features(self, inputs):
method forward (line 303) | def forward(self, inputs):
method from_name (line 324) | def from_name(cls, model_name, in_channels=3, **override_params):
method from_pretrained (line 349) | def from_pretrained(cls, model_name, weights_path=None, advprop=False,
method get_image_size (line 384) | def get_image_size(cls, model_name):
method _check_model_name_is_valid (line 398) | def _check_model_name_is_valid(cls, model_name):
method _change_in_channels (line 410) | def _change_in_channels(self, in_channels):
FILE: efficientnet_pytorch/utils.py
class Swish (line 58) | class Swish(nn.Module):
method forward (line 59) | def forward(self, x):
class SwishImplementation (line 64) | class SwishImplementation(torch.autograd.Function):
method forward (line 66) | def forward(ctx, i):
method backward (line 72) | def backward(ctx, grad_output):
class MemoryEfficientSwish (line 78) | class MemoryEfficientSwish(nn.Module):
method forward (line 79) | def forward(self, x):
function round_filters (line 83) | def round_filters(filters, global_params):
function round_repeats (line 111) | def round_repeats(repeats, global_params):
function drop_connect (line 129) | def drop_connect(inputs, p, training):
function get_width_and_height_from_size (line 157) | def get_width_and_height_from_size(x):
function calculate_output_image_size (line 174) | def calculate_output_image_size(input_image_size, stride):
function get_same_padding_conv2d (line 199) | def get_same_padding_conv2d(image_size=None):
class Conv2dDynamicSamePadding (line 215) | class Conv2dDynamicSamePadding(nn.Conv2d):
method __init__ (line 232) | def __init__(self, in_channels, out_channels, kernel_size, stride=1, d...
method forward (line 236) | def forward(self, x):
class Conv2dStaticSamePadding (line 248) | class Conv2dStaticSamePadding(nn.Conv2d):
method __init__ (line 255) | def __init__(self, in_channels, out_channels, kernel_size, stride=1, i...
method forward (line 273) | def forward(self, x):
function get_same_padding_maxPool2d (line 279) | def get_same_padding_maxPool2d(image_size=None):
class MaxPool2dDynamicSamePadding (line 295) | class MaxPool2dDynamicSamePadding(nn.MaxPool2d):
method __init__ (line 300) | def __init__(self, kernel_size, stride, padding=0, dilation=1, return_...
method forward (line 306) | def forward(self, x):
class MaxPool2dStaticSamePadding (line 319) | class MaxPool2dStaticSamePadding(nn.MaxPool2d):
method __init__ (line 324) | def __init__(self, kernel_size, stride, image_size=None, **kwargs):
method forward (line 343) | def forward(self, x):
class BlockDecoder (line 361) | class BlockDecoder(object):
method _decode_block_string (line 367) | def _decode_block_string(block_string):
method _encode_block_string (line 402) | def _encode_block_string(block):
method decode (line 426) | def decode(string_list):
method encode (line 442) | def encode(blocks_args):
function efficientnet_params (line 457) | def efficientnet_params(model_name):
function efficientnet (line 482) | def efficientnet(width_coefficient=None, depth_coefficient=None, image_s...
function get_model_params (line 531) | def get_model_params(model_name, override_params):
function load_pretrained_weights (line 584) | def load_pretrained_weights(model, model_name, weights_path=None, load_f...
FILE: examples/imagenet/main.py
function main (line 85) | def main():
function main_worker (line 120) | def main_worker(gpu, ngpus_per_node, args):
function train (line 285) | def train(train_loader, model, criterion, optimizer, epoch, args):
function validate (line 329) | def validate(val_loader, model, criterion, args):
function save_checkpoint (line 371) | def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
class AverageMeter (line 377) | class AverageMeter(object):
method __init__ (line 379) | def __init__(self, name, fmt=':f'):
method reset (line 384) | def reset(self):
method update (line 390) | def update(self, val, n=1):
method __str__ (line 396) | def __str__(self):
class ProgressMeter (line 401) | class ProgressMeter(object):
method __init__ (line 402) | def __init__(self, num_batches, *meters, prefix=""):
method print (line 407) | def print(self, batch):
method _get_batch_fmtstr (line 412) | def _get_batch_fmtstr(self, num_batches):
function adjust_learning_rate (line 418) | def adjust_learning_rate(optimizer, epoch, args):
function accuracy (line 425) | def accuracy(output, target, topk=(1,)):
FILE: hubconf.py
function _create_model_fn (line 6) | def _create_model_fn(model_name):
FILE: setup.py
class UploadCommand (line 58) | class UploadCommand(Command):
method status (line 65) | def status(s):
method initialize_options (line 69) | def initialize_options(self):
method finalize_options (line 72) | def finalize_options(self):
method run (line 75) | def run(self):
FILE: sotabench.py
function get_img_id (line 54) | def get_img_id(image_name):
FILE: tests/test_model.py
function model (line 13) | def model(request):
function pretrained (line 18) | def pretrained(request):
function net (line 23) | def net(model, pretrained):
function test_forward (line 30) | def test_forward(net, img_size):
function test_dropout_training (line 37) | def test_dropout_training(net):
function test_dropout_eval (line 43) | def test_dropout_eval(net):
function test_dropout_update (line 49) | def test_dropout_update(net):
function test_modify_dropout (line 62) | def test_modify_dropout(net, img_size):
function test_modify_pool (line 83) | def test_modify_pool(net, img_size):
function test_extract_endpoints (line 111) | def test_extract_endpoints(net, img_size):
FILE: tf_to_pytorch/convert_tf_to_pt/load_tf_weights.py
function load_param (line 7) | def load_param(checkpoint_file, conversion_table, model_name):
function load_efficientnet (line 29) | def load_efficientnet(model, checkpoint_file, model_name):
function load_and_save_temporary_tensorflow_model (line 128) | def load_and_save_temporary_tensorflow_model(model_name, model_ckpt, exa...
FILE: tf_to_pytorch/convert_tf_to_pt/load_tf_weights_tf1.py
function load_param (line 5) | def load_param(checkpoint_file, conversion_table, model_name):
function load_efficientnet (line 27) | def load_efficientnet(model, checkpoint_file, model_name):
function load_and_save_temporary_tensorflow_model (line 126) | def load_and_save_temporary_tensorflow_model(model_name, model_ckpt, exa...
FILE: tf_to_pytorch/convert_tf_to_pt/original_tf/efficientnet_builder.py
function efficientnet_params (line 35) | def efficientnet_params(model_name):
class BlockDecoder (line 53) | class BlockDecoder(object):
method _decode_block_string (line 56) | def _decode_block_string(self, block_string):
method _encode_block_string (line 88) | def _encode_block_string(self, block):
method decode (line 109) | def decode(self, string_list):
method encode (line 124) | def encode(self, blocks_args):
function swish (line 138) | def swish(features, use_native=True, use_hard=False):
function efficientnet (line 178) | def efficientnet(width_coefficient=None,
function get_model_params (line 204) | def get_model_params(model_name, override_params):
function build_model (line 226) | def build_model(images,
function build_model_base (line 299) | def build_model_base(images, model_name, training, override_params=None):
FILE: tf_to_pytorch/convert_tf_to_pt/original_tf/efficientnet_model.py
function conv_kernel_initializer (line 58) | def conv_kernel_initializer(shape, dtype=None, partition_info=None):
function dense_kernel_initializer (line 82) | def dense_kernel_initializer(shape, dtype=None, partition_info=None):
function superpixel_kernel_initializer (line 103) | def superpixel_kernel_initializer(shape, dtype='float32', partition_info...
function round_filters (line 138) | def round_filters(filters, global_params):
function round_repeats (line 157) | def round_repeats(repeats, global_params):
class MBConvBlock (line 165) | class MBConvBlock(tf.keras.layers.Layer):
method __init__ (line 172) | def __init__(self, block_args, global_params):
method block_args (line 214) | def block_args(self):
method _build (line 217) | def _build(self):
method _call_se (line 318) | def _call_se(self, input_tensor):
method call (line 333) | def call(self, inputs, training=True, survival_prob=None):
class MBConvBlockWithoutDepthwise (line 414) | class MBConvBlockWithoutDepthwise(MBConvBlock):
method _build (line 417) | def _build(self):
method call (line 448) | def call(self, inputs, training=True, survival_prob=None):
class Model (line 487) | class Model(tf.keras.Model):
method __init__ (line 493) | def __init__(self, blocks_args=None, global_params=None):
method _get_conv_block (line 515) | def _get_conv_block(self, conv_type):
method _build (line 519) | def _build(self):
method call (line 621) | def call(self,
FILE: tf_to_pytorch/convert_tf_to_pt/original_tf/eval_ckpt_main.py
class EvalCkptDriver (line 61) | class EvalCkptDriver(object):
method __init__ (line 71) | def __init__(self, model_name='efficientnet-b0', batch_size=1):
method restore_model (line 80) | def restore_model(self, sess, ckpt_dir):
method build_model (line 93) | def build_model(self, features, is_training):
method build_dataset (line 103) | def build_dataset(self, filenames, labels, is_training):
method run_inference (line 125) | def run_inference(self, ckpt_dir, image_files, labels):
function eval_example_images (line 146) | def eval_example_images(model_name, ckpt_dir, image_files, labels_map_fi...
function eval_imagenet (line 171) | def eval_imagenet(model_name,
function main (line 210) | def main(unused_argv):
FILE: tf_to_pytorch/convert_tf_to_pt/original_tf/eval_ckpt_main_tf1.py
class EvalCkptDriver (line 59) | class EvalCkptDriver(object):
method __init__ (line 69) | def __init__(self, model_name='efficientnet-b0', batch_size=1):
method restore_model (line 78) | def restore_model(self, sess, ckpt_dir):
method build_model (line 91) | def build_model(self, features, is_training):
method build_dataset (line 101) | def build_dataset(self, filenames, labels, is_training):
method run_inference (line 121) | def run_inference(self, ckpt_dir, image_files, labels):
function eval_example_images (line 142) | def eval_example_images(model_name, ckpt_dir, image_files, labels_map_fi...
function eval_imagenet (line 167) | def eval_imagenet(model_name,
function main (line 206) | def main(unused_argv):
FILE: tf_to_pytorch/convert_tf_to_pt/original_tf/preprocessing.py
function distorted_bounding_box_crop (line 29) | def distorted_bounding_box_crop(image_bytes,
function _at_least_x_are_equal (line 81) | def _at_least_x_are_equal(a, b, x):
function _decode_and_random_crop (line 88) | def _decode_and_random_crop(image_bytes, image_size):
function _decode_and_center_crop (line 111) | def _decode_and_center_crop(image_bytes, image_size):
function _flip (line 131) | def _flip(image):
function preprocess_for_train (line 137) | def preprocess_for_train(image_bytes, use_bfloat16, image_size=IMAGE_SIZE,
function preprocess_for_eval (line 191) | def preprocess_for_eval(image_bytes, use_bfloat16, image_size=IMAGE_SIZE):
function preprocess_image (line 209) | def preprocess_image(image_bytes,
FILE: tf_to_pytorch/convert_tf_to_pt/original_tf/utils.py
function build_learning_rate (line 32) | def build_learning_rate(initial_lr,
function build_optimizer (line 66) | def build_optimizer(learning_rate,
class TpuBatchNormalization (line 89) | class TpuBatchNormalization(tf.layers.BatchNormalization):
method __init__ (line 93) | def __init__(self, fused=False, **kwargs):
method _cross_replica_average (line 98) | def _cross_replica_average(self, t, num_shards_per_group):
method _moments (line 113) | def _moments(self, inputs, reduction_axes, keep_dims):
class BatchNormalization (line 139) | class BatchNormalization(tf.layers.BatchNormalization):
method __init__ (line 142) | def __init__(self, name='tpu_batch_normalization', **kwargs):
function drop_connect (line 146) | def drop_connect(inputs, is_training, survival_prob):
function archive_ckpt (line 164) | def archive_ckpt(ckpt_eval, ckpt_objective, ckpt_path):
function get_ema_vars (line 209) | def get_ema_vars():
class DepthwiseConv2D (line 219) | class DepthwiseConv2D(tf.keras.layers.DepthwiseConv2D, tf.layers.Layer):
class EvalCkptDriver (line 225) | class EvalCkptDriver(object):
method __init__ (line 236) | def __init__(self,
method restore_model (line 249) | def restore_model(self, sess, ckpt_dir, enable_ema=True, export_ckpt=N...
method build_model (line 273) | def build_model(self, features, is_training):
method get_preprocess_fn (line 278) | def get_preprocess_fn(self):
method build_dataset (line 281) | def build_dataset(self, filenames, labels, is_training):
method run_inference (line 314) | def run_inference(self,
method eval_example_images (line 341) | def eval_example_images(self,
method eval_imagenet (line 370) | def eval_imagenet(self, ckpt_dir, imagenet_eval_glob,
Condensed preview — 31 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,421K chars).
[
{
"path": ".github/workflows/main.yml",
"chars": 463,
"preview": "name: Workflow\n\non:\n push:\n branches:\n - master\n\njobs:\n pypi-job:\n runs-on: ubuntu-latest\n steps:\n - "
},
{
"path": ".gitignore",
"chars": 1476,
"preview": "# Custom \ntmp\n*.pkl\n\n# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\n# D"
},
{
"path": "LICENSE",
"chars": 11358,
"preview": "\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "README.md",
"chars": 12227,
"preview": "# EfficientNet PyTorch\n\n### Quickstart\n\nInstall with `pip install efficientnet_pytorch` and load a pretrained EfficientN"
},
{
"path": "efficientnet_pytorch/__init__.py",
"chars": 182,
"preview": "__version__ = \"0.7.1\"\nfrom .model import EfficientNet, VALID_MODELS\nfrom .utils import (\n GlobalParams,\n BlockArgs"
},
{
"path": "efficientnet_pytorch/model.py",
"chars": 17388,
"preview": "\"\"\"model.py - Model and module class for EfficientNet.\n They are built to mirror those in the official TensorFlow impl"
},
{
"path": "efficientnet_pytorch/utils.py",
"chars": 24957,
"preview": "\"\"\"utils.py - Helper functions for building the model and for loading model parameters.\n These helper functions are bu"
},
{
"path": "examples/imagenet/README.md",
"chars": 1058,
"preview": "### Imagenet\n\nThis is a preliminary directory for evaluating the model on ImageNet. It is adapted from the standard PyTo"
},
{
"path": "examples/imagenet/data/README.md",
"chars": 219,
"preview": "### ImageNet\n\nDownload ImageNet and place it into `train` and `val` folders here.\n\nMore details may be found with the of"
},
{
"path": "examples/imagenet/main.py",
"chars": 17107,
"preview": "\"\"\"\nEvaluate on ImageNet. Note that at the moment, training is not implemented (I am working on it).\nthat being said, ev"
},
{
"path": "examples/simple/check.ipynb",
"chars": 1088041,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## TensorFlow Consistency Check\\n\","
},
{
"path": "examples/simple/example.ipynb",
"chars": 1086296,
"preview": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Example\\n\",\n \"\\n\",\n \"In th"
},
{
"path": "examples/simple/labels_map.txt",
"chars": 31565,
"preview": "{\"0\": \"tench, Tinca tinca\", \"1\": \"goldfish, Carassius auratus\", \"2\": \"great white shark, white shark, man-eater, man-eat"
},
{
"path": "hubconf.py",
"chars": 1709,
"preview": "from efficientnet_pytorch import EfficientNet as _EfficientNet\n\ndependencies = ['torch']\n\n\ndef _create_model_fn(model_na"
},
{
"path": "setup.py",
"chars": 3543,
"preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n# Note: To use the 'upload' functionality of this file, you must:\n# $ p"
},
{
"path": "sotabench.py",
"chars": 2094,
"preview": "import os\nimport numpy as np\nimport PIL\nimport torch\nfrom torch.utils.data import DataLoader\nimport torchvision.transfor"
},
{
"path": "sotabench_setup.sh",
"chars": 179,
"preview": "#!/usr/bin/env bash -x\nsource /workspace/venv/bin/activate\nPYTHON=${PYTHON:-\"python\"}\n$PYTHON -m pip install torch\n$PYTH"
},
{
"path": "tests/test_model.py",
"chars": 4122,
"preview": "from collections import OrderedDict\n\nimport pytest\nimport torch\nimport torch.nn as nn\n\nfrom efficientnet_pytorch import "
},
{
"path": "tf_to_pytorch/README.md",
"chars": 1012,
"preview": "### TensorFlow to PyTorch Conversion\n\nThis directory is used to convert TensorFlow weights to PyTorch. It was hacked tog"
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/download.sh",
"chars": 630,
"preview": "#!/usr/bin/env bash\n\nmkdir original_tf\ncd original_tf\ntouch __init__.py\nwget https://raw.githubusercontent.com/tensorflo"
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/load_tf_weights.py",
"chars": 10410,
"preview": "import numpy as np\nimport tensorflow as tf\nimport torch\n\ntf.compat.v1.disable_v2_behavior()\n\ndef load_param(checkpoint_f"
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/load_tf_weights_tf1.py",
"chars": 10344,
"preview": "import numpy as np\nimport tensorflow as tf\nimport torch\n\ndef load_param(checkpoint_file, conversion_table, model_name):\n"
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/original_tf/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/original_tf/efficientnet_builder.py",
"chars": 11804,
"preview": "# Copyright 2019 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/original_tf/efficientnet_model.py",
"chars": 26027,
"preview": "# Copyright 2019 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/original_tf/eval_ckpt_main.py",
"chars": 8644,
"preview": "# Copyright 2019 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/original_tf/eval_ckpt_main_tf1.py",
"chars": 8524,
"preview": "# Copyright 2019 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/original_tf/preprocessing.py",
"chars": 9508,
"preview": "# Copyright 2019 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/original_tf/utils.py",
"chars": 15742,
"preview": "# Copyright 2019 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/rename.sh",
"chars": 148,
"preview": "for i in 0 1 2 3 4 5 6 7 8\ndo \n X=$(sha256sum efficientnet-b${i}.pth | head -c 8)\n mv efficientnet-b${i}.pth effic"
},
{
"path": "tf_to_pytorch/convert_tf_to_pt/run.sh",
"chars": 1732,
"preview": "python ../convert_tf_to_pt/load_tf_weights.py --model_name efficientnet-b0 --tf_checkpoint ../pretrained_tensorflow/effi"
}
]
About this extraction
This page contains the full source code of the lukemelas/EfficientNet-PyTorch GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 31 files (2.3 MB), approximately 603.6k tokens, and a symbol index with 166 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.