Skip to content

P
PaddleHub

PaddlePaddle / PaddleHub
1 年多 前同步成功

通知 283
Star 12117
Fork 2091
P
PaddleHub
提交 fc3deb58 编写于 作者: W wuzewu
浏览文件
操作

remove dir

上级 4f92105e
隐藏空白更改
内联 并排
Showing with 0 addition and 66746 deletion
cmdline/lac/conf/q2b.dic 已删除 100644 → 0
浏览文件 @ 4f92105e
　
、 ,
。 .
— -
～ ~
‖ |
… .
‘ '
’ '
“ "
” "
〔 (
〕 )
〈 <
〉 >
「 '
」 '
『 "
』 "
〖 [
〗 ]
【 [
】 ]
∶ :
＄ $
！ !
＂ "
＃ #
％ %
＆ &
＇ '
（ (
） )
＊ *
＋ +
， ,
－ -
． .
／ /
０ 0
１ 1
２ 2
３ 3
４ 4
５ 5
６ 6
７ 7
８ 8
９ 9
： :
； ;
＜ <
＝ =
＞ >
？ ?
＠ @
Ａ a
Ｂ b
Ｃ c
Ｄ d
Ｅ e
Ｆ f
Ｇ g
Ｈ h
Ｉ i
Ｊ j
Ｋ k
Ｌ l
Ｍ m
Ｎ n
Ｏ o
Ｐ p
Ｑ q
Ｒ r
Ｓ s
Ｔ t
Ｕ u
Ｖ v
Ｗ w
Ｘ x
Ｙ y
Ｚ z
［ [
＼ \
］ ]
＾ ^
＿ _
｀ `
ａ a
ｂ b
ｃ c
ｄ d
ｅ e
ｆ f
ｇ g
ｈ h
ｉ i
ｊ j
ｋ k
ｌ l
ｍ m
ｎ n
ｏ o
ｐ p
ｑ q
ｒ r
ｓ s
ｔ t
ｕ u
ｖ v
ｗ w
ｘ x
ｙ y
ｚ z
｛ {
｜ |
｝ }
￣ ~
〝 "
〞 "
﹐ ,
﹑ ,
﹒ .
﹔ ;
﹕ :
﹖ ?
﹗ !
﹙ (
﹚ )
﹛ {
﹜ {
﹝ [
﹞ ]
﹟ #
﹠ &
﹡ *
﹢ +
﹣ -
﹤ <
﹥ >
﹦ =
﹨ \
﹩ $
﹪ %
﹫ @
,
A a
B b
C c
D d
E e
F f
G g
H h
I i
J j
K k
L l
M m
N n
O o
P p
Q q
R r
S s
T t
U u
V v
W w
X x
Y y
Z z
cmdline/lac/conf/tag.dic 已删除 100644 → 0
浏览文件 @ 4f92105e
0 a-B
1 a-I
2 ad-B
3 ad-I
4 an-B
5 an-I
6 c-B
7 c-I
8 d-B
9 d-I
10 f-B
11 f-I
12 m-B
13 m-I
14 n-B
15 n-I
16 nr-B
17 nr-I
18 ns-B
19 ns-I
20 nt-B
21 nt-I
22 nw-B
23 nw-I
24 nz-B
25 nz-I
26 p-B
27 p-I
28 q-B
29 q-I
30 r-B
31 r-I
32 s-B
33 s-I
34 t-B
35 t-I
36 u-B
37 u-I
38 v-B
39 v-I
40 vd-B
41 vd-I
42 vn-B
43 vn-I
44 w-B
45 w-I
46 xc-B
47 xc-I
48 PER-B
49 PER-I
50 LOC-B
51 LOC-I
52 ORG-B
53 ORG-I
54 TIME-B
55 TIME-I
56 O
cmdline/lac/conf/word.dic 已删除 100644 → 0
浏览文件 @ 4f92105e
因为 它太大了无法显示 source diff 。你可以改为 查看blob。
cmdline/lac/lac.py 已删除 100644 → 0
浏览文件 @ 4f92105e
#coding: utf-8
from __future__ import print_function
import numpy as np
import paddle.fluid as fluid
import argparse
import time
import sys
import io
def parse_args():
parser = argparse.ArgumentParser("Run inference.")
parser.add_argument(
'--batch_size',
type=int,
default=5,
help='The size of a batch. (default: %(default)d)'
)
parser.add_argument(
'--model_path',
type=str,
default='./conf/model',
help='A path to the model. (default: %(default)s)'
)
parser.add_argument(
'--test_data_dir',
type=str,
default='./data/test_data',
help='A directory with test data files. (default: %(default)s)'
)
parser.add_argument(
"--word_dict_path",
type=str,
default="./conf/word.dic",
help="The path of the word dictionary. (default: %(default)s)"
)
parser.add_argument(
"--label_dict_path",
type=str,
default="./conf/tag.dic",
help="The path of the label dictionary. (default: %(default)s)"
)
parser.add_argument(
"--word_rep_dict_path",
type=str,
default="./conf/q2b.dic",
help="The path of the word replacement Dictionary. (default: %(default)s)"
)
args = parser.parse_args()
return args
def print_arguments(args):
print('----------- Configuration Arguments -----------')
for arg, value in sorted(vars(args).items()):
print('%s: %s' % (arg, value))
print('------------------------------------------------')
def get_real_tag(origin_tag):
if origin_tag == "O":
return "O"
return origin_tag[0:len(origin_tag) - 2]
# Object oriented encapsulate paddle model inference
class LACModel(object):
def __init__(self, args):
self.place = fluid.CPUPlace() # LAC use CPU place as default
self.exe = fluid.Executor(self.place)
# initialize dictionary
self.id2word_dict = self.load_dict(args.word_dict_path)
self.word2id_dict = self.load_reverse_dict(args.word_dict_path)
self.id2label_dict = self.load_dict(args.label_dict_path)
self.label2id_dict = self.load_reverse_dict(args.label_dict_path)
self.q2b_dict = self.load_dict(args.word_rep_dict_path)
self.inference_program, self.feed_target_names, self.fetch_targets = fluid.io.load_inference_model(args.model_path, self.exe)
def download_module(self):
pass
def preprocess(self, sentence):
line = sentence.strip()
word_idx = []
for word in line:
if ord(word) < 0x20:
word = ' '
if word in self.q2b_dict:
word = self.q2b_dict[word]
if word in self.word2id_dict:
word_idx.append(int(self.word2id_dict[word]))
else:
word_idx.append(int(self.word2id_dict["OOV"]))
word_idx_list = [[x for x in word_idx]]
print(word_idx_list)
word_idx_lod = self.__to_lodtensor(word_idx_list, self.place)
word_list = [line]
print(word_list)
return word_idx_lod, word_list
def segment(self, sentence):
sentence = sentence.strip()
full_out_str = ""
word_idx_lod, word_list = self.preprocess(sentence)
(crf_decode, ) = self.exe.run(self.inference_program,
feed={"word":word_idx_lod},
fetch_list=self.fetch_targets,
return_numpy=False)
lod_info = (crf_decode.lod())[0]
print(lod_info)
np_data = np.array(crf_decode)
print(np_data)
#assert len(data) == len(lod_info) - 1
for sen_index in range(len(word_list)):
word_index = 0
outstr = ""
cur_full_word = ""
cur_full_tag = ""
words = word_list[sen_index]
for tag_index in range(lod_info[sen_index],
lod_info[sen_index + 1]):
cur_word = words[word_index]
cur_tag = self.id2label_dict[str(np_data[tag_index][0])]
if cur_tag.endswith("-B") or cur_tag.endswith("O"):
if len(cur_full_word) != 0:
outstr += cur_full_word + u"/" + cur_full_tag + u" "
cur_full_word = cur_word
cur_full_tag = get_real_tag(cur_tag)
else:
cur_full_word += cur_word
word_index += 1
outstr += cur_full_word + u"/" + cur_full_tag + u" "
outstr = outstr.strip()
full_out_str += outstr + u"\n"
print(full_out_str.strip(), file=sys.stdout)
def ner(self, sentence):
pass
def postag(self, sentence):
pass
def __to_lodtensor(self, data, place):
seq_lens = [len(seq) for seq in data]
cur_len = 0
lod = [cur_len]
for l in seq_lens:
cur_len += l
lod.append(cur_len)
flattened_data = np.concatenate(data, axis=0).astype("int64")
flattened_data = flattened_data.reshape([len(flattened_data), 1])
res = fluid.LoDTensor()
res.set(flattened_data, place)
res.set_lod([lod])
return res
def load_dict(self, dict_path):
"""
Load a dict. The first column is the key and the second column is the value.
"""
result_dict = {}
for line in io.open(dict_path, "r", encoding='utf8'):
terms = line.strip("\n").split("\t")
if len(terms) != 2:
continue
result_dict[terms[0]] = terms[1]
return result_dict
def load_reverse_dict(self, dict_path):
"""
Load a dict. The first column is the value and the second column is the key.
"""
result_dict = {}
for line in io.open(dict_path, "r", encoding='utf8'):
terms = line.strip("\n").split("\t")
if len(terms) != 2:
continue
result_dict[terms[1]] = terms[0]
return result_dict
if __name__ == "__main__":
args = parse_args()
print_arguments(args)
lac = LACModel(args)
lac.segment("我是一个中国人")
example/image-classification/create_module.sh 已删除 100644 → 0
浏览文件 @ 4f92105e
#!/bin/bash
set -o nounset
set -o errexit
script_path=$(cd `dirname $0`; pwd)
cd $script_path
model_name="ResNet50"
hub_module_save_dir="./hub_module"
while getopts "m:d:" options
do
case "$options" in
d)
hub_module_save_dir=$OPTARG;;
m)
model_name=$OPTARG;;
?)
echo "unknown options"
exit 1;;
esac
done
sh pretraind_models/download_model.sh ${model_name}
python train.py --create_module=True --pretrained_model=pretraind_models/${model_name} --model ${model_name} --use_gpu=False
example/image-classification/finetune.sh 已删除 100644 → 0
浏览文件 @ 4f92105e
#!/bin/bash
set -o nounset
set -o errexit
script_path=$(cd `dirname $0`; pwd)
cd $script_path
hub_module_path=hub_module_ResNet50
data_dir=dataset
batch_size=32
use_gpu=False
num_epochs=20
class_dim=2
learning_rate=0.001
while getopts "b:c:d:gh:l:n:" options
do
case "$options" in
b)
batch_size=$OPTARG;;
c)
class_dim=$OPTARG;;
d)
data_dir=$OPTARG;;
g)
use_gpu=True;;
h)
hub_module_path=$OPTARG;;
l)
learning_rate=$OPTARG;;
n)
num_epochs=$OPTARG;;
?)
echo "unknown options"
exit 1;;
esac
done
python retrain.py --batch_size=${batch_size} --class_dim=${class_dim} --data_dir=${data_dir} --use_gpu=${use_gpu} --hub_module_path ${hub_module_path} --lr ${learning_rate} --num_epochs=${num_epochs}
example/image-classification/nets.py 已删除 100644 → 0
浏览文件 @ 4f92105e
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import paddle
import paddle.fluid as fluid
import math
__all__ = ["ResNet", "ResNet50", "ResNet101", "ResNet152"]
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):
self.params = train_parameters
self.layers = layers
def net(self, input, class_dim=1000):
layers = self.layers
supported_layers = [50, 101, 152]
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]
num_filters = [64, 128, 256, 512]
conv = self.conv_bn_layer(
input=input, num_filters=64, filter_size=7, stride=2, act='relu')
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]):
conv = self.bottleneck_block(
input=conv,
num_filters=num_filters[block],
stride=2 if i == 0 and block != 0 else 1)
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):
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,
bias_attr=False)
return fluid.layers.batch_norm(input=conv, act=act)
def shortcut(self, input, ch_out, stride):
ch_in = input.shape[1]
if ch_in != ch_out or stride != 1:
return self.conv_bn_layer(input, ch_out, 1, stride)
else:
return input
def bottleneck_block(self, input, num_filters, stride):
conv0 = self.conv_bn_layer(
input=input, num_filters=num_filters, filter_size=1, act='relu')
conv1 = self.conv_bn_layer(
input=conv0,
num_filters=num_filters,
filter_size=3,
stride=stride,
act='relu')
conv2 = self.conv_bn_layer(
input=conv1, num_filters=num_filters * 4, filter_size=1, act=None)
short = self.shortcut(input, num_filters * 4, stride)
return fluid.layers.elementwise_add(x=short, y=conv2, act='relu')
def ResNet50():
model = ResNet(layers=50)
return model
def ResNet101():
model = ResNet(layers=101)
return model
def ResNet152():
model = ResNet(layers=152)
return model
example/image-classification/pretraind_models/download_model.sh 已删除 100644 → 0
浏览文件 @ 4f92105e
#!/bin/bash
set -o nounset
set -o errexit
script_path=$(cd `dirname $0`; pwd)
if [ $# -ne 1 ]
then
echo "usage: sh $0 {PRETRAINED_MODEL_NAME}"
exit 1
fi
if [ $1 != "ResNet50" -a $1 != "ResNet101" -a $1 != "ResNet152" ]
then
echo "only suppory pretrained model in {ResNet50, ResNet101, ResNet152}"
exit 1
fi
model_name=${1}_pretrained
model=${model_name}.zip
cd ${script_path}
if [ -d ${model_name} ]
then
echo "model file ${model_name} is already existed"
exit 0
fi
if [ ! -f ${model} ]
then
wget http://paddle-imagenet-models-name.bj.bcebos.com/${model}
fi
unzip ${model}
# rm ${model}
rm -rf __MACOSX
example/image-classification/reader.py 已删除 100644 → 0
浏览文件 @ 4f92105e
import os
import math
import random
import functools
import numpy as np
import paddle
from PIL import Image, ImageEnhance
random.seed(0)
np.random.seed(0)
DATA_DIM = 224
THREAD = 8
BUF_SIZE = 102400
DATA_DIR = 'dataset'
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 random_crop(img, size, scale=[0.08, 1.0], ratio=[3. / 4., 4. / 3.]):
aspect_ratio = math.sqrt(np.random.uniform(*ratio))
w = 1. * aspect_ratio
h = 1. / aspect_ratio
bound = min((float(img.size[0]) / img.size[1]) / (w**2),
(float(img.size[1]) / img.size[0]) / (h**2))
scale_max = min(scale[1], bound)
scale_min = min(scale[0], bound)
target_area = img.size[0] * img.size[1] * np.random.uniform(
scale_min, scale_max)
target_size = math.sqrt(target_area)
w = int(target_size * w)
h = int(target_size * h)
i = np.random.randint(0, img.size[0] - w + 1)
j = np.random.randint(0, img.size[1] - h + 1)
img = img.crop((i, j, i + w, j + h))
img = img.resize((size, size), Image.LANCZOS)
return img
def rotate_image(img):
angle = np.random.randint(-10, 11)
img = img.rotate(angle)
return img
def distort_color(img):
def random_brightness(img, lower=0.5, upper=1.5):
e = np.random.uniform(lower, upper)
return ImageEnhance.Brightness(img).enhance(e)
def random_contrast(img, lower=0.5, upper=1.5):
e = np.random.uniform(lower, upper)
return ImageEnhance.Contrast(img).enhance(e)
def random_color(img, lower=0.5, upper=1.5):
e = np.random.uniform(lower, upper)
return ImageEnhance.Color(img).enhance(e)
ops = [random_brightness, random_contrast, random_color]
np.random.shuffle(ops)
img = ops[0](img)
img = ops[1](img)
img = ops[2](img)
return img
def process_image(sample, mode, color_jitter, rotate):
img_path = sample[0]
img = Image.open(img_path)
if mode == 'train':
if rotate: img = rotate_image(img)
img = random_crop(img, DATA_DIM)
else:
img = resize_short(img, target_size=256)
img = crop_image(img, target_size=DATA_DIM, center=True)
if mode == 'train':
if color_jitter:
img = distort_color(img)
if np.random.randint(0, 2) == 1:
img = img.transpose(Image.FLIP_LEFT_RIGHT)
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
if mode == 'train' or mode == 'val':
return img, sample[1]
elif mode == 'test':
return [img]
def _reader_creator(file_list,
mode,
shuffle=False,
color_jitter=False,
rotate=False,
data_dir=DATA_DIR):
def reader():
with open(file_list) as flist:
full_lines = [line.strip() for line in flist]
if shuffle:
np.random.shuffle(full_lines)
if mode == 'train' and os.getenv('PADDLE_TRAINING_ROLE'):
# distributed mode if the env var `PADDLE_TRAINING_ROLE` exits
trainer_id = int(os.getenv("PADDLE_TRAINER_ID", "0"))
trainer_count = int(os.getenv("PADDLE_TRAINERS", "1"))
per_node_lines = len(full_lines) // trainer_count
lines = full_lines[trainer_id * per_node_lines:
(trainer_id + 1) * per_node_lines]
print(
"read images from %d, length: %d, lines length: %d, total: %d"
% (trainer_id * per_node_lines, per_node_lines, len(lines),
len(full_lines)))
else:
lines = full_lines
for line in lines:
if mode == 'train' or mode == 'val':
img_path, label = line.split()
# img_path = img_path.replace("JPEG", "jpeg")
img_path = os.path.join(data_dir, img_path)
yield img_path, int(label)
elif mode == 'test':
img_path = os.path.join(data_dir, line)
yield [img_path]
mapper = functools.partial(
process_image, mode=mode, color_jitter=color_jitter, rotate=rotate)
return paddle.reader.xmap_readers(mapper, reader, THREAD, BUF_SIZE)
def train(data_dir=DATA_DIR):
file_list = os.path.join(data_dir, 'train_list.txt')
return _reader_creator(
file_list,
'train',
shuffle=True,
color_jitter=False,
rotate=False,
data_dir=data_dir + "/train")
def val(data_dir=DATA_DIR):
file_list = os.path.join(data_dir, 'val_list.txt')
return _reader_creator(
file_list, 'val', shuffle=False, data_dir=data_dir + "/val")
def test(data_dir=DATA_DIR):
file_list = os.path.join(data_dir, 'val_list.txt')
return _reader_creator(file_list, 'test', shuffle=False, data_dir=data_dir)
example/image-classification/retrain.py 已删除 100644 → 0
浏览文件 @ 4f92105e
#-*- coding:utf8 -*-
import paddle
import paddle.fluid as fluid
import paddle_hub as hub
import paddle_hub.module as module
import sys
import reader
import argparse
import functools
from utility import add_arguments, print_arguments
parser = argparse.ArgumentParser(description=__doc__)
add_arg = functools.partial(add_arguments, argparser=parser)
# yapf: disable
add_arg('hub_module_path', str, "hub_module_ResNet50", "the hub module path" )
add_arg('batch_size', int, 32, "Minibatch size.")
add_arg('use_gpu', bool, True, "Whether to use GPU or not.")
add_arg('num_epochs', int, 20, "number of epochs.")
add_arg('class_dim', int, 2, "Class number.")
add_arg('image_shape', str, "3,224,224", "input image size")
add_arg('lr', float, 0.1, "set learning rate.")
add_arg('data_dir', str, "./dataset", "The ImageNet dataset root dir.")
# yapf: enable
def retrain(modelpath):
model = module.Module(module_dir=args.hub_module_path)
feed_list, fetch_list, program, generator = model(
sign_name="feature_map", trainable=False)
test_program = program.clone()
# get the dog cat dataset
train_reader = paddle.batch(reader.train(args.data_dir), batch_size=32)
val_reader = paddle.batch(reader.val(args.data_dir), batch_size=32)
with fluid.program_guard(main_program=program):
with fluid.unique_name.guard(generator):
img = feed_list[0]
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
feature_map = fetch_list[0]
fc = fluid.layers.fc(input=feature_map, size=2, act="softmax")
cost = fluid.layers.cross_entropy(input=fc, label=label)
avg_cost = fluid.layers.mean(cost)
acc = fluid.layers.accuracy(input=fc, label=label)
# define the loss
optimizer = fluid.optimizer.Adam(learning_rate=0.001)
optimizer.minimize(avg_cost)
# running on gpu
place = fluid.CUDAPlace(0)
feeder = fluid.DataFeeder(feed_list=[img, label], place=place)
exe = fluid.Executor(place)
# init all param
exe.run(fluid.default_startup_program())
step = 0
sample_num = 0
epochs = 50
# start to train
for i in range(epochs):
for batch in train_reader():
cost, accuracy = exe.run(
feed=feeder.feed(batch),
fetch_list=[avg_cost.name, acc.name])
step += 1
print(
"epoch %d and step %d: train cost is %.2f, train acc is %.2f%%"
% (i, step, cost, accuracy * 100))
for iter, batch in enumerate(val_reader()):
cost, accuracy = exe.run(
feed=feeder.feed(batch),
fetch_list=[avg_cost.name, acc.name])
print("batch %d: val cost is %.2f, val acc is %.2f%%" %
(iter, cost, accuracy * 100))
if __name__ == "__main__":
args = parser.parse_args()
print_arguments(args)
retrain(sys.argv[1])
example/image-classification/train.py 已删除 100644 → 0
浏览文件 @ 4f92105e
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import numpy as np
import time
import sys
import functools
import math
import paddle
import paddle.fluid as fluid
import paddle.dataset.flowers as flowers
import reader
import argparse
import functools
import subprocess
import utils
import nets
import paddle_hub as hub
from utils.learning_rate import cosine_decay
from utils.fp16_utils import create_master_params_grads, master_param_to_train_param
from utility import add_arguments, print_arguments
parser = argparse.ArgumentParser(description=__doc__)
add_arg = functools.partial(add_arguments, argparser=parser)
# yapf: disable
add_arg('create_module', bool, False, "create a hub module or not" )
add_arg('batch_size', int, 32, "Minibatch size.")
add_arg('use_gpu', bool, True, "Whether to use GPU or not.")
add_arg('total_images', int, 12000, "Training image number.")
add_arg('num_epochs', int, 120, "number of epochs.")
add_arg('class_dim', int, 2, "Class number.")
add_arg('image_shape', str, "3,224,224", "input image size")
add_arg('model_save_dir', str, "output", "model save directory")
add_arg('pretrained_model', str, None, "Whether to use pretrained model.")
add_arg('lr', float, 0.1, "set learning rate.")
add_arg('lr_strategy', str, "piecewise_decay", "Set the learning rate decay strategy.")
add_arg('model', str, "ResNet50", "Set the network to use.")
add_arg('data_dir', str, "./dataset", "The ImageNet dataset root dir.")
add_arg('fp16', bool, False, "Enable half precision training with fp16." )
add_arg('scale_loss', float, 1.0, "Scale loss for fp16." )
# yapf: enable
def optimizer_setting(params):
ls = params["learning_strategy"]
if ls["name"] == "piecewise_decay":
if "total_images" not in params:
total_images = 12000
else:
total_images = params["total_images"]
batch_size = ls["batch_size"]
step = int(total_images / batch_size + 1)
bd = [step * e for e in ls["epochs"]]
base_lr = params["lr"]
lr = []
lr = [base_lr * (0.1**i) for i in range(len(bd) + 1)]
optimizer = fluid.optimizer.Momentum(
learning_rate=fluid.layers.piecewise_decay(
boundaries=bd, values=lr),
momentum=0.9,
regularization=fluid.regularizer.L2Decay(1e-4))
elif ls["name"] == "cosine_decay":
if "total_images" not in params:
total_images = 12000
else:
total_images = params["total_images"]
batch_size = ls["batch_size"]
step = int(total_images / batch_size + 1)
lr = params["lr"]
num_epochs = params["num_epochs"]
optimizer = fluid.optimizer.Momentum(
learning_rate=cosine_decay(
learning_rate=lr, step_each_epoch=step, epochs=num_epochs),
momentum=0.9,
regularization=fluid.regularizer.L2Decay(4e-5))
elif ls["name"] == "exponential_decay":
if "total_images" not in params:
total_images = 12000
else:
total_images = params["total_images"]
batch_size = ls["batch_size"]
step = int(total_images / batch_size + 1)
lr = params["lr"]
num_epochs = params["num_epochs"]
learning_decay_rate_factor = ls["learning_decay_rate_factor"]
num_epochs_per_decay = ls["num_epochs_per_decay"]
NUM_GPUS = 1
optimizer = fluid.optimizer.Momentum(
learning_rate=fluid.layers.exponential_decay(
learning_rate=lr * NUM_GPUS,
decay_steps=step * num_epochs_per_decay / NUM_GPUS,
decay_rate=learning_decay_rate_factor),
momentum=0.9,
regularization=fluid.regularizer.L2Decay(4e-5))
else:
lr = params["lr"]
optimizer = fluid.optimizer.Momentum(
learning_rate=lr,
momentum=0.9,
regularization=fluid.regularizer.L2Decay(1e-4))
return optimizer
def net_config(image, label, model, args):
class_dim = args.class_dim
model_name = args.model
out, feature_map = model.net(input=image, class_dim=class_dim)
cost, pred = fluid.layers.softmax_with_cross_entropy(
out, label, return_softmax=True)
if args.scale_loss > 1:
avg_cost = fluid.layers.mean(x=cost) * float(args.scale_loss)
else:
avg_cost = fluid.layers.mean(x=cost)
acc_top1 = fluid.layers.accuracy(input=pred, label=label, k=1)
return avg_cost, acc_top1, out, feature_map
def build_program(is_train, main_prog, startup_prog, args):
image_shape = [int(m) for m in args.image_shape.split(",")]
model_name = args.model
model = nets.__dict__[model_name]()
with fluid.program_guard(main_prog, startup_prog):
py_reader = fluid.layers.py_reader(
capacity=16,
shapes=[[-1] + image_shape, [-1, 1]],
lod_levels=[0, 0],
dtypes=["float32", "int64"],
use_double_buffer=True)
with fluid.unique_name.guard():
image, label = fluid.layers.read_file(py_reader)
if args.fp16:
image = fluid.layers.cast(image, "float16")
avg_cost, acc_top1, predition, feature_map = net_config(
image, label, model, args)
avg_cost.persistable = True
acc_top1.persistable = True
if is_train:
params = model.params
params["total_images"] = args.total_images
params["lr"] = args.lr
params["num_epochs"] = args.num_epochs
params["learning_strategy"]["batch_size"] = args.batch_size
params["learning_strategy"]["name"] = args.lr_strategy
optimizer = optimizer_setting(params)
if args.fp16:
params_grads = optimizer.backward(avg_cost)
master_params_grads = create_master_params_grads(
params_grads, main_prog, startup_prog, args.scale_loss)
optimizer.apply_gradients(master_params_grads)
master_param_to_train_param(master_params_grads,
params_grads, main_prog)
else:
optimizer.minimize(avg_cost)
return py_reader, avg_cost, acc_top1, image, predition, feature_map
def train(args):
# parameters from arguments
model_name = args.model
pretrained_model = args.pretrained_model
model_save_dir = args.model_save_dir
startup_prog = fluid.Program()
train_prog = fluid.Program()
test_prog = fluid.Program()
train_py_reader, train_cost, train_acc, image, predition, feature_map = build_program(
is_train=True,
main_prog=train_prog,
startup_prog=startup_prog,
args=args)
test_py_reader, test_cost, test_acc, image, predition, feature_map = build_program(
is_train=False,
main_prog=test_prog,
startup_prog=startup_prog,
args=args)
test_prog = test_prog.clone(for_test=True)
place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(startup_prog)
if pretrained_model:
def if_exist(var):
return os.path.exists(os.path.join(pretrained_model, var.name))
fluid.io.load_vars(
exe, pretrained_model, main_program=train_prog, predicate=if_exist)
if args.create_module:
assert pretrained_model, "need a pretrained module to create a hub module"
sign1 = hub.create_signature(
"classification", inputs=[image], outputs=[predition])
sign2 = hub.create_signature(
"feature_map", inputs=[image], outputs=[feature_map])
sign3 = hub.create_signature(inputs=[image], outputs=[predition])
hub.create_module(
sign_arr=[sign1, sign2, sign3],
program=train_prog,
module_dir="hub_module_" + args.model)
exit()
visible_device = os.getenv('CUDA_VISIBLE_DEVICES')
if visible_device:
device_num = len(visible_device.split(','))
else:
device_num = subprocess.check_output(['nvidia-smi',
'-L']).decode().count('\n')
train_batch_size = args.batch_size / device_num
test_batch_size = 16
train_reader = paddle.batch(
reader.train(), batch_size=train_batch_size, drop_last=True)
test_reader = paddle.batch(reader.val(), batch_size=test_batch_size)
train_py_reader.decorate_paddle_reader(train_reader)
test_py_reader.decorate_paddle_reader(test_reader)
train_exe = fluid.ParallelExecutor(
main_program=train_prog,
use_cuda=bool(args.use_gpu),
loss_name=train_cost.name)
train_fetch_list = [train_cost.name, train_acc.name]
test_fetch_list = [test_cost.name, test_acc.name]
params = nets.__dict__[args.model]().params
for pass_id in range(params["num_epochs"]):
train_py_reader.start()
train_info = [[], [], []]
test_info = [[], [], []]
train_time = []
batch_id = 0
try:
while True:
t1 = time.time()
loss, acc = train_exe.run(fetch_list=train_fetch_list)
t2 = time.time()
period = t2 - t1
loss = np.mean(np.array(loss))
acc = np.mean(np.array(acc))
train_info[0].append(loss)
train_info[1].append(acc)
train_time.append(period)
if batch_id % 10 == 0:
print("Pass {0}, trainbatch {1}, loss {2}, \
acc {3}, time {4}".format(pass_id, batch_id, loss, acc,
"%2.2f sec" % period))
sys.stdout.flush()
batch_id += 1
except fluid.core.EOFException:
train_py_reader.reset()
train_loss = np.array(train_info[0]).mean()
train_acc = np.array(train_info[1]).mean()
train_speed = np.array(train_time).mean() / (
train_batch_size * device_num)
test_py_reader.start()
test_batch_id = 0
try:
while True:
t1 = time.time()
loss, acc = exe.run(
program=test_prog, fetch_list=test_fetch_list)
t2 = time.time()
period = t2 - t1
loss = np.mean(loss)
acc = np.mean(acc)
test_info[0].append(loss)
test_info[1].append(acc)
if test_batch_id % 10 == 0:
print("Pass {0},testbatch {1},loss {2}, \
acc {3},time {4}".format(pass_id, test_batch_id, loss,
acc, "%2.2f sec" % period))
sys.stdout.flush()
test_batch_id += 1
except fluid.core.EOFException:
test_py_reader.reset()
test_loss = np.array(test_info[0]).mean()
test_acc = np.array(test_info[1]).mean()
print("End pass {0}, train_loss {1}, train_acc {2}, "
"test_loss {3}, test_acc {4}".format(
pass_id, train_loss, train_acc, test_loss, test_acc))
sys.stdout.flush()
model_path = os.path.join(model_save_dir + '/' + model_name,
str(pass_id))
if not os.path.isdir(model_path):
os.makedirs(model_path)
fluid.io.save_persistables(exe, model_path, main_program=train_prog)
def main():
args = parser.parse_args()
assert args.model in nets.__all__, "model is not in list %s" % nets.__all__
print_arguments(args)
train(args)
if __name__ == '__main__':
main()
example/image-classification/train.sh 已删除 100644 → 0
浏览文件 @ 4f92105e
#!/bin/bash
set -o nounset
set -o errexit
script_path=$(cd `dirname $0`; pwd)
cd $script_path
model_name=ResNet50
batch_size=32
data_dir=./dataset
class_dim=2
use_gpu=False
while getopts "m:b:c:d:g" options
do
case "$options" in
b)
batch_size=$OPTARG;;
c)
class_dim=$OPTARG;;
d)
data_dir=$OPTARG;;
m)
model_name=$OPTARG;;
g)
use_gpu=True;;
?)
echo "unknown options"
exit 1;;
esac
done
python train.py --data_dir=${data_dir} --batch_size=${batch_size} --class_dim=${class_dim} --image_shape=3,224,224 --model_save_dir=output/ --lr_strategy=piecewise_decay --lr=0.1 --model=${model_name} --use_gpu=${use_gpu}
example/image-classification/utility.py 已删除 100644 → 0
浏览文件 @ 4f92105e
"""Contains common utility functions."""
# Copyright (c) 2018 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 distutils.util
import numpy as np
import six
from paddle.fluid import core
def print_arguments(args):
"""Print argparse's arguments.
Usage:
.. code-block:: python
parser = argparse.ArgumentParser()
parser.add_argument("name", default="Jonh", type=str, help="User name.")
args = parser.parse_args()
print_arguments(args)
:param args: Input argparse.Namespace for printing.
:type args: argparse.Namespace
"""
print("----------- Configuration Arguments -----------")
for arg, value in sorted(six.iteritems(vars(args))):
print("%s: %s" % (arg, value))
print("------------------------------------------------")
def add_arguments(argname, type, default, help, argparser, **kwargs):
"""Add argparse's argument.
Usage:
.. code-block:: python
parser = argparse.ArgumentParser()
add_argument("name", str, "Jonh", "User name.", parser)
args = parser.parse_args()
"""
type = distutils.util.strtobool if type == bool else type
argparser.add_argument(
"--" + argname,
default=default,
type=type,
help=help + ' Default: %(default)s.',
**kwargs)
example/image-classification/utils/__init__.py 已删除 100644 → 0
浏览文件 @ 4f92105e
from .learning_rate import cosine_decay, lr_warmup
from .fp16_utils import create_master_params_grads, master_param_to_train_param
example/image-classification/utils/fp16_utils.py 已删除 100644 → 0
浏览文件 @ 4f92105e
from __future__ import print_function
import paddle
import paddle.fluid as fluid
def cast_fp16_to_fp32(i, o, prog):
prog.global_block().append_op(
type="cast",
inputs={"X": i},
outputs={"Out": o},
attrs={
"in_dtype": fluid.core.VarDesc.VarType.FP16,
"out_dtype": fluid.core.VarDesc.VarType.FP32
})
def cast_fp32_to_fp16(i, o, prog):
prog.global_block().append_op(
type="cast",
inputs={"X": i},
outputs={"Out": o},
attrs={
"in_dtype": fluid.core.VarDesc.VarType.FP32,
"out_dtype": fluid.core.VarDesc.VarType.FP16
})
def copy_to_master_param(p, block):
v = block.vars.get(p.name, None)
if v is None:
raise ValueError("no param name %s found!" % p.name)
new_p = fluid.framework.Parameter(
block=block,
shape=v.shape,
dtype=fluid.core.VarDesc.VarType.FP32,
type=v.type,
lod_level=v.lod_level,
stop_gradient=p.stop_gradient,
trainable=p.trainable,
optimize_attr=p.optimize_attr,
regularizer=p.regularizer,
gradient_clip_attr=p.gradient_clip_attr,
error_clip=p.error_clip,
name=v.name + ".master")
return new_p
def create_master_params_grads(params_grads, main_prog, startup_prog,
scale_loss):
master_params_grads = []
tmp_role = main_prog._current_role
OpRole = fluid.core.op_proto_and_checker_maker.OpRole
main_prog._current_role = OpRole.Backward
for p, g in params_grads:
# create master parameters
master_param = copy_to_master_param(p, main_prog.global_block())
startup_master_param = startup_prog.global_block()._clone_variable(
master_param)
startup_p = startup_prog.global_block().var(p.name)
cast_fp16_to_fp32(startup_p, startup_master_param, startup_prog)
# cast fp16 gradients to fp32 before apply gradients
if g.name.startswith("batch_norm"):
if scale_loss > 1:
scaled_g = g / float(scale_loss)
else:
scaled_g = g
master_params_grads.append([p, scaled_g])
continue
master_grad = fluid.layers.cast(g, "float32")
if scale_loss > 1:
master_grad = master_grad / float(scale_loss)
master_params_grads.append([master_param, master_grad])
main_prog._current_role = tmp_role
return master_params_grads
def master_param_to_train_param(master_params_grads, params_grads, main_prog):
for idx, m_p_g in enumerate(master_params_grads):
train_p, _ = params_grads[idx]
if train_p.name.startswith("batch_norm"):
continue
with main_prog._optimized_guard([m_p_g[0], m_p_g[1]]):
cast_fp32_to_fp16(m_p_g[0], train_p, main_prog)
example/image-classification/utils/learning_rate.py 已删除 100644 → 0
浏览文件 @ 4f92105e
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import paddle
import paddle.fluid as fluid
import paddle.fluid.layers.ops as ops
from paddle.fluid.initializer import init_on_cpu
from paddle.fluid.layers.learning_rate_scheduler import _decay_step_counter
import math
def cosine_decay(learning_rate, step_each_epoch, epochs=120):
"""Applies cosine decay to the learning rate.
lr = 0.05 * (math.cos(epoch * (math.pi / 120)) + 1)
"""
global_step = _decay_step_counter()
with init_on_cpu():
epoch = ops.floor(global_step / step_each_epoch)
decayed_lr = learning_rate * \
(ops.cos(epoch * (math.pi / epochs)) + 1)/2
return decayed_lr
def lr_warmup(learning_rate, warmup_steps, start_lr, end_lr):
""" Applies linear learning rate warmup for distributed training
Argument learning_rate can be float or a Variable
lr = lr + (warmup_rate * step / warmup_steps)
"""
assert (isinstance(end_lr, float))
assert (isinstance(start_lr, float))
linear_step = end_lr - start_lr
with fluid.default_main_program()._lr_schedule_guard():
lr = fluid.layers.tensor.create_global_var(
shape=[1],
value=0.0,
dtype='float32',
persistable=True,
name="learning_rate_warmup")
global_step = fluid.layers.learning_rate_scheduler._decay_step_counter()
with fluid.layers.control_flow.Switch() as switch:
with switch.case(global_step < warmup_steps):
decayed_lr = start_lr + linear_step * (
global_step / warmup_steps)
fluid.layers.tensor.assign(decayed_lr, lr)
with switch.default():
fluid.layers.tensor.assign(learning_rate, lr)
return lr
example/sentiment-classification/create_module.sh 已删除 100644 → 0
浏览文件 @ 4f92105e
python test_create_module.py --train_data_path ./data/train_data/corpus.train --word_dict_path ./data/train.vocab --mode train --model_path ./models
example/sentiment-classification/data/test_data/corpus.test 已删除 100644 → 0
浏览文件 @ 4f92105e
2 我 想 当初 让 我 决定 购买 锋范 的 最大 理由 还是 对 品牌 的 追求 吧 本田 在 国人 的 印象 中 相对 其他 日系 品牌 要 更好 一点
0 买 来 开 了 研究 后 才 发现 原来 本田锋范 是 小型车 研究 了 各项 尺寸 轴距 跟 A级车 有 那么 一点 差距 晕倒 小型车 卖 紧凑型车 的 价格 哎 谁 叫 他 是 本田 呢
0 貌似 操控 差 了 点 185 的 轮胎 加上 后轮 扭力 梁 整车 刚性 又 不 怎么 好 直线 开开 还是 不错 的 要是 告诉 过 弯 还是 算了吧 老老实实 开 吧
2 外观 绝对 是 同 级别 最 好看 之 一 了 不管 从 哪一个 角度 看 都是 很 流畅 的 线条 唯一 不足 的 是 车子 太 小 了 一点 要是 再 大 一点 那 就 完美 了 其实 跟 思域 还是 有 一点 像 的
2 内饰 蛮 年轻 的 而且 看上去 质感 都 蛮好 貌似 本田 所有 车 都 有点 相似 满 高档 的
2 比 奔驰 宝马 比 不 了 比 相应 的 的 车辆 小五 你 是 第一
0 美国 车 就是 费 油 既然 你 买 的 起 就能 烧 得 起 油
0 一个 规格 差 三千 总体 来说 我 的 车 还是 买 的 比较 便宜 的 但是 什么 都 没有 送 最 起码 你 座套 得 送 吧 人 就 俩字 没有 脚垫 呢 没有
0 就是 五菱 太 扣 了 。 送 个 扶手箱 才 一百元 的 事 。 一套 坐垫 也是 一百元 的 事 一套 脚垫 也是 一百元 的 事 。 总共 三百元 的 事 总 比 一个 差评 好 吧 。 不过 总体 还 可以 了 买车 时 你 多 砍价 省出来 么 就 都 有 了 对 吧
2 动力 不做 ， 1.8T 已经 满足 我 的 需求 ！
2 搭配 7速 双 离合 ， 还是 比较 省油 的 ！
0 悬挂 还是 马马虎虎 ， 比上不足 ， 比下有余 ！
2 内饰 不错 ， 运动 包皮 很 耐看 动感
2 总体来说 我 对 这个 价位 ， 这个 空间 的 景逸 很满意 ， 很 适合 我 ， 其实 买车 跟 娶 老婆 一样 ， 最最 要 的 是 要 选择 合适 自己 的 。
2 驾驶 坐姿 高 ， 视野 开阔 ； 油门 踏板 轻盈 ； 底盘 通过 性 强 。 A 柱 挡 眼 ， 因 轴距 短 转弯 时 车体 有 轻微 抖动 。
2 外观 时尚 ， 线条 流畅 ， 前脸 霸气 ， 后 屁股 性感 ， 车身 整体 表现出 年轻 的 活力 和 风度 。
0 黄色 真 的 不是 很好
2 整体 效果 还不错 ， 说 真 的 10万 以下 的 SUV 我 感觉 买 瑞虎 买 对 了 。 瑞虎 ！ 你 值得 拥有 ， 呵呵
2 做工 很好 ， 材质 也 很不错 ！
2 买 它 不 后悔 ， 已经 替 我 挣 了 不少 钱 了
2 说不上 哪 点 最 满意 ， 综合 起来 还是 很好 的
2 空间 是 可以 了 ， 后面 坐 三个 170斤 的 人 也 不 嫌 挤 ， 但 矮 了 点 ， 后备箱 给力
1 满分 是 10分 的 话 ， 性价比 给 8.5分 吧 ！ 综合 油耗 偏高 ， 如果 开市区 的 就 不太 合算 了 。
0 后排 中间 的 突起 太 高 ， 中间 坐 人 不好 放 脚 。
1 一般 ， 家用 还 可以 。
2 过去 开 面包车 ， 现在 开 和悦rs 13款 那 感觉 当然 的 不一样 。 非常 的 舒适 满意 ， 为 买 13款 我 等 了 1 年多 ， 等到 13款 上市 才 买 此 车 ， 够 痴情 吧 。
0 舒适性 不知道 怎么 说 , 椅子 舒适性 一般般 , 坐 在 前排 还 可以 ， 后排 过 减速带 , 小 坑 等等 就 明显 感到 振动 很大 。
2 相当 满意 ！ 炫耀 的 资本 ！ ！
2 车辆 非常 轻盈 有力 ！ 开 起来 非常 舒服 ！
2 与 同 价位 ， 同 级别 的 车 相比 ！ 性价比 最高 ！
1 刚 提 车 的 时候 30 + 的 油耗 ， 现在 已经 被 我 努力 开到 9 了 ， 最少 的 时候 开出 过 3.9L / 100KM ， 很 有 成就感 啊 ， 给 自己 的 预算 就是 5 - 6 毛钱 一公里 的 油 费
0 后备箱 太 小 了 ， 放下 一个 婴儿车 就 基本 放不下 其他 东西 了
0 用料 不行
2 耐看型 ， 最 开始 觉得 一般 ， 用 了 几个月 ， 越发 觉得 好看 ， 流线 车身 很 符合 我 一个 年轻人 的 审美 。
2 总的来说 ， 这 是 一款 买 了 不会 后悔 的 车 ， 当初 在 排除 日韩 车 后 ， 基本 看 扁 了 10 - 20W 的 车 ， 福克斯 太 窄 ， 速腾 太坑 ， 英朗 太笨 。 其他 什么 508 C5 迈瑞宝 中级 车 既 不符合 年轻人 也 没 小 四 耐看 ， 而且 低 配 动力 更 不足 。 在 对比 之 下 ， 真 的 找 不 出 小四 的 缺点 了 ， 所以 在 预算 15W 左右 的 C4L 绝对 是 一款 不错 的 选择 。 希望 对待 够 的 您 有 帮助 。
1 较 低 ， 新手 油耗 暂时 还 比较 高 ， 还有 下降 空间 。
1 内饰 颜色 太 深 ， 浅色 最好 了
1 在 国产车 里 ， 觉得 性价比 和 质量 还算 可以 ， 毕竟 只是 几万元 的 车子 ， 注定 了 要 包容 一些 不足 的 ， 买车 到 现在 2年 了 ， 跑 了 5万多公里 ， 经过 我 一些 小 改动 ， 开 得 还算 得心应手 。
2 还是 铃木 的 发动机 . . 皮实 耐用
1 一般般 . . . 还是 有 点 肉 . . . 不过 跑 起来 也 不错 . . .
2 空间 不错 ， 这么 小 的 车 能 有 这样 的 表现 已经 超出 我 想象 。 特别 是 头部 空间 充足
2 对于 微型车 来说 ， 舒适性 比 两轮 的 摩托车 要好 很多 ， 我 就是 觉得 刮风 下雨 的 时候 还 开 小 Q 舒服
1 目前 9.2L / 100KM ， 计算 大概 在 9.6 ， 南京 的 路 就是 堵 ， 而我 一般 就 短途 ， 也 不 经常 开 ， 基本 就 周末 开开 出去 玩玩 购 购物 走走 的 亲戚 ， 而且 我 每次 开车 都 热车 到 1000转 ， 这样 的 油耗 差不多 了
1 高速 油耗 还不错 ， 5.5-6L ， 但 在 市内 平均 车速 50KM 的 情况 下 油耗 达到 10L / 百公里 ， 还是 偏高 些 ， 特别 需要 指出 的 是 电脑 综合 油耗 误差 较大 ， 平均 油耗 10L 但 电脑 显示 基本 是 8L 。
0 动力 稍 显 疲软 ， 高速 风 噪 较大 ， 悬挂 较 硬 ， 舒适性 欠佳 ， 高 车身 激烈 驾驶 侧倾 明显 。
1 乘坐 空间 大 ， 视野 好 ， 人 坐 在里面 不 局促 ， 但 悬挂 较 硬 ， 震动感 较 明显
1 内饰 一般 ， 定位 于 几万 的 小车 ， 硬 塑料 的 材质 是 可以 接受 的
1 老生长 谈 的 油耗
2 比较 满意
2 内饰 是 不错
2 我 的 小F 入 弯 啊 ， 刹车 啊 ， 都 很自如 。 我 很喜欢 。
2 该 款 车 用 起来 皮实
2 自驾东 游 了 1万多公里 ， 各种 路面 跑起来 没有 发现 不适
1 基本上 油耗 在 工资 能够 忍耐 的 限度 内
2 空间 很大 ， 尤其 是 驾驶员 位置 调整 好 后 ， 坐 到 后排 ， 按 1.7m 的 标准 ， 基本上 有 2拳 以上 的 空间 ， 一家 出去玩 非常 舒服 ， 空间 绝对 是 引 以为 傲 的 地方 。 并且 后备箱 的 深度 也 很大 ， 基本上 能 满足 日常 要求 。 出去玩 的 话 真 的 很 能 装 东西 。
2 2.0t 的 动力 非常好 ， 可以说 是 随叫随到 ， 心 随意 动 。 想 什么 时候 有 就 什么 时候 有 ， 尤其 有 感觉 ， 一点 都 不 费力 。 就算 坐 满人 上坡 也是 很 有信心 的 ， 加上 配合 6速 双离合变速箱 绝对 是 黄金 搭档 。 在 这个 级别 的 车 能 用到 2.0t 的 发动机 绝对 是 独一无二 的 。
0 噪音 太 大
0 不 是 太 细致
2 车身 轻量化 是 日本 车 的 优势 所在 不 加 涡轮 增压 的 发动机 燃油 经济性 还行
0 一般 ， 用料 较差 ， 总 控 太 塑料感 太 强 ， 做工 不错 。
2 很 有 质感 ， 我喜欢 。
0 有点 窄 。 就是 副 驾驶 没 自动
2 比较 温馨 。 。 软 内饰
2 多媒体 加 真皮 座椅 ， 确实 还 不赖 。
2 后排座 还 可以 ， 后备箱 在 大 点 就好 了
1 大气 给 人 一种 霸气感 ， 屁股 有点 太 翘 了 点 。 倒 车灯 太 暗 。
2 空间 大 ， 外观 大气 !
0 价格高 ， 4S店 一分 都 不用 优惠 ， 配置 不是 很满意 。
0 A柱 转弯 时 很 挡 视线 ， 很多次 左 转弯 盲区 很大 啊 ， 脖子 要 扭 着 点 ， 看清楚 点 才 放心 开车 啊 ， 这 是 开车 过程 中 发现 的 最 不好 的 一点 ！
2 后排 空间 很大 ， 后备箱 也 不 小 ， 家用 足够 了 ， 后排 座椅 放倒 ， 可以 放 得 下 侧 踏板 , 够 长 了 ！
0 减震 略 差 ， 噪音 还 可以 再 改善 ， 其余 都 还 满意 ！
1 高 ， 果断 入手 之 ， 唉 ， 当初 该 忍 忍 ， 现在 入手 13款 的 ， 更 好看 ！
1 英朗 总体来说 还是 比较 满意 的 ， 不过 变速箱 漏油 的 现象 非常 普遍 ， 车 内 异响 也 比较 多
2 前 麦逊 后 多 连杆 独立 悬挂 形式 ， 底盘 调教 以 舒适性 为主 ， 油门 很 轻 ， 整车 较 重 ， 地盘 平稳 ， 车身 稳定性 较好 ； 方向盘 手感 不错 ， 电子 助力 很 爽 啊 ； 整体 操控 灵动 ； 变速 系统 平稳 而 灵敏 ； 高速 转弯 有点 侧倾 。
0 悬挂 有点 硬 ， 过 砍 都是 崩 崩 的 ， 音响效果 一般 ， 音乐 发烧友 建议 改改 ， 我 就 有 这 计划 。
2 由于 我 的 车 是 P版 ， 基本 该 有 的 都 有 ， 也 不用 改 啥 ， 总体 不错 ， 是 一款 性价比 不错 的 车 。 下面 把 我 的 车 D 版 没有 的 列下 ： 方向盘 换挡 、 定速 巡航 、 疝气 大灯 、 自动 大灯 、 电动 座椅 记忆 、 后排 座椅 加热 、 后排 中央 扶手 的 功能 按键 、 后视镜 记忆 、 后座 出 风口 、 LED 尾灯 、 后视镜 倒车 影像 、 车头 中网 、 前排 头部 气帘 ， 侧 气帘 、 胎压 监测 装置 、 大灯 清洗 装置 。 爽 吧 ， 多 了 这么多 配置 ， 建议 大家 还是 买 P 版 ， 性价比 高 。
2 油耗 很好 对于 同级 车 的 很 不在
0 纵向 空间 太 小
0 1.6 的 动力 小
2 车辆 外形 好 ， 大气 ，
2 手动挡 ， 操控 比较好 ， 转向 指向性 准确 。
1 整体 比较 舒适 ， 驾驶 起来 也是 挺 舒服 的 ， 空调 有点 不 稳定 ， 刚刚 买车 的 时候 ， 空调 很 冷 的 ， 但是 开 久 了 ， 空调 越来越 觉得 差 了 。
2 1.6DVVT + 5档 手动 ， 发动机 属于 高转速 发动机 ， 要 舍得 给 油 ， 加速 也 不错 。 手动 变速箱 手感 也 挺好 的 ， 开 了 一年 了 ， 挂档 越来越好 挂 。
2 属于 耐看型 ， 越 看 越 顺眼 。
0 感觉 车身 单薄 ， 高速 时 发 飘 。
0 车头 太 小
2 在 2。0L 自然 吸气 的 发动机 算是 较好 的 ， 加速 性能 和 马 6 2。0 相仿 ， 但是 隔音 和 底盘 更好 ， 加速 感觉 更为 线性 ， 常 不知不觉 就 上 到 120km 了 。
2 高速 性能 非常好 ， 上 到 150 － 160 不 觉得 飘 。
1 够用 的 , 家里 没有 那种 个子 特别 高 的 . 储物 空间 是 个 败笔
0 一般 吧 .
0 目前 为至 , 上 过 两次 高速 , 平时 也 就 出去玩 开开 . 车子 没 遇到 过 什么 大 问题 , 就是 车身 的 漆 太 薄 呢 , 不 注意 的 时候 上面 就 有点 啥 痕迹 呢 , 很 是 郁闷 , 还有 啊 , 最近 苏州 有 一次 小 冰雹 , 车顶 和 引擎 盖上 有 不少 小 坑 , 比较 明显 的 那种 , 但是 旁边 的 车 一个 都 没有 . 我们 附近 的 几辆 车 都 没有 发现 被 冰雹 杂 出 坑 的 现象 . 咨询 售后 说 不在 保修 范围 内 . 唉 , 就 这 车身 也 太 脆弱 呢 . 都 有点 想 把 这 车 卖 呢 , 感觉 开 这 车 上路 心里 很 没 安全感 啊 .
2 空间 巨大
0 动力 一般 ， 120码 要 3000 转
2 舒适性 还 可以 ， 起码 空间 大
0 内饰 老气 ， 做工 不错 ， 异响 也有
2 不错 好 操作
2 很 运动 符合 年轻人 的 感官
2 操控 还 可以 ， 比较 舒适 ， 但是 减震 偏 硬 ， 如果 再 改进 下 减震K5 可以 更出色 ， 轮胎 胎噪 过大 ， 高速 行驶 100迈 的 速度 音响 音量 13 胎噪 还是 可以 清晰 听到 ， 希望 2013款 可以 更换 下 轮胎
2 ： 黑 内 配 白 外 的 搭赠 永远是 经典 款 ， 坐 进 车 里 ， 真皮 座椅 和 真皮 包裹 的 中控台 ， 一下子 抛弃 了 那种 塑料感 ， 给 人 一种 豪车 的 感觉 ， 在 感受到 全景 天窗 等 丰富 的 配置 ， k5 一下 就 给 我 留下 了 很 深刻 的 印象
0 油耗 有点 大 ， 靠近 7个 油
0 动力 一般 ， 一档 ， 二档 ， 有 点 肉 ， 三档 是 我的最爱 。
1 座椅 包裹性 很 强 ， 静音 不行
2 6.7万元 的 车 在里面 是 配置 最高 的
2 车 空间 大 ， 前脸 好看 ， 而且 价格 优惠 ！
2 空间 挺 大 的 ， 比 着 同类 价位 的 车 都 好 ！
2 车 不错 ， 我 又 不是 飙车 的 ！ 刚刚 的 ！
2 还不错 ， 档位 清晰 ， 就是 有时候 倒档 不好 挂 ！
2 车型 的 外观 ， 很 动感 、 很 运动 ！
1 ： 一般 ， 稍微 有点 高 ， 特别是 怠速 的 时候 。 但是 长途 高速 很 节油
2 挂挡 入位 ， 倒车 ， 行车 ， 等 操控 都 还不错
2 简洁 。 。
0 1.0 的 排量 有点 小 。 开 空调 动力 损失 大
2 因为 有 助力 ， 开 起来 很 轻 ， 底盘 低 ， 车 体宽 （ 同 级别 ) 高速 140 都 不 觉得 飘 ， 面包 90 就 感到 飘 了 。 刹车 也 很 给力 ， 曾经 高速 120一脚 杀 到 40 . 都 没 甩尾 ， 因 低 的 底盘 开 起来 才 有 轿车 的 感觉 。 车 短 ， 停车 都 很方便
2 外观 是 我 最 满意 的 ， 买车 之 前 就 关注 熊猫 很久 ， 有 段 时间 都 不 打算 买车 了 ， 突然 就 买 了 。
2 外形 时尚 动感
2 外观 大气
1 9 到 10个 平均 时速 19
2 车子 不错 ！
2 已 够用 ， 很 猛 ， 要 舍得 踩 油门 。
0 表面 油漆 太软 , 轻轻 撞 一点 就 见底 , 前 大包围装配接缝 较大 , 特别 是 与 大灯 接缝 太 大 , 能 看见 里面 的 小 螺丝 孔 , 大灯 亮度 不够 , 对 晚上 行车 增加 了 安全 风险 , 备胎 小 几几 的 样子 我 真 的 不能 接受 ,
2 我 跑 高速 油耗 在 7.0 - - 7.8 之间 ( 全程 空调 ) 市区 10.0 - 11.5 , 油耗 还 可以 接受
2 大气 , 时尚 大方 , 锋利 的 腰线 , 性感 PP ,
2 性价比 超群 . 动力 强劲 。 车 的 稳定性 强
1 买 这 小车 吧 也 就 去 个 超市 上 个 班 走走 ， 没想过 跑 长途 ， 都是 眨眼 就 到 的 ， 所以 根本 就 没有 什么 不舒服 的
0 内饰 一般 啦 ， 有些 质量 不是 很好
0 动力 很 OK ， 配件 很 垃圾 ， 贵 啊
0 后备箱 ， 大 的 物件 啥 也 不能 放 ， 上次 去 岳父 家装 了 点 菜 就 满 了 。
2 在 舒适性 上 这么说 呢 ， 就 这个 价位 而言 的 话 这款车 的 舒适性 还是 比较 过关 的 。 可能 是因为 跨界 车 的 缘故 吧 ， 噪音 还是 有点 的 。 红黑 相间 的 皮质 座椅 坐 上去 感觉 还不错 ， 在 等人 的 时候 打开 音乐 点支 小 烟 ， 比较 惬意 。
2 开 了 快 一个月 了 ， 总体 感觉 还不错 ， 现在 我 的 小白 4 是 63900 买 的 给 媳妇 开 的 ， 因为 媳妇 的 驾照 还 没 考 出来 ， 我 代为 磨合 。 这一个月 开 着 的 感受 就是 ， 反正 又 不 真 去 野外 山区 开 ， 这个 价位 买 的 SUV 开 着 比 肖克 、 途观 还有 感觉 。
2 空间 超大 ， 操控性 好 ， 动力 够用 ， 视野 宽阔 ， 安全性 较好 。
1 本人 身材 偏 小 ， 所有 后排 空间 还 凑合
1 经常 跑 高速 ， 所以 至今 综合 8.8
2 诸多 人性化 配置 ， 随动 转向 ， 自动 大灯 ， 自动 雨刮
2 个人 感觉 很好 方向盘 很好 打
0 黑色 的 很容易 脏 还有 就是 后 箱 没有 升降器
2 当初 刚 买 来 的 时候 不太 会 开车 油门 放 太 快 让 人 有 种 很 强 的 顿挫感 现在 好 了 这个 问题 也 什么 事 ！ 油门 的 踩 放 别太急 循 序 接近 就 好多 了 ！ 还有 就是 30码 的 时候 提速 需要 一点 时间 不会 你 给 油 就 提 上来 的 本人 是 新手 也 说不出 什么 好 的 意见 只能 把 自己 感觉到 的 说 了 总而言之 这 车 没有 让 我 失望 也 没有 后悔 购买
0 上坡 要命 啊 ， 吓死 我 了 ， 有 一次2档 地板 油 上 超市 地上 车库 , 上 着 上 着 车子 越来越 没 动力 了 ， 我 中间 也 没 踩刹车 ， 可是 不管 怎么 踩 油门 车子 没有 反应 ， 换 1档 踩 油门 继续 ， 这下 车轮 原地 空转 ， 然后 让 我 体验 了 一把 赛车 的 感觉 啊 ， 一身 白毛 汗 啊 , 我 小舅子 的 凯越 3档 就 可以 冲 上去 ， 换 我 的 车 开 过 之后 他 就 说 我 这 车 动力 不行 , 在 起步 加速 的 时候 很 弱 ， 低档 加速 好 慢 , 3档 以上 加速 还行 ， 不愧为 高速 发动机 啊 ! 给 我 的 感觉 就是 车速 越 快 这 车 就 越好 开 ， 车速 越 慢 就 越 悲催 ， 1.6 车 还 跟 人家 彪 车 啊 ， 就 我们 中国 的 大马路 也 就 高速公路 上 还能 体验 一把 了 , 如果 你 喜欢 开 快车 那 这 车 比较 对 你 的 胃口 ， 至于 我 嘛 ， 我 不 喜欢 开 快车 ， 所以 我 买 错车 了 ， 当初 也是 被 5 连杆 吸引 的 , 没办法 大众神车 就是 神 啊 ， 即使 是 减配 了 可 还是 神 啊 , 至少 他 起步 加速 就是 快 , （ 我 开 过 同学 的 朗逸 ）
2 还好 吧 ， 对 得 起 2.0T 的 排量
2 1.5 排量 的 这种 动力 可以 了 。 虽然 提速 慢 ， 但 高速 上 跑 155 ， 相当 稳 。 和 家里 另 一台 1.5 排量 的 比 强 得 多
2 内饰 满意 ， 有 好多 人性化 的 储物 格 。 真皮 座椅 没有 异味 。 选 车 时 ， 我 看 过 悦动 ， 被 车 内味 一下 熏 跑 了 。
0 塑料件 的 塑料感 太 强 ， 看起来 好 低档 。
2 个人 觉得 明锐 是 斯柯达 系列 里 最 漂亮 的 了 。 前脸 大气 ， 尾部 庄重 。 有点 老年 车 的 意思 ， 不过 选择 白明 ， 在 装饰 点贴花 ， 立马 年轻 10岁 。
2 非常 满意
2 空间 确实 很大 ， 前排 后排 都 很 宽敞 ！ 1 后备箱 稍微 小点 。 本人 身高 1.81 驾驶 位置 ， 和 后排 都 很 宽敞 ， 不 窝腿
2 我 的 是 中 配 的 ， 内饰 感觉 还 可以 ； 我 个人 对 内饰 平常 很少 在意 。
2 骐达 作为 人生中 第一部 车 真 的 很不错 ； 我 好 几个 同事 ( 网络工程师 ) 第一辆 车 都是 骐达 。 照片 是 爱车 的 PP ； 贴上 此 车标 ， 感觉 确实 很少 人 按 喇叭 滴 我 了 ！ 哈哈
2 油耗 基本 满意 ， 市区 百公里 9升 多 ， 跑 高速 8升 左右 。 本人 跑 了 13000多公里 平均 油耗 9.2升 ， 这 也 和 自己 的 驾驶 习惯 有 很大 的 关系 ， 总体来说 油耗 还在 接受 范围 内 。
2 对于 主打 家用 车型 来说 ， 卡罗拉 无疑 是 做 的 最 成功 的 ， 毕竟 4000万 的 销量 在 那 放 着 。 但 现在 同 级别 车型 日益 更新 的 今天 ， 丰田 你 不 觉得 有 压力 吗 。
2 超级喜欢 小指 的 外观 ！
0 动力 稍 弱 啊 ~ ~
2 从 买车 到 现在 一个月 ， 跑 了 3000公里 了 ， 开始 选 车 的 时候 和 老婆 起 了 争议 ， 僵持 了 一个多星期 ， 老婆 说 买途观 ， 但是 我 觉得 途观 没 个性 ， 并且 感觉 有点像 中年人 开 的 ， 老婆 就 觉得 小指 的 配置 没有 途观 高 ， 个人 觉得 有些 配置 是 没 必要 的 ， 有时候 一年 都 不 碰 一次 ， 其实 还是 要 自己 喜欢 吧 ， 但是 最好 老婆 还是 妥协 了 ， 哈哈 ， 接 车 的 那天 老 高兴 了 ， 但是 SSSS 店 有点 小气 ， 什么 礼品 都 没 送 ， 哎 ~ ~ ~ 目前 跑 了 3000公里 ， 油耗 市区 11 - 12个 ， 长途 8.5 ， 还在 接受 范围 之 内 ， 并且 觉得 空间 也 够用 了 ， 也 能 装 下 不少 东西 ， 动力 方面 反正 我 觉得 是 够用 了 ， 因为 小指 毕竟 是 越野车 ， 想要 强大 的 动力 或者 速度 与 激情 的 话 当然 买 轿车 哈 ~ ~ 当然 也 可以 买 大 切 一类 的 ， 俺 是 非常 喜欢 大切 的 ， 就是 经济 条件 不 允许 ， 所以 先 娶 个 小切 吧 ~ 哈哈 。 目前 小切 经过 大风 大雨 ， 没 发现 天窗 漏水 等 问题 ， 感觉 很 欣慰 ， 不 多 说 了 ， 看图 吧 ~ ~ ~ 注意 ： 个人 观点 ， 不喜 勿 喷 ！ ~ ~ 谢谢 ！
0 动力 不足 ， 起步 稍微 有点 慢
2 其实 有很多 。 一发 动机 世界 10佳 ， 动力 足够 ， 而且 使用 93号 汽油 ； 二 安全性 超高 ， 据说 车 内 人员 死亡率 为 00 ； 三 车型 够 酷 ， 外形 很 吸引 人
1 2.0T 无 四驱 。 之 前 一直 想 买 4 四驱 SUV , 但是 看到 此 车 2.0T ， 被 其 优点 吸引 ， 放弃 四驱 ； 刚 400公里 的 时候 低速 熄火 ， 挺 难堪 恐怖 的 一件 事情 。 现在 900公里 没有 在 发生 过 ， 不知道 后面 会 怎么样
2 感觉 不错 ， 没 开 过 其他 车 ， 第一辆 车 ， 感觉 告诉 很 爽 ， 140 稳 得 很 。
2 建议 直接 上高配 ， 买 回来 之后 自己 加装 了 不少 东西 ， 折腾 下来 比 高配 的 都 贵 ， 哈哈 ， 得不偿失 啊 ， 总体来说 还是 个 好车 ， 以后 换 车 应该 会 继续 考虑 雪铁龙 。
2 作为 职业 司机 来讲 我的选择 是 对 的
2 新 速腾 的 性价比 可以说 是 A级 中 最低 的 ， 几乎 是 全国 无 优惠 ， 更 甚至 黑心 的 4S 再 加价 加 配 后 的 价钱 已经 是 B级车 的 价钱 了 ， 但是 喜欢 就是 喜欢 ， 我 想 和 我 一样 买 新 速腾 的 除了 喜欢 外观 之外 ， 更重要 的 是 速腾 体现 了 家用车 的 综合 经济性 。
2 主 副 驾驶 空间 都 还算 宽敞 ， 视野 很好 ， 避震 软硬 适中 ， 适合 多种 路况 。
0 售后 太 差 ！
2 综合 的 油耗 低 、 全 车 配置 和 功能 适用性 高 而 无需 增加 配置 、 操控 比较 精准 、 音响效果 还 可以 。
2 很 耐看 ， 越 看 越 顺眼 ， 肌肉感 很 强 。 后 屁股 太 有 个性 了 ， 呵呵 。
2 个人 认为 本 车 的 超大 空间 在 普通 家用 轿车 的 队伍 里 是 无人 可以 匹敌 的 ， 只能 跨界 同 SUV 比较 。
2 外观 经过 几次 小型 改装 后 ， 本人 很 是 喜欢 。 尾部 秃秃 的 感觉 没有了 ！ 整体 日系 风范 毕露 。
2 易 上手 。
2 新手 感觉 还行
2 新手 总体来说 不错 的
1 1.6L 的 发动机 ， 很多人 都 说 肉 ， 其实 没有 肉 的 车 ， 只有 肉 的 人 ， 狠 得 下 心 去 踩 油门 那么 动力 还是 完全 满足 一般 使用 的 。
2 鹰眼 大灯 很漂亮 ， 感觉 挺 威猛 ， 但是 卤素大灯 是 硬伤 ， 其实 也 够用 。 车体 流线感 不错 ， 感觉 阳刚 又 不 失 锐气 ， 很 时尚 。 前脸 和 屁股 都是 很漂亮 ， 进气 栅 上 大大 的 LOGO 也 很 给力 ~
2 ： 操控 一流 ， 指向 精准 ， 路感 好 。
0 后排 空间 确实 是 小 啊 ， 老婆 和 小孩 坐 前面 ， 椅子 往后 挪 ， 后座 的 脚 就 很难 放 。
2 可以 的 。 我 又 不 比赛 ， 这点 够了 。 要 比赛 V12 去 啊 。 朋友 锐志 要 和 我 比 提速 我 还在 磨合期 等 过 了 比较 下 。
2 非常 满意 本人 1米 8多 体重 180斤 坐 里面 空间 有余 豪华版 电动 座椅 上下 前后 调节 很方便 后排 没 的 说 同 级别 最大 中级 车 的 后排 头部 空间 充足 驾驶 视线 很好 车身 高 的 缘故
2 油耗 7.3 左右 ， 市区 大概 8 - 9个 油 ， 高速 大概 6 - 7个 油 ， 0码 左右 油耗 大概 6个 油 ， 很好 ， 综合 起来 我 的 油耗 也 就 在 7个 多一点 了 ， 能 完全 接受 。
0 配件 质量 有待 提高 。
0 地盘 悬挂 比较 软 ， 颠簸 路面 容易 托底
0 低速 一般
1 漂亮 ， 大灯 偷工减料
2 有 ESP , 6 气囊 ， 性价比 高
2 这个 是 一大 优势 了 ， 空间 绝对 够塞 ， 后座 放下 后 简直 就是 一张 床 了 ， 一直 笑称 ： 一张 八仙桌 都 能 放 进去
1 就是 1.2档 起步 太 肉 ， 感觉 没 动力 ， 但是 一旦 速度 起来 了 ， 感觉 就是 爽 了 ， 3档 开始 无 压力
2 我 的 是 2.5G 的 ， 动力 绝对 够用 ， 抢 红绿灯 是 个 好手 ， 高速 上面 加速 比较 快 ， 一 踩 油门 轻松 到 120 .
2 转向 精准 ， 在 低速 状态 下 方向盘 助力 还是 很好 用 ， 方向 轻 ； 高速 状态 下 方向 助力 能 自动 调节 ， 避免 了 打 碎盘 或 路面 不平 带来 的 方向 摇晃 。
2 还在 观望 的 同学 赶紧 下手 吧 、 福克斯 绝对 是 你 值得 拥有 的 车型 、 还是 那句话 “ 早买 早 享受 ”
2 整车 质量 良好 ， 钢板 很 厚 ！
2 还不错 ， 真皮 座椅 软 硬度 适中 ， 隔音 效果 也 好 可以 ， 减震 效果 很好 ！ 空调 效果 也 行 ， 可惜 没有 后 排出 风口 ！ 音响效果 尚可 ， 原 车 导航 的 电视 功能 不错 ！
0 减震 太 硬 ， ， 过 起 伏路 硬帮帮 的
2 方向盘 转向 很 精确 ， 也 很舒服 ， 挡位 行程 很舒服 ， 挂挡 感觉 明显 ， 出现 过 1档 不好 挂 的 情况 ， ， 我 换 到 2档 再 到 1 挡 就好 了 ， ， 在 论坛 看到 有人 说 手动车 1档 倒档 不好 挂 是 正常 的 ？ 也 没 多大 影响 ， ， 现在 这样 也 很好 了
0 内饰 就 1般 了 硬 塑料 太多 ， 也不 精致 ， 不过 就 几W 的 车 你 也 不能 各方面 都 要求 那么 高
2 车 的 空间 比较 大 ， 操控 性能 很好 ， 特别 是 上 了 高速 以后 ， 车 很 稳 ， 同事 坐 了 我 的 车 大加 赞赏 啊 ， 车 得 用料 很 足 ， 感觉 很 厚重 ！
2 操控 很 灵敏 ， 方向 的 指向性 很好 ， 低速 很 轻 ， 高速 很 稳 ， 值得 赞赏 。
2 非常 大 ， 比 一般 的 轿车 空间 都 大 ， 而且 车身 偏高 ， 头部 空间 也 很 舒适
2 外观 漂亮 、 大气 ， 流线感 强 ， 运动 范 十足
0 黑色 内饰 ， 显得 空间 小 了 ， 还 显 灰 。 噪音 有点 大 ， 但 要 做 隔音 。 的 排 太 直 了 。
0 还行 ， 比 轿车 差点 ， 音响效果 中等 偏 上 ， 后排 空间 小 ， 比较 直 ， 对 我 来说 比较 压抑 。 从来 没 坐 过 。
1 低调 之 前 和 新 帕萨特 分 不 清 现在 不 细看 和 宝来朗逸 速腾 差 不 了 多少
1 中规中矩 大众 统一 的 内饰
2 舒适性 基本 可以 ， 性价比 已 不错 了 。
2 舒适性 感觉 还 可以
1 2.0 起步 也不 算 肉 ， 开 绿叶肉 点 。 但是 时速 过 90 ， 给 油 后 动力 输出 不足 。 当然 它 不是 2.0T , 这个 也 不能 苛求 ；
example/sentiment-classification/data/train.vocab 已删除 100644 → 0
浏览文件 @ 4f92105e
因为 它太大了无法显示 source diff 。你可以改为 查看blob。
example/sentiment-classification/data/train_data/corpus.train 已删除 100644 → 0
浏览文件 @ 4f92105e
因为 它太大了无法显示 source diff 。你可以改为 查看blob。
example/sentiment-classification/finetune.sh 已删除 100644 → 0
浏览文件 @ 4f92105e
python sentiment_classify.py --train_data_path ./data/train_data/corpus.train --word_dict_path ./data/train.vocab --mode finetune --model_path ./models
example/sentiment-classification/nets.py 已删除 100644 → 0
浏览文件 @ 4f92105e
import sys
import time
import numpy as np
import paddle.fluid as fluid
import paddle
import paddle_hub as hub
def bow_net(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2):
"""
Bow net
"""
# embedding layer
emb = fluid.layers.embedding(
input=data, size=[dict_dim, emb_dim], param_attr="bow_embedding")
# bow layer
bow = fluid.layers.sequence_pool(input=emb, pool_type='sum')
bow_tanh = fluid.layers.tanh(bow)
# full connect layer
fc_1 = fluid.layers.fc(
input=bow_tanh, size=hid_dim, act="tanh", name="bow_fc1")
fc_2 = fluid.layers.fc(
input=fc_1, size=hid_dim2, act="tanh", name="bow_fc2")
# softmax layer
prediction = fluid.layers.fc(
input=[fc_2], size=class_dim, act="softmax", name="fc_softmax")
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction, fc_1
def cnn_net(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2,
win_size=3):
"""
Conv net
"""
# embedding layer
emb = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim])
# convolution layer
conv_3 = fluid.nets.sequence_conv_pool(
input=emb,
num_filters=hid_dim,
filter_size=win_size,
act="tanh",
pool_type="max")
# full connect layer
fc_1 = fluid.layers.fc(input=[conv_3], size=hid_dim2)
# softmax layer
prediction = fluid.layers.fc(input=[fc_1], size=class_dim, act="softmax")
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction, [conv_3]
def lstm_net(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2,
emb_lr=30.0):
"""
Lstm net
"""
# embedding layer
emb = fluid.layers.embedding(
input=data,
size=[dict_dim, emb_dim],
param_attr=fluid.ParamAttr(learning_rate=emb_lr))
# Lstm layer
fc0 = fluid.layers.fc(input=emb, size=hid_dim * 4)
lstm_h, c = fluid.layers.dynamic_lstm(
input=fc0, size=hid_dim * 4, is_reverse=False)
# max pooling layer
lstm_max = fluid.layers.sequence_pool(input=lstm_h, pool_type='max')
lstm_max_tanh = fluid.layers.tanh(lstm_max)
# full connect layer
fc1 = fluid.layers.fc(input=lstm_max_tanh, size=hid_dim2, act='tanh')
# softmax layer
prediction = fluid.layers.fc(input=fc1, size=class_dim, act='softmax')
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction, lstm_max_tanh
def bilstm_net(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2,
emb_lr=30.0):
"""
Bi-Lstm net
"""
# embedding layer
emb = fluid.layers.embedding(
input=data,
size=[dict_dim, emb_dim],
param_attr=fluid.ParamAttr(learning_rate=emb_lr))
# bi-lstm layer
fc0 = fluid.layers.fc(input=emb, size=hid_dim * 4)
rfc0 = fluid.layers.fc(input=emb, size=hid_dim * 4)
lstm_h, c = fluid.layers.dynamic_lstm(
input=fc0, size=hid_dim * 4, is_reverse=False)
rlstm_h, c = fluid.layers.dynamic_lstm(
input=rfc0, size=hid_dim * 4, is_reverse=True)
# extract last layer
lstm_last = fluid.layers.sequence_last_step(input=lstm_h)
rlstm_last = fluid.layers.sequence_last_step(input=rlstm_h)
lstm_last_tanh = fluid.layers.tanh(lstm_last)
rlstm_last_tanh = fluid.layers.tanh(rlstm_last)
# concat layer
lstm_concat = fluid.layers.concat(input=[lstm_last, rlstm_last], axis=1)
# full connect layer
fc1 = fluid.layers.fc(input=lstm_concat, size=hid_dim2, act='tanh')
# softmax layer
prediction = fluid.layers.fc(input=fc1, size=class_dim, act='softmax')
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction, lstm_concat
def gru_net(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2,
emb_lr=30.0):
"""
gru net
"""
emb = fluid.layers.embedding(
input=data,
size=[dict_dim, emb_dim],
param_attr=fluid.ParamAttr(learning_rate=emb_lr))
fc0 = fluid.layers.fc(input=emb, size=hid_dim * 3)
gru_h = fluid.layers.dynamic_gru(input=fc0, size=hid_dim, is_reverse=False)
gru_max = fluid.layers.sequence_pool(input=gru_h, pool_type='max')
gru_max_tanh = fluid.layers.tanh(gru_max)
fc1 = fluid.layers.fc(input=gru_max_tanh, size=hid_dim2, act='tanh')
prediction = fluid.layers.fc(input=fc1, size=class_dim, act='softmax')
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction, gru_max_tanh
example/sentiment-classification/sentiment_classify.py 已删除 100644 → 0
浏览文件 @ 4f92105e
# coding: utf-8
import sys
import os
import time
import unittest
import contextlib
import logging
import argparse
import ast
import paddle.fluid as fluid
import paddle_hub as hub
import utils
from nets import bow_net
from nets import cnn_net
from nets import lstm_net
from nets import bilstm_net
from nets import gru_net
logger = logging.getLogger("paddle-fluid")
logger.setLevel(logging.INFO)
def parse_args():
parser = argparse.ArgumentParser("Sentiment Classification.")
# training data path
parser.add_argument(
"--train_data_path",
type=str,
required=False,
help="The path of trainning data. Should be given in train mode!")
# test data path
parser.add_argument(
"--test_data_path",
type=str,
required=False,
help="The path of test data. Should be given in eval or infer mode!")
# word_dict path
parser.add_argument(
"--word_dict_path",
type=str,
required=True,
help="The path of word dictionary.")
# current mode
parser.add_argument(
"--mode",
type=str,
required=True,
choices=['train', 'eval', 'infer', 'finetune'],
help="train/eval/infer mode")
# model type
parser.add_argument(
"--model_type", type=str, default="bow_net", help="type of model")
# model save path
parser.add_argument(
"--model_path",
type=str,
default="models",
required=True,
help="The path to saved the trained models.")
# Number of passes for the training task.
parser.add_argument(
"--num_passes",
type=int,
default=10,
help="Number of passes for the training task.")
# Batch size
parser.add_argument(
"--batch_size",
type=int,
default=256,
help="The number of training examples in one forward/backward pass.")
# lr value for training
parser.add_argument(
"--lr", type=float, default=0.002, help="The lr value for training.")
# Whether to use gpu
parser.add_argument(
"--use_gpu",
type=ast.literal_eval,
default=False,
help="Whether to use gpu to train the model.")
# parallel train
parser.add_argument(
"--is_parallel",
type=ast.literal_eval,
default=False,
help="Whether to train the model in parallel.")
args = parser.parse_args()
return args
def train_net(train_reader,
word_dict,
network_name,
use_gpu,
parallel,
save_dirname,
lr=0.002,
batch_size=128,
pass_num=30):
"""
train network
"""
if network_name == "bilstm_net":
network = bilstm_net
elif network_name == "bow_net":
network = bow_net
elif network_name == "cnn_net":
network = cnn_net
elif network_name == "lstm_net":
network = lstm_net
elif network_name == "gru_net":
network = gru_net
else:
print("unknown network type")
return
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
data = fluid.layers.data(
name="words", shape=[1], dtype="int64", lod_level=1)
cost, acc, pred, sent_emb = network(data, label, len(word_dict) + 2)
# set optimizer
sgd_optimizer = fluid.optimizer.Adagrad(learning_rate=lr)
sgd_optimizer.minimize(cost)
# set place, executor, datafeeder
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list=["words", "label"], place=place)
exe.run(fluid.default_startup_program())
# start training...
for pass_id in range(pass_num):
data_size, data_count, total_acc, total_cost = 0, 0, 0.0, 0.0
for batch in train_reader():
avg_cost_np, avg_acc_np = exe.run(
fluid.default_main_program(),
feed=feeder.feed(batch),
fetch_list=[cost, acc],
return_numpy=True)
data_size = len(batch)
total_acc += data_size * avg_acc_np
total_cost += data_size * avg_cost_np
data_count += data_size
avg_cost = total_cost / data_count
avg_acc = total_acc / data_count
print("[train info]: pass_id: %d, avg_acc: %f, avg_cost: %f" %
(pass_id, avg_acc, avg_cost))
# create Senta module
module_dir = os.path.join(save_dirname, network_name)
signature = hub.create_signature(
"default", inputs=[data], outputs=[sent_emb])
hub.create_module(
sign_arr=signature,
program=fluid.default_main_program(),
module_dir=module_dir,
word_dict=word_dict)
def finetune_net(train_reader,
word_dict,
network_name,
use_gpu,
parallel,
save_dirname,
lr=0.002,
batch_size=128,
pass_num=30):
"""
train network
"""
if network_name == "bilstm_net":
network = bilstm_net
elif network_name == "bow_net":
network = bow_net
elif network_name == "cnn_net":
network = cnn_net
elif network_name == "lstm_net":
network = lstm_net
elif network_name == "gru_net":
network = gru_net
else:
print("unknown network type")
return
emb_dim = 128
hid_dim = 128
hid_dim2 = 96
class_dim = 2
dict_dim = len(word_dict) + 2
module_dir = os.path.join(save_dirname, network_name)
module = hub.Module(module_dir=module_dir)
feed_list, fetch_list, program, generator = module(
sign_name="default", trainable=True)
with fluid.program_guard(main_program=program):
with fluid.unique_name.guard(generator):
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
# data = module.get_feed_var_by_index(0)
#TODO(ZeyuChen): how to get output paramter according to proto config
sent_emb = fetch_list[0]
# sent_emb = module.get_fetch_var_by_index(0)
fc_1 = fluid.layers.fc(
input=sent_emb, size=hid_dim, act="tanh", name="bow_fc1")
fc_2 = fluid.layers.fc(
input=fc_1, size=hid_dim2, act="tanh", name="bow_fc2")
# softmax layer
pred = fluid.layers.fc(input=[fc_2], size=class_dim, act="softmax")
# print(fluid.default_main_program())
cost = fluid.layers.mean(
fluid.layers.cross_entropy(input=pred, label=label))
acc = fluid.layers.accuracy(input=pred, label=label)
# with open("./prototxt/bow_net.forward.program_desc.prototxt",
# "w") as fo:
# program_desc = str(fluid.default_main_program())
# fo.write(program_desc)
# set optimizer
sgd_optimizer = fluid.optimizer.Adagrad(learning_rate=lr)
sgd_optimizer.minimize(cost)
with open("./prototxt/bow_net.finetune.program_desc.prototxt",
"w") as fo:
program_desc = str(fluid.default_main_program())
fo.write(program_desc)
# set place, executor, datafeeder
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list=["words", "label"], place=place)
exe.run(fluid.default_startup_program())
# start training...
for pass_id in range(pass_num):
data_size, data_count, total_acc, total_cost = 0, 0, 0.0, 0.0
for batch in train_reader():
avg_cost_np, avg_acc_np = exe.run(
fluid.default_main_program(),
feed=feeder.feed(batch),
fetch_list=[cost, acc],
return_numpy=True)
data_size = len(batch)
total_acc += data_size * avg_acc_np
total_cost += data_size * avg_cost_np
data_count += data_size
avg_cost = total_cost / data_count
avg_acc = total_acc / data_count
print("[train info]: pass_id: %d, avg_acc: %f, avg_cost: %f" %
(pass_id, avg_acc, avg_cost))
# save the model
model_dir = os.path.join(save_dirname, network_name + "_finetune")
fluid.io.save_persistables(
executor=exe, dirname=model_dir, main_program=None)
def eval_net(test_reader, use_gpu, model_path=None):
"""
Evaluation function
"""
if model_path is None:
print(str(model_path) + "can not be found")
return
# set place, executor
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
inference_scope = fluid.core.Scope()
with fluid.scope_guard(inference_scope):
# load the saved model
[inference_program, feed_target_names,
fetch_targets] = fluid.io.load_inference_model(model_path, exe)
# compute 2class and 3class accuracy
class2_acc, class3_acc = 0.0, 0.0
total_count, neu_count = 0, 0
for data in test_reader():
# infer a batch
pred = exe.run(
inference_program,
feed=utils.data2tensor(data, place),
fetch_list=fetch_targets,
return_numpy=True)
for i, val in enumerate(data):
class3_label, class2_label = utils.get_predict_label(
pred[0][i, 1])
true_label = val[1]
if class2_label == true_label:
class2_acc += 1
if class3_label == true_label:
class3_acc += 1
if true_label == 1.0:
neu_count += 1
total_count += len(data)
class2_acc = class2_acc / (total_count - neu_count)
class3_acc = class3_acc / total_count
print("[test info] model_path: %s, class2_acc: %f, class3_acc: %f" %
(model_path, class2_acc, class3_acc))
def infer_net(test_reader, use_gpu, model_path=None):
"""
Inference function
"""
if model_path is None:
print(str(model_path) + "can not be found")
return
# set place, executor
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
inference_scope = fluid.core.Scope()
with fluid.scope_guard(inference_scope):
# load the saved model
[inference_program, feed_target_names,
fetch_targets] = fluid.io.load_inference_model(model_path, exe)
for data in test_reader():
# infer a batch
pred = exe.run(
inference_program,
feed=utils.data2tensor(data, place),
fetch_list=fetch_targets,
return_numpy=True)
for i, val in enumerate(data):
class3_label, class2_label = utils.get_predict_label(
pred[0][i, 1])
pos_prob = pred[0][i, 1]
neg_prob = 1 - pos_prob
print("predict label: %d, pos_prob: %f, neg_prob: %f" %
(class3_label, pos_prob, neg_prob))
def main(args):
# train mode
if args.mode == "train":
# prepare_data to get word_dict, train_reader
word_dict, train_reader = utils.prepare_data(args.train_data_path,
args.word_dict_path,
args.batch_size, args.mode)
train_net(train_reader, word_dict, args.model_type, args.use_gpu,
args.is_parallel, args.model_path, args.lr, args.batch_size,
args.num_passes)
# train mode
if args.mode == "finetune":
# prepare_data to get word_dict, train_reader
word_dict, train_reader = utils.prepare_data(args.train_data_path,
args.word_dict_path,
args.batch_size, args.mode)
finetune_net(train_reader, word_dict, args.model_type, args.use_gpu,
args.is_parallel, args.model_path, args.lr,
args.batch_size, args.num_passes)
# eval mode
elif args.mode == "eval":
# prepare_data to get word_dict, test_reader
word_dict, test_reader = utils.prepare_data(args.test_data_path,
args.word_dict_path,
args.batch_size, args.mode)
eval_net(test_reader, args.use_gpu, args.model_path)
# infer mode
elif args.mode == "infer":
# prepare_data to get word_dict, test_reader
word_dict, test_reader = utils.prepare_data(args.test_data_path,
args.word_dict_path,
args.batch_size, args.mode)
infer_net(test_reader, args.use_gpu, args.model_path)
if __name__ == "__main__":
args = parse_args()
main(args)
example/sentiment-classification/test_create_module.py 已删除 100644 → 0
浏览文件 @ 4f92105e
# Copyright (c) 2019 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.
# coding: utf-8
import sys
import os
import time
import unittest
import contextlib
import logging
import argparse
import ast
import utils
import paddle.fluid as fluid
import paddle_hub as hub
from nets import bow_net
from nets import cnn_net
from nets import lstm_net
from nets import bilstm_net
from nets import gru_net
logger = logging.getLogger("paddle-fluid")
logger.setLevel(logging.INFO)
def parse_args():
parser = argparse.ArgumentParser("Sentiment Classification.")
# training data path
parser.add_argument(
"--train_data_path",
type=str,
required=False,
help="The path of trainning data. Should be given in train mode!")
# test data path
parser.add_argument(
"--test_data_path",
type=str,
required=False,
help="The path of test data. Should be given in eval or infer mode!")
# word_dict path
parser.add_argument(
"--word_dict_path",
type=str,
required=True,
help="The path of word dictionary.")
# current mode
parser.add_argument(
"--mode",
type=str,
required=True,
choices=['train', 'eval', 'infer'],
help="train/eval/infer mode")
# model type
parser.add_argument(
"--model_type", type=str, default="bow_net", help="type of model")
# model save path parser.add_argument(
parser.add_argument(
"--model_path",
type=str,
default="models",
required=True,
help="The path to saved the trained models.")
# Number of passes for the training task.
parser.add_argument(
"--num_passes",
type=int,
default=3,
help="Number of passes for the training task.")
# Batch size
parser.add_argument(
"--batch_size",
type=int,
default=256,
help="The number of training examples in one forward/backward pass.")
# lr value for training
parser.add_argument(
"--lr", type=float, default=0.002, help="The lr value for training.")
# Whether to use gpu
parser.add_argument(
"--use_gpu",
type=ast.literal_eval,
default=False,
help="Whether to use gpu to train the model.")
# parallel train
parser.add_argument(
"--is_parallel",
type=ast.literal_eval,
default=False,
help="Whether to train the model in parallel.")
args = parser.parse_args()
return args
def bow_net_module(data,
label,
dict_dim,
emb_dim=128,
hid_dim=128,
hid_dim2=96,
class_dim=2):
"""
Bow net
"""
module_dir = "./model/test_create_module"
# embedding layer
emb = fluid.layers.embedding(
input=data, size=[dict_dim, emb_dim], param_attr="bow_embedding")
# bow layer
bow = fluid.layers.sequence_pool(input=emb, pool_type='sum')
bow_tanh = fluid.layers.tanh(bow)
# full connect layer
fc_1 = fluid.layers.fc(
input=bow_tanh, size=hid_dim, act="tanh", name="bow_fc1")
fc_2 = fluid.layers.fc(
input=fc_1, size=hid_dim2, act="tanh", name="bow_fc2")
# softmax layer
prediction = fluid.layers.fc(
input=[fc_2], size=class_dim, act="softmax", name="fc_softmax")
cost = fluid.layers.cross_entropy(input=prediction, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc = fluid.layers.accuracy(input=prediction, label=label)
return avg_cost, acc, prediction, emb
def train_net(train_reader,
word_dict,
network_name,
use_gpu,
parallel,
save_dirname,
lr=0.002,
batch_size=128,
pass_num=10):
"""
train network
"""
if network_name == "bilstm_net":
network = bilstm_net
elif network_name == "bow_net":
network = bow_net
elif network_name == "cnn_net":
network = cnn_net
elif network_name == "lstm_net":
network = lstm_net
elif network_name == "gru_net":
network = gru_net
else:
print("unknown network type")
return
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
data = fluid.layers.data(
name="words", shape=[1], dtype="int64", lod_level=1)
cost, acc, pred, emb = network(data, label, len(word_dict) + 2)
# set optimizer
sgd_optimizer = fluid.optimizer.Adagrad(learning_rate=lr)
sgd_optimizer.minimize(cost)
# set place, executor, datafeeder
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list=["words", "label"], place=place)
exe.run(fluid.default_startup_program())
# start training...
for pass_id in range(pass_num):
data_size, data_count, total_acc, total_cost = 0, 0, 0.0, 0.0
for batch in train_reader():
avg_cost_np, avg_acc_np = exe.run(
fluid.default_main_program(),
feed=feeder.feed(batch),
fetch_list=[cost, acc],
return_numpy=True)
data_size = len(batch)
total_acc += data_size * avg_acc_np
total_cost += data_size * avg_cost_np
data_count += data_size
avg_cost = total_cost / data_count
avg_acc = total_acc / data_count
print("[train info]: pass_id: %d, avg_acc: %f, avg_cost: %f" %
(pass_id, avg_acc, avg_cost))
# save the model
module_dir = os.path.join(save_dirname, network_name)
config = hub.ModuleConfig(module_dir)
config.save_dict(word_dict=word_dict)
# saving config
input_desc = {"words": data.name}
output_desc = {"emb": emb.name}
config.register_feed_signature(input_desc)
config.register_fetch_signature(output_desc)
config.dump()
feed_var_name = config.feed_var_name("words")
fluid.io.save_inference_model(module_dir, [feed_var_name], emb, exe)
def retrain_net(train_reader,
word_dict,
network_name,
use_gpu,
parallel,
save_dirname,
lr=0.002,
batch_size=128,
pass_num=30):
"""
train network
"""
if network_name == "bilstm_net":
network = bilstm_net
elif network_name == "bow_net":
network = bow_net
elif network_name == "cnn_net":
network = cnn_net
elif network_name == "lstm_net":
network = lstm_net
elif network_name == "gru_net":
network = gru_net
else:
print("unknown network type")
return
dict_dim = len(word_dict) + 2
emb_dim = 128
hid_dim = 128
hid_dim2 = 96
class_dim = 2
module_path = "./models/bow_net"
module = hub.Module(module_dir=module_path)
main_program = fluid.Program()
startup_program = fluid.Program()
# use switch program to test fine-tuning
fluid.framework.switch_main_program(module.get_inference_program())
# remove feed fetch operator and variable
hub.ModuleUtils.remove_feed_fetch_op(fluid.default_main_program())
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
data = module.get_feed_var("words")
emb = module.get_fetch_var("emb")
# bow layer
bow = fluid.layers.sequence_pool(input=emb, pool_type='sum')
bow_tanh = fluid.layers.tanh(bow)
# full connect layer
fc_1 = fluid.layers.fc(
input=bow_tanh, size=hid_dim, act="tanh", name="bow_fc1")
fc_2 = fluid.layers.fc(
input=fc_1, size=hid_dim2, act="tanh", name="bow_fc2")
# softmax layer
pred = fluid.layers.fc(input=[fc_2], size=class_dim, act="softmax")
cost = fluid.layers.mean(
fluid.layers.cross_entropy(input=pred, label=label))
acc = fluid.layers.accuracy(input=pred, label=label)
# set optimizer
sgd_optimizer = fluid.optimizer.Adagrad(learning_rate=lr)
sgd_optimizer.minimize(cost)
# set place, executor, datafeeder
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list=["words", "label"], place=place)
exe.run(fluid.default_startup_program())
# start training...
for pass_id in range(pass_num):
data_size, data_count, total_acc, total_cost = 0, 0, 0.0, 0.0
for batch in train_reader():
avg_cost_np, avg_acc_np = exe.run(
fluid.default_main_program(),
feed=feeder.feed(batch),
fetch_list=[cost, acc],
return_numpy=True)
data_size = len(batch)
total_acc += data_size * avg_acc_np
total_cost += data_size * avg_cost_np
data_count += data_size
avg_cost = total_cost / data_count
avg_acc = total_acc / data_count
print("[train info]: pass_id: %d, avg_acc: %f, avg_cost: %f" %
(pass_id, avg_acc, avg_cost))
# save the model
module_dir = os.path.join(save_dirname, network_name + "_retrain")
fluid.io.save_inference_model(module_dir, ["words"], emb, exe)
config = hub.ModuleConfig(module_dir)
config.save_dict(word_dict=word_dict)
config.dump()
def main(args):
# prepare_data to get word_dict, train_reader
word_dict, train_reader = utils.prepare_data(
args.train_data_path, args.word_dict_path, args.batch_size, args.mode)
train_net(train_reader, word_dict, args.model_type, args.use_gpu,
args.is_parallel, args.model_path, args.lr, args.batch_size,
args.num_passes)
# NOTE(ZeyuChen): can't run train_net and retrain_net together
# retrain_net(train_reader, word_dict, args.model_type, args.use_gpu,
# args.is_parallel, args.model_path, args.lr, args.batch_size,
# args.num_passes)
if __name__ == "__main__":
args = parse_args()
main(args)
example/sentiment-classification/test_finetune.py 已删除 100644 → 0
浏览文件 @ 4f92105e
# Copyright (c) 2019 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.
# coding: utf-8
import sys
import os
import time
import unittest
import contextlib
import logging
import argparse
import ast
import utils
import paddle.fluid as fluid
import paddle_hub as hub
from nets import bow_net
from nets import cnn_net
from nets import lstm_net
from nets import bilstm_net
from nets import gru_net
logger = logging.getLogger("paddle-fluid")
logger.setLevel(logging.INFO)
def parse_args():
parser = argparse.ArgumentParser("Sentiment Classification.")
# training data path
parser.add_argument(
"--train_data_path",
type=str,
required=False,
help="The path of trainning data. Should be given in train mode!")
# test data path
parser.add_argument(
"--test_data_path",
type=str,
required=False,
help="The path of test data. Should be given in eval or infer mode!")
# word_dict path
parser.add_argument(
"--word_dict_path",
type=str,
required=True,
help="The path of word dictionary.")
# current mode
parser.add_argument(
"--mode",
type=str,
required=True,
choices=['train', 'eval', 'infer'],
help="train/eval/infer mode")
# model type
parser.add_argument(
"--model_type", type=str, default="bow_net", help="type of model")
# model save path
parser.add_argument(
"--model_path",
type=str,
default="models",
required=True,
help="The path to saved the trained models.")
# Number of passes for the training task.
parser.add_argument(
"--num_passes",
type=int,
default=10,
help="Number of passes for the training task.")
# Batch size
parser.add_argument(
"--batch_size",
type=int,
default=256,
help="The number of training examples in one forward/backward pass.")
# lr value for training
parser.add_argument(
"--lr", type=float, default=0.002, help="The lr value for training.")
# Whether to use gpu
parser.add_argument(
"--use_gpu",
type=ast.literal_eval,
default=False,
help="Whether to use gpu to train the model.")
# parallel train
parser.add_argument(
"--is_parallel",
type=ast.literal_eval,
default=False,
help="Whether to train the model in parallel.")
args = parser.parse_args()
return args
def retrain_net(train_reader,
word_dict,
network_name,
use_gpu,
parallel,
save_dirname,
lr=0.002,
batch_size=128,
pass_num=30):
"""
train network
"""
if network_name == "bilstm_net":
network = bilstm_net
elif network_name == "bow_net":
network = bow_net
elif network_name == "cnn_net":
network = cnn_net
elif network_name == "lstm_net":
network = lstm_net
elif network_name == "gru_net":
network = gru_net
else:
print("unknown network type")
return
dict_dim = len(word_dict) + 2
emb_dim = 128
hid_dim = 128
hid_dim2 = 96
class_dim = 2
module_path = "./models/bow_net"
module = hub.Module(module_dir=module_path)
main_program = fluid.Program()
startup_program = fluid.Program()
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
data = module.get_feed_var_by_index(0)
emb = module.get_fetch_var_by_index(0)
emb2 = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim])
# # # embedding layer
# emb = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim])
# # bow layer
bow = fluid.layers.sequence_pool(input=emb, pool_type='sum')
bow_tanh = fluid.layers.tanh(bow)
# full connect layer
fc_1 = fluid.layers.fc(
input=bow_tanh, size=hid_dim, act="tanh", name="bow_fc1")
fc_2 = fluid.layers.fc(
input=fc_1, size=hid_dim2, act="tanh", name="bow_fc2")
# softmax layer
pred = fluid.layers.fc(input=[fc_2], size=class_dim, act="softmax")
# print(fluid.default_main_program())
cost = fluid.layers.mean(
fluid.layers.cross_entropy(input=pred, label=label))
acc = fluid.layers.accuracy(input=pred, label=label)
# set optimizer
sgd_optimizer = fluid.optimizer.Adagrad(learning_rate=lr)
sgd_optimizer.minimize(cost)
# set place, executor, datafeeder
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list=["words", "label"], place=place)
exe.run(fluid.default_startup_program())
# start training...
for pass_id in range(pass_num):
data_size, data_count, total_acc, total_cost = 0, 0, 0.0, 0.0
for batch in train_reader():
avg_cost_np, avg_acc_np = exe.run(
fluid.default_main_program(),
feed=feeder.feed(batch),
fetch_list=[cost, acc],
return_numpy=True)
data_size = len(batch)
total_acc += data_size * avg_acc_np
total_cost += data_size * avg_cost_np
data_count += data_size
avg_cost = total_cost / data_count
avg_acc = total_acc / data_count
print("[train info]: pass_id: %d, avg_acc: %f, avg_cost: %f" %
(pass_id, avg_acc, avg_cost))
# save the model
module_dir = os.path.join(save_dirname, network_name + "_retrain")
fluid.io.save_inference_model(module_dir, ["words"], emb, exe)
input_desc = {"words": data.name}
output_desc = {"emb": emb.name}
config = hub.ModuleConfig(module_dir)
config.save_dict(word_dict=word_dict)
config.dump()
def main(args):
# prepare_data to get word_dict, train_reader
word_dict, train_reader = utils.prepare_data(
args.train_data_path, args.word_dict_path, args.batch_size, args.mode)
retrain_net(train_reader, word_dict, args.model_type, args.use_gpu,
args.is_parallel, args.model_path, args.lr, args.batch_size,
args.num_passes)
if __name__ == "__main__":
args = parse_args()
main(args)
example/sentiment-classification/train.sh 已删除 100644 → 0
浏览文件 @ 4f92105e
python sentiment_classify.py --train_data_path ./data/train_data/corpus.train --word_dict_path ./data/train.vocab --mode train --model_path ./models --num_passes=1
example/sentiment-classification/utils.py 已删除 100644 → 0
浏览文件 @ 4f92105e
import os
import sys
import time
import numpy as np
import random
import paddle.fluid as fluid
import paddle
def get_predict_label(pos_prob):
neg_prob = 1 - pos_prob
# threshold should be (1, 0.5)
neu_threshold = 0.55
if neg_prob > neu_threshold:
class3_label = 0
elif pos_prob > neu_threshold:
class3_label = 2
else:
class3_label = 1
if pos_prob >= neg_prob:
class2_label = 2
else:
class2_label = 0
return class3_label, class2_label
def to_lodtensor(data, place):
"""
convert ot LODtensor
"""
seq_lens = [len(seq) for seq in data]
cur_len = 0
lod = [cur_len]
for l in seq_lens:
cur_len += l
lod.append(cur_len)
flattened_data = np.concatenate(data, axis=0).astype("int64")
flattened_data = flattened_data.reshape([len(flattened_data), 1])
res = fluid.LoDTensor()
res.set(flattened_data, place)
res.set_lod([lod])
return res
def data2tensor(data, place):
"""
data2tensor
"""
input_seq = to_lodtensor(list(map(lambda x: x[0], data)), place)
return {"words": input_seq}
def data_reader(file_path, word_dict, is_shuffle=True):
"""
Convert word sequence into slot
"""
unk_id = len(word_dict)
all_data = []
with open(file_path, "r") as fin:
for line in fin:
cols = line.strip().split("\t")
label = int(cols[0])
wids = [
word_dict[x] if x in word_dict else unk_id
for x in cols[1].split(" ")
]
all_data.append((wids, label))
if is_shuffle:
random.shuffle(all_data)
def reader():
for doc, label in all_data:
yield doc, label
return reader
def load_vocab(file_path):
"""
load the given vocabulary
"""
vocab = {}
with open(file_path) as f:
wid = 0
for line in f:
vocab[line.strip()] = wid
wid += 1
vocab["<unk>"] = len(vocab)
return vocab
def prepare_data(data_path, word_dict_path, batch_size, mode):
"""
prepare data
"""
assert os.path.exists(
word_dict_path), "The given word dictionary dose not exist."
if mode == "train":
assert os.path.exists(
data_path), "The given training data does not exist."
if mode == "eval" or mode == "infer":
assert os.path.exists(data_path), "The given test data does not exist."
word_dict = load_vocab(word_dict_path)
if mode == "train":
train_reader = paddle.batch(
data_reader(data_path, word_dict, True), batch_size)
return word_dict, train_reader
else:
test_reader = paddle.batch(
data_reader(data_path, word_dict, False), batch_size)
return word_dict, test_reader
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或