Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/Oneflow-Inc/vision

Datasets, Transforms and Models specific to Computer Vision
https://github.com/Oneflow-Inc/vision

Last synced: about 2 months ago
JSON representation

Datasets, Transforms and Models specific to Computer Vision

Host: GitHub
URL: https://github.com/Oneflow-Inc/vision
Owner: Oneflow-Inc
License: bsd-3-clause
Created: 2021-10-11T06:44:00.000Z (almost 3 years ago)
Default Branch: main
Last Pushed: 2023-11-17T03:33:19.000Z (10 months ago)
Last Synced: 2024-07-21T21:41:32.428Z (2 months ago)
Language: Python
Homepage: https://flowvision.readthedocs.io/en/latest/index.html
Size: 20.2 MB
Stars: 82
Watchers: 41
Forks: 17
Open Issues: 21
Metadata Files:
- Readme: README.md
- License: LICENSE

Awesome Lists containing this project

README

flowvision

## Introduction
The flowvision package consists of popular datasets, SOTA computer vision models, layers, utilities, schedulers, advanced data augmentations and common image transformations based on OneFlow.

## Installation
First install OneFlow, please refer to [install-oneflow](https://github.com/Oneflow-Inc/oneflow#install-oneflow) for more details.

Then install the latest stable release of `flowvision`
```bash
pip install flowvision==0.2.2
```

## Overview of flowvision structure

Vision Models

Components

Augmentation and Datasets

Classification

AlexNet

SqueezeNet

GoogleNet

InceptionV3

ResNet

ResNeXt

ResNeSt

SENet

DenseNet

ShuffleNetV2

MobileNetV2

MobileNetV3

MNASNet

Res2Net

EfficientNet

GhostNet

RegNet

ReXNet

Vision Transformer

DeiT

Swin Transformer

CSwin Transformer

CrossFormer

PoolFormer

Mlp Mixer

ResMLP

gMLP

ConvMixer

ConvNeXt

LeViT

RegionViT

UniFormer

MobileViT

DeiT-III

CaiT

GENet

HRNet

Detection

SSDLite

Faster RCNN

RetinaNet

Segmentation

DeepLabV3

Neural Style Transfer

StyleNet

Face Recognition

IResNet

Attention Layers

CBAM

Non Local Attention

Global Context

Gated Channel Transform

Coordinate Attention

Regularization Layers

Drop Block

Drop Path

Stochastic Depth

LayerNorm2D

Basic Layers

Patch Embedding

Mlp Block

Activation Layers

Hard Sigmoid

Hard Swish

Initialization Function

Truncated Normal

Lecun Normal

LR Scheduler

StepLRScheduler

MultiStepLRScheduler

CosineLRScheduler

LinearLRScheduler

PolyLRScheduler

TanhLRScheduler

Loss

LabelSmoothingCrossEntropy

SoftTargetCrossEntropy

Basic Augmentation

CenterCrop

RandomCrop

RandomResizedCrop

FiveCrop

TenCrop

RandomVerticalFlip

RandomHorizontalFlip

Resize

RandomGrayscale

GaussianBlur

Advanced Augmentation

Mixup

CutMix

AugMix

RandomErasing

Rand Augmentation

Auto Augmentation

Datasets

CIFAR10

CIFAR100

COCO

FashionMNIST

ImageNet

## Documentation
Please refer to [docs](https://flowvision.readthedocs.io/en/latest/index.html) for full API documentation and tutorials

## ChangeLog
Please refer to [ChangeLog](https://flowvision.readthedocs.io/en/latest/changelog.html) for details and release history

## Model Zoo
We have conducted all the tests under the same setting, please refer to the model page [here](./results/results_imagenet.md) for more details.

## Quick Start
### Create a model
In flowvision we support two ways to create a model.

- Import the target model from `flowvision.models`, e.g., create `alexnet` from flowvision

```python
from flowvision.models.alexnet import alexnet
model = alexnet()

# will download the pretrained model
model = alexnet(pretrained=True)

# customize model to fit different number of classes
model = alexnet(num_classes=100)
```

- Or create model in an easier way by using `ModelCreator`, e.g., create `alexnet` model by `ModelCreator`
```python
from flowvision.models import ModelCreator
alexnet = ModelCreator.create_model("alexnet")

# will download the pretrained model
alexnet = ModelCreator.create_model("alexnet", pretrained=True)

# customize model to fit different number of classes
alexnet = ModelCreator.create_model("alexnet", num_classes=100)
```

### Tabulate all models with pretrained weights
`ModelCreator.model_table()` returns a tabular results of available models in `flowvision`. To check all of pretrained models, pass in `pretrained=True` in `ModelCreator.model_table()`.
```python
from flowvision.models import ModelCreator
all_pretrained_models = ModelCreator.model_table(pretrained=True)
print(all_pretrained_models)
```
You can get the results like:
```python
╒════════════════════════════════════════════╤══════════════╕
│ Supported Models │ Pretrained │
╞════════════════════════════════════════════╪══════════════╡
│ alexnet │ true │
├────────────────────────────────────────────┼──────────────┤
│ convmixer_1024_20 │ true │
├────────────────────────────────────────────┼──────────────┤
│ convmixer_1536_20 │ true │
├────────────────────────────────────────────┼──────────────┤
│ convmixer_768_32_relu │ true │
├────────────────────────────────────────────┼──────────────┤
│ crossformer_base_patch4_group7_224 │ true │
├────────────────────────────────────────────┼──────────────┤
│ crossformer_large_patch4_group7_224 │ true │
├────────────────────────────────────────────┼──────────────┤
│ crossformer_small_patch4_group7_224 │ true │
├────────────────────────────────────────────┼──────────────┤
│ crossformer_tiny_patch4_group7_224 │ true │
├────────────────────────────────────────────┼──────────────┤
│ ... │ ... │
├────────────────────────────────────────────┼──────────────┤
│ wide_resnet101_2 │ true │
├────────────────────────────────────────────┼──────────────┤
│ wide_resnet50_2 │ true │
╘════════════════════════════════════════════╧══════════════╛
```

### Search for supported model by Wildcard
It is easy to search for model architectures by using Wildcard as below:
```python
from flowvision.models import ModelCreator
all_efficientnet_models = ModelCreator.model_table("**efficientnet**")
print(all_efficientnet_models)
```
You can get the results like:
```python
╒════════════════════╤══════════════╕
│ Supported Models │ Pretrained │
╞════════════════════╪══════════════╡
│ efficientnet_b0 │ true │
├────────────────────┼──────────────┤
│ efficientnet_b1 │ true │
├────────────────────┼──────────────┤
│ efficientnet_b2 │ true │
├────────────────────┼──────────────┤
│ efficientnet_b3 │ true │
├────────────────────┼──────────────┤
│ efficientnet_b4 │ true │
├────────────────────┼──────────────┤
│ efficientnet_b5 │ true │
├────────────────────┼──────────────┤
│ efficientnet_b6 │ true │
├────────────────────┼──────────────┤
│ efficientnet_b7 │ true │
╘════════════════════╧══════════════╛
```

### List all models supported in flowvision
`ModelCreator.model_list` has similar function as `ModelCreator.model_table` but return a list object, which gives the user a more flexible way to check the supported model in flowvision.
- List all models with pretrained weights
```python
from flowvision.models import ModelCreator
all_pretrained_models = ModelCreator.model_list(pretrained=True)
print(all_pretrained_models[:5])
```
You can get the results like:
```python
['alexnet',
'convmixer_1024_20',
'convmixer_1536_20',
'convmixer_768_32_relu',
'crossformer_base_patch4_group7_224']
```

- Support wildcard search
```python
from flowvision.models import ModelCreator
all_efficientnet_models = ModelCreator.model_list("**efficientnet**")
print(all_efficientnet_models)
```
You can get the results like:
```python
['efficientnet_b0',
'efficientnet_b1',
'efficientnet_b2',
'efficientnet_b3',
'efficientnet_b4',
'efficientnet_b5',
'efficientnet_b6',
'efficientnet_b7']
```

## Disclaimer on Datasets
This is a utility library that downloads and prepares public datasets. We do not host or distribute these datasets, vouch for their quality or fairness, or claim that you have license to use the dataset. It is your responsibility to determine whether you have permission to use the dataset under the dataset's license.

If you're a dataset owner and wish to update any part of it (description, citation, etc.), or do not want your dataset to be included in this library, please get in touch through a GitHub issue. Thanks for your contribution to the ML community!