def parse_new_rnn():
reset_parser()
data = layer.data(
name="word", type=data_type.dense_vector(dict_dim))
label = layer.data(
name="label", type=data_type.dense_vector(label_dim))
emb = layer.embedding(input=data, size=word_dim)
boot_layer = layer.data(
name="boot", type=data_type.dense_vector(10))
boot_layer = layer.fc(name='boot_fc', input=boot_layer, size=10)
def step(y, wid):
z = layer.embedding(input=wid, size=word_dim)
mem = layer.memory(
name="rnn_state", size=hidden_dim, boot_layer=boot_layer)
out = layer.fc(input=[y, z, mem],
size=hidden_dim,
act=activation.Tanh(),
bias_attr=True,
name="rnn_state")
return out
out = layer.recurrent_group(
name="rnn", step=step, input=[emb, data])
rep = layer.last_seq(input=out)
prob = layer.fc(size=label_dim,
input=rep,
act=activation.Softmax(),
bias_attr=True)
cost = layer.classification_cost(input=prob, label=label)
return str(layer.parse_network(cost))
def print_result(self):
reset_parser()
img = np.transpose(self.data, (2, 0, 1))
test_data = [(img.flatten(),)]
parameters_file = self.args.w
with gzip.open(parameters_file, 'r') as f:
parameters = paddle.parameters.Parameters.from_tar(f)
predict = paddle.infer(output_layer = self.model, parameters=parameters, input=test_data)
predict = np.squeeze(predict)
super(TestPaddle, self).print_result(predict)
def inference(cls, architecture, files, path, image_path):
import numpy as np
if cls.sanity_check(architecture):
# refer to https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/tests/test_rnn_layer.py#L35
reset_parser()
# refer to https://github.com/PaddlePaddle/Paddle/issues/7403
paddle.init(use_gpu=False, trainer_count=1)
DATA_DIM = 3 * paddle_extractor._image_size * paddle_extractor._image_size # Use 3 * 331 * 331 or 3 * 299 * 299 for Inception-ResNet-v2.
CLASS_DIM = paddle_extractor.class_dim_map[architecture]
image = paddle.layer.data(
name="image", type=paddle.data_type.dense_vector(DATA_DIM))
if 'resnet' in architecture:
from mmdnn.conversion.examples.paddle.models import resnet
depth = int(architecture.strip('resnet'))
out = resnet.resnet_imagenet(image,
class_dim=CLASS_DIM,
depth=depth)
elif architecture == 'vgg16':
from mmdnn.conversion.examples.paddle.models import vgg
out = vgg.vgg16(image, class_dim=CLASS_DIM)
else:
print("Not support for {} yet.", architecture)
return None
_, parameters_file = files
with gzip.open(parameters_file, 'r') as f:
parameters = paddle.parameters.Parameters.from_tar(f)
func = TestKit.preprocess_func['paddle'][architecture]
img = func(image_path)
img = np.transpose(img, [2, 0, 1])
test_data = [(img.flatten(), )]
predict = paddle.infer(output_layer=out,
parameters=parameters,
input=test_data)
predict = np.squeeze(predict)
return predict
else:
return None
def parse_new_rnn():
reset_parser()
def new_step(y):
mem = layer.memory(name="rnn_state", size=hidden_dim)
out = layer.fc(input=[y, mem],
size=hidden_dim,
act=activation.Tanh(),
bias_attr=True,
name="rnn_state")
return out
data = layer.data(
name="word", type=data_type.integer_value(dict_dim))
embd = layer.embedding(input=data, size=word_dim)
rnn_layer = layer.recurrent_group(
name="rnn", step=new_step, input=embd, reverse=True)
return str(layer.parse_network(rnn_layer))
def parse_old_rnn():
reset_parser()
def step(y):
mem = conf_helps.memory(name="rnn_state", size=hidden_dim)
out = conf_helps.fc_layer(
input=[y, mem],
size=hidden_dim,
act=activation.Tanh(),
bias_attr=True,
name="rnn_state")
return out
def test():
data = conf_helps.data_layer(name="word", size=dict_dim)
embd = conf_helps.embedding_layer(input=data, size=word_dim)
conf_helps.recurrent_group(
name="rnn", step=step, input=embd, reverse=True)
return str(parse_network(test))
def parse_new_rnn():
reset_parser()
def new_step(y):
mem = layer.memory(name="rnn_state", size=hidden_dim)
out = layer.fc(input=[y, mem],
size=hidden_dim,
act=activation.Tanh(),
bias_attr=True,
name="rnn_state")
return out
data = layer.data(name="word",
type=data_type.integer_value(dict_dim))
embd = layer.embedding(input=data, size=word_dim)
rnn_layer = layer.recurrent_group(name="rnn",
step=new_step,
input=embd,
reverse=True)
return str(layer.parse_network(rnn_layer))
def parse_old_rnn():
reset_parser()
def step(y):
mem = conf_helps.memory(name="rnn_state", size=hidden_dim)
out = conf_helps.fc_layer(input=[y, mem],
size=hidden_dim,
act=activation.Tanh(),
bias_attr=True,
name="rnn_state")
return out
def test():
data = conf_helps.data_layer(name="word", size=dict_dim)
embd = conf_helps.embedding_layer(input=data, size=word_dim)
conf_helps.recurrent_group(name="rnn",
step=step,
input=embd,
reverse=True)
return str(parse_network(test))
def parse_old_rnn():
reset_parser()
def test():
data = conf_helps.data_layer(name="word", size=dict_dim)
label = conf_helps.data_layer(name="label", size=label_dim)
emb = conf_helps.embedding_layer(input=data, size=word_dim)
boot_layer = conf_helps.data_layer(name="boot", size=10)
boot_layer = conf_helps.fc_layer(
name='boot_fc', input=boot_layer, size=10)
def step(y, wid):
z = conf_helps.embedding_layer(input=wid, size=word_dim)
mem = conf_helps.memory(
name="rnn_state",
size=hidden_dim,
boot_layer=boot_layer)
out = conf_helps.fc_layer(
input=[y, z, mem],
size=hidden_dim,
act=conf_helps.TanhActivation(),
bias_attr=True,
name="rnn_state")
return out
out = conf_helps.recurrent_group(
name="rnn", step=step, input=[emb, data])
rep = conf_helps.last_seq(input=out)
prob = conf_helps.fc_layer(
size=label_dim,
input=rep,
act=conf_helps.SoftmaxActivation(),
bias_attr=True)
conf_helps.outputs(
conf_helps.classification_cost(
input=prob, label=label))
return str(parse_network(test))
def parse_old_rnn():
reset_parser()
def test():
data = conf_helps.data_layer(name="word", size=dict_dim)
label = conf_helps.data_layer(name="label", size=label_dim)
emb = conf_helps.embedding_layer(input=data, size=word_dim)
boot_layer = conf_helps.data_layer(name="boot", size=10)
boot_layer = conf_helps.fc_layer(name='boot_fc',
input=boot_layer,
size=10)
def step(y, wid):
z = conf_helps.embedding_layer(input=wid, size=word_dim)
mem = conf_helps.memory(name="rnn_state",
size=hidden_dim,
boot_layer=boot_layer)
out = conf_helps.fc_layer(input=[y, z, mem],
size=hidden_dim,
act=conf_helps.TanhActivation(),
bias_attr=True,
name="rnn_state")
return out
out = conf_helps.recurrent_group(name="rnn",
step=step,
input=[emb, data])
rep = conf_helps.last_seq(input=out)
prob = conf_helps.fc_layer(size=label_dim,
input=rep,
act=conf_helps.SoftmaxActivation(),
bias_attr=True)
conf_helps.outputs(
conf_helps.classification_cost(input=prob, label=label))
return str(parse_network(test))
def download(cls, architecture, path="./"):
if cls.sanity_check(architecture):
reset_parser()
DATA_DIM = 3 * paddle_extractor._image_size * paddle_extractor._image_size # Use 3 * 331 * 331 or 3 * 299 * 299 for Inception-ResNet-v2.
CLASS_DIM = paddle_extractor.class_dim_map[architecture]
image = paddle.layer.data(
name="image", type=paddle.data_type.dense_vector(DATA_DIM))
if 'resnet' in architecture:
from mmdnn.conversion.examples.paddle.models import resnet
depth = int(architecture.strip('resnet'))
out = resnet.resnet_imagenet(image,
class_dim=CLASS_DIM,
depth=depth)
elif architecture == 'vgg16':
from mmdnn.conversion.examples.paddle.models import vgg
out = vgg.vgg16(image, class_dim=CLASS_DIM)
else:
print("Not support for {} yet.", architecture)
return None
architecture_file = path + architecture + '.bin'
paddle_extractor.dump_v2_config(out, architecture_file, True)
weight_file = download_file(
cls.architecture_map[architecture]['params'],
directory=path,
local_fname=architecture + '.tar.gz')
if not weight_file:
return None
print("MXNet Model {} saved as [{}] and [{}].".format(
architecture, architecture_file, weight_file))
return (architecture_file, weight_file)
else:
return None
def parse_new_rnn():
reset_parser()
data = layer.data(name="word",
type=data_type.dense_vector(dict_dim))
label = layer.data(name="label",
type=data_type.dense_vector(label_dim))
emb = layer.embedding(input=data, size=word_dim)
boot_layer = layer.data(name="boot",
type=data_type.dense_vector(10))
boot_layer = layer.fc(name='boot_fc', input=boot_layer, size=10)
def step(y, wid):
z = layer.embedding(input=wid, size=word_dim)
mem = layer.memory(name="rnn_state",
size=hidden_dim,
boot_layer=boot_layer)
out = layer.fc(input=[y, z, mem],
size=hidden_dim,
act=activation.Tanh(),
bias_attr=True,
name="rnn_state")
return out
out = layer.recurrent_group(name="rnn",
step=step,
input=[emb, data])
rep = layer.last_seq(input=out)
prob = layer.fc(size=label_dim,
input=rep,
act=activation.Softmax(),
bias_attr=True)
cost = layer.classification_cost(input=prob, label=label)
return str(layer.parse_network(cost))
def _main():
parser = argparse.ArgumentParser()
parser.add_argument('-n',
'--network',
type=_text_type,
help='Model Type',
required=True,
choices=MODEL_URL.keys())
parser.add_argument('-i',
'--image',
default=None,
type=_text_type,
help='Test Image Path')
parser.add_argument('-o',
'--output_dir',
default='./',
type=_text_type,
help='Paddlepaddle parameters file name')
args = parser.parse_args()
fn = download_file(MODEL_URL[args.network],
local_fname=architecture + '.tar.gz',
directory=args.output_dir)
if not fn:
return -1
DATA_DIM = 3 * IMG_SIZE * IMG_SIZE # Use 3 * 331 * 331 or 3 * 299 * 299 for Inception-ResNet-v2.
CLASS_DIM = CLASS_DIMS[args.network]
# refer to https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/tests/test_rnn_layer.py#L35
reset_parser()
# refer to https://github.com/PaddlePaddle/Paddle/issues/7403
paddle.init(use_gpu=False, trainer_count=1)
image = paddle.layer.data(name="image",
type=paddle.data_type.dense_vector(DATA_DIM))
if 'resnet' in architecture:
from mmdnn.conversion.examples.paddle.models import resnet
depth = int(architecture.strip('resnet'))
out = resnet.resnet_imagenet(image, class_dim=CLASS_DIM, depth=depth)
elif architecture == 'vgg16':
from mmdnn.conversion.examples.paddle.models import vgg
out = vgg.vgg16(image, class_dim=CLASS_DIM)
else:
print("Not support for {} yet.", architecture)
return None
dump_v2_config(out, args.output_dir + architecture + '.bin')
print("Model {} is saved as {} and {}.".format(
args.network, args.output_dir + architecture + '.bin', fn))
if args.image:
import numpy as np
from mmdnn.conversion.examples.imagenet_test import TestKit
func = TestKit.preprocess_func['paddle'][args.network]
img = func(args.image)
img = np.transpose(img, (2, 0, 1))
test_data = [(img.flatten(), )]
with gzip.open(parameters_file, 'r') as f:
parameters = paddle.parameters.Parameters.from_tar(f)
predict = paddle.infer(output_layer=out,
parameters=parameters,
input=test_data)
predict = np.squeeze(predict)
top_indices = predict.argsort()[-5:][::-1]
result = [(i, predict[i]) for i in top_indices]
print(result)
print(np.sum(result))
return 0
