├── FSRCNN ├── FSRCNN_Net.png ├── set_env.sh ├── solver.prototxt ├── fsrcnn_input_datalayer.py └── train.prototxt ├── MY_SR ├── result │ ├── new.jpg │ └── original.jpg ├── set_env.sh ├── solver.prototxt ├── deploy.prototxt ├── train.prototxt └── aoi_srcnn_input_datalayer.py ├── SRCNN ├── result │ ├── new.jpg │ ├── original.jpg │ └── _iter_584789.caffemodel ├── set_env.sh ├── solver.prototxt ├── DataMatrixGenerate_demo.py ├── deploy.prototxt ├── train.prototxt └── srcnn_input_datalayer.py ├── VDSR ├── result │ ├── new.jpg │ ├── original.jpg │ └── _iter_10000.caffemodel ├── set_env.sh ├── solver.prototxt ├── vdsr_input_datalayer.py ├── deploy.prototxt └── train.prototxt ├── .gitignore └── README.md /FSRCNN/FSRCNN_Net.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BobLiu20/SuperResolution_Caffe/HEAD/FSRCNN/FSRCNN_Net.png -------------------------------------------------------------------------------- /MY_SR/result/new.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BobLiu20/SuperResolution_Caffe/HEAD/MY_SR/result/new.jpg -------------------------------------------------------------------------------- /SRCNN/result/new.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BobLiu20/SuperResolution_Caffe/HEAD/SRCNN/result/new.jpg -------------------------------------------------------------------------------- /VDSR/result/new.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BobLiu20/SuperResolution_Caffe/HEAD/VDSR/result/new.jpg -------------------------------------------------------------------------------- /MY_SR/result/original.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BobLiu20/SuperResolution_Caffe/HEAD/MY_SR/result/original.jpg -------------------------------------------------------------------------------- /SRCNN/result/original.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BobLiu20/SuperResolution_Caffe/HEAD/SRCNN/result/original.jpg -------------------------------------------------------------------------------- /VDSR/result/original.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BobLiu20/SuperResolution_Caffe/HEAD/VDSR/result/original.jpg -------------------------------------------------------------------------------- /SRCNN/result/_iter_584789.caffemodel: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BobLiu20/SuperResolution_Caffe/HEAD/SRCNN/result/_iter_584789.caffemodel -------------------------------------------------------------------------------- /VDSR/result/_iter_10000.caffemodel: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BobLiu20/SuperResolution_Caffe/HEAD/VDSR/result/_iter_10000.caffemodel -------------------------------------------------------------------------------- /FSRCNN/set_env.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | export LD_LIBRARY_PATH=/usr/local/lib/:$LD_LIBRARY_PATH 4 | export PYTHONPATH=`pwd`:$PYTHONPATH 5 | 6 | -------------------------------------------------------------------------------- /MY_SR/set_env.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | export LD_LIBRARY_PATH=/usr/local/lib/:$LD_LIBRARY_PATH 4 | export PYTHONPATH=`pwd`:$PYTHONPATH 5 | 6 | -------------------------------------------------------------------------------- /SRCNN/set_env.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | export LD_LIBRARY_PATH=/usr/local/lib/:$LD_LIBRARY_PATH 4 | export PYTHONPATH=`pwd`:$PYTHONPATH 5 | 6 | -------------------------------------------------------------------------------- /VDSR/set_env.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | export LD_LIBRARY_PATH=/usr/local/lib/:$LD_LIBRARY_PATH 4 | export PYTHONPATH=`pwd`:$PYTHONPATH 5 | 6 | -------------------------------------------------------------------------------- /SRCNN/solver.prototxt: -------------------------------------------------------------------------------- 1 | average_loss: 100 2 | base_lr: 0.001 3 | display: 100 4 | gamma: 0.1 5 | iter_size: 1 6 | lr_policy: "fixed" 7 | max_iter: 1000000 8 | momentum: 0.9 9 | test_initialization: false 10 | test_interval: 50000000 11 | test_iter: 500 12 | net: "train.prototxt" 13 | weight_decay: 0.0005 14 | snapshot_prefix: "model/" 15 | 16 | -------------------------------------------------------------------------------- /MY_SR/solver.prototxt: -------------------------------------------------------------------------------- 1 | # The train/test net protocol buffer definition 2 | net: "train.prototxt" 3 | test_iter: 1 4 | test_interval: 500000000 5 | # The base learning rate, momentum and the weight decay of the network. 6 | type: "Adam" 7 | base_lr: 0.0001 8 | weight_decay: 0.0001 9 | # The learning rate policy 10 | lr_policy: "fixed" 11 | # Display every 100 iterations 12 | display: 100 13 | # The maximum number of iterations 14 | max_iter: 1000000 15 | # snapshot intermediate results 16 | snapshot: 5000 17 | snapshot_prefix: "model/" 18 | # solver mode: CPU or GPU 19 | solver_mode: GPU 20 | 21 | test_initialization: false 22 | 23 | -------------------------------------------------------------------------------- /VDSR/solver.prototxt: -------------------------------------------------------------------------------- 1 | # The train/test net protocol buffer definition 2 | net: "train.prototxt" 3 | test_iter: 1 4 | test_interval: 500000000 5 | # The base learning rate, momentum and the weight decay of the network. 6 | type: "Adam" 7 | base_lr: 0.0001 8 | weight_decay: 0.0001 9 | # The learning rate policy 10 | lr_policy: "fixed" 11 | # Display every 100 iterations 12 | display: 100 13 | # The maximum number of iterations 14 | max_iter: 1000000 15 | # snapshot intermediate results 16 | snapshot: 5000 17 | snapshot_prefix: "model/" 18 | # solver mode: CPU or GPU 19 | solver_mode: GPU 20 | 21 | test_initialization: false 22 | 23 | -------------------------------------------------------------------------------- /FSRCNN/solver.prototxt: -------------------------------------------------------------------------------- 1 | # The train/test net protocol buffer definition 2 | net: "train.prototxt" 3 | test_iter: 500 4 | # Carry out testing every 500 training iterations. 5 | test_interval: 50000000 6 | # The base learning rate, momentum and the weight decay of the network. 7 | base_lr: 0.001 8 | momentum: 0.9 9 | weight_decay: 0 10 | # The learning rate policy 11 | lr_policy: "fixed" 12 | # Display every 100 iterations 13 | display: 100 14 | # The maximum number of iterations 15 | max_iter: 10000000 16 | # snapshot intermediate results 17 | snapshot: 10000 18 | snapshot_prefix: "model/" 19 | # solver mode: CPU or GPU 20 | solver_mode: GPU 21 | 22 | test_initialization: false 23 | 24 | 25 | -------------------------------------------------------------------------------- /SRCNN/DataMatrixGenerate_demo.py: -------------------------------------------------------------------------------- 1 | 2 | import numpy as np 3 | import cv2 4 | import string, random 5 | from pydmtx import DataMatrix as DMTX 6 | 7 | def gen_dmtx(): 8 | def id_generator(size=16, max_letter=6): 9 | _str = '' 10 | _letter_cnt = 0 11 | for i in range(size): 12 | if _letter_cnt < max_letter: 13 | _c = random.choice(string.ascii_uppercase + string.digits) 14 | if _c in string.ascii_uppercase: 15 | _letter_cnt += 1 16 | else: 17 | _c = random.choice(string.digits) 18 | _str += _c 19 | return _str 20 | _dmtx = DMTX(shape=3)# shape=3 is 16x16 21 | while True: 22 | # 022RDXBTH4001093 23 | _str = id_generator(16) 24 | try: 25 | _dmtx.encode(_str) 26 | except Exception, e: 27 | continue 28 | _im = np.array(_dmtx.image)[:,:,::-1] 29 | yield _im 30 | 31 | if __name__ == '__main__': 32 | _im = gen_dmtx().next() 33 | cv2.imwrite('test.jpg', _im) 34 | 35 | -------------------------------------------------------------------------------- /.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 | env/ 12 | build/ 13 | develop-eggs/ 14 | dist/ 15 | downloads/ 16 | eggs/ 17 | .eggs/ 18 | lib/ 19 | lib64/ 20 | parts/ 21 | sdist/ 22 | var/ 23 | wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 27 | 28 | # PyInstaller 29 | # Usually these files are written by a python script from a template 30 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 31 | *.manifest 32 | *.spec 33 | 34 | # Installer logs 35 | pip-log.txt 36 | pip-delete-this-directory.txt 37 | 38 | # Unit test / coverage reports 39 | htmlcov/ 40 | .tox/ 41 | .coverage 42 | .coverage.* 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | *.cover 47 | .hypothesis/ 48 | 49 | # Translations 50 | *.mo 51 | *.pot 52 | 53 | # Django stuff: 54 | *.log 55 | local_settings.py 56 | 57 | # Flask stuff: 58 | instance/ 59 | .webassets-cache 60 | 61 | # Scrapy stuff: 62 | .scrapy 63 | 64 | # Sphinx documentation 65 | docs/_build/ 66 | 67 | # PyBuilder 68 | target/ 69 | 70 | # Jupyter Notebook 71 | .ipynb_checkpoints 72 | 73 | # pyenv 74 | .python-version 75 | 76 | # celery beat schedule file 77 | celerybeat-schedule 78 | 79 | # SageMath parsed files 80 | *.sage.py 81 | 82 | # dotenv 83 | .env 84 | 85 | # virtualenv 86 | .venv 87 | venv/ 88 | ENV/ 89 | 90 | # Spyder project settings 91 | .spyderproject 92 | .spyproject 93 | 94 | # Rope project settings 95 | .ropeproject 96 | 97 | # mkdocs documentation 98 | /site 99 | 100 | # mypy 101 | .mypy_cache/ 102 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Super Resolution 2 | ============== 3 | All of this methods is implementation in caffe python. 4 | 5 | ### Instruction 6 | 7 | * VDSR (Very Deep network for Super-Resolution) is an end-to-end network with 20 convolutional layers for single image super-resolution. [[Web]](http://cv.snu.ac.kr/research/VDSR/) 8 | 9 | * SRCNN (Image Super-Resolution Using Deep Convolutional Networks) [[Web]](http://mmlab.ie.cuhk.edu.hk/projects/SRCNN.html) 10 | 11 | * FSRCNN (Accelerating the Super-Resolution Convolutional Neural Network) [[Web]](http://mmlab.ie.cuhk.edu.hk/projects/FSRCNN.html) 12 | 13 | * MY_SR was modified from VDSR and SRCNN. Better performance for this task. 14 | 15 | ### How to training in my code 16 | First of all. I use Super-Resolution to do data matrix reader (Enhance picture quality). 17 | My platform is Ubuntu 14.04 with pycaffe. 18 | 19 | #### 1. Install libdmtx 20 | 21 | Download source code from this [site](https://sourceforge.net/p/libdmtx/dmtx-wrappers/ci/master/tree/). 22 | And then following readme to build and install libdmtx. Also do python setup.py install to install python wrapper name pydmtx. 23 | 24 | #### 2. Set environment variable 25 | ``` 26 | export LD_LIBRARY_PATH=/usr/local/lib/:$LD_LIBRARY_PATH 27 | export PYTHONPATH=`pwd`:$PYTHONPATH 28 | ``` 29 | #### 3. Start to training 30 | ``` 31 | caffe train --solver=solver.prototxt --gpu=0 32 | ``` 33 | 34 | ### Result compare 35 | 36 | * VDSR 37 | 38 | ![original](VDSR/result/original.jpg?raw=true) VS ![new](VDSR/result/new.jpg?raw=true) 39 | 40 | * SRCNN 41 | 42 | ![original](SRCNN/result/original.jpg) VS ![new](SRCNN/result/new.jpg) 43 | 44 | * MY_SR 45 | 46 | ![original](MY_SR/result/original.jpg) VS ![new](MY_SR/result/new.jpg) 47 | 48 | -------------------------------------------------------------------------------- /SRCNN/deploy.prototxt: -------------------------------------------------------------------------------- 1 | name: "SRCNN" 2 | layer { 3 | name: "Input1" 4 | type: "Input" 5 | top: "data" 6 | input_param { 7 | shape { 8 | dim: 1 9 | dim: 1 10 | dim: 100 11 | dim: 100 12 | } 13 | } 14 | } 15 | layer { 16 | name: "conv1" 17 | type: "Convolution" 18 | bottom: "data" 19 | top: "conv1" 20 | param { 21 | lr_mult: 1 22 | } 23 | param { 24 | lr_mult: 2 25 | } 26 | convolution_param { 27 | num_output: 64 28 | kernel_size: 9 29 | stride: 1 30 | weight_filler { 31 | type: "gaussian" 32 | std: 0.4 33 | } 34 | bias_filler { 35 | type: "constant" 36 | value: 0 37 | } 38 | } 39 | } 40 | 41 | layer { 42 | name: "relu1" 43 | type: "ReLU" 44 | bottom: "conv1" 45 | top: "conv1" 46 | } 47 | 48 | layer { 49 | name: "conv2" 50 | type: "Convolution" 51 | bottom: "conv1" 52 | top: "conv2" 53 | param { 54 | lr_mult: 1 55 | } 56 | param { 57 | lr_mult: 2 58 | } 59 | convolution_param { 60 | num_output: 32 61 | kernel_size: 1 62 | stride: 1 63 | weight_filler { 64 | type: "gaussian" 65 | std: 0.01 66 | } 67 | bias_filler { 68 | type: "constant" 69 | value: 0 70 | } 71 | } 72 | } 73 | 74 | layer { 75 | name: "relu2" 76 | type: "ReLU" 77 | bottom: "conv2" 78 | top: "conv2" 79 | } 80 | 81 | layer { 82 | name: "recon" 83 | type: "Convolution" 84 | bottom: "conv2" 85 | top: "recon" 86 | param { 87 | lr_mult: 0.1 88 | } 89 | param { 90 | lr_mult: 0.2 91 | } 92 | convolution_param { 93 | num_output: 1 94 | kernel_size: 5 95 | stride: 1 96 | weight_filler { 97 | type: "gaussian" 98 | std: 0.01 99 | } 100 | bias_filler { 101 | type: "constant" 102 | value: 0 103 | } 104 | } 105 | } 106 | 107 | layer { 108 | name: "sigmoid1" 109 | type: "Sigmoid" 110 | bottom: "recon" 111 | top: "recon" 112 | } 113 | 114 | 115 | -------------------------------------------------------------------------------- /SRCNN/train.prototxt: -------------------------------------------------------------------------------- 1 | name: "SRCNN" 2 | layer { 3 | type: 'Python' 4 | name: 'data' 5 | top: 'data' 6 | top: 'label' 7 | # include { 8 | # phase: TRAIN 9 | # } 10 | python_param { 11 | # the module name -- usually the filename -- that needs to be in $PYTHONPATH 12 | module: 'srcnn_input_datalayer' 13 | # the layer name -- the class name in the module 14 | layer: 'ImageInputDataLayer' 15 | # parameter 16 | param_str: '{"batch_size":128, "im_shape":(100,100), "la_shape":(88,88)}' 17 | } 18 | } 19 | layer { 20 | name: "conv1" 21 | type: "Convolution" 22 | bottom: "data" 23 | top: "conv1" 24 | param { 25 | lr_mult: 1 26 | } 27 | param { 28 | lr_mult: 2 29 | } 30 | convolution_param { 31 | num_output: 64 32 | kernel_size: 9 33 | stride: 1 34 | weight_filler { 35 | type: "gaussian" 36 | std: 0.4 37 | } 38 | bias_filler { 39 | type: "constant" 40 | value: 0 41 | } 42 | } 43 | } 44 | 45 | layer { 46 | name: "relu1" 47 | type: "ReLU" 48 | bottom: "conv1" 49 | top: "conv1" 50 | } 51 | 52 | layer { 53 | name: "conv2" 54 | type: "Convolution" 55 | bottom: "conv1" 56 | top: "conv2" 57 | param { 58 | lr_mult: 1 59 | } 60 | param { 61 | lr_mult: 2 62 | } 63 | convolution_param { 64 | num_output: 32 65 | kernel_size: 1 66 | stride: 1 67 | weight_filler { 68 | type: "gaussian" 69 | std: 0.01 70 | } 71 | bias_filler { 72 | type: "constant" 73 | value: 0 74 | } 75 | } 76 | } 77 | 78 | layer { 79 | name: "relu2" 80 | type: "ReLU" 81 | bottom: "conv2" 82 | top: "conv2" 83 | } 84 | 85 | layer { 86 | name: "recon" 87 | type: "Convolution" 88 | bottom: "conv2" 89 | top: "recon" 90 | param { 91 | lr_mult: 0.1 92 | } 93 | param { 94 | lr_mult: 0.2 95 | } 96 | convolution_param { 97 | num_output: 1 98 | kernel_size: 5 99 | stride: 1 100 | weight_filler { 101 | type: "gaussian" 102 | std: 0.01 103 | } 104 | bias_filler { 105 | type: "constant" 106 | value: 0 107 | } 108 | } 109 | } 110 | 111 | layer { 112 | name: "sigmoid1" 113 | type: "Sigmoid" 114 | bottom: "recon" 115 | top: "recon" 116 | } 117 | 118 | layer { 119 | name: "loss" 120 | bottom: "recon" 121 | bottom: "label" 122 | top: "loss" 123 | type: "EuclideanLoss" 124 | } 125 | -------------------------------------------------------------------------------- /MY_SR/deploy.prototxt: -------------------------------------------------------------------------------- 1 | name: "VDSRCNN" 2 | layer { 3 | name: "Input1" 4 | type: "Input" 5 | top: "data" 6 | input_param { 7 | shape { 8 | dim: 1 9 | dim: 1 10 | dim: 112 11 | dim: 112 12 | } 13 | } 14 | } 15 | 16 | layer { 17 | name: "pre_conv1" 18 | type: "Convolution" 19 | bottom: "data" 20 | top: "pre_conv1" 21 | param { 22 | lr_mult: 1 23 | } 24 | param { 25 | lr_mult: 2 26 | } 27 | convolution_param { 28 | num_output: 64 29 | kernel_size: 9 30 | stride: 1 31 | weight_filler { 32 | type: "gaussian" 33 | std: 0.4 34 | } 35 | bias_filler { 36 | type: "constant" 37 | value: 0 38 | } 39 | } 40 | } 41 | 42 | layer { 43 | name: "pre_relu1" 44 | type: "ReLU" 45 | bottom: "pre_conv1" 46 | top: "pre_conv1" 47 | } 48 | 49 | layer { 50 | name: "pre_conv2" 51 | type: "Convolution" 52 | bottom: "pre_conv1" 53 | top: "pre_conv2" 54 | param { 55 | lr_mult: 1 56 | } 57 | param { 58 | lr_mult: 2 59 | } 60 | convolution_param { 61 | num_output: 32 62 | kernel_size: 1 63 | stride: 1 64 | weight_filler { 65 | type: "gaussian" 66 | std: 0.01 67 | } 68 | bias_filler { 69 | type: "constant" 70 | value: 0 71 | } 72 | } 73 | } 74 | 75 | layer { 76 | name: "pre_relu2" 77 | type: "ReLU" 78 | bottom: "pre_conv2" 79 | top: "pre_conv2" 80 | } 81 | 82 | layer { 83 | name: "pre_recon" 84 | type: "Convolution" 85 | bottom: "pre_conv2" 86 | top: "pre_recon" 87 | param { 88 | lr_mult: 0.1 89 | } 90 | param { 91 | lr_mult: 0.2 92 | } 93 | convolution_param { 94 | num_output: 1 95 | kernel_size: 5 96 | stride: 1 97 | weight_filler { 98 | type: "gaussian" 99 | std: 0.01 100 | } 101 | bias_filler { 102 | type: "constant" 103 | value: 0 104 | } 105 | } 106 | } 107 | 108 | layer { 109 | name: "pre_sigmoid1" 110 | type: "Sigmoid" 111 | bottom: "pre_recon" 112 | top: "pre_recon_out" 113 | } 114 | 115 | layer { 116 | name: "conv1" 117 | type: "Convolution" 118 | bottom: "pre_recon_out" 119 | top: "conv1" 120 | param { 121 | lr_mult: 1 122 | } 123 | param { 124 | lr_mult: 0.1 125 | } 126 | propagate_down:false 127 | convolution_param { 128 | num_output: 64 129 | kernel_size: 3 130 | stride: 1 131 | pad: 1 132 | weight_filler { 133 | type: "msra" 134 | } 135 | bias_filler { 136 | type: "constant" 137 | } 138 | } 139 | } 140 | 141 | layer { 142 | name: "relu1" 143 | type: "ReLU" 144 | bottom: "conv1" 145 | top: "conv1" 146 | } 147 | 148 | layer { 149 | name: "conv2" 150 | type: "Convolution" 151 | bottom: "conv1" 152 | top: "conv2" 153 | param { 154 | lr_mult: 1 155 | } 156 | param { 157 | lr_mult: 0.1 158 | } 159 | convolution_param { 160 | num_output: 64 161 | kernel_size: 3 162 | stride: 1 163 | pad: 1 164 | weight_filler { 165 | type: "msra" 166 | } 167 | bias_filler { 168 | type: "constant" 169 | } 170 | } 171 | } 172 | 173 | layer { 174 | name: "relu2" 175 | type: "ReLU" 176 | bottom: "conv2" 177 | top: "conv2" 178 | } 179 | 180 | layer { 181 | name: "conv3" 182 | type: "Convolution" 183 | bottom: "conv2" 184 | top: "conv3" 185 | param { 186 | lr_mult: 1 187 | } 188 | param { 189 | lr_mult: 0.1 190 | } 191 | convolution_param { 192 | num_output: 1 193 | kernel_size: 3 194 | stride: 1 195 | pad: 1 196 | weight_filler { 197 | type: "msra" 198 | } 199 | bias_filler { 200 | type: "constant" 201 | } 202 | } 203 | } 204 | 205 | layer { 206 | name: "sum" 207 | type: "Eltwise" 208 | bottom: "pre_recon_out" 209 | bottom: "conv3" 210 | top: "sum" 211 | propagate_down:false 212 | propagate_down:true 213 | eltwise_param { 214 | operation: 1 215 | } 216 | } 217 | 218 | layer { 219 | name: "sigmoid2" 220 | type: "Sigmoid" 221 | bottom: "sum" 222 | top: "sum" 223 | } 224 | 225 | 226 | -------------------------------------------------------------------------------- /MY_SR/train.prototxt: -------------------------------------------------------------------------------- 1 | name: "VDSRCNN" 2 | layer { 3 | type: 'Python' 4 | name: 'data' 5 | top: 'data' 6 | top: 'label' 7 | include { 8 | phase: TRAIN 9 | } 10 | python_param { 11 | # the module name -- usually the filename -- that needs to be in $PYTHONPATH 12 | module: 'aoi_srcnn_input_datalayer' 13 | # the layer name -- the class name in the module 14 | layer: 'ImageInputDataLayer' 15 | # parameter 16 | param_str: '{"batch_size":64, "im_shape":(112,112), "la_shape":(100,100)}' 17 | } 18 | } 19 | 20 | layer { 21 | type: 'Python' 22 | name: 'data' 23 | top: 'data' 24 | top: 'label' 25 | include { 26 | phase: TEST 27 | } 28 | python_param { 29 | # the module name -- usually the filename -- that needs to be in $PYTHONPATH 30 | module: 'aoi_srcnn_input_datalayer' 31 | # the layer name -- the class name in the module 32 | layer: 'ImageInputDataLayer' 33 | # parameter 34 | param_str: '{"batch_size":1, "im_shape":(112,112), "la_shape":(100,100)}' 35 | } 36 | } 37 | 38 | layer { 39 | name: "pre_conv1" 40 | type: "Convolution" 41 | bottom: "data" 42 | top: "pre_conv1" 43 | param { 44 | lr_mult: 1 45 | } 46 | param { 47 | lr_mult: 2 48 | } 49 | convolution_param { 50 | num_output: 64 51 | kernel_size: 9 52 | stride: 1 53 | weight_filler { 54 | type: "gaussian" 55 | std: 0.4 56 | } 57 | bias_filler { 58 | type: "constant" 59 | value: 0 60 | } 61 | } 62 | } 63 | 64 | layer { 65 | name: "pre_relu1" 66 | type: "ReLU" 67 | bottom: "pre_conv1" 68 | top: "pre_conv1" 69 | } 70 | 71 | layer { 72 | name: "pre_conv2" 73 | type: "Convolution" 74 | bottom: "pre_conv1" 75 | top: "pre_conv2" 76 | param { 77 | lr_mult: 1 78 | } 79 | param { 80 | lr_mult: 2 81 | } 82 | convolution_param { 83 | num_output: 32 84 | kernel_size: 1 85 | stride: 1 86 | weight_filler { 87 | type: "gaussian" 88 | std: 0.01 89 | } 90 | bias_filler { 91 | type: "constant" 92 | value: 0 93 | } 94 | } 95 | } 96 | 97 | layer { 98 | name: "pre_relu2" 99 | type: "ReLU" 100 | bottom: "pre_conv2" 101 | top: "pre_conv2" 102 | } 103 | 104 | layer { 105 | name: "pre_recon" 106 | type: "Convolution" 107 | bottom: "pre_conv2" 108 | top: "pre_recon" 109 | param { 110 | lr_mult: 0.1 111 | } 112 | param { 113 | lr_mult: 0.2 114 | } 115 | convolution_param { 116 | num_output: 1 117 | kernel_size: 5 118 | stride: 1 119 | weight_filler { 120 | type: "gaussian" 121 | std: 0.01 122 | } 123 | bias_filler { 124 | type: "constant" 125 | value: 0 126 | } 127 | } 128 | } 129 | 130 | layer { 131 | name: "pre_sigmoid1" 132 | type: "Sigmoid" 133 | bottom: "pre_recon" 134 | top: "pre_recon_out" 135 | } 136 | 137 | layer { 138 | name: "conv1" 139 | type: "Convolution" 140 | bottom: "pre_recon_out" 141 | top: "conv1" 142 | param { 143 | lr_mult: 1 144 | } 145 | param { 146 | lr_mult: 0.1 147 | } 148 | convolution_param { 149 | num_output: 64 150 | kernel_size: 3 151 | stride: 1 152 | pad: 1 153 | weight_filler { 154 | type: "msra" 155 | } 156 | bias_filler { 157 | type: "constant" 158 | } 159 | } 160 | } 161 | 162 | layer { 163 | name: "relu1" 164 | type: "ReLU" 165 | bottom: "conv1" 166 | top: "conv1" 167 | } 168 | 169 | layer { 170 | name: "conv2" 171 | type: "Convolution" 172 | bottom: "conv1" 173 | top: "conv2" 174 | param { 175 | lr_mult: 1 176 | } 177 | param { 178 | lr_mult: 0.1 179 | } 180 | convolution_param { 181 | num_output: 64 182 | kernel_size: 3 183 | stride: 1 184 | pad: 1 185 | weight_filler { 186 | type: "msra" 187 | } 188 | bias_filler { 189 | type: "constant" 190 | } 191 | } 192 | } 193 | 194 | layer { 195 | name: "relu2" 196 | type: "ReLU" 197 | bottom: "conv2" 198 | top: "conv2" 199 | } 200 | 201 | layer { 202 | name: "conv3" 203 | type: "Convolution" 204 | bottom: "conv2" 205 | top: "conv3" 206 | param { 207 | lr_mult: 1 208 | } 209 | param { 210 | lr_mult: 0.1 211 | } 212 | convolution_param { 213 | num_output: 1 214 | kernel_size: 3 215 | stride: 1 216 | pad: 1 217 | weight_filler { 218 | type: "msra" 219 | } 220 | bias_filler { 221 | type: "constant" 222 | } 223 | } 224 | } 225 | 226 | layer { 227 | name: "sum" 228 | type: "Eltwise" 229 | bottom: "pre_recon_out" 230 | bottom: "conv3" 231 | top: "sum" 232 | propagate_down:false 233 | propagate_down:true 234 | eltwise_param { 235 | operation: 1 236 | } 237 | } 238 | 239 | layer { 240 | name: "sigmoid2" 241 | type: "Sigmoid" 242 | bottom: "sum" 243 | top: "sum" 244 | } 245 | 246 | layer { 247 | name: "loss" 248 | type: "EuclideanLoss" 249 | bottom: "sum" 250 | bottom: "label" 251 | top: "loss" 252 | } 253 | 254 | -------------------------------------------------------------------------------- /VDSR/vdsr_input_datalayer.py: -------------------------------------------------------------------------------- 1 | 2 | # by Bob in 20170326 3 | import numpy as np 4 | import cv2 5 | import caffe 6 | import os 7 | import string, random 8 | from pydmtx import DataMatrix as DMTX 9 | 10 | class ImageInputDataLayer(caffe.Layer): 11 | def setup(self, bottom, top): 12 | self.top_names = ['data', 'label'] 13 | 14 | # === Read input parameters === 15 | 16 | # params is a python dictionary with layer parameters. 17 | self.params = eval(self.param_str) 18 | 19 | # store input as class variables 20 | self.batch_size = self.params['batch_size'] 21 | 22 | # Create a batch loader to load the images. 23 | self.batch_loader = BatchLoader(self.params) 24 | 25 | # === reshape tops === 26 | top[0].reshape( 27 | self.batch_size, 1, self.params['im_shape'][0], self.params['im_shape'][1]) 28 | top[1].reshape( 29 | self.batch_size, 1, self.params['la_shape'][0], self.params['la_shape'][1]) 30 | 31 | def forward(self, bottom, top): 32 | """ 33 | Load data. 34 | """ 35 | for itt in range(self.batch_size): 36 | # Use the batch loader to load the next image. 37 | im, label = self.batch_loader.load_next_image() 38 | 39 | # Add directly to the caffe data layer 40 | top[0].data[itt, 0, ...] = im 41 | top[1].data[itt, 0, ...] = label 42 | 43 | def reshape(self, bottom, top): 44 | # === reshape tops === 45 | top[0].reshape( 46 | self.batch_size, 1, self.params['im_shape'][0], self.params['im_shape'][1]) 47 | top[1].reshape( 48 | self.batch_size, 1, self.params['la_shape'][0], self.params['la_shape'][1]) 49 | 50 | def backward(self, top, propagate_down, bottom): 51 | """ 52 | These layers does not back propagate 53 | """ 54 | pass 55 | 56 | 57 | class BatchLoader(object): 58 | def __init__(self, params): 59 | self.batch_size = params['batch_size'] 60 | self.im_shape = params['im_shape'] 61 | self.la_shape = params['la_shape'] 62 | 63 | self.image_generator = self.__image_generator() 64 | 65 | def load_next_image(self): 66 | """ 67 | Load the next image in a batch. 68 | """ 69 | return self.image_generator.next() 70 | 71 | def __image_generator(self): 72 | def id_generator(size=16, max_letter=6): 73 | _str = '' 74 | _letter_cnt = 0 75 | for i in range(size): 76 | if _letter_cnt < max_letter: 77 | _c = random.choice(string.ascii_uppercase + string.digits) 78 | if _c in string.ascii_uppercase: 79 | _letter_cnt += 1 80 | else: 81 | _c = random.choice(string.digits) 82 | _str += _c 83 | return _str 84 | def blur_method(_im, m): 85 | if m == 0: 86 | return _im 87 | elif m == 1: 88 | return cv2.GaussianBlur(_im, (5, 5), 0) 89 | elif m == 2: 90 | return cv2.blur(_im, (5,5)) 91 | elif m == 3: 92 | return cv2.medianBlur(_im, 5) 93 | else: 94 | return _im 95 | def brightness(_im): 96 | _brightness_offset = np.random.randint(-50, 50) 97 | return cv2.convertScaleAbs(_im, alpha=1, beta=_brightness_offset) 98 | 99 | _dmtx = DMTX(shape=3)# shape=3 is 16x16 100 | while True: 101 | # 022RDXBTH4001093 102 | _str = id_generator(16, 2) 103 | _dmtx.encode(_str) 104 | _im = np.array(_dmtx.image)# [:,:,::-1] 105 | _im = cv2.cvtColor(_im, cv2.COLOR_RGB2GRAY) 106 | _im = cv2.resize(_im, (self.im_shape[1], self.im_shape[0]), interpolation=cv2.INTER_CUBIC) 107 | _h, _w = _im.shape[:2] 108 | # random mirco rotation 109 | _angle = np.random.randint(-6, 6) / 2.0 110 | _rot_mat = cv2.getRotationMatrix2D((_w / 2, _h / 2), _angle, 1) 111 | _im = cv2.warpAffine(_im, _rot_mat, (_w, _h)) 112 | # get label 113 | _label = cv2.resize(_im, (self.la_shape[1], self.la_shape[0]), interpolation=cv2.INTER_CUBIC) 114 | # low-resolution 115 | _scale = np.random.choice(range(1, 6)) 116 | _im = cv2.resize(_im, (0,0), fx=1/float(_scale), fy=1/float(_scale), interpolation=cv2.INTER_CUBIC) 117 | _im = cv2.resize(_im, (self.im_shape[1], self.im_shape[0]), interpolation=cv2.INTER_CUBIC) 118 | # add noise 119 | _im = blur_method(_im, np.random.choice(range(0, 4))) 120 | _im = brightness(_im) 121 | # to caffe data format 122 | _im = _im.astype(np.float32, copy=False) 123 | _label = _label.astype(np.float32, copy=False) 124 | _im *= 0.0039215684 125 | _label *= 0.0039215684 126 | 127 | yield _im, _label 128 | 129 | -------------------------------------------------------------------------------- /FSRCNN/fsrcnn_input_datalayer.py: -------------------------------------------------------------------------------- 1 | 2 | # by Bob in 20170326 3 | import numpy as np 4 | import cv2 5 | import caffe 6 | import os 7 | import string, random 8 | from pydmtx import DataMatrix as DMTX 9 | 10 | class ImageInputDataLayer(caffe.Layer): 11 | def setup(self, bottom, top): 12 | self.top_names = ['data', 'label'] 13 | 14 | # === Read input parameters === 15 | 16 | # params is a python dictionary with layer parameters. 17 | self.params = eval(self.param_str) 18 | 19 | # store input as class variables 20 | self.batch_size = self.params['batch_size'] 21 | 22 | # Create a batch loader to load the images. 23 | self.batch_loader = BatchLoader(self.params) 24 | 25 | # === reshape tops === 26 | top[0].reshape( 27 | self.batch_size, 1, self.params['im_shape'][0], self.params['im_shape'][1]) 28 | top[1].reshape( 29 | self.batch_size, 1, self.params['la_shape'][0], self.params['la_shape'][1]) 30 | 31 | def forward(self, bottom, top): 32 | """ 33 | Load data. 34 | """ 35 | for itt in range(self.batch_size): 36 | # Use the batch loader to load the next image. 37 | im, label = self.batch_loader.load_next_image() 38 | 39 | # Add directly to the caffe data layer 40 | top[0].data[itt, 0, ...] = im 41 | top[1].data[itt, 0, ...] = label 42 | 43 | def reshape(self, bottom, top): 44 | # === reshape tops === 45 | top[0].reshape( 46 | self.batch_size, 1, self.params['im_shape'][0], self.params['im_shape'][1]) 47 | top[1].reshape( 48 | self.batch_size, 1, self.params['la_shape'][0], self.params['la_shape'][1]) 49 | 50 | def backward(self, top, propagate_down, bottom): 51 | """ 52 | These layers does not back propagate 53 | """ 54 | pass 55 | 56 | 57 | class BatchLoader(object): 58 | def __init__(self, params): 59 | self.batch_size = params['batch_size'] 60 | self.im_shape = params['im_shape'] 61 | self.la_shape = params['la_shape'] 62 | 63 | self.image_generator = self.__image_generator() 64 | 65 | def load_next_image(self): 66 | """ 67 | Load the next image in a batch. 68 | """ 69 | return self.image_generator.next() 70 | 71 | def __image_generator(self): 72 | def id_generator(size=16, max_letter=6): 73 | _str = '' 74 | _letter_cnt = 0 75 | for i in range(size): 76 | if _letter_cnt < max_letter: 77 | _c = random.choice(string.ascii_uppercase + string.digits) 78 | if _c in string.ascii_uppercase: 79 | _letter_cnt += 1 80 | else: 81 | _c = random.choice(string.digits) 82 | _str += _c 83 | return _str 84 | def blur_method(_im, m): 85 | if m == 0: 86 | return _im 87 | elif m == 1: 88 | return cv2.GaussianBlur(_im, (5, 5), 0) 89 | elif m == 2: 90 | return cv2.blur(_im, (5,5)) 91 | elif m == 3: 92 | return cv2.medianBlur(_im, 5) 93 | else: 94 | return _im 95 | def brightness(_im): 96 | _brightness_offset = np.random.randint(-50, 50) 97 | return cv2.convertScaleAbs(_im, alpha=1, beta=_brightness_offset) 98 | 99 | _dmtx = DMTX(shape=3)# shape=3 is 16x16 100 | while True: 101 | # 022RDXBTH4001093 102 | _str = id_generator(16, 2) 103 | _dmtx.encode(_str) 104 | _im = np.array(_dmtx.image)# [:,:,::-1] 105 | _im = cv2.cvtColor(_im, cv2.COLOR_RGB2GRAY) 106 | _im = cv2.resize(_im, (self.im_shape[1], self.im_shape[0]), interpolation=cv2.INTER_CUBIC) 107 | _h, _w = _im.shape[:2] 108 | # random mirco rotation 109 | _angle = np.random.randint(-6, 6) / 2.0 110 | _rot_mat = cv2.getRotationMatrix2D((_w / 2, _h / 2), _angle, 1) 111 | _im = cv2.warpAffine(_im, _rot_mat, (_w, _h)) 112 | # get label 113 | _label = cv2.resize(_im, (self.la_shape[1], self.la_shape[0]), interpolation=cv2.INTER_CUBIC) 114 | # low-resolution 115 | _scale = np.random.choice(range(1, 6)) 116 | _im = cv2.resize(_im, (0,0), fx=1/float(_scale), fy=1/float(_scale), interpolation=cv2.INTER_CUBIC) 117 | _im = cv2.resize(_im, (self.im_shape[1], self.im_shape[0]), interpolation=cv2.INTER_CUBIC) 118 | # add noise 119 | _im = blur_method(_im, np.random.choice(range(0, 4))) 120 | _im = brightness(_im) 121 | # to caffe data format 122 | _im = _im.astype(np.float32, copy=False) 123 | _label = _label.astype(np.float32, copy=False) 124 | _im *= 0.0039215684 125 | _label *= 0.0039215684 126 | 127 | yield _im, _label 128 | 129 | -------------------------------------------------------------------------------- /SRCNN/srcnn_input_datalayer.py: -------------------------------------------------------------------------------- 1 | 2 | # by Bob in 20170326 3 | import numpy as np 4 | import cv2 5 | import caffe 6 | import os 7 | import string, random 8 | from pydmtx import DataMatrix as DMTX 9 | 10 | class ImageInputDataLayer(caffe.Layer): 11 | def setup(self, bottom, top): 12 | self.top_names = ['data', 'label'] 13 | 14 | # === Read input parameters === 15 | 16 | # params is a python dictionary with layer parameters. 17 | self.params = eval(self.param_str) 18 | 19 | # store input as class variables 20 | self.batch_size = self.params['batch_size'] 21 | 22 | # Create a batch loader to load the images. 23 | self.batch_loader = BatchLoader(self.params) 24 | 25 | # === reshape tops === 26 | top[0].reshape( 27 | self.batch_size, 1, self.params['im_shape'][0], self.params['im_shape'][1]) 28 | top[1].reshape( 29 | self.batch_size, 1, self.params['la_shape'][0], self.params['la_shape'][1]) 30 | 31 | def forward(self, bottom, top): 32 | """ 33 | Load data. 34 | """ 35 | for itt in range(self.batch_size): 36 | # Use the batch loader to load the next image. 37 | im, label = self.batch_loader.load_next_image() 38 | 39 | # Add directly to the caffe data layer 40 | top[0].data[itt, 0, ...] = im 41 | top[1].data[itt, 0, ...] = label 42 | 43 | def reshape(self, bottom, top): 44 | # === reshape tops === 45 | top[0].reshape( 46 | self.batch_size, 1, self.params['im_shape'][0], self.params['im_shape'][1]) 47 | top[1].reshape( 48 | self.batch_size, 1, self.params['la_shape'][0], self.params['la_shape'][1]) 49 | 50 | def backward(self, top, propagate_down, bottom): 51 | """ 52 | These layers does not back propagate 53 | """ 54 | pass 55 | 56 | 57 | class BatchLoader(object): 58 | def __init__(self, params): 59 | self.batch_size = params['batch_size'] 60 | self.im_shape = params['im_shape'] 61 | self.la_shape = params['la_shape'] 62 | 63 | self.image_generator = self.__image_generator() 64 | 65 | def load_next_image(self): 66 | """ 67 | Load the next image in a batch. 68 | """ 69 | return self.image_generator.next() 70 | 71 | def __image_generator(self): 72 | def id_generator(size=16, max_letter=6): 73 | _str = '' 74 | _letter_cnt = 0 75 | for i in range(size): 76 | if _letter_cnt < max_letter: 77 | _c = random.choice(string.ascii_uppercase + string.digits) 78 | if _c in string.ascii_uppercase: 79 | _letter_cnt += 1 80 | else: 81 | _c = random.choice(string.digits) 82 | _str += _c 83 | return _str 84 | def blur_method(_im, m): 85 | if m == 0: 86 | return _im 87 | elif m == 1: 88 | return cv2.GaussianBlur(_im, (5, 5), 0) 89 | elif m == 2: 90 | return cv2.blur(_im, (5,5)) 91 | elif m == 3: 92 | return cv2.medianBlur(_im, 5) 93 | else: 94 | return _im 95 | def brightness(_im): 96 | _brightness_offset = np.random.randint(-50, 50) 97 | return cv2.convertScaleAbs(_im, alpha=1, beta=_brightness_offset) 98 | 99 | _dmtx = DMTX(shape=3)# shape=3 is 16x16 100 | while True: 101 | # 022RDXBTH4001093 102 | _str = id_generator(16, 2) 103 | _dmtx.encode(_str) 104 | _im = np.array(_dmtx.image)# [:,:,::-1] 105 | _im = cv2.cvtColor(_im, cv2.COLOR_RGB2GRAY) 106 | _im = cv2.resize(_im, (self.im_shape[1], self.im_shape[0])) 107 | _h, _w = _im.shape[:2] 108 | # random mirco rotation 109 | _angle = np.random.randint(-6, 6) / 2.0 110 | _rot_mat = cv2.getRotationMatrix2D((_w / 2, _h / 2), _angle, 1) 111 | _im = cv2.warpAffine(_im, _rot_mat, (_w, _h)) 112 | # get label 113 | _h2, _w2 = self.la_shape 114 | _label = _im[(_h-_h2)/2:-(_h-_h2)/2, (_w-_w2)/2:-(_w-_w2)/2] 115 | # low-resolution 116 | _scale = np.random.choice(range(1, 6)) 117 | _im = cv2.resize(_im, (0,0), fx=1/float(_scale), fy=1/float(_scale)) 118 | _im = cv2.resize(_im, (self.im_shape[1], self.im_shape[0])) 119 | # add noise 120 | _im = blur_method(_im, np.random.choice(range(0, 4))) 121 | _im = brightness(_im) 122 | # to caffe data format 123 | _im = _im.astype(np.float32, copy=False) 124 | _label = _label.astype(np.float32, copy=False) 125 | _im *= 0.0039215684 126 | _label *= 0.0039215684 127 | 128 | yield _im, _label 129 | 130 | if __name__ == '__main__': 131 | im = cv2.imread('90080_2_3.jpg') 132 | a = ImageTransformer((64, 64), 127) 133 | while True: 134 | a.process(im, 2, True) 135 | -------------------------------------------------------------------------------- /MY_SR/aoi_srcnn_input_datalayer.py: -------------------------------------------------------------------------------- 1 | 2 | # by Bob in 20170326 3 | import numpy as np 4 | import cv2 5 | import caffe 6 | import os 7 | import string, random 8 | from pydmtx import DataMatrix as DMTX 9 | 10 | class ImageInputDataLayer(caffe.Layer): 11 | def setup(self, bottom, top): 12 | self.top_names = ['data', 'label'] 13 | 14 | # === Read input parameters === 15 | 16 | # params is a python dictionary with layer parameters. 17 | self.params = eval(self.param_str) 18 | 19 | # store input as class variables 20 | self.batch_size = self.params['batch_size'] 21 | 22 | # Create a batch loader to load the images. 23 | self.batch_loader = BatchLoader(self.params) 24 | 25 | # === reshape tops === 26 | top[0].reshape( 27 | self.batch_size, 1, self.params['im_shape'][0], self.params['im_shape'][1]) 28 | top[1].reshape( 29 | self.batch_size, 1, self.params['la_shape'][0], self.params['la_shape'][1]) 30 | 31 | def forward(self, bottom, top): 32 | """ 33 | Load data. 34 | """ 35 | for itt in range(self.batch_size): 36 | # Use the batch loader to load the next image. 37 | im, label = self.batch_loader.load_next_image() 38 | 39 | # Add directly to the caffe data layer 40 | top[0].data[itt, 0, ...] = im 41 | top[1].data[itt, 0, ...] = label 42 | 43 | def reshape(self, bottom, top): 44 | # === reshape tops === 45 | top[0].reshape( 46 | self.batch_size, 1, self.params['im_shape'][0], self.params['im_shape'][1]) 47 | top[1].reshape( 48 | self.batch_size, 1, self.params['la_shape'][0], self.params['la_shape'][1]) 49 | 50 | def backward(self, top, propagate_down, bottom): 51 | """ 52 | These layers does not back propagate 53 | """ 54 | pass 55 | 56 | 57 | class BatchLoader(object): 58 | def __init__(self, params): 59 | self.batch_size = params['batch_size'] 60 | self.im_shape = params['im_shape'] 61 | self.la_shape = params['la_shape'] 62 | 63 | self.image_generator = self.__image_generator() 64 | 65 | def load_next_image(self): 66 | """ 67 | Load the next image in a batch. 68 | """ 69 | return self.image_generator.next() 70 | 71 | def __image_generator(self): 72 | def id_generator(size=16, max_letter=6): 73 | _str = '' 74 | _letter_cnt = 0 75 | for i in range(size): 76 | if _letter_cnt < max_letter: 77 | _c = random.choice(string.ascii_uppercase + string.digits) 78 | if _c in string.ascii_uppercase: 79 | _letter_cnt += 1 80 | else: 81 | _c = random.choice(string.digits) 82 | _str += _c 83 | return _str 84 | def blur_method(_im, m): 85 | if m == 0: 86 | return _im 87 | elif m == 1: 88 | return cv2.GaussianBlur(_im, (5, 5), 0) 89 | elif m == 2: 90 | return cv2.blur(_im, (5,5)) 91 | elif m == 3: 92 | return cv2.medianBlur(_im, 5) 93 | else: 94 | return _im 95 | def brightness(_im): 96 | _brightness_offset = np.random.randint(-50, 50) 97 | return cv2.convertScaleAbs(_im, alpha=1, beta=_brightness_offset) 98 | 99 | _dmtx = DMTX(shape=3)# shape=3 is 16x16 100 | while True: 101 | # 022RDXBTH4001093 102 | _str = id_generator(16, 2) 103 | _dmtx.encode(_str) 104 | _im = np.array(_dmtx.image)# [:,:,::-1] 105 | _im = cv2.cvtColor(_im, cv2.COLOR_RGB2GRAY) 106 | _im = cv2.resize(_im, (self.im_shape[1]-12, self.im_shape[0]-12)) 107 | _h, _w = _im.shape[:2] 108 | # random mirco rotation 109 | _angle = np.random.randint(-6, 6) / 2.0 110 | _rot_mat = cv2.getRotationMatrix2D((_w / 2, _h / 2), _angle, 1) 111 | _im = cv2.warpAffine(_im, _rot_mat, (_w, _h)) 112 | # get label 113 | _label = cv2.resize(_im, (self.la_shape[1], self.la_shape[0])) 114 | # low-resolution 115 | _scale = np.random.choice(range(1, 6)) 116 | _im = cv2.resize(_im, (0,0), fx=1/float(_scale), fy=1/float(_scale)) 117 | _im = cv2.resize(_im, (self.im_shape[1]-12, self.im_shape[0]-12)) 118 | # add border. Need by net. 112 -> 100 119 | _im = cv2.copyMakeBorder(_im, 6, 6, 6, 6, cv2.BORDER_REPLICATE) 120 | # add noise 121 | _im = blur_method(_im, np.random.choice(range(0, 4))) 122 | _im = brightness(_im) 123 | # to caffe data format 124 | _im = _im.astype(np.float32, copy=False) 125 | _label = _label.astype(np.float32, copy=False) 126 | _im *= 0.0039215684 127 | _label *= 0.0039215684 128 | 129 | yield _im, _label 130 | 131 | if __name__ == '__main__': 132 | im = cv2.imread('90080_2_3.jpg') 133 | a = ImageTransformer((64, 64), 127) 134 | while True: 135 | a.process(im, 2, True) 136 | -------------------------------------------------------------------------------- /FSRCNN/train.prototxt: -------------------------------------------------------------------------------- 1 | name: "FSRCNN" 2 | layer { 3 | type: 'Python' 4 | name: 'data' 5 | top: 'data' 6 | top: 'label' 7 | # include { 8 | # phase: TRAIN 9 | # } 10 | python_param { 11 | # the module name -- usually the filename -- that needs to be in $PYTHONPATH 12 | module: 'fsrcnn_input_datalayer' 13 | # the layer name -- the class name in the module 14 | layer: 'ImageInputDataLayer' 15 | # parameter 16 | param_str: '{"batch_size":128, "im_shape":(64,64), "la_shape":(178,178)}' 17 | } 18 | } 19 | 20 | layer { 21 | name: "conv1" 22 | type: "Convolution" 23 | bottom: "data" 24 | top: "conv1" 25 | param { 26 | lr_mult: 1 27 | } 28 | param { 29 | lr_mult: 0.1 30 | } 31 | convolution_param { 32 | num_output: 56 33 | kernel_size: 5 34 | stride: 1 35 | pad: 0 36 | weight_filler { 37 | type: "gaussian" 38 | std: 0.0378 39 | } 40 | bias_filler { 41 | type: "constant" 42 | value: 0 43 | } 44 | } 45 | } 46 | 47 | layer { 48 | name: "relu1" 49 | type: "PReLU" 50 | bottom: "conv1" 51 | top: "conv1" 52 | prelu_param { 53 | channel_shared: 1 54 | } 55 | } 56 | 57 | layer { 58 | name: "conv2" 59 | type: "Convolution" 60 | bottom: "conv1" 61 | top: "conv2" 62 | param { 63 | lr_mult: 1 64 | } 65 | param { 66 | lr_mult: 0.1 67 | } 68 | convolution_param { 69 | num_output: 12 70 | kernel_size: 1 71 | stride: 1 72 | group: 1 73 | pad: 0 74 | weight_filler { 75 | type: "gaussian" 76 | std: 0.3536 77 | } 78 | bias_filler { 79 | type: "constant" 80 | value: 0 81 | } 82 | } 83 | } 84 | 85 | layer { 86 | name: "relu2" 87 | type: "PReLU" 88 | bottom: "conv2" 89 | top: "conv2" 90 | prelu_param { 91 | channel_shared: 1 92 | } 93 | } 94 | 95 | layer { 96 | name: "conv22" 97 | type: "Convolution" 98 | bottom: "conv2" 99 | top: "conv22" 100 | param { 101 | lr_mult: 1 102 | } 103 | param { 104 | lr_mult: 0.1 105 | } 106 | convolution_param { 107 | num_output: 12 108 | kernel_size: 3 109 | stride: 1 110 | group: 1 111 | pad: 1 112 | weight_filler { 113 | type: "gaussian" 114 | std: 0.1179 115 | } 116 | bias_filler { 117 | type: "constant" 118 | value: 0 119 | } 120 | } 121 | } 122 | 123 | layer { 124 | name: "relu22" 125 | type: "PReLU" 126 | bottom: "conv22" 127 | top: "conv22" 128 | prelu_param { 129 | channel_shared: 1 130 | } 131 | } 132 | 133 | layer { 134 | name: "conv23" 135 | type: "Convolution" 136 | bottom: "conv22" 137 | top: "conv23" 138 | param { 139 | lr_mult: 1 140 | } 141 | param { 142 | lr_mult: 0.1 143 | } 144 | convolution_param { 145 | num_output: 12 146 | kernel_size: 3 147 | stride: 1 148 | group: 1 149 | pad: 1 150 | weight_filler { 151 | type: "gaussian" 152 | std: 0.1179 153 | } 154 | bias_filler { 155 | type: "constant" 156 | value: 0 157 | } 158 | } 159 | } 160 | 161 | layer { 162 | name: "relu23" 163 | type: "PReLU" 164 | bottom: "conv23" 165 | top: "conv23" 166 | prelu_param { 167 | channel_shared: 1 168 | } 169 | } 170 | 171 | layer { 172 | name: "conv24" 173 | type: "Convolution" 174 | bottom: "conv23" 175 | top: "conv24" 176 | param { 177 | lr_mult: 1 178 | } 179 | param { 180 | lr_mult: 0.1 181 | } 182 | convolution_param { 183 | num_output: 12 184 | kernel_size: 3 185 | stride: 1 186 | group: 1 187 | pad: 1 188 | weight_filler { 189 | type: "gaussian" 190 | std: 0.1179 191 | } 192 | bias_filler { 193 | type: "constant" 194 | value: 0 195 | } 196 | } 197 | } 198 | 199 | layer { 200 | name: "relu24" 201 | type: "PReLU" 202 | bottom: "conv24" 203 | top: "conv24" 204 | prelu_param { 205 | channel_shared: 1 206 | } 207 | } 208 | 209 | layer { 210 | name: "conv25" 211 | type: "Convolution" 212 | bottom: "conv24" 213 | top: "conv25" 214 | param { 215 | lr_mult: 1 216 | } 217 | param { 218 | lr_mult: 0.1 219 | } 220 | convolution_param { 221 | num_output: 12 222 | kernel_size: 3 223 | stride: 1 224 | group: 1 225 | pad: 1 226 | weight_filler { 227 | type: "gaussian" 228 | std: 0.1179 229 | } 230 | bias_filler { 231 | type: "constant" 232 | value: 0 233 | } 234 | } 235 | } 236 | 237 | layer { 238 | name: "relu25" 239 | type: "PReLU" 240 | bottom: "conv25" 241 | top: "conv25" 242 | prelu_param { 243 | channel_shared: 1 244 | } 245 | } 246 | 247 | layer { 248 | name: "conv26" 249 | type: "Convolution" 250 | bottom: "conv25" 251 | top: "conv26" 252 | param { 253 | lr_mult: 1 254 | } 255 | param { 256 | lr_mult: 0.1 257 | } 258 | convolution_param { 259 | num_output: 56 260 | kernel_size: 1 261 | stride: 1 262 | group: 1 263 | pad: 0 264 | weight_filler { 265 | type: "gaussian" 266 | std: 0.189 267 | } 268 | bias_filler { 269 | type: "constant" 270 | value: 0 271 | } 272 | } 273 | } 274 | 275 | layer { 276 | name: "relu26" 277 | type: "PReLU" 278 | bottom: "conv26" 279 | top: "conv26" 280 | prelu_param { 281 | channel_shared: 1 282 | } 283 | } 284 | 285 | layer { 286 | name: "conv3" 287 | type: "Deconvolution" 288 | bottom: "conv26" 289 | top: "conv3" 290 | param { 291 | lr_mult: 0.1 292 | } 293 | param { 294 | lr_mult: 0.1 295 | } 296 | convolution_param { 297 | num_output: 1 298 | kernel_size: 9 299 | stride: 3 300 | pad: 4 301 | weight_filler { 302 | type: "gaussian" 303 | std: 0.001 304 | } 305 | bias_filler { 306 | type: "constant" 307 | value: 0 308 | } 309 | } 310 | } 311 | 312 | layer { 313 | name: "sigmoid1" 314 | type: "Sigmoid" 315 | bottom: "conv3" 316 | top: "conv3" 317 | } 318 | 319 | layer { 320 | name: "loss" 321 | type: "EuclideanLoss" 322 | bottom: "conv3" 323 | bottom: "label" 324 | top: "loss" 325 | } 326 | -------------------------------------------------------------------------------- /VDSR/deploy.prototxt: -------------------------------------------------------------------------------- 1 | name: "VDSR" 2 | input: "data" 3 | input_dim: 1 4 | input_dim: 1 5 | input_dim: 100 6 | input_dim: 100 7 | 8 | layer { 9 | name: "conv1" 10 | type: "Convolution" 11 | bottom: "data" 12 | top: "conv1" 13 | param { 14 | lr_mult: 1 15 | } 16 | param { 17 | lr_mult: 0.1 18 | } 19 | convolution_param { 20 | num_output: 64 21 | kernel_size: 3 22 | stride: 1 23 | pad: 1 24 | weight_filler { 25 | type: "msra" 26 | } 27 | bias_filler { 28 | type: "constant" 29 | } 30 | } 31 | } 32 | 33 | layer { 34 | name: "relu1" 35 | type: "ReLU" 36 | bottom: "conv1" 37 | top: "conv1" 38 | } 39 | 40 | layer { 41 | name: "conv2" 42 | type: "Convolution" 43 | bottom: "conv1" 44 | top: "conv2" 45 | param { 46 | lr_mult: 1 47 | } 48 | param { 49 | lr_mult: 0.1 50 | } 51 | convolution_param { 52 | num_output: 64 53 | kernel_size: 3 54 | stride: 1 55 | pad: 1 56 | weight_filler { 57 | type: "msra" 58 | } 59 | bias_filler { 60 | type: "constant" 61 | } 62 | } 63 | } 64 | 65 | layer { 66 | name: "relu2" 67 | type: "ReLU" 68 | bottom: "conv2" 69 | top: "conv2" 70 | } 71 | 72 | layer { 73 | name: "conv3" 74 | type: "Convolution" 75 | bottom: "conv2" 76 | top: "conv3" 77 | param { 78 | lr_mult: 1 79 | } 80 | param { 81 | lr_mult: 0.1 82 | } 83 | convolution_param { 84 | num_output: 64 85 | kernel_size: 3 86 | stride: 1 87 | pad: 1 88 | weight_filler { 89 | type: "msra" 90 | } 91 | bias_filler { 92 | type: "constant" 93 | } 94 | } 95 | } 96 | 97 | layer { 98 | name: "relu3" 99 | type: "ReLU" 100 | bottom: "conv3" 101 | top: "conv3" 102 | } 103 | 104 | layer { 105 | name: "conv4" 106 | type: "Convolution" 107 | bottom: "conv3" 108 | top: "conv4" 109 | param { 110 | lr_mult: 1 111 | } 112 | param { 113 | lr_mult: 0.1 114 | } 115 | convolution_param { 116 | num_output: 64 117 | kernel_size: 3 118 | stride: 1 119 | pad: 1 120 | weight_filler { 121 | type: "msra" 122 | } 123 | bias_filler { 124 | type: "constant" 125 | } 126 | } 127 | } 128 | 129 | layer { 130 | name: "relu4" 131 | type: "ReLU" 132 | bottom: "conv4" 133 | top: "conv4" 134 | } 135 | 136 | layer { 137 | name: "conv5" 138 | type: "Convolution" 139 | bottom: "conv4" 140 | top: "conv5" 141 | param { 142 | lr_mult: 1 143 | } 144 | param { 145 | lr_mult: 0.1 146 | } 147 | convolution_param { 148 | num_output: 64 149 | kernel_size: 3 150 | stride: 1 151 | pad: 1 152 | weight_filler { 153 | type: "msra" 154 | } 155 | bias_filler { 156 | type: "constant" 157 | } 158 | } 159 | } 160 | 161 | layer { 162 | name: "relu5" 163 | type: "ReLU" 164 | bottom: "conv5" 165 | top: "conv5" 166 | } 167 | 168 | layer { 169 | name: "conv6" 170 | type: "Convolution" 171 | bottom: "conv5" 172 | top: "conv6" 173 | param { 174 | lr_mult: 1 175 | } 176 | param { 177 | lr_mult: 0.1 178 | } 179 | convolution_param { 180 | num_output: 64 181 | kernel_size: 3 182 | stride: 1 183 | pad: 1 184 | weight_filler { 185 | type: "msra" 186 | } 187 | bias_filler { 188 | type: "constant" 189 | } 190 | } 191 | } 192 | 193 | layer { 194 | name: "relu6" 195 | type: "ReLU" 196 | bottom: "conv6" 197 | top: "conv6" 198 | } 199 | 200 | layer { 201 | name: "conv7" 202 | type: "Convolution" 203 | bottom: "conv6" 204 | top: "conv7" 205 | param { 206 | lr_mult: 1 207 | } 208 | param { 209 | lr_mult: 0.1 210 | } 211 | convolution_param { 212 | num_output: 64 213 | kernel_size: 3 214 | stride: 1 215 | pad: 1 216 | weight_filler { 217 | type: "msra" 218 | } 219 | bias_filler { 220 | type: "constant" 221 | } 222 | } 223 | } 224 | 225 | layer { 226 | name: "relu7" 227 | type: "ReLU" 228 | bottom: "conv7" 229 | top: "conv7" 230 | } 231 | 232 | layer { 233 | name: "conv8" 234 | type: "Convolution" 235 | bottom: "conv7" 236 | top: "conv8" 237 | param { 238 | lr_mult: 1 239 | } 240 | param { 241 | lr_mult: 0.1 242 | } 243 | convolution_param { 244 | num_output: 64 245 | kernel_size: 3 246 | stride: 1 247 | pad: 1 248 | weight_filler { 249 | type: "msra" 250 | } 251 | bias_filler { 252 | type: "constant" 253 | } 254 | } 255 | } 256 | 257 | layer { 258 | name: "relu8" 259 | type: "ReLU" 260 | bottom: "conv8" 261 | top: "conv8" 262 | } 263 | 264 | layer { 265 | name: "conv9" 266 | type: "Convolution" 267 | bottom: "conv8" 268 | top: "conv9" 269 | param { 270 | lr_mult: 1 271 | } 272 | param { 273 | lr_mult: 0.1 274 | } 275 | convolution_param { 276 | num_output: 64 277 | kernel_size: 3 278 | stride: 1 279 | pad: 1 280 | weight_filler { 281 | type: "msra" 282 | } 283 | bias_filler { 284 | type: "constant" 285 | } 286 | } 287 | } 288 | 289 | layer { 290 | name: "relu9" 291 | type: "ReLU" 292 | bottom: "conv9" 293 | top: "conv9" 294 | } 295 | 296 | layer { 297 | name: "conv10" 298 | type: "Convolution" 299 | bottom: "conv9" 300 | top: "conv10" 301 | param { 302 | lr_mult: 1 303 | } 304 | param { 305 | lr_mult: 0.1 306 | } 307 | convolution_param { 308 | num_output: 64 309 | kernel_size: 3 310 | stride: 1 311 | pad: 1 312 | weight_filler { 313 | type: "msra" 314 | } 315 | bias_filler { 316 | type: "constant" 317 | } 318 | } 319 | } 320 | 321 | layer { 322 | name: "relu10" 323 | type: "ReLU" 324 | bottom: "conv10" 325 | top: "conv10" 326 | } 327 | 328 | layer { 329 | name: "conv11" 330 | type: "Convolution" 331 | bottom: "conv10" 332 | top: "conv11" 333 | param { 334 | lr_mult: 1 335 | } 336 | param { 337 | lr_mult: 0.1 338 | } 339 | convolution_param { 340 | num_output: 64 341 | kernel_size: 3 342 | stride: 1 343 | pad: 1 344 | weight_filler { 345 | type: "msra" 346 | } 347 | bias_filler { 348 | type: "constant" 349 | } 350 | } 351 | } 352 | 353 | layer { 354 | name: "relu11" 355 | type: "ReLU" 356 | bottom: "conv11" 357 | top: "conv11" 358 | } 359 | 360 | layer { 361 | name: "conv12" 362 | type: "Convolution" 363 | bottom: "conv11" 364 | top: "conv12" 365 | param { 366 | lr_mult: 1 367 | } 368 | param { 369 | lr_mult: 0.1 370 | } 371 | convolution_param { 372 | num_output: 64 373 | kernel_size: 3 374 | stride: 1 375 | pad: 1 376 | weight_filler { 377 | type: "msra" 378 | } 379 | bias_filler { 380 | type: "constant" 381 | } 382 | } 383 | } 384 | 385 | layer { 386 | name: "relu12" 387 | type: "ReLU" 388 | bottom: "conv12" 389 | top: "conv12" 390 | } 391 | 392 | layer { 393 | name: "conv13" 394 | type: "Convolution" 395 | bottom: "conv12" 396 | top: "conv13" 397 | param { 398 | lr_mult: 1 399 | } 400 | param { 401 | lr_mult: 0.1 402 | } 403 | convolution_param { 404 | num_output: 64 405 | kernel_size: 3 406 | stride: 1 407 | pad: 1 408 | weight_filler { 409 | type: "msra" 410 | } 411 | bias_filler { 412 | type: "constant" 413 | } 414 | } 415 | } 416 | 417 | layer { 418 | name: "relu13" 419 | type: "ReLU" 420 | bottom: "conv13" 421 | top: "conv13" 422 | } 423 | 424 | layer { 425 | name: "conv14" 426 | type: "Convolution" 427 | bottom: "conv13" 428 | top: "conv14" 429 | param { 430 | lr_mult: 1 431 | } 432 | param { 433 | lr_mult: 0.1 434 | } 435 | convolution_param { 436 | num_output: 64 437 | kernel_size: 3 438 | stride: 1 439 | pad: 1 440 | weight_filler { 441 | type: "msra" 442 | } 443 | bias_filler { 444 | type: "constant" 445 | } 446 | } 447 | } 448 | 449 | layer { 450 | name: "relu14" 451 | type: "ReLU" 452 | bottom: "conv14" 453 | top: "conv14" 454 | } 455 | 456 | layer { 457 | name: "conv15" 458 | type: "Convolution" 459 | bottom: "conv14" 460 | top: "conv15" 461 | param { 462 | lr_mult: 1 463 | } 464 | param { 465 | lr_mult: 0.1 466 | } 467 | convolution_param { 468 | num_output: 64 469 | kernel_size: 3 470 | stride: 1 471 | pad: 1 472 | weight_filler { 473 | type: "msra" 474 | } 475 | bias_filler { 476 | type: "constant" 477 | } 478 | } 479 | } 480 | 481 | layer { 482 | name: "relu15" 483 | type: "ReLU" 484 | bottom: "conv15" 485 | top: "conv15" 486 | } 487 | 488 | layer { 489 | name: "conv16" 490 | type: "Convolution" 491 | bottom: "conv15" 492 | top: "conv16" 493 | param { 494 | lr_mult: 1 495 | } 496 | param { 497 | lr_mult: 0.1 498 | } 499 | convolution_param { 500 | num_output: 64 501 | kernel_size: 3 502 | stride: 1 503 | pad: 1 504 | weight_filler { 505 | type: "msra" 506 | } 507 | bias_filler { 508 | type: "constant" 509 | } 510 | } 511 | } 512 | 513 | layer { 514 | name: "relu16" 515 | type: "ReLU" 516 | bottom: "conv16" 517 | top: "conv16" 518 | } 519 | 520 | layer { 521 | name: "conv17" 522 | type: "Convolution" 523 | bottom: "conv16" 524 | top: "conv17" 525 | param { 526 | lr_mult: 1 527 | } 528 | param { 529 | lr_mult: 0.1 530 | } 531 | convolution_param { 532 | num_output: 64 533 | kernel_size: 3 534 | stride: 1 535 | pad: 1 536 | weight_filler { 537 | type: "msra" 538 | } 539 | bias_filler { 540 | type: "constant" 541 | } 542 | } 543 | } 544 | 545 | layer { 546 | name: "relu17" 547 | type: "ReLU" 548 | bottom: "conv17" 549 | top: "conv17" 550 | } 551 | 552 | layer { 553 | name: "conv18" 554 | type: "Convolution" 555 | bottom: "conv17" 556 | top: "conv18" 557 | param { 558 | lr_mult: 1 559 | } 560 | param { 561 | lr_mult: 0.1 562 | } 563 | convolution_param { 564 | num_output: 64 565 | kernel_size: 3 566 | stride: 1 567 | pad: 1 568 | weight_filler { 569 | type: "msra" 570 | } 571 | bias_filler { 572 | type: "constant" 573 | } 574 | } 575 | } 576 | 577 | layer { 578 | name: "relu18" 579 | type: "ReLU" 580 | bottom: "conv18" 581 | top: "conv18" 582 | } 583 | 584 | layer { 585 | name: "conv19" 586 | type: "Convolution" 587 | bottom: "conv18" 588 | top: "conv19" 589 | param { 590 | lr_mult: 1 591 | } 592 | param { 593 | lr_mult: 0.1 594 | } 595 | convolution_param { 596 | num_output: 64 597 | kernel_size: 3 598 | stride: 1 599 | pad: 1 600 | weight_filler { 601 | type: "msra" 602 | } 603 | bias_filler { 604 | type: "constant" 605 | } 606 | } 607 | } 608 | 609 | layer { 610 | name: "relu19" 611 | type: "ReLU" 612 | bottom: "conv19" 613 | top: "conv19" 614 | } 615 | 616 | layer { 617 | name: "conv20" 618 | type: "Convolution" 619 | bottom: "conv19" 620 | top: "conv20" 621 | param { 622 | lr_mult: 1 623 | } 624 | param { 625 | lr_mult: 0.1 626 | } 627 | convolution_param { 628 | num_output: 1 629 | kernel_size: 3 630 | stride: 1 631 | pad: 1 632 | weight_filler { 633 | type: "msra" 634 | } 635 | bias_filler { 636 | type: "constant" 637 | } 638 | } 639 | } 640 | 641 | layer { 642 | name: "sum" 643 | type: "Eltwise" 644 | bottom: "data" 645 | bottom: "conv20" 646 | top: "sum" 647 | eltwise_param { 648 | operation: 1 649 | } 650 | } 651 | -------------------------------------------------------------------------------- /VDSR/train.prototxt: -------------------------------------------------------------------------------- 1 | name: "VDSR" 2 | layer { 3 | type: 'Python' 4 | name: 'data' 5 | top: 'data' 6 | top: 'label' 7 | include { 8 | phase: TRAIN 9 | } 10 | python_param { 11 | # the module name -- usually the filename -- that needs to be in $PYTHONPATH 12 | module: 'vdsr_input_datalayer' 13 | # the layer name -- the class name in the module 14 | layer: 'ImageInputDataLayer' 15 | # parameter 16 | param_str: '{"batch_size":64, "im_shape":(100,100), "la_shape":(100,100)}' 17 | } 18 | } 19 | 20 | layer { 21 | type: 'Python' 22 | name: 'data' 23 | top: 'data' 24 | top: 'label' 25 | include { 26 | phase: TEST 27 | } 28 | python_param { 29 | # the module name -- usually the filename -- that needs to be in $PYTHONPATH 30 | module: 'vdsr_input_datalayer' 31 | # the layer name -- the class name in the module 32 | layer: 'ImageInputDataLayer' 33 | # parameter 34 | param_str: '{"batch_size":1, "im_shape":(100,100), "la_shape":(100,100)}' 35 | } 36 | } 37 | 38 | layer { 39 | name: "conv1" 40 | type: "Convolution" 41 | bottom: "data" 42 | top: "conv1" 43 | param { 44 | lr_mult: 1 45 | } 46 | param { 47 | lr_mult: 0.1 48 | } 49 | convolution_param { 50 | num_output: 64 51 | kernel_size: 3 52 | stride: 1 53 | pad: 1 54 | weight_filler { 55 | type: "msra" 56 | } 57 | bias_filler { 58 | type: "constant" 59 | } 60 | } 61 | } 62 | 63 | layer { 64 | name: "relu1" 65 | type: "ReLU" 66 | bottom: "conv1" 67 | top: "conv1" 68 | } 69 | 70 | layer { 71 | name: "conv2" 72 | type: "Convolution" 73 | bottom: "conv1" 74 | top: "conv2" 75 | param { 76 | lr_mult: 1 77 | } 78 | param { 79 | lr_mult: 0.1 80 | } 81 | convolution_param { 82 | num_output: 64 83 | kernel_size: 3 84 | stride: 1 85 | pad: 1 86 | weight_filler { 87 | type: "msra" 88 | } 89 | bias_filler { 90 | type: "constant" 91 | } 92 | } 93 | } 94 | 95 | layer { 96 | name: "relu2" 97 | type: "ReLU" 98 | bottom: "conv2" 99 | top: "conv2" 100 | } 101 | 102 | layer { 103 | name: "conv3" 104 | type: "Convolution" 105 | bottom: "conv2" 106 | top: "conv3" 107 | param { 108 | lr_mult: 1 109 | } 110 | param { 111 | lr_mult: 0.1 112 | } 113 | convolution_param { 114 | num_output: 64 115 | kernel_size: 3 116 | stride: 1 117 | pad: 1 118 | weight_filler { 119 | type: "msra" 120 | } 121 | bias_filler { 122 | type: "constant" 123 | } 124 | } 125 | } 126 | 127 | layer { 128 | name: "relu3" 129 | type: "ReLU" 130 | bottom: "conv3" 131 | top: "conv3" 132 | } 133 | 134 | layer { 135 | name: "conv4" 136 | type: "Convolution" 137 | bottom: "conv3" 138 | top: "conv4" 139 | param { 140 | lr_mult: 1 141 | } 142 | param { 143 | lr_mult: 0.1 144 | } 145 | convolution_param { 146 | num_output: 64 147 | kernel_size: 3 148 | stride: 1 149 | pad: 1 150 | weight_filler { 151 | type: "msra" 152 | } 153 | bias_filler { 154 | type: "constant" 155 | } 156 | } 157 | } 158 | 159 | layer { 160 | name: "relu4" 161 | type: "ReLU" 162 | bottom: "conv4" 163 | top: "conv4" 164 | } 165 | 166 | layer { 167 | name: "conv5" 168 | type: "Convolution" 169 | bottom: "conv4" 170 | top: "conv5" 171 | param { 172 | lr_mult: 1 173 | } 174 | param { 175 | lr_mult: 0.1 176 | } 177 | convolution_param { 178 | num_output: 64 179 | kernel_size: 3 180 | stride: 1 181 | pad: 1 182 | weight_filler { 183 | type: "msra" 184 | } 185 | bias_filler { 186 | type: "constant" 187 | } 188 | } 189 | } 190 | 191 | layer { 192 | name: "relu5" 193 | type: "ReLU" 194 | bottom: "conv5" 195 | top: "conv5" 196 | } 197 | 198 | layer { 199 | name: "conv6" 200 | type: "Convolution" 201 | bottom: "conv5" 202 | top: "conv6" 203 | param { 204 | lr_mult: 1 205 | } 206 | param { 207 | lr_mult: 0.1 208 | } 209 | convolution_param { 210 | num_output: 64 211 | kernel_size: 3 212 | stride: 1 213 | pad: 1 214 | weight_filler { 215 | type: "msra" 216 | } 217 | bias_filler { 218 | type: "constant" 219 | } 220 | } 221 | } 222 | 223 | layer { 224 | name: "relu6" 225 | type: "ReLU" 226 | bottom: "conv6" 227 | top: "conv6" 228 | } 229 | 230 | layer { 231 | name: "conv7" 232 | type: "Convolution" 233 | bottom: "conv6" 234 | top: "conv7" 235 | param { 236 | lr_mult: 1 237 | } 238 | param { 239 | lr_mult: 0.1 240 | } 241 | convolution_param { 242 | num_output: 64 243 | kernel_size: 3 244 | stride: 1 245 | pad: 1 246 | weight_filler { 247 | type: "msra" 248 | } 249 | bias_filler { 250 | type: "constant" 251 | } 252 | } 253 | } 254 | 255 | layer { 256 | name: "relu7" 257 | type: "ReLU" 258 | bottom: "conv7" 259 | top: "conv7" 260 | } 261 | 262 | layer { 263 | name: "conv8" 264 | type: "Convolution" 265 | bottom: "conv7" 266 | top: "conv8" 267 | param { 268 | lr_mult: 1 269 | } 270 | param { 271 | lr_mult: 0.1 272 | } 273 | convolution_param { 274 | num_output: 64 275 | kernel_size: 3 276 | stride: 1 277 | pad: 1 278 | weight_filler { 279 | type: "msra" 280 | } 281 | bias_filler { 282 | type: "constant" 283 | } 284 | } 285 | } 286 | 287 | layer { 288 | name: "relu8" 289 | type: "ReLU" 290 | bottom: "conv8" 291 | top: "conv8" 292 | } 293 | 294 | layer { 295 | name: "conv9" 296 | type: "Convolution" 297 | bottom: "conv8" 298 | top: "conv9" 299 | param { 300 | lr_mult: 1 301 | } 302 | param { 303 | lr_mult: 0.1 304 | } 305 | convolution_param { 306 | num_output: 64 307 | kernel_size: 3 308 | stride: 1 309 | pad: 1 310 | weight_filler { 311 | type: "msra" 312 | } 313 | bias_filler { 314 | type: "constant" 315 | } 316 | } 317 | } 318 | 319 | layer { 320 | name: "relu9" 321 | type: "ReLU" 322 | bottom: "conv9" 323 | top: "conv9" 324 | } 325 | 326 | layer { 327 | name: "conv10" 328 | type: "Convolution" 329 | bottom: "conv9" 330 | top: "conv10" 331 | param { 332 | lr_mult: 1 333 | } 334 | param { 335 | lr_mult: 0.1 336 | } 337 | convolution_param { 338 | num_output: 64 339 | kernel_size: 3 340 | stride: 1 341 | pad: 1 342 | weight_filler { 343 | type: "msra" 344 | } 345 | bias_filler { 346 | type: "constant" 347 | } 348 | } 349 | } 350 | 351 | layer { 352 | name: "relu10" 353 | type: "ReLU" 354 | bottom: "conv10" 355 | top: "conv10" 356 | } 357 | 358 | layer { 359 | name: "conv11" 360 | type: "Convolution" 361 | bottom: "conv10" 362 | top: "conv11" 363 | param { 364 | lr_mult: 1 365 | } 366 | param { 367 | lr_mult: 0.1 368 | } 369 | convolution_param { 370 | num_output: 64 371 | kernel_size: 3 372 | stride: 1 373 | pad: 1 374 | weight_filler { 375 | type: "msra" 376 | } 377 | bias_filler { 378 | type: "constant" 379 | } 380 | } 381 | } 382 | 383 | layer { 384 | name: "relu11" 385 | type: "ReLU" 386 | bottom: "conv11" 387 | top: "conv11" 388 | } 389 | 390 | layer { 391 | name: "conv12" 392 | type: "Convolution" 393 | bottom: "conv11" 394 | top: "conv12" 395 | param { 396 | lr_mult: 1 397 | } 398 | param { 399 | lr_mult: 0.1 400 | } 401 | convolution_param { 402 | num_output: 64 403 | kernel_size: 3 404 | stride: 1 405 | pad: 1 406 | weight_filler { 407 | type: "msra" 408 | } 409 | bias_filler { 410 | type: "constant" 411 | } 412 | } 413 | } 414 | 415 | layer { 416 | name: "relu12" 417 | type: "ReLU" 418 | bottom: "conv12" 419 | top: "conv12" 420 | } 421 | 422 | layer { 423 | name: "conv13" 424 | type: "Convolution" 425 | bottom: "conv12" 426 | top: "conv13" 427 | param { 428 | lr_mult: 1 429 | } 430 | param { 431 | lr_mult: 0.1 432 | } 433 | convolution_param { 434 | num_output: 64 435 | kernel_size: 3 436 | stride: 1 437 | pad: 1 438 | weight_filler { 439 | type: "msra" 440 | } 441 | bias_filler { 442 | type: "constant" 443 | } 444 | } 445 | } 446 | 447 | layer { 448 | name: "relu13" 449 | type: "ReLU" 450 | bottom: "conv13" 451 | top: "conv13" 452 | } 453 | 454 | layer { 455 | name: "conv14" 456 | type: "Convolution" 457 | bottom: "conv13" 458 | top: "conv14" 459 | param { 460 | lr_mult: 1 461 | } 462 | param { 463 | lr_mult: 0.1 464 | } 465 | convolution_param { 466 | num_output: 64 467 | kernel_size: 3 468 | stride: 1 469 | pad: 1 470 | weight_filler { 471 | type: "msra" 472 | } 473 | bias_filler { 474 | type: "constant" 475 | } 476 | } 477 | } 478 | 479 | layer { 480 | name: "relu14" 481 | type: "ReLU" 482 | bottom: "conv14" 483 | top: "conv14" 484 | } 485 | 486 | layer { 487 | name: "conv15" 488 | type: "Convolution" 489 | bottom: "conv14" 490 | top: "conv15" 491 | param { 492 | lr_mult: 1 493 | } 494 | param { 495 | lr_mult: 0.1 496 | } 497 | convolution_param { 498 | num_output: 64 499 | kernel_size: 3 500 | stride: 1 501 | pad: 1 502 | weight_filler { 503 | type: "msra" 504 | } 505 | bias_filler { 506 | type: "constant" 507 | } 508 | } 509 | } 510 | 511 | layer { 512 | name: "relu15" 513 | type: "ReLU" 514 | bottom: "conv15" 515 | top: "conv15" 516 | } 517 | 518 | layer { 519 | name: "conv16" 520 | type: "Convolution" 521 | bottom: "conv15" 522 | top: "conv16" 523 | param { 524 | lr_mult: 1 525 | } 526 | param { 527 | lr_mult: 0.1 528 | } 529 | convolution_param { 530 | num_output: 64 531 | kernel_size: 3 532 | stride: 1 533 | pad: 1 534 | weight_filler { 535 | type: "msra" 536 | } 537 | bias_filler { 538 | type: "constant" 539 | } 540 | } 541 | } 542 | 543 | layer { 544 | name: "relu16" 545 | type: "ReLU" 546 | bottom: "conv16" 547 | top: "conv16" 548 | } 549 | 550 | layer { 551 | name: "conv17" 552 | type: "Convolution" 553 | bottom: "conv16" 554 | top: "conv17" 555 | param { 556 | lr_mult: 1 557 | } 558 | param { 559 | lr_mult: 0.1 560 | } 561 | convolution_param { 562 | num_output: 64 563 | kernel_size: 3 564 | stride: 1 565 | pad: 1 566 | weight_filler { 567 | type: "msra" 568 | } 569 | bias_filler { 570 | type: "constant" 571 | } 572 | } 573 | } 574 | 575 | layer { 576 | name: "relu17" 577 | type: "ReLU" 578 | bottom: "conv17" 579 | top: "conv17" 580 | } 581 | 582 | layer { 583 | name: "conv18" 584 | type: "Convolution" 585 | bottom: "conv17" 586 | top: "conv18" 587 | param { 588 | lr_mult: 1 589 | } 590 | param { 591 | lr_mult: 0.1 592 | } 593 | convolution_param { 594 | num_output: 64 595 | kernel_size: 3 596 | stride: 1 597 | pad: 1 598 | weight_filler { 599 | type: "msra" 600 | } 601 | bias_filler { 602 | type: "constant" 603 | } 604 | } 605 | } 606 | 607 | layer { 608 | name: "relu18" 609 | type: "ReLU" 610 | bottom: "conv18" 611 | top: "conv18" 612 | } 613 | 614 | layer { 615 | name: "conv19" 616 | type: "Convolution" 617 | bottom: "conv18" 618 | top: "conv19" 619 | param { 620 | lr_mult: 1 621 | } 622 | param { 623 | lr_mult: 0.1 624 | } 625 | convolution_param { 626 | num_output: 64 627 | kernel_size: 3 628 | stride: 1 629 | pad: 1 630 | weight_filler { 631 | type: "msra" 632 | } 633 | bias_filler { 634 | type: "constant" 635 | } 636 | } 637 | } 638 | 639 | layer { 640 | name: "relu19" 641 | type: "ReLU" 642 | bottom: "conv19" 643 | top: "conv19" 644 | } 645 | 646 | layer { 647 | name: "conv20" 648 | type: "Convolution" 649 | bottom: "conv19" 650 | top: "conv20" 651 | param { 652 | lr_mult: 1 653 | } 654 | param { 655 | lr_mult: 0.1 656 | } 657 | convolution_param { 658 | num_output: 1 659 | kernel_size: 3 660 | stride: 1 661 | pad: 1 662 | weight_filler { 663 | type: "msra" 664 | } 665 | bias_filler { 666 | type: "constant" 667 | } 668 | } 669 | } 670 | 671 | layer { 672 | name: "sum" 673 | type: "Eltwise" 674 | bottom: "data" 675 | bottom: "conv20" 676 | top: "sum" 677 | eltwise_param { 678 | operation: 1 679 | } 680 | } 681 | 682 | layer { 683 | name: "loss" 684 | type: "EuclideanLoss" 685 | bottom: "sum" 686 | bottom: "label" 687 | top: "loss" 688 | } 689 | --------------------------------------------------------------------------------