Merge branch 'develop' of https://github.com/baidu/Paddle into convolution
hedaoyuan
8 years ago
commit
1e0cc74145
@ -1,9 +0,0 @@
|
||||
data/cifar-10-batches-py
|
||||
data/cifar-out
|
||||
cifar_vgg_model/*
|
||||
plot.png
|
||||
train.log
|
||||
image_provider_copy_1.py
|
||||
*pyc
|
||||
train.list
|
||||
test.list
|
||||
@ -1,74 +0,0 @@
|
||||
# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
|
||||
#
|
||||
# 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.
|
||||
|
||||
import paddle.v2 as paddle
|
||||
|
||||
__all__ = ['resnet_cifar10']
|
||||
|
||||
|
||||
def conv_bn_layer(input,
|
||||
ch_out,
|
||||
filter_size,
|
||||
stride,
|
||||
padding,
|
||||
active_type=paddle.activation.Relu(),
|
||||
ch_in=None):
|
||||
tmp = paddle.layer.img_conv(
|
||||
input=input,
|
||||
filter_size=filter_size,
|
||||
num_channels=ch_in,
|
||||
num_filters=ch_out,
|
||||
stride=stride,
|
||||
padding=padding,
|
||||
act=paddle.activation.Linear(),
|
||||
bias_attr=False)
|
||||
return paddle.layer.batch_norm(input=tmp, act=active_type)
|
||||
|
||||
|
||||
def shortcut(ipt, n_in, n_out, stride):
|
||||
if n_in != n_out:
|
||||
return conv_bn_layer(ipt, n_out, 1, stride, 0,
|
||||
paddle.activation.Linear())
|
||||
else:
|
||||
return ipt
|
||||
|
||||
|
||||
def basicblock(ipt, ch_out, stride):
|
||||
ch_in = ch_out * 2
|
||||
tmp = conv_bn_layer(ipt, ch_out, 3, stride, 1)
|
||||
tmp = conv_bn_layer(tmp, ch_out, 3, 1, 1, paddle.activation.Linear())
|
||||
short = shortcut(ipt, ch_in, ch_out, stride)
|
||||
return paddle.layer.addto(input=[tmp, short], act=paddle.activation.Relu())
|
||||
|
||||
|
||||
def layer_warp(block_func, ipt, features, count, stride):
|
||||
tmp = block_func(ipt, features, stride)
|
||||
for i in range(1, count):
|
||||
tmp = block_func(tmp, features, 1)
|
||||
return tmp
|
||||
|
||||
|
||||
def resnet_cifar10(ipt, depth=32):
|
||||
# depth should be one of 20, 32, 44, 56, 110, 1202
|
||||
assert (depth - 2) % 6 == 0
|
||||
n = (depth - 2) / 6
|
||||
nStages = {16, 64, 128}
|
||||
conv1 = conv_bn_layer(
|
||||
ipt, ch_in=3, ch_out=16, filter_size=3, stride=1, padding=1)
|
||||
res1 = layer_warp(basicblock, conv1, 16, n, 1)
|
||||
res2 = layer_warp(basicblock, res1, 32, n, 2)
|
||||
res3 = layer_warp(basicblock, res2, 64, n, 2)
|
||||
pool = paddle.layer.img_pool(
|
||||
input=res3, pool_size=8, stride=1, pool_type=paddle.pooling.Avg())
|
||||
return pool
|
||||
@ -1,92 +0,0 @@
|
||||
# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
|
||||
#
|
||||
# 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
|
||||
|
||||
import sys
|
||||
|
||||
import paddle.v2 as paddle
|
||||
|
||||
from api_v2_vgg import vgg_bn_drop
|
||||
|
||||
|
||||
def main():
|
||||
datadim = 3 * 32 * 32
|
||||
classdim = 10
|
||||
|
||||
# PaddlePaddle init
|
||||
paddle.init(use_gpu=False, trainer_count=1)
|
||||
|
||||
image = paddle.layer.data(
|
||||
name="image", type=paddle.data_type.dense_vector(datadim))
|
||||
|
||||
# Add neural network config
|
||||
# option 1. resnet
|
||||
# net = resnet_cifar10(image, depth=32)
|
||||
# option 2. vgg
|
||||
net = vgg_bn_drop(image)
|
||||
|
||||
out = paddle.layer.fc(input=net,
|
||||
size=classdim,
|
||||
act=paddle.activation.Softmax())
|
||||
|
||||
lbl = paddle.layer.data(
|
||||
name="label", type=paddle.data_type.integer_value(classdim))
|
||||
cost = paddle.layer.classification_cost(input=out, label=lbl)
|
||||
|
||||
# Create parameters
|
||||
parameters = paddle.parameters.create(cost)
|
||||
|
||||
# Create optimizer
|
||||
momentum_optimizer = paddle.optimizer.Momentum(
|
||||
momentum=0.9,
|
||||
regularization=paddle.optimizer.L2Regularization(rate=0.0002 * 128),
|
||||
learning_rate=0.1 / 128.0,
|
||||
learning_rate_decay_a=0.1,
|
||||
learning_rate_decay_b=50000 * 100,
|
||||
learning_rate_schedule='discexp',
|
||||
batch_size=128)
|
||||
|
||||
# End batch and end pass event handler
|
||||
def event_handler(event):
|
||||
if isinstance(event, paddle.event.EndIteration):
|
||||
if event.batch_id % 100 == 0:
|
||||
print "\nPass %d, Batch %d, Cost %f, %s" % (
|
||||
event.pass_id, event.batch_id, event.cost, event.metrics)
|
||||
else:
|
||||
sys.stdout.write('.')
|
||||
sys.stdout.flush()
|
||||
if isinstance(event, paddle.event.EndPass):
|
||||
result = trainer.test(
|
||||
reader=paddle.batch(
|
||||
paddle.dataset.cifar.test10(), batch_size=128),
|
||||
feeding={'image': 0,
|
||||
'label': 1})
|
||||
print "\nTest with Pass %d, %s" % (event.pass_id, result.metrics)
|
||||
|
||||
# Create trainer
|
||||
trainer = paddle.trainer.SGD(cost=cost,
|
||||
parameters=parameters,
|
||||
update_equation=momentum_optimizer)
|
||||
trainer.train(
|
||||
reader=paddle.batch(
|
||||
paddle.reader.shuffle(
|
||||
paddle.dataset.cifar.train10(), buf_size=50000),
|
||||
batch_size=128),
|
||||
num_passes=5,
|
||||
event_handler=event_handler,
|
||||
feeding={'image': 0,
|
||||
'label': 1})
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@ -1,47 +0,0 @@
|
||||
# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
|
||||
#
|
||||
# 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.
|
||||
|
||||
import paddle.v2 as paddle
|
||||
|
||||
__all__ = ['vgg_bn_drop']
|
||||
|
||||
|
||||
def vgg_bn_drop(input):
|
||||
def conv_block(ipt, num_filter, groups, dropouts, num_channels=None):
|
||||
return paddle.networks.img_conv_group(
|
||||
input=ipt,
|
||||
num_channels=num_channels,
|
||||
pool_size=2,
|
||||
pool_stride=2,
|
||||
conv_num_filter=[num_filter] * groups,
|
||||
conv_filter_size=3,
|
||||
conv_act=paddle.activation.Relu(),
|
||||
conv_with_batchnorm=True,
|
||||
conv_batchnorm_drop_rate=dropouts,
|
||||
pool_type=paddle.pooling.Max())
|
||||
|
||||
conv1 = conv_block(input, 64, 2, [0.3, 0], 3)
|
||||
conv2 = conv_block(conv1, 128, 2, [0.4, 0])
|
||||
conv3 = conv_block(conv2, 256, 3, [0.4, 0.4, 0])
|
||||
conv4 = conv_block(conv3, 512, 3, [0.4, 0.4, 0])
|
||||
conv5 = conv_block(conv4, 512, 3, [0.4, 0.4, 0])
|
||||
|
||||
drop = paddle.layer.dropout(input=conv5, dropout_rate=0.5)
|
||||
fc1 = paddle.layer.fc(input=drop, size=512, act=paddle.activation.Linear())
|
||||
bn = paddle.layer.batch_norm(
|
||||
input=fc1,
|
||||
act=paddle.activation.Relu(),
|
||||
layer_attr=paddle.attr.Extra(drop_rate=0.5))
|
||||
fc2 = paddle.layer.fc(input=bn, size=512, act=paddle.activation.Linear())
|
||||
return fc2
|
||||
@ -1,21 +0,0 @@
|
||||
#!/bin/bash
|
||||
# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
|
||||
#
|
||||
# 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.
|
||||
set -e
|
||||
wget https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
|
||||
tar zxf cifar-10-python.tar.gz
|
||||
rm cifar-10-python.tar.gz
|
||||
rm -rf cifar-out/*
|
||||
echo Converting CIFAR data to images.....
|
||||
python process_cifar.py ./cifar-10-batches-py ./cifar-out
|
||||
@ -1,89 +0,0 @@
|
||||
# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
|
||||
#
|
||||
# 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.
|
||||
|
||||
import numpy as np
|
||||
import sys
|
||||
import os
|
||||
import PIL.Image as Image
|
||||
"""
|
||||
Usage: python process_cifar input_dir output_dir
|
||||
"""
|
||||
|
||||
|
||||
def mkdir_not_exist(path):
|
||||
"""
|
||||
Make dir if the path does not exist.
|
||||
path: the path to be created.
|
||||
"""
|
||||
if not os.path.exists(path):
|
||||
os.mkdir(path)
|
||||
|
||||
|
||||
def create_dir_structure(output_dir):
|
||||
"""
|
||||
Create the directory structure for the directory.
|
||||
output_dir: the direcotry structure path.
|
||||
"""
|
||||
mkdir_not_exist(os.path.join(output_dir))
|
||||
mkdir_not_exist(os.path.join(output_dir, "train"))
|
||||
mkdir_not_exist(os.path.join(output_dir, "test"))
|
||||
|
||||
|
||||
def convert_batch(batch_path, label_set, label_map, output_dir, data_split):
|
||||
"""
|
||||
Convert CIFAR batch to the structure of Paddle format.
|
||||
batch_path: the batch to be converted.
|
||||
label_set: the set of labels.
|
||||
output_dir: the output path.
|
||||
data_split: whether it is training or testing data.
|
||||
"""
|
||||
data = np.load(batch_path)
|
||||
for data, label, filename in zip(data['data'], data['labels'],
|
||||
data['filenames']):
|
||||
data = data.reshape((3, 32, 32))
|
||||
data = np.transpose(data, (1, 2, 0))
|
||||
label = label_map[label]
|
||||
output_dir_this = os.path.join(output_dir, data_split, str(label))
|
||||
output_filename = os.path.join(output_dir_this, filename)
|
||||
if not label in label_set:
|
||||
label_set[label] = True
|
||||
mkdir_not_exist(output_dir_this)
|
||||
Image.fromarray(data).save(output_filename)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
input_dir = sys.argv[1]
|
||||
output_dir = sys.argv[2]
|
||||
num_batch = 5
|
||||
create_dir_structure(output_dir)
|
||||
label_map = {
|
||||
0: "airplane",
|
||||
1: "automobile",
|
||||
2: "bird",
|
||||
3: "cat",
|
||||
4: "deer",
|
||||
5: "dog",
|
||||
6: "frog",
|
||||
7: "horse",
|
||||
8: "ship",
|
||||
9: "truck"
|
||||
}
|
||||
labels = {}
|
||||
for i in range(1, num_batch + 1):
|
||||
convert_batch(
|
||||
os.path.join(input_dir, "data_batch_%d" % i), labels, label_map,
|
||||
output_dir, "train")
|
||||
convert_batch(
|
||||
os.path.join(input_dir, "test_batch"), {}, label_map, output_dir,
|
||||
"test")
|
||||
@ -1,89 +0,0 @@
|
||||
# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
|
||||
#
|
||||
# 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.
|
||||
|
||||
import io
|
||||
import random
|
||||
|
||||
import paddle.utils.image_util as image_util
|
||||
from paddle.trainer.PyDataProvider2 import *
|
||||
|
||||
|
||||
#
|
||||
# {'img_size': 32,
|
||||
# 'settings': a global object,
|
||||
# 'color': True,
|
||||
# 'mean_img_size': 32,
|
||||
# 'meta': './data/cifar-out/batches/batches.meta',
|
||||
# 'num_classes': 10,
|
||||
# 'file_list': ('./data/cifar-out/batches/train_batch_000',),
|
||||
# 'use_jpeg': True}
|
||||
def hook(settings, img_size, mean_img_size, num_classes, color, meta, use_jpeg,
|
||||
is_train, **kwargs):
|
||||
settings.mean_img_size = mean_img_size
|
||||
settings.img_size = img_size
|
||||
settings.num_classes = num_classes
|
||||
settings.color = color
|
||||
settings.is_train = is_train
|
||||
|
||||
if settings.color:
|
||||
settings.img_raw_size = settings.img_size * settings.img_size * 3
|
||||
else:
|
||||
settings.img_raw_size = settings.img_size * settings.img_size
|
||||
|
||||
settings.meta_path = meta
|
||||
settings.use_jpeg = use_jpeg
|
||||
|
||||
settings.img_mean = image_util.load_meta(settings.meta_path,
|
||||
settings.mean_img_size,
|
||||
settings.img_size, settings.color)
|
||||
|
||||
settings.logger.info('Image size: %s', settings.img_size)
|
||||
settings.logger.info('Meta path: %s', settings.meta_path)
|
||||
settings.input_types = {
|
||||
'image': dense_vector(settings.img_raw_size),
|
||||
'label': integer_value(settings.num_classes)
|
||||
}
|
||||
|
||||
settings.logger.info('DataProvider Initialization finished')
|
||||
|
||||
|
||||
@provider(init_hook=hook, min_pool_size=0)
|
||||
def processData(settings, file_list):
|
||||
"""
|
||||
The main function for loading data.
|
||||
Load the batch, iterate all the images and labels in this batch.
|
||||
file_list: the batch file list.
|
||||
"""
|
||||
with open(file_list, 'r') as fdata:
|
||||
lines = [line.strip() for line in fdata]
|
||||
random.shuffle(lines)
|
||||
for file_name in lines:
|
||||
with io.open(file_name.strip(), 'rb') as file:
|
||||
data = cPickle.load(file)
|
||||
indexes = list(range(len(data['images'])))
|
||||
if settings.is_train:
|
||||
random.shuffle(indexes)
|
||||
for i in indexes:
|
||||
if settings.use_jpeg == 1:
|
||||
img = image_util.decode_jpeg(data['images'][i])
|
||||
else:
|
||||
img = data['images'][i]
|
||||
img_feat = image_util.preprocess_img(
|
||||
img, settings.img_mean, settings.img_size,
|
||||
settings.is_train, settings.color)
|
||||
label = data['labels'][i]
|
||||
yield {
|
||||
'image': img_feat.astype('float32'),
|
||||
'label': int(label)
|
||||
}
|
||||
@ -1,221 +0,0 @@
|
||||
# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
|
||||
#
|
||||
# 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.
|
||||
|
||||
import numpy as np
|
||||
from PIL import Image
|
||||
from cStringIO import StringIO
|
||||
|
||||
|
||||
def resize_image(img, target_size):
|
||||
"""
|
||||
Resize an image so that the shorter edge has length target_size.
|
||||
img: the input image to be resized.
|
||||
target_size: the target resized image size.
|
||||
"""
|
||||
percent = (target_size / float(min(img.size[0], img.size[1])))
|
||||
resized_size = int(round(img.size[0] * percent)), int(
|
||||
round(img.size[1] * percent))
|
||||
img = img.resize(resized_size, Image.ANTIALIAS)
|
||||
return img
|
||||
|
||||
|
||||
def flip(im):
|
||||
"""
|
||||
Return the flipped image.
|
||||
Flip an image along the horizontal direction.
|
||||
im: input image, (H x W x K) ndarrays
|
||||
"""
|
||||
if len(im.shape) == 3:
|
||||
return im[:, :, ::-1]
|
||||
else:
|
||||
return im[:, ::-1]
|
||||
|
||||
|
||||
def crop_img(im, inner_size, color=True, test=True):
|
||||
"""
|
||||
Return cropped image.
|
||||
The size of the cropped image is inner_size * inner_size.
|
||||
im: (K x H x W) ndarrays
|
||||
inner_size: the cropped image size.
|
||||
color: whether it is color image.
|
||||
test: whether in test mode.
|
||||
If False, does random cropping and flipping.
|
||||
If True, crop the center of images.
|
||||
"""
|
||||
if color:
|
||||
height, width = max(inner_size, im.shape[1]), max(inner_size,
|
||||
im.shape[2])
|
||||
padded_im = np.zeros((3, height, width))
|
||||
startY = (height - im.shape[1]) / 2
|
||||
startX = (width - im.shape[2]) / 2
|
||||
endY, endX = startY + im.shape[1], startX + im.shape[2]
|
||||
padded_im[:, startY:endY, startX:endX] = im
|
||||
else:
|
||||
im = im.astype('float32')
|
||||
height, width = max(inner_size, im.shape[0]), max(inner_size,
|
||||
im.shape[1])
|
||||
padded_im = np.zeros((height, width))
|
||||
startY = (height - im.shape[0]) / 2
|
||||
startX = (width - im.shape[1]) / 2
|
||||
endY, endX = startY + im.shape[0], startX + im.shape[1]
|
||||
padded_im[startY:endY, startX:endX] = im
|
||||
if test:
|
||||
startY = (height - inner_size) / 2
|
||||
startX = (width - inner_size) / 2
|
||||
else:
|
||||
startY = np.random.randint(0, height - inner_size + 1)
|
||||
startX = np.random.randint(0, width - inner_size + 1)
|
||||
endY, endX = startY + inner_size, startX + inner_size
|
||||
if color:
|
||||
pic = padded_im[:, startY:endY, startX:endX]
|
||||
else:
|
||||
pic = padded_im[startY:endY, startX:endX]
|
||||
if (not test) and (np.random.randint(2) == 0):
|
||||
pic = flip(pic)
|
||||
return pic
|
||||
|
||||
|
||||
def decode_jpeg(jpeg_string):
|
||||
np_array = np.array(Image.open(StringIO(jpeg_string)))
|
||||
if len(np_array.shape) == 3:
|
||||
np_array = np.transpose(np_array, (2, 0, 1))
|
||||
return np_array
|
||||
|
||||
|
||||
def preprocess_img(im, img_mean, crop_size, is_train, color=True):
|
||||
"""
|
||||
Does data augmentation for images.
|
||||
If is_train is false, cropping the center region from the image.
|
||||
If is_train is true, randomly crop a region from the image,
|
||||
and randomy does flipping.
|
||||
im: (K x H x W) ndarrays
|
||||
"""
|
||||
im = im.astype('float32')
|
||||
test = not is_train
|
||||
pic = crop_img(im, crop_size, color, test)
|
||||
pic -= img_mean
|
||||
return pic.flatten()
|
||||
|
||||
|
||||
def load_meta(meta_path, mean_img_size, crop_size, color=True):
|
||||
"""
|
||||
Return the loaded meta file.
|
||||
Load the meta image, which is the mean of the images in the dataset.
|
||||
The mean image is subtracted from every input image so that the expected mean
|
||||
of each input image is zero.
|
||||
"""
|
||||
mean = np.load(meta_path)['data_mean']
|
||||
border = (mean_img_size - crop_size) / 2
|
||||
if color:
|
||||
assert (mean_img_size * mean_img_size * 3 == mean.shape[0])
|
||||
mean = mean.reshape(3, mean_img_size, mean_img_size)
|
||||
mean = mean[:, border:border + crop_size, border:border +
|
||||
crop_size].astype('float32')
|
||||
else:
|
||||
assert (mean_img_size * mean_img_size == mean.shape[0])
|
||||
mean = mean.reshape(mean_img_size, mean_img_size)
|
||||
mean = mean[border:border + crop_size, border:border +
|
||||
crop_size].astype('float32')
|
||||
return mean
|
||||
|
||||
|
||||
def load_image(img_path, is_color=True):
|
||||
"""
|
||||
Load image and return.
|
||||
img_path: image path.
|
||||
is_color: is color image or not.
|
||||
"""
|
||||
img = Image.open(img_path)
|
||||
img.load()
|
||||
return img
|
||||
|
||||
|
||||
def oversample(img, crop_dims):
|
||||
"""
|
||||
image : iterable of (H x W x K) ndarrays
|
||||
crop_dims: (height, width) tuple for the crops.
|
||||
Returned data contains ten crops of input image, namely,
|
||||
four corner patches and the center patch as well as their
|
||||
horizontal reflections.
|
||||
"""
|
||||
# Dimensions and center.
|
||||
im_shape = np.array(img[0].shape)
|
||||
crop_dims = np.array(crop_dims)
|
||||
im_center = im_shape[:2] / 2.0
|
||||
|
||||
# Make crop coordinates
|
||||
h_indices = (0, im_shape[0] - crop_dims[0])
|
||||
w_indices = (0, im_shape[1] - crop_dims[1])
|
||||
crops_ix = np.empty((5, 4), dtype=int)
|
||||
curr = 0
|
||||
for i in h_indices:
|
||||
for j in w_indices:
|
||||
crops_ix[curr] = (i, j, i + crop_dims[0], j + crop_dims[1])
|
||||
curr += 1
|
||||
crops_ix[4] = np.tile(im_center, (1, 2)) + np.concatenate(
|
||||
[-crop_dims / 2.0, crop_dims / 2.0])
|
||||
crops_ix = np.tile(crops_ix, (2, 1))
|
||||
|
||||
# Extract crops
|
||||
crops = np.empty(
|
||||
(10 * len(img), crop_dims[0], crop_dims[1], im_shape[-1]),
|
||||
dtype=np.float32)
|
||||
ix = 0
|
||||
for im in img:
|
||||
for crop in crops_ix:
|
||||
crops[ix] = im[crop[0]:crop[2], crop[1]:crop[3], :]
|
||||
ix += 1
|
||||
crops[ix - 5:ix] = crops[ix - 5:ix, :, ::-1, :] # flip for mirrors
|
||||
return crops
|
||||
|
||||
|
||||
class ImageTransformer:
|
||||
def __init__(self,
|
||||
transpose=None,
|
||||
channel_swap=None,
|
||||
mean=None,
|
||||
is_color=True):
|
||||
self.transpose = transpose
|
||||
self.channel_swap = None
|
||||
self.mean = None
|
||||
self.is_color = is_color
|
||||
|
||||
def set_transpose(self, order):
|
||||
if self.is_color:
|
||||
assert 3 == len(order)
|
||||
self.transpose = order
|
||||
|
||||
def set_channel_swap(self, order):
|
||||
if self.is_color:
|
||||
assert 3 == len(order)
|
||||
self.channel_swap = order
|
||||
|
||||
def set_mean(self, mean):
|
||||
# mean value, may be one value per channel
|
||||
if mean.ndim == 1:
|
||||
mean = mean[:, np.newaxis, np.newaxis]
|
||||
else:
|
||||
# elementwise mean
|
||||
if self.is_color:
|
||||
assert len(mean.shape) == 3
|
||||
self.mean = mean
|
||||
|
||||
def transformer(self, data):
|
||||
if self.transpose is not None:
|
||||
data = data.transpose(self.transpose)
|
||||
if self.channel_swap is not None:
|
||||
data = data[self.channel_swap, :, :]
|
||||
if self.mean is not None:
|
||||
data -= self.mean
|
||||
return data
|
||||
@ -1,20 +0,0 @@
|
||||
#!/bin/bash
|
||||
# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
|
||||
#
|
||||
# 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.
|
||||
set -e
|
||||
|
||||
model=cifar_vgg_model/pass-00299/
|
||||
image=data/cifar-out/test/airplane/seaplane_s_000978.png
|
||||
use_gpu=1
|
||||
python prediction.py $model $image $use_gpu
|
||||
@ -1,159 +0,0 @@
|
||||
# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
|
||||
#
|
||||
# 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.
|
||||
|
||||
import os, sys
|
||||
import numpy as np
|
||||
import logging
|
||||
from PIL import Image
|
||||
from optparse import OptionParser
|
||||
|
||||
import paddle.utils.image_util as image_util
|
||||
|
||||
from py_paddle import swig_paddle, DataProviderConverter
|
||||
from paddle.trainer.PyDataProvider2 import dense_vector
|
||||
from paddle.trainer.config_parser import parse_config
|
||||
|
||||
logging.basicConfig(
|
||||
format='[%(levelname)s %(asctime)s %(filename)s:%(lineno)s] %(message)s')
|
||||
logging.getLogger().setLevel(logging.INFO)
|
||||
|
||||
|
||||
class ImageClassifier():
|
||||
def __init__(self,
|
||||
train_conf,
|
||||
use_gpu=True,
|
||||
model_dir=None,
|
||||
resize_dim=None,
|
||||
crop_dim=None,
|
||||
mean_file=None,
|
||||
oversample=False,
|
||||
is_color=True):
|
||||
"""
|
||||
train_conf: network configure.
|
||||
model_dir: string, directory of model.
|
||||
resize_dim: int, resized image size.
|
||||
crop_dim: int, crop size.
|
||||
mean_file: string, image mean file.
|
||||
oversample: bool, oversample means multiple crops, namely five
|
||||
patches (the four corner patches and the center
|
||||
patch) as well as their horizontal reflections,
|
||||
ten crops in all.
|
||||
"""
|
||||
self.train_conf = train_conf
|
||||
self.model_dir = model_dir
|
||||
if model_dir is None:
|
||||
self.model_dir = os.path.dirname(train_conf)
|
||||
|
||||
self.resize_dim = resize_dim
|
||||
self.crop_dims = [crop_dim, crop_dim]
|
||||
self.oversample = oversample
|
||||
self.is_color = is_color
|
||||
|
||||
self.transformer = image_util.ImageTransformer(is_color=is_color)
|
||||
self.transformer.set_transpose((2, 0, 1))
|
||||
|
||||
self.mean_file = mean_file
|
||||
mean = np.load(self.mean_file)['data_mean']
|
||||
mean = mean.reshape(3, self.crop_dims[0], self.crop_dims[1])
|
||||
self.transformer.set_mean(mean) # mean pixel
|
||||
gpu = 1 if use_gpu else 0
|
||||
conf_args = "is_test=1,use_gpu=%d,is_predict=1" % (gpu)
|
||||
conf = parse_config(train_conf, conf_args)
|
||||
swig_paddle.initPaddle("--use_gpu=%d" % (gpu))
|
||||
self.network = swig_paddle.GradientMachine.createFromConfigProto(
|
||||
conf.model_config)
|
||||
assert isinstance(self.network, swig_paddle.GradientMachine)
|
||||
self.network.loadParameters(self.model_dir)
|
||||
|
||||
data_size = 3 * self.crop_dims[0] * self.crop_dims[1]
|
||||
slots = [dense_vector(data_size)]
|
||||
self.converter = DataProviderConverter(slots)
|
||||
|
||||
def get_data(self, img_path):
|
||||
"""
|
||||
1. load image from img_path.
|
||||
2. resize or oversampling.
|
||||
3. transformer data: transpose, sub mean.
|
||||
return K x H x W ndarray.
|
||||
img_path: image path.
|
||||
"""
|
||||
image = image_util.load_image(img_path, self.is_color)
|
||||
if self.oversample:
|
||||
# image_util.resize_image: short side is self.resize_dim
|
||||
image = image_util.resize_image(image, self.resize_dim)
|
||||
image = np.array(image)
|
||||
input = np.zeros(
|
||||
(1, image.shape[0], image.shape[1], 3), dtype=np.float32)
|
||||
input[0] = image.astype(np.float32)
|
||||
input = image_util.oversample(input, self.crop_dims)
|
||||
else:
|
||||
image = image.resize(self.crop_dims, Image.ANTIALIAS)
|
||||
input = np.zeros(
|
||||
(1, self.crop_dims[0], self.crop_dims[1], 3), dtype=np.float32)
|
||||
input[0] = np.array(image).astype(np.float32)
|
||||
|
||||
data_in = []
|
||||
for img in input:
|
||||
img = self.transformer.transformer(img).flatten()
|
||||
data_in.append([img.tolist()])
|
||||
return data_in
|
||||
|
||||
def forward(self, input_data):
|
||||
in_arg = self.converter(input_data)
|
||||
return self.network.forwardTest(in_arg)
|
||||
|
||||
def forward(self, data, output_layer):
|
||||
"""
|
||||
input_data: py_paddle input data.
|
||||
output_layer: specify the name of probability, namely the layer with
|
||||
softmax activation.
|
||||
return: the predicting probability of each label.
|
||||
"""
|
||||
input = self.converter(data)
|
||||
self.network.forwardTest(input)
|
||||
output = self.network.getLayerOutputs(output_layer)
|
||||
# For oversampling, average predictions across crops.
|
||||
# If not, the shape of output[name]: (1, class_number),
|
||||
# the mean is also applicable.
|
||||
return output[output_layer]['value'].mean(0)
|
||||
|
||||
def predict(self, image=None, output_layer=None):
|
||||
assert isinstance(image, basestring)
|
||||
assert isinstance(output_layer, basestring)
|
||||
data = self.get_data(image)
|
||||
prob = self.forward(data, output_layer)
|
||||
lab = np.argsort(-prob)
|
||||
logging.info("Label of %s is: %d", image, lab[0])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
image_size = 32
|
||||
crop_size = 32
|
||||
multi_crop = True
|
||||
config = "vgg_16_cifar.py"
|
||||
output_layer = "__fc_layer_1__"
|
||||
mean_path = "data/cifar-out/batches/batches.meta"
|
||||
model_path = sys.argv[1]
|
||||
image = sys.argv[2]
|
||||
use_gpu = bool(int(sys.argv[3]))
|
||||
|
||||
obj = ImageClassifier(
|
||||
train_conf=config,
|
||||
model_dir=model_path,
|
||||
resize_dim=image_size,
|
||||
crop_dim=crop_size,
|
||||
mean_file=mean_path,
|
||||
use_gpu=use_gpu,
|
||||
oversample=multi_crop)
|
||||
obj.predict(image, output_layer)
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue