m53297601
/
Paddle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

format python code in python directory

Browse Source
avx_docs
qijun 9 years ago
parent ef5e483ca4
commit a1ba3f442f
54 changed files with 3498 additions and 2926 deletions
Show Stats Download Patch File Download Diff File

1
python/paddle/__init__.py
Unescape View File

@ -11,4 +11,3 @@
# 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.

35
python/paddle/trainer/PyDataProvider2.py
Unescape View File

@ -18,9 +18,8 @@ import collections
import functools
import itertools
logging.basicConfig(
format="[%(levelname)s %(asctime)s %(filename)s:%(lineno)s]"
" %(message)s")
logging.basicConfig(format="[%(levelname)s %(asctime)s %(filename)s:%(lineno)s]"
" %(message)s")
class SequenceType(object):
@ -132,8 +131,10 @@ class InputOrderWrapper(object):
def __call__(self, obj, filename):
for item in self.generator(obj, filename):
if isinstance(item, dict):
yield [item.get(input_name, None) for input_name in
self.input_order]
yield [
item.get(input_name, None)
for input_name in self.input_order
]
else:
yield item
@ -162,8 +163,8 @@ class CheckWrapper(object):
yield items
except AssertionError as e:
self.logger.warning(
"Item (%s) is not fit the input type with error %s"
% (repr(item), repr(e)))
"Item (%s) is not fit the input type with error %s" %
(repr(item), repr(e)))
if self.check_fail_continue:
continue
@ -202,13 +203,17 @@ class CheckWrapper(object):
callback(each)
def provider(input_types=None, should_shuffle=None, pool_size=-1,
def provider(input_types=None,
should_shuffle=None,
pool_size=-1,
min_pool_size=-1,
can_over_batch_size=True,
calc_batch_size=None,
cache=CacheType.NO_CACHE,
check=False, check_fail_continue=False,
init_hook=None, **kwargs):
check=False,
check_fail_continue=False,
init_hook=None,
**kwargs):
"""
Provider decorator. Use it to make a function into PyDataProvider2 object.
In this function, user only need to get each sample for some train/test
@ -318,9 +323,9 @@ def provider(input_types=None, should_shuffle=None, pool_size=-1,
"Could not recognize should_shuffle (%s), "
"just use default value of should_shuffle."
" Please set should_shuffle to bool value or "
"something in %s" % (
repr(self.should_shuffle),
repr(true_table + false_table)))
"something in %s" %
(repr(self.should_shuffle),
repr(true_table + false_table)))
self.should_shuffle = None
self.pool_size = pool_size
@ -351,8 +356,7 @@ def provider(input_types=None, should_shuffle=None, pool_size=-1,
self.generator = InputOrderWrapper(self.generator,
self.input_order)
if self.check:
self.generator = CheckWrapper(self.generator,
self.slots,
self.generator = CheckWrapper(self.generator, self.slots,
check_fail_continue,
self.logger)
@ -368,4 +372,3 @@ def deserialize_args(args):
:return:
"""
return cPickle.loads(args)

35
python/paddle/trainer/PyDataProviderWrapper.py
Unescape View File

@ -11,7 +11,6 @@
# 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.
"""
This module provide a wrapper(decorator) to wrap a data process method into a
PyDataProvider. Some examples are shown `here <data_provider/python_case.html>`_.
@ -47,6 +46,7 @@ except ImportError:
import io
class SlotType(object): # Just a hint for user.
pass
@ -83,6 +83,7 @@ class SparseNonValueSlot(SlotType):
- **SubSeq**: [[[int, int, ...], [int, ....], ...] , \
[[int, int, ...], [int, ....], ...] , ...]
"""
def __init__(self, dim):
"""
:param dim: slot dimension
@ -294,8 +295,9 @@ class GeneralPyDataProvider:
fn = "%s_%d" % (self.profile_filename, self.profile_count)
sortby = "cumulative"
with open(fn, "w") as f:
pstats.Stats(self.profiler, stream=f).sort_stats(
sortby).print_stats()
pstats.Stats(
self.profiler,
stream=f).sort_stats(sortby).print_stats()
self.logger.info("saving profile to file %s" % fn)
self.profile_count += 1
self.logger.info("resetting profile")
@ -453,9 +455,10 @@ class GeneralPyDataProvider:
seq_stream.flush()
subseq_stream.flush()
return "".join([self.int_packer.pack(current_batch_size),
data_bytes.getvalue(),
seq_bytes.getvalue(), subseq_bytes.getvalue()])
return "".join([
self.int_packer.pack(current_batch_size), data_bytes.getvalue(),
seq_bytes.getvalue(), subseq_bytes.getvalue()
])
finally:
data_stream.close()
@ -516,7 +519,7 @@ class GeneralPyDataProvider:
self.data_pool[idx])
idx -= 1
ret_list += self.data_pool[self.data_pool_idx: idx + 1]
ret_list += self.data_pool[self.data_pool_idx:idx + 1]
# for speed reason, just shift left index, not delete data actually.
self.data_pool_idx = idx + 1
@ -537,8 +540,8 @@ class GeneralPyDataProvider:
if self.max_pool_size == 0:
for i in xrange(min(self.file_count, len(self.generators))):
self.data_pool += list(self.generators[i])
self.generators = self.generators[
min(self.file_count, len(self.generators)):]
self.generators = self.generators[min(self.file_count,
len(self.generators)):]
self.max_pool_size = len(self.data_pool)
else:
while len(self.data_pool) < self.max_pool_size and len(
@ -562,9 +565,15 @@ def default_init_hook(cls, *args, **kwargs):
del cls, args, kwargs
def provider(slots=None, use_seq=False, should_shuffle=True, pool_size=1,
can_over_batch_size=True, calc_batch_size=lambda data: 1,
debug=False, init_hook=default_init_hook, profile_filename=None):
def provider(slots=None,
use_seq=False,
should_shuffle=True,
pool_size=1,
can_over_batch_size=True,
calc_batch_size=lambda data: 1,
debug=False,
init_hook=default_init_hook,
profile_filename=None):
"""
The decorator for PyDataProvider. User should use this to create Provider class.
User should only concern how to read sample from file.
@ -663,7 +672,7 @@ def provider(slots=None, use_seq=False, should_shuffle=True, pool_size=1,
def __init__(self, *file_list, **kwargs):
logging.basicConfig(
format="[%(levelname)s %(asctime)s %(filename)s:%(lineno)s]"
" %(message)s")
" %(message)s")
self.logger = logging.getLogger("")
if debug:

1
python/paddle/trainer/__init__.py
Unescape View File

@ -11,4 +11,3 @@
# 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.

2008
python/paddle/trainer/config_parser.py
View File

File diff suppressed because it is too large Load Diff

10
python/paddle/trainer/config_parser_extension.py
Unescape View File

@ -17,11 +17,10 @@ from paddle.proto.DataConfig_pb2 import DataConfig
g_config = None
def SimpleData(
files=None,
feat_dim=None,
context_len=None,
buffer_capacity=None):
def SimpleData(files=None,
feat_dim=None,
context_len=None,
buffer_capacity=None):
data_config = DataConfig()
data_config.type = 'simple'
@ -33,6 +32,7 @@ def SimpleData(
data_config.buffer_capacity = buffer_capacity
return data_config
def get_config_funcs(trainer_config):
global g_config
g_config = trainer_config

489
python/paddle/trainer/recurrent_units.py
View File

File diff suppressed because it is too large Load Diff

51
python/paddle/trainer_config_helpers/activations.py
Unescape View File

@ -12,13 +12,12 @@
# See the License for the specific language governing permissions and
# limitations under the License.
__all__ = ["TanhActivation", "SigmoidActivation",
"SoftmaxActivation", "IdentityActivation", "LinearActivation",
'SequenceSoftmaxActivation', 'ExpActivation',
"ReluActivation", "BReluActivation", "SoftReluActivation",
"STanhActivation",
"AbsActivation", "SquareActivation",
"BaseActivation"]
__all__ = [
"TanhActivation", "SigmoidActivation", "SoftmaxActivation",
"IdentityActivation", "LinearActivation", 'SequenceSoftmaxActivation',
'ExpActivation', "ReluActivation", "BReluActivation", "SoftReluActivation",
"STanhActivation", "AbsActivation", "SquareActivation", "BaseActivation"
]
class BaseActivation(object):
@ -51,7 +50,8 @@ class TanhActivation(BaseActivation):
f(z)=tanh(z)=\\frac{e^z-e^{-z}}{e^z+e^{-z}}
"""
def __init__(self): BaseActivation.__init__(self, 'tanh', True)
def __init__(self):
BaseActivation.__init__(self, 'tanh', True)
class SigmoidActivation(BaseActivation):
@ -63,7 +63,8 @@ class SigmoidActivation(BaseActivation):
f(z) = \\frac{1}{1+exp(-z)}
"""
def __init__(self): BaseActivation.__init__(self, 'sigmoid', True)
def __init__(self):
BaseActivation.__init__(self, 'sigmoid', True)
class SoftmaxActivation(BaseActivation):
@ -104,7 +105,8 @@ class IdentityActivation(BaseActivation):
Just do nothing for output both forward/backward.
"""
def __init__(self): BaseActivation.__init__(self, '', False)
def __init__(self):
BaseActivation.__init__(self, '', False)
LinearActivation = IdentityActivation
@ -124,7 +126,8 @@ class ReluActivation(BaseActivation):
0 &\\quad\\mathrm{otherwize}
"""
def __init__(self): BaseActivation.__init__(self, 'relu', True)
def __init__(self):
BaseActivation.__init__(self, 'relu', True)
class BReluActivation(BaseActivation):
@ -141,7 +144,8 @@ class BReluActivation(BaseActivation):
0 &\\quad \\mathrm{otherwise}
"""
def __init__(self): BaseActivation.__init__(self, 'brelu', False)
def __init__(self):
BaseActivation.__init__(self, 'brelu', False)
class SoftReluActivation(BaseActivation):
@ -149,7 +153,9 @@ class SoftReluActivation(BaseActivation):
SoftRelu Activation.
"""
def __init__(self): BaseActivation.__init__(self, 'softrelu', False)
def __init__(self):
BaseActivation.__init__(self, 'softrelu', False)
class STanhActivation(BaseActivation):
"""
@ -160,7 +166,8 @@ class STanhActivation(BaseActivation):
f(z) = 1.7159 * tanh(2/3*z)
"""
def __init__(self): BaseActivation.__init__(self, 'stanh', False)
def __init__(self):
BaseActivation.__init__(self, 'stanh', False)
class AbsActivation(BaseActivation):
@ -178,7 +185,8 @@ class AbsActivation(BaseActivation):
0 &\\quad if \\quad z = 0
"""
def __init__(self): BaseActivation.__init__(self, 'abs', False)
def __init__(self):
BaseActivation.__init__(self, 'abs', False)
class SquareActivation(BaseActivation):
@ -189,7 +197,9 @@ class SquareActivation(BaseActivation):
f(z) = z^2.
"""
def __init__(self): BaseActivation.__init__(self, 'square', False)
def __init__(self):
BaseActivation.__init__(self, 'square', False)
class ExpActivation(BaseActivation):
"""
@ -198,7 +208,10 @@ class ExpActivation(BaseActivation):
.. math::
f(z) = e^z.
"""
def __init__(self): BaseActivation.__init__(self, 'exponential', False)
def __init__(self):
BaseActivation.__init__(self, 'exponential', False)
class LogActivation(BaseActivation):
"""
@ -207,4 +220,6 @@ class LogActivation(BaseActivation):
.. math::
f(z) = log(z)
"""
def __init__(self): BaseActivation.__init__(self, 'log', False)
def __init__(self):
BaseActivation.__init__(self, 'log', False)

37
python/paddle/trainer_config_helpers/attrs.py
Unescape View File

@ -13,8 +13,9 @@
# limitations under the License.
from paddle.trainer.config_parser import *
__all__ = ['ParamAttr', 'ExtraAttr', 'ParameterAttribute',
'ExtraLayerAttribute']
__all__ = [
'ParamAttr', 'ExtraAttr', 'ParameterAttribute', 'ExtraLayerAttribute'
]
def convert_and_compare(x, Type):
@ -25,7 +26,8 @@ def convert_and_compare(x, Type):
:param Type: target type to check x over
"""
return type(x)(Type(x))==x
return type(x)(Type(x)) == x
def is_compatible_with(x, Type):
"""
@ -38,9 +40,9 @@ def is_compatible_with(x, Type):
return True
try:
if float == Type or int == Type:
# avoid those types that can be converted to float/int but not very
# meaningful and could potentially lead to error
# i.e., str and bool typed value should not be used for initializing float/int variable
# avoid those types that can be converted to float/int but not very
# meaningful and could potentially lead to error
# i.e., str and bool typed value should not be used for initializing float/int variable
if not isinstance(x, str) and not isinstance(x, bool):
return convert_and_compare(x, Type)
elif bool == Type:
@ -91,9 +93,17 @@ class ParameterAttribute(object):
:type sparse_update: bool
"""
def __init__(self, name=None, is_static=False, initial_std=None,
initial_mean=None, initial_max=None, initial_min=None,
l1_rate=None, l2_rate=None, learning_rate=None, momentum=None,
def __init__(self,
name=None,
is_static=False,
initial_std=None,
initial_mean=None,
initial_max=None,
initial_min=None,
l1_rate=None,
l2_rate=None,
learning_rate=None,
momentum=None,
sparse_update=False):
# initialize strategy.
if is_static:
@ -183,7 +193,10 @@ class ExtraLayerAttribute(object):
:type device: int
"""
def __init__(self, error_clipping_threshold=None, drop_rate=None, device=None):
def __init__(self,
error_clipping_threshold=None,
drop_rate=None,
device=None):
self.attr = dict()
if isinstance(error_clipping_threshold, float):
assert error_clipping_threshold > 0
@ -200,8 +213,8 @@ class ExtraLayerAttribute(object):
for key in self.attr:
if not hasattr(self, 'can_%s' % key) or \
not getattr(self, 'can_%s' % key):
raise NotImplementedError(
"Layer %s cannot support %s" % (layer_name, key))
raise NotImplementedError("Layer %s cannot support %s" %
(layer_name, key))
@staticmethod
def to_kwargs(attr):

55
python/paddle/trainer_config_helpers/data_sources.py
Unescape View File

@ -11,7 +11,6 @@
# 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.
"""
Data Sources are helpers to define paddle training data or testing data.
"""
@ -26,8 +25,12 @@ except ImportError:
__all__ = ['define_py_data_sources2']
def define_py_data_source(file_list, cls, module,
obj, args=None, async=False,
def define_py_data_source(file_list,
cls,
module,
obj,
args=None,
async=False,
data_cls=PyData):
"""
Define a python data source.
@ -76,8 +79,9 @@ def define_py_data_source(file_list, cls, module,
args = pickle.dumps(args, 0)
if data_cls is None:
def py_data2(files, load_data_module, load_data_object, load_data_args,
**kwargs):
**kwargs):
data = DataBase()
data.type = 'py2'
data.files = files
@ -86,17 +90,25 @@ def define_py_data_source(file_list, cls, module,
data.load_data_args = load_data_args
data.async_load_data = True
return data
data_cls = py_data2
cls(data_cls(files=file_list,
load_data_module=module,
load_data_object=obj,
load_data_args=args,
async_load_data=async))
data_cls = py_data2
def define_py_data_sources(train_list, test_list, module, obj, args=None,
train_async=False, data_cls=PyData):
cls(
data_cls(
files=file_list,
load_data_module=module,
load_data_object=obj,
load_data_args=args,
async_load_data=async))
def define_py_data_sources(train_list,
test_list,
module,
obj,
args=None,
train_async=False,
data_cls=PyData):
"""
The annotation is almost the same as define_py_data_sources2, except that
it can specific train_async and data_cls.
@ -125,8 +137,8 @@ def define_py_data_sources(train_list, test_list, module, obj, args=None,
"""
def __is_splitable__(o):
return (isinstance(o, list) or isinstance(o, tuple)
) and hasattr(o, '__len__') and len(o) == 2
return (isinstance(o, list) or
isinstance(o, tuple)) and hasattr(o, '__len__') and len(o) == 2
assert train_list is not None or test_list is not None
assert module is not None and obj is not None
@ -196,9 +208,10 @@ def define_py_data_sources2(train_list, test_list, module, obj, args=None):
:return: None
:rtype: None
"""
define_py_data_sources(train_list=train_list,
test_list=test_list,
module=module,
obj=obj,
args=args,
data_cls=None)
define_py_data_sources(
train_list=train_list,
test_list=test_list,
module=module,
obj=obj,
args=args,
data_cls=None)

19
python/paddle/trainer_config_helpers/default_decorators.py
Unescape View File

@ -18,16 +18,18 @@ from .attrs import ParamAttr
from .activations import TanhActivation
from paddle.trainer.config_parser import *
__all__ = ['wrap_name_default', 'wrap_param_attr_default',
'wrap_bias_attr_default', 'wrap_act_default',
'wrap_param_default']
__all__ = [
'wrap_name_default', 'wrap_param_attr_default', 'wrap_bias_attr_default',
'wrap_act_default', 'wrap_param_default'
]
def __default_not_set_callback__(kwargs, name):
return name not in kwargs or kwargs[name] is None
def wrap_param_default(param_names=None, default_factory=None,
def wrap_param_default(param_names=None,
default_factory=None,
not_set_callback=__default_not_set_callback__):
assert param_names is not None
assert isinstance(param_names, list) or isinstance(param_names, tuple)
@ -43,7 +45,8 @@ def wrap_param_default(param_names=None, default_factory=None,
if argspec.defaults:
num_positional -= len(argspec.defaults)
if not argspec.varargs and len(args) > num_positional:
logger.fatal("Must use keyword arguments for non-positional args")
logger.fatal(
"Must use keyword arguments for non-positional args")
for name in param_names:
if not_set_callback(kwargs, name): # Not set
kwargs[name] = default_factory(func)
@ -112,13 +115,13 @@ def wrap_param_attr_default(param_names=None, default_factory=None):
return wrap_param_default(param_names, default_factory)
def wrap_bias_attr_default(param_names=None, default_factory=None,
def wrap_bias_attr_default(param_names=None,
default_factory=None,
has_bias=True):
if param_names is None:
param_names = ['bias_attr']
if default_factory is None:
default_factory = lambda _: ParamAttr(initial_std=0.,
initial_mean=0.)
default_factory = lambda _: ParamAttr(initial_std=0., initial_mean=0.)
def __bias_attr_not_set__(kwargs, name):
if has_bias:

241
python/paddle/trainer_config_helpers/evaluators.py
View File

File diff suppressed because it is too large Load Diff

1433
python/paddle/trainer_config_helpers/layers.py
View File

File diff suppressed because it is too large Load Diff

27
python/paddle/trainer_config_helpers/math.py
Unescape View File

@ -21,16 +21,18 @@ from paddle.trainer.config_parser import logger
__all__ = []
def register_unary_math_op(op_name, act):
def op(input, name=None):
return mixed_layer(input=[identity_projection(input=input)],
name=name,
act=act)
return mixed_layer(
input=[identity_projection(input=input)], name=name, act=act)
op = wrap_name_default(op_name)(op)
op.__doc__ = type(act).__doc__
globals()[op_name] = op
__all__.append(op_name)
register_unary_math_op('exp', act.ExpActivation())
register_unary_math_op('log', act.LogActivation())
register_unary_math_op('abs', act.AbsActivation())
@ -38,6 +40,7 @@ register_unary_math_op('sigmoid', act.SigmoidActivation())
register_unary_math_op('tanh', act.TanhActivation())
register_unary_math_op('square', act.SquareActivation())
def add(layeroutput, other):
if is_compatible_with(other, float):
return slope_intercept_layer(input=layeroutput, intercept=other)
@ -45,8 +48,10 @@ def add(layeroutput, other):
logger.fatal("LayerOutput can only be added with"
" another LayerOutput or a number")
if layeroutput.size == other.size:
return mixed_layer(input=[identity_projection(input=layeroutput),
identity_projection(input=other)])
return mixed_layer(input=[
identity_projection(input=layeroutput),
identity_projection(input=other)
])
if other.size != 1 and layeroutput.size != 1:
logger.fatal("Two LayerOutput can be added only if they have equal size"
" or one of their sizes is 1. sizes are %s and %s" %
@ -56,12 +61,15 @@ def add(layeroutput, other):
layeroutput = other
other = tmp
other = repeat_layer(other, layeroutput.size)
return mixed_layer(input=[identity_projection(input=layeroutput),
identity_projection(input=other)])
return mixed_layer(input=[
identity_projection(input=layeroutput), identity_projection(input=other)
])
LayerOutput.__radd__ = add
LayerOutput.__add__ = add
def sub(layeroutput, other):
if is_compatible_with(other, float):
return slope_intercept_layer(input=layeroutput, intercept=other)
@ -71,14 +79,18 @@ def sub(layeroutput, other):
neg = slope_intercept_layer(input=other, slope=-1.0)
return add(layeroutput, neg)
LayerOutput.__sub__ = sub
def rsub(layeroutput, other):
neg = slope_intercept_layer(input=layeroutput, slope=-1.0)
return add(neg, other)
LayerOutput.__rsub__ = rsub
def mul(layeroutput, other):
if is_compatible_with(other, float):
return slope_intercept_layer(input=layeroutput, slope=other)
@ -93,5 +105,6 @@ def mul(layeroutput, other):
logger.fatal("At least one of the operand of '*' must be a number"
" or a LayerOutput with size=1")
LayerOutput.__mul__ = mul
LayerOutput.__rmul__ = mul

772
python/paddle/trainer_config_helpers/networks.py
View File

File diff suppressed because it is too large Load Diff

51
python/paddle/trainer_config_helpers/optimizers.py
Unescape View File

@ -17,11 +17,12 @@ from paddle.trainer.config_parser import Settings, default_decay_rate, \
from .default_decorators import wrap_param_default
__all__ = ['Optimizer', 'BaseSGDOptimizer', 'MomentumOptimizer',
'AdamaxOptimizer', 'AdamOptimizer', 'AdaGradOptimizer',
'RMSPropOptimizer', 'DecayedAdaGradOptimizer',
'AdaDeltaOptimizer', 'BaseRegularization', 'L2Regularization',
'settings', 'ModelAverage']
__all__ = [
'Optimizer', 'BaseSGDOptimizer', 'MomentumOptimizer', 'AdamaxOptimizer',
'AdamOptimizer', 'AdaGradOptimizer', 'RMSPropOptimizer',
'DecayedAdaGradOptimizer', 'AdaDeltaOptimizer', 'BaseRegularization',
'L2Regularization', 'settings', 'ModelAverage'
]
class Optimizer(object):
@ -90,18 +91,15 @@ class MomentumOptimizer(BaseSGDOptimizer):
:param sparse: with sparse support or not.
:type sparse: bool
"""
def extra_settings(self):
default_momentum(self.momentum)
def to_setting_kwargs(self):
if self.sparse:
return {
'learning_method': 'sparse_momentum'
}
return {'learning_method': 'sparse_momentum'}
else:
return {
'learning_method': 'momentum'
}
return {'learning_method': 'momentum'}
def __init__(self, momentum=None, sparse=False):
self.momentum = momentum
@ -197,9 +195,7 @@ class AdaGradOptimizer(BaseSGDOptimizer):
"""
def to_setting_kwargs(self):
return {
'learning_method': 'adagrad'
}
return {'learning_method': 'adagrad'}
def __init__(self):
pass
@ -311,9 +307,7 @@ class L2Regularization(BaseRegularization):
def to_setting_kwargs(self):
if self.algorithm == 'owlqn':
return {
'l2weight': self.decay_rate
}
return {'l2weight': self.decay_rate}
else:
return dict()
@ -330,7 +324,8 @@ class ModelAverage(Optimizer):
'do_average_in_cpu': self.do_average_in_cpu
}
def __init__(self, average_window,
def __init__(self,
average_window,
max_average_window=None,
do_average_in_cpu=False):
self.average_window = average_window
@ -356,10 +351,10 @@ def __extends__(dict1, dict2):
return dict1
@wrap_param_default(['learning_method'],
default_factory=lambda _: MomentumOptimizer())
@wrap_param_default(['regularization'],
default_factory=lambda _: BaseRegularization())
@wrap_param_default(
['learning_method'], default_factory=lambda _: MomentumOptimizer())
@wrap_param_default(
['regularization'], default_factory=lambda _: BaseRegularization())
def settings(batch_size,
learning_rate=1e-3,
learning_rate_decay_a=0.,
@ -373,8 +368,7 @@ def settings(batch_size,
regularization=None,
is_async=False,
model_average=None,
gradient_clipping_threshold=None
):
gradient_clipping_threshold=None):
"""
Set the optimization method, learning rate, batch size, and other training
settings. The currently supported algorithms are SGD and Async-SGD.
@ -415,10 +409,11 @@ def settings(batch_size,
else:
algorithm = 'owlqn'
args=['batch_size', 'learning_rate', 'learning_rate_decay_a',
'learning_rate_decay_b', 'learning_rate_schedule',
'learning_rate_args', 'average_window', 'do_average_in_cpu',
'max_average_window']
args = [
'batch_size', 'learning_rate', 'learning_rate_decay_a',
'learning_rate_decay_b', 'learning_rate_schedule', 'learning_rate_args',
'average_window', 'do_average_in_cpu', 'max_average_window'
]
kwargs = dict()
kwargs['algorithm'] = algorithm
for arg in args:

23
python/paddle/trainer_config_helpers/poolings.py
Unescape View File

@ -11,18 +11,12 @@
# 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.
"""
"""
__all__ = [
"BasePoolingType",
"MaxPooling",
"AvgPooling",
"CudnnMaxPooling",
"CudnnAvgPooling",
"SumPooling",
"SquareRootNPooling"
"BasePoolingType", "MaxPooling", "AvgPooling", "CudnnMaxPooling",
"CudnnAvgPooling", "SumPooling", "SquareRootNPooling"
]
@ -36,6 +30,7 @@ class BasePoolingType(object):
:type name: basestring
"""
def __init__(self, name):
self.name = name
@ -54,6 +49,7 @@ class MaxPooling(BasePoolingType):
value. None means use default value in proto.
:type output_max_index: bool|None
"""
def __init__(self, output_max_index=None):
BasePoolingType.__init__(self, "max")
self.output_max_index = output_max_index
@ -64,6 +60,7 @@ class CudnnMaxPooling(BasePoolingType):
Cudnn max pooling only support GPU. Return the maxinum value in the
pooling window.
"""
def __init__(self):
BasePoolingType.__init__(self, "cudnn-max-pool")
@ -73,9 +70,11 @@ class CudnnAvgPooling(BasePoolingType):
Cudnn average pooling only support GPU. Return the average value in the
pooling window.
"""
def __init__(self):
BasePoolingType.__init__(self, "cudnn-avg-pool")
class AvgPooling(BasePoolingType):
"""
Average pooling.
@ -105,7 +104,9 @@ class SumPooling(AvgPooling):
sum(samples\\_of\\_a\\_sequence)
"""
def __init__(self): AvgPooling.__init__(self, AvgPooling.STRATEGY_SUM)
def __init__(self):
AvgPooling.__init__(self, AvgPooling.STRATEGY_SUM)
class SquareRootNPooling(AvgPooling):
@ -118,4 +119,6 @@ class SquareRootNPooling(AvgPooling):
sum(samples\\_of\\_a\\_sequence)/sqrt(sample\\_num)
"""
def __init__(self): AvgPooling.__init__(self, AvgPooling.STRATEGY_SQROOTN)
def __init__(self):
AvgPooling.__init__(self, AvgPooling.STRATEGY_SQROOTN)

19
python/paddle/trainer_config_helpers/tests/configs/img_layers.py
Unescape View File

@ -1,22 +1,23 @@
from paddle.trainer_config_helpers import *
settings(
learning_rate=1e-3,
batch_size=1000
)
settings(learning_rate=1e-3, batch_size=1000)
img = data_layer(name='image', size=256*256)
img = data_layer(name='image', size=256 * 256)
# the parse_conv in config_parse.py is not strictly accurate when filter_size
# is not square. So here set square filter_size.
img_conv = img_conv_layer(input=img, num_channels=1, num_filters=64,
filter_size=(32, 32), padding=(1, 1), stride=(1, 1),
act=LinearActivation())
img_conv = img_conv_layer(
input=img,
num_channels=1,
num_filters=64,
filter_size=(32, 32),
padding=(1, 1),
stride=(1, 1),
act=LinearActivation())
img_bn = batch_norm_layer(input=img_conv, act=ReluActivation())
img_norm = img_cmrnorm_layer(input=img_bn, size=32)
img_pool = img_pool_layer(input=img_conv, pool_size=32, pool_type=MaxPooling())
outputs(img_pool, img_norm)

20
python/paddle/trainer_config_helpers/tests/configs/img_trans_layers.py
Unescape View File

@ -1,22 +1,24 @@
from paddle.trainer_config_helpers import *
settings(
learning_rate=1e-3,
batch_size=1000
)
settings(learning_rate=1e-3, batch_size=1000)
img = data_layer(name='image', size=227*227)
img = data_layer(name='image', size=227 * 227)
# the parse_conv in config_parse.py is not strictly accurate when filter_size
# is not square. So here set square filter_size.
img_conv = img_conv_layer(input=img, num_channels=1, num_filters=64,
filter_size=(32, 32), padding=(1, 1), stride=(1, 1),
act=LinearActivation(), trans=True)
img_conv = img_conv_layer(
input=img,
num_channels=1,
num_filters=64,
filter_size=(32, 32),
padding=(1, 1),
stride=(1, 1),
act=LinearActivation(),
trans=True)
img_bn = batch_norm_layer(input=img_conv, act=ReluActivation())
img_norm = img_cmrnorm_layer(input=img_bn, size=32)
img_pool = img_pool_layer(input=img_conv, pool_size=32, pool_type=MaxPooling())
outputs(img_pool, img_norm)

17
python/paddle/trainer_config_helpers/tests/configs/last_first_seq.py
Unescape View File

@ -1,21 +1,12 @@
from paddle.trainer_config_helpers import *
settings(
batch_size=1000,
learning_rate=1e-5
)
settings(batch_size=1000, learning_rate=1e-5)
din = data_layer(name='data', size=30)
seq_op = [
first_seq,
last_seq
]
seq_op = [first_seq, last_seq]
agg_level = [
AggregateLevel.EACH_SEQUENCE,
AggregateLevel.EACH_TIMESTEP
]
agg_level = [AggregateLevel.EACH_SEQUENCE, AggregateLevel.EACH_TIMESTEP]
opts = []
@ -23,4 +14,4 @@ for op in seq_op:
for al in agg_level:
opts.append(op(input=din, agg_level=al))
outputs(opts)
outputs(opts)

16
python/paddle/trainer_config_helpers/tests/configs/layer_activations.py
Unescape View File

@ -4,18 +4,18 @@ Test all activations.
from paddle.trainer_config_helpers import *
settings(
learning_rate=1e-4,
batch_size=1000
)
settings(learning_rate=1e-4, batch_size=1000)
din = data_layer(name='input', size=100)
acts = [
TanhActivation, SigmoidActivation, SoftmaxActivation, IdentityActivation,
LinearActivation, ExpActivation, ReluActivation, BReluActivation,
SoftReluActivation, STanhActivation, AbsActivation, SquareActivation]
SoftReluActivation, STanhActivation, AbsActivation, SquareActivation
]
outputs(
[fc_layer(input=din, size=100, act=act(), name="layer_%d" % i) for i, act in
enumerate(acts)])
outputs([
fc_layer(
input=din, size=100, act=act(), name="layer_%d" % i)
for i, act in enumerate(acts)
])

8
python/paddle/trainer_config_helpers/tests/configs/math_ops.py
Unescape View File

@ -1,10 +1,7 @@
from paddle.trainer_config_helpers import *
from paddle.trainer_config_helpers import math
settings(
batch_size=1000,
learning_rate=1e-5
)
settings(batch_size=1000, learning_rate=1e-5)
x = data_layer(name='data', size=100)
x = math.exp(x)
@ -21,10 +18,9 @@ y = y - 2
y = 2 - y
y = 2 * y
y = y * 3
z= data_layer(name='data_2', size=1)
z = data_layer(name='data_2', size=1)
y = y * z
y = z * y
y = y + z
y = z + y
outputs(y)

29
python/paddle/trainer_config_helpers/tests/configs/projections.py
Unescape View File

@ -3,10 +3,7 @@ Test mixed layer, projections and operators.
'''
from paddle.trainer_config_helpers import *
settings(
batch_size=1000,
learning_rate=1e-4
)
settings(batch_size=1000, learning_rate=1e-4)
din = data_layer(name='test', size=100)
@ -30,18 +27,20 @@ with mixed_layer() as m5:
with mixed_layer() as m6:
m6 += dotmul_operator(a=m3, b=m4)
img = data_layer(name='img', size=32*32)
flt = data_layer(name='filter', size=3*3*1*64)
img = data_layer(name='img', size=32 * 32)
flt = data_layer(name='filter', size=3 * 3 * 1 * 64)
with mixed_layer() as m7:
m7 += conv_operator(img=img, filter=flt, num_filters=64,
num_channels=1, filter_size=3)
end = mixed_layer(input=[full_matrix_projection(input=m5),
trans_full_matrix_projection(input=m6),
full_matrix_projection(input=m7)],
size=100,
layer_attr=ExtraAttr(drop_rate=0.5,
error_clipping_threshold=40))
m7 += conv_operator(
img=img, filter=flt, num_filters=64, num_channels=1, filter_size=3)
end = mixed_layer(
input=[
full_matrix_projection(input=m5),
trans_full_matrix_projection(input=m6), full_matrix_projection(input=m7)
],
size=100,
layer_attr=ExtraAttr(
drop_rate=0.5, error_clipping_threshold=40))
outputs(end)

27
python/paddle/trainer_config_helpers/tests/configs/shared_fc.py
Unescape View File

@ -1,9 +1,6 @@
from paddle.trainer_config_helpers import *
settings(
learning_rate=1e-4,
batch_size=1000
)
settings(learning_rate=1e-4, batch_size=1000)
a = data_layer(name='feature_a', size=200)
b = data_layer(name='feature_b', size=200)
@ -11,12 +8,22 @@ b = data_layer(name='feature_b', size=200)
fc_param = ParamAttr(name='fc_param', initial_max=1.0, initial_min=-1.0)
bias_param = ParamAttr(name='bias_param', initial_mean=0.0, initial_std=0.0)
softmax_param = ParamAttr(name='softmax_param', initial_max=1.0, initial_min=-1.0)
softmax_param = ParamAttr(
name='softmax_param', initial_max=1.0, initial_min=-1.0)
hidden_a = fc_layer(input=a, size=200, param_attr=fc_param, bias_attr=bias_param)
hidden_b = fc_layer(input=b, size=200, param_attr=fc_param, bias_attr=bias_param)
hidden_a = fc_layer(
input=a, size=200, param_attr=fc_param, bias_attr=bias_param)
hidden_b = fc_layer(
input=b, size=200, param_attr=fc_param, bias_attr=bias_param)
predict = fc_layer(input=[hidden_a, hidden_b], param_attr=[softmax_param, softmax_param],
bias_attr=False, size=10, act=SoftmaxActivation())
predict = fc_layer(
input=[hidden_a, hidden_b],
param_attr=[softmax_param, softmax_param],
bias_attr=False,
size=10,
act=SoftmaxActivation())
outputs(classification_cost(input=predict, label=data_layer(name='label', size=10)))
outputs(
classification_cost(
input=predict, label=data_layer(
name='label', size=10)))

28
python/paddle/trainer_config_helpers/tests/configs/shared_lstm.py
Unescape View File

@ -16,14 +16,26 @@ with mixed_layer(size=400, bias_attr=False) as m2:
lstm_param = ParamAttr(name='lstm_param')
lstm_bias = ParamAttr(name='lstm_bias', initial_mean=0., initial_std=0.)
lstm1 = lstmemory_group(input=m1, param_attr=lstm_param, lstm_bias_attr=lstm_bias, mixed_bias_attr=False)
lstm2 = lstmemory_group(input=m2, param_attr=lstm_param, lstm_bias_attr=lstm_bias, mixed_bias_attr=False)
lstm1 = lstmemory_group(
input=m1,
param_attr=lstm_param,
lstm_bias_attr=lstm_bias,
mixed_bias_attr=False)
lstm2 = lstmemory_group(
input=m2,
param_attr=lstm_param,
lstm_bias_attr=lstm_bias,
mixed_bias_attr=False)
softmax_param = ParamAttr(name='softmax_param')
predict = fc_layer(input=[last_seq(input=lstm1), last_seq(input=lstm2)],
size=10,
param_attr=[softmax_param, softmax_param],
bias_attr=False,
act=SoftmaxActivation())
outputs(classification_cost(input=predict, label=data_layer(name='label', size=10)))
predict = fc_layer(
input=[last_seq(input=lstm1), last_seq(input=lstm2)],
size=10,
param_attr=[softmax_param, softmax_param],
bias_attr=False,
act=SoftmaxActivation())
outputs(
classification_cost(
input=predict, label=data_layer(
name='label', size=10)))

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save