├── .gitignore ├── README.md ├── dataset.py ├── demo.ipynb ├── net.py ├── requirements.txt ├── train.py ├── trained_model └── buster_epoch_13.pth ├── utils.py └── visualizes ├── visualize1.png ├── visualize2.png └── visualize3.png /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | share/python-wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 27 | MANIFEST 28 | 29 | # PyInstaller 30 | # Usually these files are written by a python script from a template 31 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 32 | *.manifest 33 | *.spec 34 | 35 | # Installer logs 36 | pip-log.txt 37 | pip-delete-this-directory.txt 38 | 39 | # Unit test / coverage reports 40 | htmlcov/ 41 | .tox/ 42 | .nox/ 43 | .coverage 44 | .coverage.* 45 | .cache 46 | nosetests.xml 47 | coverage.xml 48 | *.cover 49 | *.py,cover 50 | .hypothesis/ 51 | .pytest_cache/ 52 | cover/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | .pybuilder/ 76 | target/ 77 | 78 | # Jupyter Notebook 79 | .ipynb_checkpoints 80 | 81 | # IPython 82 | profile_default/ 83 | ipython_config.py 84 | 85 | # pyenv 86 | # For a library or package, you might want to ignore these files since the code is 87 | # intended to run in multiple environments; otherwise, check them in: 88 | # .python-version 89 | 90 | # pipenv 91 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 92 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 93 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 94 | # install all needed dependencies. 95 | #Pipfile.lock 96 | 97 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 98 | __pypackages__/ 99 | 100 | # Celery stuff 101 | celerybeat-schedule 102 | celerybeat.pid 103 | 104 | # SageMath parsed files 105 | *.sage.py 106 | 107 | # Environments 108 | .env 109 | .venv 110 | env/ 111 | venv/ 112 | ENV/ 113 | env.bak/ 114 | venv.bak/ 115 | 116 | # Spyder project settings 117 | .spyderproject 118 | .spyproject 119 | 120 | # Rope project settings 121 | .ropeproject 122 | 123 | # mkdocs documentation 124 | /site 125 | 126 | # mypy 127 | .mypy_cache/ 128 | .dmypy.json 129 | dmypy.json 130 | 131 | # Pyre type checker 132 | .pyre/ 133 | 134 | # pytype static type analyzer 135 | .pytype/ 136 | 137 | # Cython debug symbols 138 | cython_debug/ 139 | 140 | .vscode/ 141 | .ipynb_checkpoints/ 142 | datasets/ 143 | logs/ -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | # BusterNet_pytorch: Detecting Copy-Move Image Forgery with Source/Target Localization 3 | 4 | ### Introduction 5 | I reimplement a novel deep neural architecture for image copy-move forgery detection (CMFD), code-named *BusterNet*. 6 | 7 | In this repository, we release many paper related things, including 8 | 9 | - a pretrained BusterNet model (trained model at epoch 13) 10 | - custom layers implemented in pytorch 11 | - python demo notebook 12 | 13 | 14 | ### Example 15 | 16 | ![alt text](visualizes/visualize1.png "Visualize 1") 17 | ![alt text](visualizes/visualize2.png "Visualize 2") 18 | ![alt text](visualizes/visualize3.png "Visualize 3") 19 | 20 | ### Dataset 21 | USCISI-CMFD Dataset 22 | 23 | #### Introduction 24 | This copy-move forgery detection(CMFD) dataset relies on 25 | - [MIT SUN2012 Database](https://groups.csail.mit.edu/vision/SUN/) 26 | - [MS COCO Dataset](http://cocodataset.org/#home) 27 | 28 | More precisely, we synthesize a copy-move forgery sample using the following steps 29 | 30 | 1. select a sample in the two above dataset 31 | 2. select one of its object polygon 32 | 3. use both sample image and polgyon mask to synthesize a sample 33 | 34 | More detailed description can be found in paper. 35 | 36 | #### Folder Content 37 | This USCISI-CMFD dataset folder contains the following things: 38 | 39 | * **api.py** - USCISI-CMFD dataset API 40 | * **USCISI-CMFD Dataset** - USCISI-CMFD LMDB dataset 41 | * Two versions are NOT included due to repo size limit. Please right click to download from the google drive. 42 | * [**USCISI-CMFD-Small**](https://drive.google.com/file/d/14WrmeVRTf9T0umSW6I267zBrsmCjCEIQ/view?usp=sharing) - 100 samples, ~40MB 43 | * [**USCISI-CMFD-Full**](https://drive.google.com/file/d/1gsx5c-oilsFEzX_j1zKTPP4yWEs6T385/view?usp=sharing) - 100K samples, ~100GB 44 | * After uncompressing the downloaded dataset, you should see the following files 45 | * **data.mdb** - sample LMDB data file 46 | * **samples.keys** - a file listing sample keys (each line is a key) 47 | * **lock.mdb** - sample LMDB locker file 48 | * **Demo.ipynb** - a python notebook show the usage of API 49 | * **ReadMe.md** - this file 50 | 51 | **NOTE** due to the repository size limit, the full USCISI-CMFD dataset will be provided upon request. 52 | 53 | ### Training 54 | 1. Download dataset to folder 'datasets' with link about. The ownership belong to yue_wu[at]isi.edu, therefor if you dont have accept permission. Please to contact him. 55 | (Optional) Download pretrained VGG16 at [VGG16](https://download.pytorch.org/models/vgg16-397923af.pth) 56 | 2. Install independent package. 57 | ```pip install -r requirements.txt``` 58 | 3. Training: 59 | ```python train.py``` 60 | with custom argurments: 61 | ``` 62 | usage: Buster Net [-h] [-n NUM_WORKERS] [-b BATCH_SIZE] [--num_gpus NUM_GPUS] 63 | [--freeze_layers [FREEZE_LAYERS [FREEZE_LAYERS ...]]] 64 | [--lr LR] [--optim OPTIM] [--num_epochs NUM_EPOCHS] 65 | [--val_interval VAL_INTERVAL] 66 | [--save_interval SAVE_INTERVAL] 67 | [--es_min_delta ES_MIN_DELTA] [--es_patience ES_PATIENCE] 68 | [--lmdb_dir LMDB_DIR] [--log_path LOG_PATH] 69 | [-w LOAD_WEIGHTS] [--saved_path SAVED_PATH] 70 | ``` 71 | 4. Try predict in demo.ipynb 72 | 73 | ### Citation 74 | If you use the provided code or data in any publication, please kindly cite the following paper. 75 | 76 | @inproceedings{wu2018eccv, 77 | title={BusterNet: Detecting Image Copy-Move Forgery With Source/Target Localization}, 78 | author={Wu, Yue, and AbdAlmageed, Wael and Natarajan, Prem}, 79 | booktitle={European Conference on Computer Vision (ECCV)}, 80 | year={2018}, 81 | organization={Springer}, 82 | } 83 | 84 | ### Contact 85 | - Name: Nguyen Thanh Dat 86 | - Email: ntdat017\[at\]gmail.com 87 | 88 | 89 | ### License 90 | The Software is made available for academic or non-commercial purposes only. The license is for a copy of the program for an unlimited term. Individuals requesting a license for commercial use must pay for a commercial license. 91 | 92 | USC Stevens Institute for Innovation 93 | University of Southern California 94 | 1150 S. Olive Street, Suite 2300 95 | Los Angeles, CA 90115, USA 96 | ATTN: Accounting 97 | 98 | DISCLAIMER. USC MAKES NO EXPRESS OR IMPLIED WARRANTIES, EITHER IN FACT OR BY OPERATION OF LAW, BY STATUTE OR OTHERWISE, AND USC SPECIFICALLY AND EXPRESSLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, VALIDITY OF THE SOFTWARE OR ANY OTHER INTELLECTUAL PROPERTY RIGHTS OR NON-INFRINGEMENT OF THE INTELLECTUAL PROPERTY OR OTHER RIGHTS OF ANY THIRD PARTY. SOFTWARE IS MADE AVAILABLE AS-IS. LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT WILL USC BE LIABLE TO ANY USER OF THIS CODE FOR ANY INCIDENTAL, CONSEQUENTIAL, EXEMPLARY OR PUNITIVE DAMAGES OF ANY KIND, LOST GOODWILL, LOST PROFITS, LOST BUSINESS AND/OR ANY INDIRECT ECONOMIC DAMAGES WHATSOEVER, REGARDLESS OF WHETHER SUCH DAMAGES ARISE FROM CLAIMS BASED UPON CONTRACT, NEGLIGENCE, TORT (INCLUDING STRICT LIABILITY OR OTHER LEGAL THEORY), A BREACH OF ANY WARRANTY OR TERM OF THIS AGREEMENT, AND REGARDLESS OF WHETHER USC WAS ADVISED OR HAD REASON TO KNOW OF THE POSSIBILITY OF INCURRING SUCH DAMAGES IN ADVANCE. 99 | 100 | For commercial license pricing and annual commercial update and support pricing, please contact: 101 | 102 | Rakesh Pandit USC Stevens Institute for Innovation 103 | University of Southern California 104 | 1150 S. Olive Street, Suite 2300 105 | Los Angeles, CA 90115, USA 106 | 107 | Tel: +1 213-821-3552 108 | Fax: +1 213-821-5001 109 | Email: rakeshvp@usc.edu and ccto: accounting@stevens.usc.edu 110 | 111 | 112 | -------------------------------------------------------------------------------- /dataset.py: -------------------------------------------------------------------------------- 1 | import os 2 | import numpy as np 3 | 4 | import cv2 5 | import json 6 | import lmdb 7 | import pyarrow as pa 8 | 9 | import torch 10 | from torch.utils.data import Dataset 11 | from torchvision import transforms 12 | 13 | class USCISIDataset(Dataset): 14 | def __init__(self, lmdb_dir, sample_file, transform=None, target_transform=None, differentiate_target=True): 15 | super(USCISIDataset, self).__init__() 16 | 17 | self.lmdb_dir = lmdb_dir 18 | self.sample_file = os.path.join(lmdb_dir, sample_file) 19 | self.transform = transform 20 | self.target_transform = target_transform 21 | self.differentiate_target = differentiate_target 22 | 23 | assert os.path.isdir(lmdb_dir) 24 | self.lmdb_dir = lmdb_dir 25 | assert os.path.isfile(self.sample_file) 26 | 27 | self._init_db() 28 | 29 | 30 | def _init_db(self): 31 | self.env = lmdb.open(self.lmdb_dir, subdir=os.path.isdir(self.lmdb_dir), 32 | readonly=True, lock=False, 33 | readahead=False, meminit=False) 34 | # with self.env.begin(write=False) as txn: 35 | # self.length = txn.stat()['entries'] - 1 36 | self.keys = self._load_sample_keys() 37 | 38 | def _load_sample_keys(self) : 39 | with open(self.sample_file, 'r') as f: 40 | keys = [line.strip() for line in f.readlines()] 41 | return keys 42 | 43 | def __getitem__(self, index: int): 44 | img, target = None, None 45 | env = self.env 46 | with env.begin(write=False) as txn: 47 | lut_str = txn.get(self.keys[index].encode()) 48 | img, cmd_mask, trans_mat = self._decode_lut_str(lut_str) 49 | 50 | if self.transform is not None: 51 | img = self.transform(img) 52 | if self.target_transform is not None: 53 | cmd_mask = cmd_mask.astype(np.uint8) 54 | cmd_mask = self.target_transform(cmd_mask) 55 | cmd_mask = (cmd_mask * 256).type(torch.int32) 56 | 57 | return img, cmd_mask, trans_mat 58 | 59 | def __len__(self) -> int: 60 | return len(self.keys) 61 | 62 | 63 | def _decode_lut_str(self, lut_str) : 64 | '''Decode a raw LMDB lut 65 | INPUT: 66 | lut_str = str, raw string retrieved from LMDB 67 | OUTPUT: 68 | image = np.ndarray, dtype='uint8', cmd image 69 | cmd_mask = np.ndarray, dtype='float32', cmd mask 70 | trans_mat = np.ndarray, dtype='float32', cmd transform matrix 71 | ''' 72 | # 1. get raw lut 73 | lut = json.loads(lut_str) 74 | # 2. reconstruct image 75 | image = self._get_image_from_lut(lut) 76 | # 3. reconstruct copy-move masks 77 | cmd_mask = self._get_mask_from_lut(lut) 78 | # 4. get transform matrix if necessary 79 | trans_mat = self._get_transmat_from_lut(lut) 80 | return ( image, cmd_mask, trans_mat ) 81 | 82 | 83 | def _get_image_from_lut( self, lut ) : 84 | '''Decode image array from LMDB lut 85 | INPUT: 86 | lut = dict, raw decoded lut retrieved from LMDB 87 | OUTPUT: 88 | image = np.ndarray, dtype='uint8' 89 | ''' 90 | image_jpeg_buffer = lut['image_jpeg_buffer'] 91 | image = cv2.imdecode( np.array(image_jpeg_buffer).astype('uint8').reshape([-1,1]), 1 ) 92 | return image 93 | 94 | def _get_mask_from_lut( self, lut ) : 95 | '''Decode copy-move mask from LMDB lut 96 | INPUT: 97 | lut = dict, raw decoded lut retrieved from LMDB 98 | OUTPUT: 99 | cmd_mask = np.ndarray, dtype='float32' 100 | shape of HxWx1, if differentiate_target=False 101 | shape of HxWx3, if differentiate target=True 102 | NOTE: 103 | cmd_mask is encoded in the one-hot style, if differentiate target=True. 104 | color channel, R, G, and B stand for TARGET, SOURCE, and BACKGROUND classes 105 | ''' 106 | def reconstruct( cnts, h, w, val=1 ) : 107 | rst = np.zeros([h,w], dtype='uint8') 108 | cv2.fillPoly( rst, cnts, val ) 109 | return rst 110 | h, w = lut['image_height'], lut['image_width'] 111 | src_cnts = [ np.array(cnts).reshape([-1,1,2]) for cnts in lut['source_contour'] ] 112 | src_mask = reconstruct( src_cnts, h, w, val = 1 ) 113 | tgt_cnts = [ np.array(cnts).reshape([-1,1,2]) for cnts in lut['target_contour'] ] 114 | tgt_mask = reconstruct( tgt_cnts, h, w, val = 1 ) 115 | if ( self.differentiate_target ) : 116 | # 3-class target 117 | background = np.ones([h,w]).astype('uint8') - np.maximum(src_mask, tgt_mask) 118 | cmd_mask = np.dstack( [tgt_mask, src_mask, background ] ).astype(np.float32) 119 | else : 120 | # 2-class target 121 | cmd_mask = np.maximum(src_mask, tgt_mask).astype(np.float32) 122 | return cmd_mask 123 | def _get_transmat_from_lut( self, lut ) : 124 | '''Decode transform matrix between SOURCE and TARGET 125 | INPUT: 126 | lut = dict, raw decoded lut retrieved from LMDB 127 | OUTPUT: 128 | trans_mat = np.ndarray, dtype='float32', size of 3x3 129 | ''' 130 | trans_mat = lut['transform_matrix'] 131 | return np.array(trans_mat).reshape([3,3]) 132 | 133 | 134 | 135 | # def collater(data): 136 | # imgs = [s['img'] for s in data] 137 | # annots = [s['annot'] for s in data] 138 | # scales = [s['scale'] for s in data] 139 | 140 | # imgs = torch.from_numpy(np.stack(imgs, axis=0)) 141 | 142 | # max_num_annots = max(annot.shape[0] for annot in annots) 143 | 144 | # if max_num_annots > 0: 145 | 146 | # annot_padded = torch.ones((len(annots), max_num_annots, 5)) * -1 147 | 148 | # for idx, annot in enumerate(annots): 149 | # if annot.shape[0] > 0: 150 | # annot_padded[idx, :annot.shape[0], :] = annot 151 | # else: 152 | # annot_padded = torch.ones((len(annots), 1, 5)) * -1 153 | 154 | # imgs = imgs.permute(0, 3, 1, 2) 155 | 156 | # return {'img': imgs, 'annot': annot_padded, 'scale': scales} -------------------------------------------------------------------------------- /demo.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "%load_ext autoreload\n", 10 | "\n", 11 | "%autoreload 2" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": null, 17 | "metadata": {}, 18 | "outputs": [], 19 | "source": [ 20 | "import os\n", 21 | "import numpy as np\n", 22 | "from torchvision import transforms\n", 23 | "\n", 24 | "import matplotlib.pyplot as plt\n", 25 | "import torch \n", 26 | "import torch.nn as nn\n", 27 | "from torch.utils.data import DataLoader\n", 28 | "\n", 29 | "from net import BusterNet\n", 30 | "from dataset import USCISIDataset" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 3, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "\n", 40 | "def viz(imgs_np, simi_out_np, mani_out_np, mask_out_np, index):\n", 41 | " fig = plt.figure(figsize=(20, 80))\n", 42 | "\n", 43 | " img = imgs_np[index]\n", 44 | " img = imgs_np[index] * [0.229, 0.224, 0.225] + [0.485, 0.456, 0.406]\n", 45 | "\n", 46 | " ax = fig.add_subplot(1, 4, 1)\n", 47 | " plt.imshow(img)\n", 48 | " plt.title('Original Image')\n", 49 | "\n", 50 | " simi_pred = (simi_out_np[index] * 2).astype(np.uint8)\n", 51 | " ax = fig.add_subplot(1, 4, 2)\n", 52 | " plt.imshow(simi_pred[:,:, 0])\n", 53 | " plt.title('Similarity mask')\n", 54 | "\n", 55 | " mani_pred = (mani_out_np[index] * 2).astype(np.uint8)\n", 56 | " ax = fig.add_subplot(1, 4, 3)\n", 57 | " plt.imshow(mani_pred[:,:, 0])\n", 58 | " plt.title('Manipulation mask')\n", 59 | "\n", 60 | " mask_pred = (mask_out_np[index] * 2).astype(np.uint8) * 255\n", 61 | " ax = fig.add_subplot(1, 4, 4)\n", 62 | " plt.imshow(mask_pred)\n", 63 | " plt.title('Output mask')\n", 64 | "\n", 65 | " plt.show()" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 6, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "# Download dataset to ./datasets/\n", 75 | "lmdb_dir = './datasets/USCISI-CMFD'\n", 76 | "test_file = 'test.keys'\n", 77 | "input_size = 256\n", 78 | "\n", 79 | "transform = transforms.Compose([\n", 80 | " transforms.ToPILImage(),\n", 81 | " transforms.Resize((input_size, input_size)),\n", 82 | " transforms.ToTensor(),\n", 83 | " transforms.Normalize(mean=[0.485, 0.456, 0.406],\n", 84 | " std=[0.229, 0.224, 0.225]),\n", 85 | "])\n", 86 | "target_transform = transforms.Compose([\n", 87 | " transforms.ToPILImage(),\n", 88 | " transforms.Resize((input_size, input_size)),\n", 89 | " transforms.ToTensor(),\n", 90 | "])\n", 91 | "test_set = USCISIDataset(lmdb_dir, test_file, transform, target_transform)\n", 92 | "\n", 93 | "test_params = {'batch_size': 16,\n", 94 | " 'shuffle': False,\n", 95 | " 'drop_last': True,\n", 96 | " # 'collate_fn': collater,\n", 97 | " 'num_workers': 1}\n", 98 | "\n", 99 | "test_generator = DataLoader(test_set, **test_params)" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": 7, 105 | "metadata": {}, 106 | "outputs": [], 107 | "source": [ 108 | "data = next(iter(test_generator))\n", 109 | "\n", 110 | "imgs, gts, _= data" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 8, 116 | "metadata": {}, 117 | "outputs": [ 118 | { 119 | "name": "stderr", 120 | "output_type": "stream", 121 | "text": [ 122 | "/home/klein/miniconda3/envs/torch/lib/python3.6/site-packages/torch/nn/functional.py:2479: UserWarning: Default upsampling behavior when mode=bilinear is changed to align_corners=False since 0.4.0. Please specify align_corners=True if the old behavior is desired. See the documentation of nn.Upsample for details.\n", 123 | " \"See the documentation of nn.Upsample for details.\".format(mode))\n" 124 | ] 125 | } 126 | ], 127 | "source": [ 128 | "model = BusterNet(256)\n", 129 | "\n", 130 | "model.load_state_dict(torch.load('trained_model/buster_epoch_13.pth'))\n", 131 | "\n", 132 | "model.eval()\n", 133 | "with torch.no_grad():\n", 134 | " preds = model(imgs)\n", 135 | " \n", 136 | "mask_out, mani_output, simi_output = preds\n", 137 | "\n", 138 | "mask_out_np = mask_out.permute(0, 2, 3, 1).numpy()\n", 139 | "mani_out_np = mani_output.permute(0, 2, 3, 1).numpy()\n", 140 | "simi_out_np = simi_output.permute(0, 2, 3, 1).numpy()\n" 141 | ] 142 | }, 143 | { 144 | "cell_type": "code", 145 | "execution_count": 21, 146 | "metadata": {}, 147 | "outputs": [ 148 | { 149 | "name": "stderr", 150 | "output_type": "stream", 151 | "text": [ 152 | "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" 153 | ] 154 | }, 155 | { 156 | "data": { 157 | "image/png": "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\n", 158 | "text/plain": [ 159 | "
" 160 | ] 161 | }, 162 | "metadata": { 163 | "needs_background": "light" 164 | }, 165 | "output_type": "display_data" 166 | } 167 | ], 168 | "source": [ 169 | "index = 11\n", 170 | "imgs_np = imgs.permute(0, 2, 3, 1).numpy()\n", 171 | "\n", 172 | "viz(imgs_np, simi_out_np, mani_out_np, mask_out_np, index)" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "metadata": {}, 179 | "outputs": [], 180 | "source": [] 181 | } 182 | ], 183 | "metadata": { 184 | "kernelspec": { 185 | "display_name": "torch", 186 | "language": "python", 187 | "name": "torch" 188 | }, 189 | "language_info": { 190 | "codemirror_mode": { 191 | "name": "ipython", 192 | "version": 3 193 | }, 194 | "file_extension": ".py", 195 | "mimetype": "text/x-python", 196 | "name": "python", 197 | "nbconvert_exporter": "python", 198 | "pygments_lexer": "ipython3", 199 | "version": "3.6.10" 200 | } 201 | }, 202 | "nbformat": 4, 203 | "nbformat_minor": 4 204 | } 205 | -------------------------------------------------------------------------------- /net.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | import torchvision.models as models 5 | 6 | from utils import Conv2dStaticSamePadding as Conv2d 7 | 8 | class BasicConv2D(nn.Module): 9 | def __init__(self, in_channels, out_channels, **kwargs): 10 | super(BasicConv2D, self).__init__() 11 | self.conv = Conv2d(in_channels, out_channels, bias=True, **kwargs) 12 | self.bn = nn.BatchNorm2d(out_channels, eps=1e-3) 13 | 14 | def forward(self, x): 15 | x = self.conv(x) 16 | x = self.bn(x) 17 | return F.relu(x, inplace=True) 18 | 19 | class Inception(nn.Module): 20 | '''BatchNorm Inception module with batch normalization 21 | Input: 22 | x = tensor4D, (n_samples, n_rows, n_cols, n_feats) 23 | ''' 24 | def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, conv_block=None, is_last=False): 25 | super(Inception, self).__init__() 26 | if conv_block is None: 27 | conv_block = BasicConv2D 28 | if is_last: 29 | k_size1, k_size2, k_size3 = 5, 7, 11 30 | else: 31 | k_size1, k_size2, k_size3 = 1, 3, 5 32 | 33 | self.branch1 = conv_block(in_channels, ch1x1, kernel_size=k_size1) 34 | 35 | self.branch2 = nn.Sequential( 36 | conv_block(in_channels, ch3x3red, kernel_size=1), 37 | conv_block(ch3x3red, ch3x3, kernel_size=k_size2, padding=1) 38 | ) 39 | 40 | self.branch3 = nn.Sequential( 41 | conv_block(in_channels, ch5x5red, kernel_size=1), 42 | conv_block(ch5x5red, ch5x5, kernel_size=k_size3, padding=1) 43 | ) 44 | 45 | def forward(self, x): 46 | x1 = self.branch1(x) 47 | x2 = self.branch2(x) 48 | x3 = self.branch3(x) 49 | 50 | outputs = torch.cat((x1, x2, x3), dim=1) 51 | return outputs 52 | 53 | class CorrelationPercPooling(nn.Module): 54 | '''Custom Self-Correlation Percentile Pooling Layer 55 | ''' 56 | def __init__(self, nb_pools=256, **kwargs): 57 | super(CorrelationPercPooling, self).__init__() 58 | self.nb_pools = nb_pools 59 | 60 | n_maps = 16*16 61 | 62 | if self.nb_pools is not None: 63 | self.ranks = torch.floor(torch.linspace(0, n_maps -1, self.nb_pools)).type(torch.long) 64 | else: 65 | self.ranks = torch.range(1, n_maps, dtype=torch.long) 66 | 67 | def forward(self, x): 68 | ''' 69 | x_shape: (n, c, h, w) 70 | ''' 71 | n_bsize, n_feats, n_cols, n_rows = x.shape 72 | n_maps = n_cols * n_rows 73 | x_3d = x.reshape(n_bsize, n_feats, n_maps) 74 | 75 | x_corr_3d = torch.matmul(x_3d.transpose(1, 2), x_3d) / n_feats 76 | x_corr = x_corr_3d.reshape(n_bsize, n_maps, n_cols, n_rows) 77 | 78 | # ranks = ranks.to(devices) 79 | x_sort, _ = torch.topk(x_corr, k=n_maps, dim=1, sorted=True) 80 | 81 | x_f1st_sort = x_sort.permute(1, 2, 3, 0) 82 | x_f1st_pool = x_f1st_sort[self.ranks] 83 | x_pool = x_f1st_pool.permute(3, 0, 1, 2) 84 | 85 | return x_pool 86 | 87 | def make_layers(cfg, batch_norm=False): 88 | layers = [] 89 | in_channels = 3 90 | for v in cfg: 91 | if v == 'M': 92 | layers += [nn.MaxPool2d(kernel_size=2, stride=2)] 93 | else: 94 | conv2d = Conv2d(in_channels, v, kernel_size=3, padding=1) 95 | if batch_norm: 96 | layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)] 97 | else: 98 | layers += [conv2d, nn.ReLU(inplace=True)] 99 | in_channels = v 100 | return layers 101 | 102 | cfgs = { 103 | 'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'], 104 | 'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'], 105 | 'C': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M'], 106 | 'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'], 107 | 'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'], 108 | } 109 | 110 | class DeconvBlock(nn.Module): 111 | def __init__(self, in_channels, out_channels): 112 | super(DeconvBlock, self).__init__() 113 | self.upsample = nn.UpsamplingBilinear2d(scale_factor=2) 114 | 115 | h_channels = out_channels // 2 116 | self.inception = Inception(in_channels, out_channels, h_channels, out_channels, h_channels, out_channels) 117 | 118 | def forward(self, x): 119 | x = self.upsample(x) 120 | x = self.inception(x) 121 | return x 122 | 123 | class MaskDecoder(nn.Module): 124 | def __init__(self, in_channels=512): 125 | super(MaskDecoder, self).__init__() 126 | self.f16 = Inception(in_channels, 8, 4, 8, 4, 8) 127 | 128 | self.deconv_0 = DeconvBlock(24, 6) 129 | self.deconv_1 = DeconvBlock(18, 4) 130 | self.deconv_2 = DeconvBlock(12, 2) 131 | self.deconv_3 = DeconvBlock(6, 2) 132 | 133 | self.pred_mask = Inception(6, 2, 1, 2, 1, 2, is_last=True) 134 | 135 | def forward(self, x): 136 | f16 = self.f16(x) 137 | f32 = self.deconv_0(f16) 138 | f64 = self.deconv_1(f32) 139 | f128 = self.deconv_2(f64) 140 | f256 = self.deconv_3(f128) 141 | pred_mask = self.pred_mask(f256) 142 | 143 | return pred_mask 144 | 145 | class ManipulationNet(nn.Module): 146 | def __init__(self): 147 | super(ManipulationNet, self).__init__() 148 | # self.features = nn.Sequential(*make_layers(cfgs['C'])) 149 | self.features = models.vgg16_bn().features[:-10] 150 | self.mask_decoder = MaskDecoder(512) 151 | self.classifier = nn.Sequential( 152 | Conv2d(6, 1, kernel_size=3), 153 | nn.Sigmoid() 154 | ) 155 | 156 | def forward(self, x): 157 | x = self.features(x) 158 | x = self.mask_decoder(x) 159 | mask = self.classifier(x) 160 | return x, mask 161 | 162 | class SimilarityNet(nn.Module): 163 | def __init__(self): 164 | super(SimilarityNet, self).__init__() 165 | # self.features = nn.Sequential(*make_layers(cfgs['C'])) 166 | self.features = models.vgg16_bn().features[:-10] 167 | self.correlation_per_pooling = CorrelationPercPooling(nb_pools=256) 168 | self.mask_decoder = MaskDecoder(256) 169 | self.classifier = nn.Sequential( 170 | Conv2d(6, 1, kernel_size=3), 171 | nn.Sigmoid() 172 | ) 173 | 174 | def forward(self, x): 175 | x = self.features(x) 176 | x = self.correlation_per_pooling(x) 177 | x = self.mask_decoder(x) 178 | mask = self.classifier(x) 179 | return x, mask 180 | 181 | class BusterNet(nn.Module): 182 | def __init__(self, image_size): 183 | super(BusterNet, self).__init__() 184 | 185 | self.image_size = image_size 186 | 187 | self.manipulation_net = ManipulationNet() 188 | self.similarity_net = SimilarityNet() 189 | 190 | self.inception = nn.Sequential( 191 | Inception(12, 3, 3, 3, 3, 3), 192 | Conv2d(9, 3, kernel_size=3), 193 | nn.Softmax2d() 194 | ) 195 | 196 | def forward(self, x): 197 | mani_feat, mani_output = self.manipulation_net(x) 198 | simi_feat, simi_output = self.similarity_net(x) 199 | 200 | merged_feat = torch.cat([simi_feat, mani_feat], dim=1) 201 | 202 | x = self.inception(merged_feat) 203 | 204 | mask_out = F.interpolate(x, size=(self.image_size, self.image_size), mode='bilinear') 205 | return mask_out, mani_output, simi_output 206 | 207 | if __name__ == "__main__": 208 | model = BusterNet(256) 209 | print(model) 210 | num_params = sum(p.numel() for p in model.parameters() if p.requires_grad) 211 | print(num_params) 212 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | imgaug==0.2.6 2 | lmdb==1.0.0 3 | numpy==1.17.5 4 | opencv-python==4.4.0.46 5 | opencv-python-headless==4.2.0.34 6 | Pillow==7.1.2 7 | tensorboard==2.2.2 8 | tensorboard-plugin-wit==1.7.0 9 | tensorboardX==2.1 10 | torch==1.2.0 11 | torchvision==0.4.0 12 | tqdm==4.46.0 13 | -------------------------------------------------------------------------------- /train.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | import datetime 3 | import os 4 | import traceback 5 | 6 | import numpy as np 7 | import torch 8 | from torch import nn 9 | from torch.utils.data import DataLoader 10 | from torchvision import transforms 11 | from tensorboardX import SummaryWriter 12 | from tqdm import tqdm 13 | 14 | from dataset import USCISIDataset 15 | from net import BusterNet 16 | from utils import CustomDataParallel 17 | 18 | def get_args(): 19 | parser = argparse.ArgumentParser('Buster Net') 20 | parser.add_argument('-n', '--num_workers', type=int, default=16, help='num_workers of dataloader') 21 | parser.add_argument('-b', '--batch_size', type=int, default=4, help='The number of images per batch among all devices') 22 | parser.add_argument('--num_gpus', type=int, default=1, help='The number of gpus') # Multi gpus not support yet. 23 | parser.add_argument('--freeze_layers', nargs='*', default=None, 24 | help='freeze layers with strategy') 25 | parser.add_argument('--lr', type=float, default=1e-2) 26 | parser.add_argument('--optim', type=str, default='adamw', help='select optimizer for training, ' 27 | 'suggest using \'adamw\' or \'adam\' until the' 28 | ' very final stage then switch to \'sgd\'') 29 | parser.add_argument('--num_epochs', type=int, default=500) 30 | parser.add_argument('--val_interval', type=int, default=1, help='Number of epoches between valing phases') 31 | parser.add_argument('--save_interval', type=int, default=500, help='Number of steps between saving') 32 | parser.add_argument('--es_min_delta', type=float, default=0.0, 33 | help='Early stopping\'s parameter: minimum change loss to qualify as an improvement') 34 | parser.add_argument('--es_patience', type=int, default=0, 35 | help='Early stopping\'s parameter: number of epochs with no improvement after which training will be stopped. Set to 0 to disable this technique.') 36 | parser.add_argument('--lmdb_dir', type=str, default='./datasets/USCISI-CMFD', help='the root folder of dataset') 37 | parser.add_argument('--log_path', type=str, default='./logs/') 38 | parser.add_argument('-w', '--load_weights', type=str, default=None, 39 | help='whether to load weights from a checkpoint, set None to initialize, set \'last\' to load last checkpoint') 40 | parser.add_argument('--saved_path', type=str, default='logs/') 41 | 42 | args = parser.parse_args() 43 | return args 44 | 45 | 46 | class ModelWithLoss(nn.Module): 47 | def __init__(self, model, train_simi=True, train_mani=True, train_fusion=True, debug=False): 48 | super().__init__() 49 | self.ce_criterion = nn.CrossEntropyLoss() 50 | self.bce_criterion = nn.BCELoss() 51 | self.model = model 52 | self.train_simi = train_simi 53 | self.train_mani = train_mani 54 | self.train_fusion = train_fusion 55 | self.debug = debug 56 | 57 | def forward(self, imgs, gts): 58 | fusion_preds, mani_preds, simi_preds = self.model(imgs) 59 | simi_gts = (1 - gts[:, 2, :, :]).type(torch.float) 60 | mani_gts = gts[:, 0, :, :].type(torch.float) 61 | _, fusion_gts = gts.max(dim=1) 62 | 63 | loss = torch.zeros(3) 64 | if self.train_fusion: 65 | fusion_loss = self.ce_criterion(fusion_preds, fusion_gts) 66 | loss[0] = fusion_loss 67 | if self.train_mani: 68 | mani_preds = mani_preds.squeeze(1) 69 | mani_loss = self.bce_criterion(mani_preds, mani_gts) 70 | loss[1] = mani_loss 71 | if self.train_simi: 72 | simi_preds = simi_preds.squeeze(1) 73 | simi_loss = self.bce_criterion(simi_preds, simi_gts) 74 | loss[2] = simi_loss 75 | 76 | return loss 77 | 78 | 79 | def train(opt): 80 | train_file = 'train.keys' 81 | val_file = 'valid.keys' 82 | # Train similarity network or manipulation network independently or the whole network. 83 | train_simi=True 84 | train_mani=True 85 | train_fusion=True 86 | 87 | # According to the papers, set input_size default to 256. 88 | input_size = 256 89 | 90 | train_transform = transforms.Compose([ 91 | transforms.ToPILImage(), 92 | transforms.Resize((input_size, input_size)), 93 | # transforms.RandomHorizontalFlip(), 94 | transforms.ToTensor(), 95 | transforms.Normalize(mean=[0.485, 0.456, 0.406], 96 | std=[0.229, 0.224, 0.225]), 97 | ]) 98 | val_transform = transforms.Compose([ 99 | transforms.ToPILImage(), 100 | transforms.Resize((input_size, input_size)), 101 | transforms.ToTensor(), 102 | transforms.Normalize(mean=[0.485, 0.456, 0.406], 103 | std=[0.229, 0.224, 0.225]), 104 | ]) 105 | target_transform = transforms.Compose([ 106 | transforms.ToPILImage(), 107 | transforms.Resize((input_size, input_size)), 108 | transforms.ToTensor(), 109 | ]) 110 | train_set = USCISIDataset(opt.lmdb_dir, train_file, train_transform, target_transform) 111 | val_set = USCISIDataset(opt.lmdb_dir, val_file, val_transform, target_transform) 112 | 113 | training_params = {'batch_size': opt.batch_size, 114 | 'shuffle': True, 115 | 'drop_last': True, 116 | # 'collate_fn': collater, 117 | 'num_workers': opt.num_workers} 118 | 119 | val_params = {'batch_size': opt.batch_size, 120 | 'shuffle': False, 121 | 'drop_last': True, 122 | # 'collate_fn': collater, 123 | 'num_workers': opt.num_workers} 124 | 125 | training_generator = DataLoader(train_set, **training_params) 126 | val_generator = DataLoader(val_set, **val_params) 127 | 128 | model = BusterNet(image_size=input_size) 129 | 130 | if opt.load_weights is not None: 131 | try: 132 | # Load pretrain VGG16 in https://download.pytorch.org/models/vgg16-397923af.pth or continuing training 133 | if 'vgg16_bn' in opt.load_weights: 134 | vgg_backbone = torch.load(opt.load_weights) 135 | model.manipulation_net.load_state_dict(vgg_backbone, strict=False) 136 | model.similarity_net.load_state_dict(vgg_backbone, strict=False) 137 | else: 138 | model.load_state_dict(torch.load(opt.load_weights), strict=False) 139 | except RuntimeError as e: 140 | print(f'[Warning] Ignoring {e}') 141 | print( 142 | f'[Info] loaded weights: {os.path.basename(opt.load_weights)}') 143 | else: 144 | print('[Info] initializing weights...') 145 | # init_weights(model) 146 | 147 | if opt.freeze_layers is not None: 148 | assert isinstance(opt.freeze_layers, list), "Required List string" 149 | def freeze_layers(m): 150 | classname = m.__class__.__name__ 151 | for ntl in opt.freeze_layers: 152 | if ntl in classname: 153 | for param in m.parameters(): 154 | param.require_grad = False 155 | 156 | model.apply(freeze_layers) 157 | print('[Info] freeze layers in ', opt.freeze_layers) 158 | 159 | # warp the model with loss function, to reduce the memory usage on gpu0 and speedup 160 | model = ModelWithLoss(model, train_simi=train_simi, train_mani=train_mani, train_fusion=train_fusion) 161 | 162 | if opt.num_gpus > 1 and opt.batch_size // opt.num_gpus < 4: 163 | model.apply(replace_w_sync_bn) 164 | use_sync_bn = True 165 | else: 166 | use_sync_bn = False 167 | 168 | os.makedirs(opt.saved_path, exist_ok=True) 169 | writer = SummaryWriter(opt.log_path + f'/{datetime.datetime.now().strftime("%Y%m%d-%H%M%S")}/') 170 | 171 | if opt.num_gpus > 0: 172 | model = model.cuda() 173 | if opt.num_gpus > 1: 174 | model = CustomDataParallel(model, opt.num_gpus) 175 | if use_sync_bn: 176 | patch_replication_callback(model) 177 | 178 | if opt.optim == 'adamw': 179 | optimizer = torch.optim.AdamW(model.parameters(), opt.lr) 180 | elif opt.optim == 'adam': 181 | optimizer = torch.optim.Adam(model.parameters(), opt.lr) 182 | else: 183 | optimizer = torch.optim.SGD(model.parameters(), opt.lr, momentum=0.9, nesterov=True) 184 | 185 | scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=3, verbose=True) 186 | 187 | last_step = 0 188 | epoch = 0 189 | best_loss = 1e5 190 | best_epoch = 0 191 | step = max(0, last_step) 192 | model.train() 193 | 194 | num_iter_per_epoch = len(training_generator) 195 | 196 | try: 197 | for epoch in range(opt.num_epochs): 198 | 199 | epoch_loss = [] 200 | progress_bar = tqdm(training_generator) 201 | for iter, data in enumerate(progress_bar): 202 | last_epoch = step // num_iter_per_epoch 203 | if iter < step - last_epoch * num_iter_per_epoch: 204 | progress_bar.update() 205 | continue 206 | try: 207 | imgs, gts, _ = data 208 | 209 | if opt.num_gpus == 1: 210 | # if only one gpu, just send it to cuda:0 211 | # elif multiple gpus, send it to multiple gpus in CustomDataParallel, not here 212 | imgs = imgs.cuda() 213 | gts = gts.cuda() 214 | 215 | optimizer.zero_grad() 216 | 217 | fusion_loss, mani_loss, simi_loss = model(imgs, gts) 218 | fusion_loss = fusion_loss.mean() 219 | simi_loss = simi_loss.mean() 220 | mani_loss = mani_loss.mean() 221 | 222 | loss = fusion_loss + mani_loss + simi_loss 223 | if loss == 0 or not torch.isfinite(loss): 224 | continue 225 | 226 | loss.backward() 227 | # torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1) 228 | optimizer.step() 229 | 230 | epoch_loss.append(float(loss)) 231 | 232 | progress_bar.set_description( 233 | 'Step: {}. Epoch: {}/{}. Iteration: {}/{}. Fusion loss: {:.5f}. Mani loss: {:.5f}. Mini loss: {:.5f} Total loss: {:.5f}'.format( 234 | step, epoch, opt.num_epochs, iter + 1, num_iter_per_epoch, fusion_loss.item(), 235 | mani_loss.item(), simi_loss.item(), loss.item())) 236 | writer.add_scalar('Loss', loss, step) 237 | writer.add_scalar('fusion_loss', fusion_loss, step) 238 | writer.add_scalar('simi_loss', simi_loss, step) 239 | writer.add_scalar('mani_loss', mani_loss, step) 240 | 241 | # log learning_rate 242 | current_lr = optimizer.param_groups[0]['lr'] 243 | writer.add_scalar('learning_rate', current_lr, step) 244 | 245 | step += 1 246 | 247 | if step % opt.save_interval == 0 and step > 0: 248 | save_checkpoint(model, f'model_{epoch}_{step}.pth') 249 | print('checkpoint...') 250 | 251 | except Exception as e: 252 | print('[Error]', traceback.format_exc()) 253 | print(e) 254 | continue 255 | scheduler.step(np.mean(epoch_loss)) 256 | 257 | if epoch % opt.val_interval == 0: 258 | model.eval() 259 | loss_fusion_ls = [] 260 | loss_simi_ls = [] 261 | loss_mani_ls = [] 262 | for iter, data in enumerate(val_generator): 263 | with torch.no_grad(): 264 | imgs, gts, _ = data 265 | 266 | if opt.num_gpus == 1: 267 | imgs = imgs.cuda() 268 | gts = gts.cuda() 269 | 270 | fusion_loss, mani_loss, simi_loss = model(imgs, gts) 271 | fusion_loss = fusion_loss.mean() 272 | simi_loss = simi_loss.mean() 273 | mani_loss = mani_loss.mean() 274 | 275 | loss = fusion_loss + mani_loss + simi_loss 276 | if loss == 0 or not torch.isfinite(loss): 277 | continue 278 | 279 | loss_fusion_ls.append(fusion_loss.item()) 280 | loss_simi_ls.append(simi_loss.item()) 281 | loss_mani_ls.append(mani_loss.item()) 282 | 283 | fusion_loss = np.mean(loss_fusion_ls) 284 | simi_loss = np.mean(loss_simi_ls) 285 | mani_loss = np.mean(loss_mani_ls) 286 | loss = fusion_loss + simi_loss + mani_loss 287 | 288 | print( 289 | 'Val. Epoch: {}/{}. Fusion loss: {:1.5f}. Simi loss: {:1.5f}. Mani loss: {:1.5f}. Total loss: {:1.5f}'.format( 290 | epoch, opt.num_epochs, fusion_loss, simi_loss, mani_loss, loss)) 291 | writer.add_scalar('Val_Loss', loss, step) 292 | writer.add_scalar('Val_Fusion_loss', fusion_loss, step) 293 | writer.add_scalar('Val_Simi_loss', simi_loss, step) 294 | writer.add_scalar('Val_Mani_loss', mani_loss, step) 295 | 296 | if loss + opt.es_min_delta < best_loss: 297 | best_loss = loss 298 | best_epoch = epoch 299 | 300 | save_checkpoint(model, f'model_{epoch}_{step}.pth') 301 | 302 | model.train() 303 | 304 | # Early stopping 305 | if epoch - best_epoch > opt.es_patience > 0: 306 | print('[Info] Stop training at epoch {}. The lowest loss achieved is {}'.format(epoch, best_loss)) 307 | break 308 | except KeyboardInterrupt: 309 | save_checkpoint(model, f'model_{epoch}_{step}.pth') 310 | writer.close() 311 | writer.close() 312 | 313 | def save_checkpoint(model, name): 314 | if isinstance(model, CustomDataParallel): 315 | torch.save(model.module.model.state_dict(), os.path.join(opt.saved_path, name)) 316 | else: 317 | torch.save(model.model.state_dict(), os.path.join(opt.saved_path, name)) 318 | 319 | if __name__ == '__main__': 320 | opt = get_args() 321 | train(opt) 322 | -------------------------------------------------------------------------------- /trained_model/buster_epoch_13.pth: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ntdat017/BusterNet_pytorch/6a03f73eeb648e6effe729958dac765c9e601ee3/trained_model/buster_epoch_13.pth -------------------------------------------------------------------------------- /utils.py: -------------------------------------------------------------------------------- 1 | # Author: Zylo117 2 | 3 | import math 4 | 5 | from torch import nn 6 | import torch.nn.functional as F 7 | 8 | 9 | class Conv2dStaticSamePadding(nn.Module): 10 | """ 11 | created by Zylo117 12 | The real keras/tensorflow conv2d with same padding 13 | """ 14 | 15 | def __init__(self, in_channels, out_channels, kernel_size, stride=1, bias=True, groups=1, dilation=1, **kwargs): 16 | super().__init__() 17 | self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride=stride, 18 | bias=bias, groups=groups) 19 | self.stride = self.conv.stride 20 | self.kernel_size = self.conv.kernel_size 21 | self.dilation = self.conv.dilation 22 | 23 | if isinstance(self.stride, int): 24 | self.stride = [self.stride] * 2 25 | elif len(self.stride) == 1: 26 | self.stride = [self.stride[0]] * 2 27 | 28 | if isinstance(self.kernel_size, int): 29 | self.kernel_size = [self.kernel_size] * 2 30 | elif len(self.kernel_size) == 1: 31 | self.kernel_size = [self.kernel_size[0]] * 2 32 | 33 | def forward(self, x): 34 | h, w = x.shape[-2:] 35 | 36 | extra_h = (math.ceil(w / self.stride[1]) - 1) * self.stride[1] - w + self.kernel_size[1] 37 | extra_v = (math.ceil(h / self.stride[0]) - 1) * self.stride[0] - h + self.kernel_size[0] 38 | 39 | left = extra_h // 2 40 | right = extra_h - left 41 | top = extra_v // 2 42 | bottom = extra_v - top 43 | 44 | x = F.pad(x, [left, right, top, bottom]) 45 | 46 | x = self.conv(x) 47 | return x 48 | 49 | 50 | class CustomDataParallel(nn.DataParallel): 51 | """ 52 | force splitting data to all gpus instead of sending all data to cuda:0 and then moving around. 53 | """ 54 | 55 | def __init__(self, module, num_gpus): 56 | super().__init__(module) 57 | self.num_gpus = num_gpus 58 | 59 | def scatter(self, inputs, kwargs, device_ids): 60 | # More like scatter and data prep at the same time. The point is we prep the data in such a way 61 | # that no scatter is necessary, and there's no need to shuffle stuff around different GPUs. 62 | devices = ['cuda:' + str(x) for x in range(self.num_gpus)] 63 | splits = inputs[0].shape[0] // self.num_gpus 64 | 65 | if splits == 0: 66 | raise Exception('Batchsize must be greater than num_gpus.') 67 | 68 | return [(inputs[0][splits * device_idx: splits * (device_idx + 1)].to(f'cuda:{device_idx}', non_blocking=True), 69 | inputs[1][splits * device_idx: splits * (device_idx + 1)].to(f'cuda:{device_idx}', non_blocking=True)) 70 | for device_idx in range(len(devices))], \ 71 | [kwargs] * len(devices) -------------------------------------------------------------------------------- /visualizes/visualize1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ntdat017/BusterNet_pytorch/6a03f73eeb648e6effe729958dac765c9e601ee3/visualizes/visualize1.png -------------------------------------------------------------------------------- /visualizes/visualize2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ntdat017/BusterNet_pytorch/6a03f73eeb648e6effe729958dac765c9e601ee3/visualizes/visualize2.png -------------------------------------------------------------------------------- /visualizes/visualize3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ntdat017/BusterNet_pytorch/6a03f73eeb648e6effe729958dac765c9e601ee3/visualizes/visualize3.png --------------------------------------------------------------------------------