https://github.com/reshalfahsi/separableconv-torch
PyTorch implementation of Depthwise Separable Convolution
https://github.com/reshalfahsi/separableconv-torch
deep-learning depthwise-separable-convolutions pytorch
Last synced: 9 months ago
JSON representation
PyTorch implementation of Depthwise Separable Convolution
- Host: GitHub
- URL: https://github.com/reshalfahsi/separableconv-torch
- Owner: reshalfahsi
- License: mit
- Created: 2022-07-28T15:23:24.000Z (almost 4 years ago)
- Default Branch: main
- Last Pushed: 2022-08-28T15:17:46.000Z (almost 4 years ago)
- Last Synced: 2025-08-27T21:58:05.669Z (11 months ago)
- Topics: deep-learning, depthwise-separable-convolutions, pytorch
- Language: Python
- Homepage:
- Size: 51.8 KB
- Stars: 12
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
Unofficial PyTorch Module - Depthwise Separable Convolution
An illustration of Depthwise Separable Convolution. Credit: [Depthwise Convolution Is All You Need for Learning Multiple Visual Domains](https://paperswithcode.com/paper/depthwise-convolution-is-all-you-need-for).
PyTorch (unofficial) implementation of Depthwise Separable Convolution. This type of convolution is introduced by Chollet in [Xception: Deep Learning With Depthwise Separable Convolutions](https://arxiv.org/abs/1610.02357). This package provides ``SeparableConv1d``, ``SeparableConv2d``, ``SeparableConv3d``, ``LazySeparableConv1d``, ``LazySeparableConv2d``, and ``LazySeparableConv3d``.
## Installation
Install `separableconv-torch` using `pip` (require: Python >=3.7).
```console
pip install separableconv-torch
```
## Parameters
| Parameter | Description | Type |
| ------------- | ------------- | ------------- |
| in_channels | Number of channels in the input image | int |
| out_channels | Number of channels produced by the convolution | int |
| kernel_size | Size of the convolving kernel | int or tuple |
| stride | Stride of the convolution. Default: 1 | int or tuple, optional |
| padding | Padding added to all four sides of the input. Default: 0 | int, tuple or str, optional |
| padding_mode | ``'zeros'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. Default: ``'zeros'`` | string, optional|
| dilation | Spacing between kernel elements. Default: 1 | int or tuple, optional |
| depth_multiplier | The number of depthwise convolution output channels for each input channel. The total number of depthwise convolution output channels will be equal to `in_channels * depth_multiplier`. Default: 1| int, optional |
| normalization_dw | depthwise convolution normalization. Default: 'bn' | str, optional |
| normalization_pw | pointwise convolution normalization. Default: 'bn' | str, optional |
| activation_dw | depthwise convolution activation. Default: ``torch.nn.ReLU`` | Callable[`...`, `torch.nn.Module`], optional |
| activation_pw | pointwise convolution activation. Default: ``torch.nn.ReLU`` | Callable[`...`, `torch.nn.Module`], optional |
| bias | If ``True``, adds a learnable bias to the output. Default: ``True`` | bool, optional |
## Example Usage
For 1-dimensional case.
```python
import torch
import separableconv.nn as nn
# set input
input = torch.randn(4, 10, 100)
# define model
m = nn.SeparableConv1d(10, 30, 3)
# process input through model
output = m(input)
```
For 2-dimensional case.
```python
import torch
import separableconv.nn as nn
# set input
input = torch.randn(4, 10, 100, 100)
# define model
m = nn.SeparableConv2d(10, 30, 3)
# process input through model
output = m(input)
```
For 3-dimensional case.
```python
import torch
import separableconv.nn as nn
# set input
input = torch.randn(4, 10, 100, 100, 100)
# define model
m = nn.SeparableConv3d(10, 30, 3)
# process input through model
output = m(input)
```
Stacked SeparableConv2d.
```python
import torch
import separableconv.nn as nn
# set input
input = torch.randn(4, 3, 100, 100)
# define model
m = nn.Sequential(
nn.SeparableConv2d(3, 32, 3),
nn.SeparableConv2d(32, 64, 3),
nn.SeparableConv2d(64, 96, 3))
# process input through model
output = m(input)
```
For lazy 2-dimensional case.
```python
import torch
import separableconv.nn as nn
# set input
input = torch.randn(4, 10, 100, 100)
# define model
m = nn.LazySeparableConv2d(30, 3)
# process input through model
output = m(input)
```