Skip to content

P
PaddleHub

PaddlePaddle / PaddleHub
大约 2 年 前同步成功

通知 285
Star 12117
Fork 2091
P
PaddleHub
未验证 提交 cbae1549 编写于 作者: W wuzewu 提交者： GitHub
浏览文件
操作

update resnet50_vd_imagenet_ssld

上级 99548331 ed7ce373
展开全部 隐藏空白更改
内联 并排
Showing with 241 addition and 1828 deletion
hub_module/modules/image/classification/resnet50_vd_imagenet_ssld/README.md 已删除 100644 → 0
浏览文件 @ 99548331
```shell
$ hub install resnet50_vd_imagenet_ssld==1.0.0
```
<p align="center">
<img src="http://bj.bcebos.com/ibox-thumbnail98/77fa9b7003e4665867855b2b65216519?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-04-08T11%3A05%3A10Z%2F1800%2F%2F1df0ecb4a52adefeae240c9e2189e8032560333e399b3187ef1a76e4ffa5f19f" hspace='5' width=800/> <br /> ResNet 系列的网络结构
</p>
模型的详情可参考[论文](https://arxiv.org/pdf/1812.01187.pdf)
## 命令行预测
```
hub run resnet50_vd_imagenet_ssld --input_path "/PATH/TO/IMAGE"
```
## API
```python
def get_expected_image_width()
```
返回预处理的图片宽度，也就是224。
```python
def get_expected_image_height()
```
返回预处理的图片高度，也就是224。
```python
def get_pretrained_images_mean()
```
返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
```python
def get_pretrained_images_std()
```
返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
```python
def context(trainable=True, pretrained=True)
```
**参数**
* trainable (bool): 计算图的参数是否为可训练的；
* pretrained (bool): 是否加载默认的预训练模型。
**返回**
* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；
* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
* classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
* feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
* context\_prog(fluid.Program): 计算图，用于迁移学习。
```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
**参数**
* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU 来预测；
* top\_k (int): 返回预测结果的前 k 个。
**返回**
res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
将模型保存到指定路径。
**参数**
* dirname: 存在模型的目录名称
* model_filename: 模型文件名称，默认为\_\_model\_\_
* params_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
## 代码示例
```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="resnet50_vd_imagenet_ssld")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
## 服务部署
PaddleHub Serving可以部署一个在线动物识别服务。
## 第一步：启动PaddleHub Serving
运行启动命令：
```shell
$ hub serving start -m resnet50_vd_imagenet_ssld
```
这样就完成了一个在线动物识别服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/resnet50_vd_imagenet_ssld"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
### 查看代码
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 1.6.2
paddlehub >= 1.6.0
hub_module/modules/image/classification/resnet50_vd_imagenet_ssld/data_feed.py 已删除 100644 → 0
浏览文件 @ 99548331
# coding=utf-8
import os
import time
from collections import OrderedDict
import cv2
import numpy as np
from PIL import Image
__all__ = ['reader']
DATA_DIM = 224
img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
def resize_short(img, target_size):
percent = float(target_size) / min(img.size[0], img.size[1])
resized_width = int(round(img.size[0] * percent))
resized_height = int(round(img.size[1] * percent))
img = img.resize((resized_width, resized_height), Image.LANCZOS)
return img
def crop_image(img, target_size, center):
width, height = img.size
size = target_size
if center == True:
w_start = (width - size) / 2
h_start = (height - size) / 2
else:
w_start = np.random.randint(0, width - size + 1)
h_start = np.random.randint(0, height - size + 1)
w_end = w_start + size
h_end = h_start + size
img = img.crop((w_start, h_start, w_end, h_end))
return img
def process_image(img):
img = resize_short(img, target_size=256)
img = crop_image(img, target_size=DATA_DIM, center=True)
if img.mode != 'RGB':
img = img.convert('RGB')
img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
img -= img_mean
img /= img_std
return img
def reader(images=None, paths=None):
"""
Preprocess to yield image.
Args:
images (list[numpy.ndarray]): images data, shape of each is [H, W, C].
paths (list[str]): paths to images.
Yield:
each (collections.OrderedDict): info of original image, preprocessed image.
"""
component = list()
if paths:
for im_path in paths:
each = OrderedDict()
assert os.path.isfile(
im_path), "The {} isn't a valid file path.".format(im_path)
each['org_im_path'] = im_path
each['org_im'] = Image.open(im_path)
each['org_im_width'], each['org_im_height'] = each['org_im'].size
component.append(each)
if images is not None:
assert type(images), "images is a list."
for im in images:
each = OrderedDict()
each['org_im'] = Image.fromarray(im[:, :, ::-1])
each['org_im_path'] = 'ndarray_time={}'.format(
round(time.time(), 6) * 1e6)
each['org_im_width'], each['org_im_height'] = each['org_im'].size
component.append(each)
for element in component:
element['image'] = process_image(element['org_im'])
yield element
hub_module/modules/image/classification/resnet50_vd_imagenet_ssld/module.py
浏览文件 @ cbae1549
# coding=utf-8 # copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
from __future__ import absolute_import #
from __future__ import division # Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
import ast # You may obtain a copy of the License at
import argparse #
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os import os
import math
import numpy as np import numpy as np
import paddle.fluid as fluid import paddle
import paddlehub as hub from paddle import ParamAttr
from paddle.fluid.core import PaddleTensor, AnalysisConfig, create_paddle_predictor import paddle.nn as nn
from paddlehub.module.module import moduleinfo, runnable, serving from paddle.nn import Conv2d, BatchNorm, Linear, Dropout
from paddlehub.common.paddle_helper import add_vars_prefix from paddle.nn import AdaptiveAvgPool2d, MaxPool2d, AvgPool2d
from paddle.nn.initializer import Uniform
from resnet50_vd_imagenet_ssld.processor import postprocess, base64_to_cv2 from paddlehub.module.module import moduleinfo
from resnet50_vd_imagenet_ssld.data_feed import reader from paddlehub.module.cv_module import ImageClassifierModule
from resnet50_vd_imagenet_ssld.resnet_vd import ResNet50_vd
class ConvBNLayer(nn.Layer):
@moduleinfo( """Basic conv bn layer."""
name="resnet50_vd_imagenet_ssld", def __init__(
type="CV/image_classification", self,
author="paddlepaddle", num_channels: int,
author_email="paddle-dev@baidu.com", num_filters: int,
summary= filter_size: int,
"ResNet50vd is a image classfication model, this module is trained with ImageNet-2012 dataset.", stride: int = 1,
version="1.0.0") groups: int = 1,
class ResNet50vdDishes(hub.Module): is_vd_mode: bool = False,
def _initialize(self): act: str = None,
self.default_pretrained_model_path = os.path.join( name: str = None,
self.directory, "model") ):
label_file = os.path.join(self.directory, "label_list.txt") super(ConvBNLayer, self).__init__()
with open(label_file, 'r', encoding='utf-8') as file:
self.label_list = file.read().split("\n")[:-1] self.is_vd_mode = is_vd_mode
self._set_config() self._pool2d_avg = AvgPool2d(kernel_size=2, stride=2, padding=0, ceil_mode=True)
self._conv = Conv2d(in_channels=num_channels,
def get_expected_image_width(self): out_channels=num_filters,
return 224 kernel_size=filter_size,
stride=stride,
def get_expected_image_height(self): padding=(filter_size - 1) // 2,
return 224 groups=groups,
weight_attr=ParamAttr(name=name + "_weights"),
def get_pretrained_images_mean(self): bias_attr=False)
im_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3) if name == "conv1":
return im_mean bn_name = "bn_" + name
else:
def get_pretrained_images_std(self): bn_name = "bn" + name[3:]
im_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3) self._batch_norm = BatchNorm(num_filters,
return im_std act=act,
param_attr=ParamAttr(name=bn_name + '_scale'),
def _set_config(self): bias_attr=ParamAttr(bn_name + '_offset'),
""" moving_mean_name=bn_name + '_mean',
predictor config setting moving_variance_name=bn_name + '_variance')
"""
cpu_config = AnalysisConfig(self.default_pretrained_model_path) def forward(self, inputs: paddle.Tensor):
cpu_config.disable_glog_info() if self.is_vd_mode:
cpu_config.disable_gpu() inputs = self._pool2d_avg(inputs)
self.cpu_predictor = create_paddle_predictor(cpu_config) y = self._conv(inputs)
y = self._batch_norm(y)
try: return y
_places = os.environ["CUDA_VISIBLE_DEVICES"]
int(_places[0])
use_gpu = True class BottleneckBlock(nn.Layer):
except: """Bottleneck Block for ResNet50_vd."""
use_gpu = False def __init__(self,
if use_gpu: num_channels: int,
gpu_config = AnalysisConfig(self.default_pretrained_model_path) num_filters: int,
gpu_config.disable_glog_info() stride: int,
gpu_config.enable_use_gpu( shortcut: bool = True,
memory_pool_init_size_mb=1000, device_id=0) if_first: bool = False,
self.gpu_predictor = create_paddle_predictor(gpu_config) name: str = None):
super(BottleneckBlock, self).__init__()
def context(self, trainable=True, pretrained=True):
"""context for transfer learning. self.conv0 = ConvBNLayer(num_channels=num_channels,
num_filters=num_filters,
Args: filter_size=1,
trainable (bool): Set parameters in program to be trainable. act='relu',
pretrained (bool) : Whether to load pretrained model. name=name + "_branch2a")
self.conv1 = ConvBNLayer(num_channels=num_filters,
Returns: num_filters=num_filters,
inputs (dict): key is 'image', corresponding vaule is image tensor. filter_size=3,
outputs (dict): key is : stride=stride,
'classification', corresponding value is the result of classification. act='relu',
'feature_map', corresponding value is the result of the layer before the fully connected layer. name=name + "_branch2b")
context_prog (fluid.Program): program for transfer learning. self.conv2 = ConvBNLayer(num_channels=num_filters,
""" num_filters=num_filters * 4,
context_prog = fluid.Program() filter_size=1,
startup_prog = fluid.Program() act=None,
with fluid.program_guard(context_prog, startup_prog): name=name + "_branch2c")
with fluid.unique_name.guard():
image = fluid.layers.data( if not shortcut:
name="image", shape=[3, 224, 224], dtype="float32") self.short = ConvBNLayer(num_channels=num_channels,
resnet_vd = ResNet50_vd() num_filters=num_filters * 4,
output, feature_map = resnet_vd.net( filter_size=1,
input=image, class_dim=len(self.label_list)) stride=1,
is_vd_mode=False if if_first else True,
name_prefix = '@HUB_{}@'.format(self.name) name=name + "_branch1")
inputs = {'image': name_prefix + image.name}
outputs = { self.shortcut = shortcut
'classification': name_prefix + output.name,
'feature_map': name_prefix + feature_map.name def forward(self, inputs: paddle.Tensor):
} y = self.conv0(inputs)
add_vars_prefix(context_prog, name_prefix) conv1 = self.conv1(y)
add_vars_prefix(startup_prog, name_prefix) conv2 = self.conv2(conv1)
global_vars = context_prog.global_block().vars
inputs = { if self.shortcut:
key: global_vars[value] short = inputs
for key, value in inputs.items() else:
} short = self.short(inputs)
outputs = { y = paddle.elementwise_add(x=short, y=conv2, act='relu')
key: global_vars[value] return y
for key, value in outputs.items()
}
class BasicBlock(nn.Layer):
place = fluid.CPUPlace() """Basic block for ResNet50_vd."""
exe = fluid.Executor(place) def __init__(self,
# pretrained num_channels: int,
if pretrained: num_filters: int,
stride: int,
def _if_exist(var): shortcut: bool = True,
b = os.path.exists( if_first: bool = False,
os.path.join(self.default_pretrained_model_path, name: str = None):
var.name)) super(BasicBlock, self).__init__()
return b self.stride = stride
self.conv0 = ConvBNLayer(num_channels=num_channels,
fluid.io.load_vars( num_filters=num_filters,
exe, filter_size=3,
self.default_pretrained_model_path, stride=stride,
context_prog, act='relu',
predicate=_if_exist) name=name + "_branch2a")
else: self.conv1 = ConvBNLayer(num_channels=num_filters,
exe.run(startup_prog) num_filters=num_filters,
# trainable filter_size=3,
for param in context_prog.global_block().iter_parameters(): act=None,
param.trainable = trainable name=name + "_branch2b")
return inputs, outputs, context_prog
if not shortcut:
def classification(self, self.short = ConvBNLayer(num_channels=num_channels,
images=None, num_filters=num_filters,
paths=None, filter_size=1,
batch_size=1, stride=1,
use_gpu=False, is_vd_mode=False if if_first else True,
top_k=1): name=name + "_branch1")
"""
API for image classification. self.shortcut = shortcut
Args: def forward(self, inputs: paddle.Tensor):
images (numpy.ndarray): data of images, shape of each is [H, W, C], color space must be BGR. y = self.conv0(inputs)
paths (list[str]): The paths of images. conv1 = self.conv1(y)
batch_size (int): batch size.
use_gpu (bool): Whether to use gpu. if self.shortcut:
top_k (int): Return top k results. short = inputs
else:
Returns: short = self.short(inputs)
res (list[dict]): The classfication results. y = paddle.elementwise_add(x=short, y=conv1, act='relu')
""" return y
if use_gpu:
try:
_places = os.environ["CUDA_VISIBLE_DEVICES"] @moduleinfo(name="resnet50_vd_imagenet_ssld",
int(_places[0]) type="CV/classification",
except: author="paddlepaddle",
raise RuntimeError( author_email="",
"Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id." summary="resnet50_vd_imagenet_ssld is a classification model, "
) "this module is trained with Imagenet dataset.",
version="1.1.0",
all_data = list() meta=ImageClassifierModule)
for yield_data in reader(images, paths): class ResNet50_vd(nn.Layer):
all_data.append(yield_data) """ResNet50_vd model."""
def __init__(self, class_dim: int = 1000, load_checkpoint: str = None):
total_num = len(all_data) super(ResNet50_vd, self).__init__()
loop_num = int(np.ceil(total_num / batch_size))
self.layers = 50
res = list()
for iter_id in range(loop_num): depth = [3, 4, 6, 3]
batch_data = list() num_channels = [64, 256, 512, 1024]
handle_id = iter_id * batch_size num_filters = [64, 128, 256, 512]
for image_id in range(batch_size):
try: self.conv1_1 = ConvBNLayer(num_channels=3, num_filters=32, filter_size=3, stride=2, act='relu', name="conv1_1")
batch_data.append(all_data[handle_id + image_id]) self.conv1_2 = ConvBNLayer(num_channels=32, num_filters=32, filter_size=3, stride=1, act='relu', name="conv1_2")
except: self.conv1_3 = ConvBNLayer(num_channels=32, num_filters=64, filter_size=3, stride=1, act='relu', name="conv1_3")
pass self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1)
# feed batch image
batch_image = np.array([data['image'] for data in batch_data]) self.block_list = []
batch_image = PaddleTensor(batch_image.copy())
predictor_output = self.gpu_predictor.run([ for block in range(len(depth)):
batch_image shortcut = False
]) if use_gpu else self.cpu_predictor.run([batch_image]) for i in range(depth[block]):
out = postprocess(
data_out=predictor_output[0].as_ndarray(), conv_name = "res" + str(block + 2) + chr(97 + i)
label_list=self.label_list, bottleneck_block = self.add_sublayer(
top_k=top_k) 'bb_%d_%d' % (block, i),
res += out BottleneckBlock(num_channels=num_channels[block] if i == 0 else num_filters[block] * 4,
return res num_filters=num_filters[block],
stride=2 if i == 0 and block != 0 else 1,
def save_inference_model(self, shortcut=shortcut,
dirname, if_first=block == i == 0,
model_filename=None, name=conv_name))
params_filename=None, self.block_list.append(bottleneck_block)
combined=True): shortcut = True
if combined:
model_filename = "__model__" if not model_filename else model_filename self.pool2d_avg = AdaptiveAvgPool2d(1)
params_filename = "__params__" if not params_filename else params_filename self.pool2d_avg_channels = num_channels[-1] * 2
place = fluid.CPUPlace() stdv = 1.0 / math.sqrt(self.pool2d_avg_channels * 1.0)
exe = fluid.Executor(place)
self.out = Linear(self.pool2d_avg_channels,
program, feeded_var_names, target_vars = fluid.io.load_inference_model( class_dim,
dirname=self.default_pretrained_model_path, executor=exe) weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv), name="fc_0.w_0"),
bias_attr=ParamAttr(name="fc_0.b_0"))
fluid.io.save_inference_model(
dirname=dirname, if load_checkpoint is not None:
main_program=program, model_dict = paddle.load(load_checkpoint)[0]
executor=exe, self.set_dict(model_dict)
feeded_var_names=feeded_var_names, print("load custom checkpoint success")
target_vars=target_vars,
model_filename=model_filename, else:
params_filename=params_filename) checkpoint = os.path.join(self.directory, 'resnet50_vd_ssld.pdparams')
if not os.path.exists(checkpoint):
@serving os.system(
def serving_method(self, images, **kwargs): 'wget https://paddlehub.bj.bcebos.com/dygraph/image_classification/resnet50_vd_ssld.pdparams -O ' +
""" checkpoint)
Run as a service. model_dict = paddle.load(checkpoint)[0]
""" self.set_dict(model_dict)
images_decode = [base64_to_cv2(image) for image in images] print("load pretrained checkpoint success")
results = self.classification(images=images_decode, **kwargs)
return results def forward(self, inputs: paddle.Tensor):
y = self.conv1_1(inputs)
@runnable y = self.conv1_2(y)
def run_cmd(self, argvs): y = self.conv1_3(y)
""" y = self.pool2d_max(y)
Run as a command. for block in self.block_list:
""" y = block(y)
self.parser = argparse.ArgumentParser( y = self.pool2d_avg(y)
description="Run the {} module.".format(self.name), y = paddle.reshape(y, shape=[-1, self.pool2d_avg_channels])
prog='hub run {}'.format(self.name), y = self.out(y)
usage='%(prog)s', return y
add_help=True)
self.arg_input_group = self.parser.add_argument_group(
title="Input options", description="Input data. Required")
self.arg_config_group = self.parser.add_argument_group(
title="Config options",
description=
"Run configuration for controlling module behavior, not required.")
self.add_module_config_arg()
self.add_module_input_arg()
args = self.parser.parse_args(argvs)
results = self.classification(
paths=[args.input_path],
batch_size=args.batch_size,
use_gpu=args.use_gpu)
return results
def add_module_config_arg(self):
"""
Add the command config options.
"""
self.arg_config_group.add_argument(
'--use_gpu',
type=ast.literal_eval,
default=False,
help="whether use GPU or not.")
self.arg_config_group.add_argument(
'--batch_size',
type=ast.literal_eval,
default=1,
help="batch size.")
self.arg_config_group.add_argument(
'--top_k',
type=ast.literal_eval,
default=1,
help="Return top k results.")
def add_module_input_arg(self):
"""
Add the command input options.
"""
self.arg_input_group.add_argument(
'--input_path', type=str, help="path to image.")
hub_module/modules/image/classification/resnet50_vd_imagenet_ssld/processor.py 已删除 100644 → 0
浏览文件 @ 99548331
# coding=utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import base64
import cv2
import os
import numpy as np
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data
def softmax(x):
orig_shape = x.shape
if len(x.shape) > 1:
tmp = np.max(x, axis=1)
x -= tmp.reshape((x.shape[0], 1))
x = np.exp(x)
tmp = np.sum(x, axis=1)
x /= tmp.reshape((x.shape[0], 1))
else:
tmp = np.max(x)
x -= tmp
x = np.exp(x)
tmp = np.sum(x)
x /= tmp
return x
def postprocess(data_out, label_list, top_k):
"""
Postprocess output of network, one image at a time.
Args:
data_out (numpy.ndarray): output data of network.
label_list (list): list of label.
top_k (int): Return top k results.
"""
output = []
for result in data_out:
result_i = softmax(result)
output_i = {}
indexs = np.argsort(result_i)[::-1][0:top_k]
for index in indexs:
label = label_list[index].split(',')[0]
output_i[label] = float(result_i[index])
output.append(output_i)
return output
hub_module/modules/image/classification/resnet50_vd_imagenet_ssld/resnet_vd.py 已删除 100755 → 0
浏览文件 @ 99548331
#copyright (c) 2019 PaddlePaddle Authors. All Rights Reserve.
#
#Licensed under the Apache License, Version 2.0 (the "License");
#you may not use this file except in compliance with the License.
#You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
#Unless required by applicable law or agreed to in writing, software
#distributed under the License is distributed on an "AS IS" BASIS,
#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#See the License for the specific language governing permissions and
#limitations under the License.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import math
import paddle
import paddle.fluid as fluid
from paddle.fluid.param_attr import ParamAttr
__all__ = [
"ResNet", "ResNet50_vd", "ResNet101_vd", "ResNet152_vd", "ResNet200_vd"
]
train_parameters = {
"input_size": [3, 224, 224],
"input_mean": [0.485, 0.456, 0.406],
"input_std": [0.229, 0.224, 0.225],
"learning_strategy": {
"name": "piecewise_decay",
"batch_size": 256,
"epochs": [30, 60, 90],
"steps": [0.1, 0.01, 0.001, 0.0001]
}
}
class ResNet():
def __init__(self, layers=50, is_3x3=False):
self.params = train_parameters
self.layers = layers
self.is_3x3 = is_3x3
def net(self, input, class_dim=1000):
is_3x3 = self.is_3x3
layers = self.layers
supported_layers = [50, 101, 152, 200]
assert layers in supported_layers, \
"supported layers are {} but input layer is {}".format(supported_layers, layers)
if layers == 50:
depth = [3, 4, 6, 3]
elif layers == 101:
depth = [3, 4, 23, 3]
elif layers == 152:
depth = [3, 8, 36, 3]
elif layers == 200:
depth = [3, 12, 48, 3]
num_filters = [64, 128, 256, 512]
if is_3x3 == False:
conv = self.conv_bn_layer(
input=input,
num_filters=64,
filter_size=7,
stride=2,
act='relu')
else:
conv = self.conv_bn_layer(
input=input,
num_filters=32,
filter_size=3,
stride=2,
act='relu',
name='conv1_1')
conv = self.conv_bn_layer(
input=conv,
num_filters=32,
filter_size=3,
stride=1,
act='relu',
name='conv1_2')
conv = self.conv_bn_layer(
input=conv,
num_filters=64,
filter_size=3,
stride=1,
act='relu',
name='conv1_3')
conv = fluid.layers.pool2d(
input=conv,
pool_size=3,
pool_stride=2,
pool_padding=1,
pool_type='max')
for block in range(len(depth)):
for i in range(depth[block]):
if layers in [101, 152, 200] and block == 2:
if i == 0:
conv_name = "res" + str(block + 2) + "a"
else:
conv_name = "res" + str(block + 2) + "b" + str(i)
else:
conv_name = "res" + str(block + 2) + chr(97 + i)
conv = self.bottleneck_block(
input=conv,
num_filters=num_filters[block],
stride=2 if i == 0 and block != 0 else 1,
if_first=block == 0,
name=conv_name)
pool = fluid.layers.pool2d(
input=conv, pool_size=7, pool_type='avg', global_pooling=True)
stdv = 1.0 / math.sqrt(pool.shape[1] * 1.0)
out = fluid.layers.fc(
input=pool,
size=class_dim,
param_attr=fluid.param_attr.ParamAttr(
initializer=fluid.initializer.Uniform(-stdv, stdv)))
return out, pool
def conv_bn_layer(self,
input,
num_filters,
filter_size,
stride=1,
groups=1,
act=None,
name=None):
conv = fluid.layers.conv2d(
input=input,
num_filters=num_filters,
filter_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=groups,
act=None,
param_attr=ParamAttr(name=name + "_weights"),
bias_attr=False)
if name == "conv1":
bn_name = "bn_" + name
else:
bn_name = "bn" + name[3:]
return fluid.layers.batch_norm(
input=conv,
act=act,
param_attr=ParamAttr(name=bn_name + '_scale'),
bias_attr=ParamAttr(bn_name + '_offset'),
moving_mean_name=bn_name + '_mean',
moving_variance_name=bn_name + '_variance')
def conv_bn_layer_new(self,
input,
num_filters,
filter_size,
stride=1,
groups=1,
act=None,
name=None):
pool = fluid.layers.pool2d(
input=input,
pool_size=2,
pool_stride=2,
pool_padding=0,
pool_type='avg')
conv = fluid.layers.conv2d(
input=pool,
num_filters=num_filters,
filter_size=filter_size,
stride=1,
padding=(filter_size - 1) // 2,
groups=groups,
act=None,
param_attr=ParamAttr(name=name + "_weights"),
bias_attr=False)
if name == "conv1":
bn_name = "bn_" + name
else:
bn_name = "bn" + name[3:]
return fluid.layers.batch_norm(
input=conv,
act=act,
param_attr=ParamAttr(name=bn_name + '_scale'),
bias_attr=ParamAttr(bn_name + '_offset'),
moving_mean_name=bn_name + '_mean',
moving_variance_name=bn_name + '_variance')
def shortcut(self, input, ch_out, stride, name, if_first=False):
ch_in = input.shape[1]
if ch_in != ch_out or stride != 1:
if if_first:
return self.conv_bn_layer(input, ch_out, 1, stride, name=name)
else:
return self.conv_bn_layer_new(
input, ch_out, 1, stride, name=name)
else:
return input
def bottleneck_block(self, input, num_filters, stride, name, if_first):
conv0 = self.conv_bn_layer(
input=input,
num_filters=num_filters,
filter_size=1,
act='relu',
name=name + "_branch2a")
conv1 = self.conv_bn_layer(
input=conv0,
num_filters=num_filters,
filter_size=3,
stride=stride,
act='relu',
name=name + "_branch2b")
conv2 = self.conv_bn_layer(
input=conv1,
num_filters=num_filters * 4,
filter_size=1,
act=None,
name=name + "_branch2c")
short = self.shortcut(
input,
num_filters * 4,
stride,
if_first=if_first,
name=name + "_branch1")
return fluid.layers.elementwise_add(x=short, y=conv2, act='relu')
def ResNet50_vd():
model = ResNet(layers=50, is_3x3=True)
return model
def ResNet101_vd():
model = ResNet(layers=101, is_3x3=True)
return model
def ResNet152_vd():
model = ResNet(layers=152, is_3x3=True)
return model
def ResNet200_vd():
model = ResNet(layers=200, is_3x3=True)
return model
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或