def __init__(
self,
prev_layer,
model_fn,
layer_args=None,
name='estimator_layer',
):
super(EstimatorLayer, self).__init__(prev_layer=prev_layer,
layer_args=layer_args,
name=name)
logging.info("EstimatorLayer %s: %s" % (self.name, model_fn))
if model_fn is None:
raise ValueError('model fn is None')
logging.warning(
"This API will be removed, please use LambdaLayer instead.")
with tf.variable_scope(name) as vs:
self.outputs = model_fn(self.inputs, **self.layer_args)
variables = tf.get_collection(TF_GRAPHKEYS_VARIABLES,
scope=vs.name)
self._add_layers(self.outputs)
self._add_params(variables)
def __init__(
self,
prev_layer,
keras_layer,
keras_args=None,
name='keras_layer',
):
super(KerasLayer, self).__init__(prev_layer=prev_layer, name=name)
logging.info("KerasLayer %s: %s" % (name, keras_layer))
self.inputs = prev_layer.outputs
if prev_layer is None:
raise ValueError("layer is None")
if keras_args is None:
keras_args = {}
logging.warning(
"This API will be removed, please use LambdaLayer instead.")
with tf.variable_scope(name) as vs:
self.outputs = keras_layer(self.inputs, **keras_args)
variables = tf.get_collection(TF_GRAPHKEYS_VARIABLES,
scope=vs.name)
self.all_layers.append(self.outputs)
self.all_params.extend(variables)
def __init__(
self,
prev_layer,
model_fn,
args=None,
name='estimator_layer',
):
super(EstimatorLayer, self).__init__(prev_layer=prev_layer, name=name)
logging.info("EstimatorLayer %s: %s" % (name, model_fn))
self.inputs = prev_layer.outputs
if model_fn is None:
raise ValueError('model fn is None')
if args is None:
args = {}
logging.warning("This API will be removed, please use LambdaLayer instead.")
with tf.variable_scope(name) as vs:
self.outputs = model_fn(self.inputs, **args)
variables = tf.get_collection(TF_GRAPHKEYS_VARIABLES, scope=vs.name)
# self.all_layers = list(layer.all_layers)
# self.all_params = list(layer.all_params)
# self.all_drop = dict(layer.all_drop)
self.all_layers.append(self.outputs)
self.all_params.extend(variables)
def rename_kwargs(kwargs, aliases, end_support_version, func_name):
for alias, new in aliases.items():
if alias in kwargs:
if new in kwargs:
raise TypeError('{}() received both {} and {}'.format(func_name, alias, new))
warnings.warn('{}() - {} is deprecated; use {}'.format(func_name, alias, new), DeprecationWarning)
logging.warning(
"DeprecationWarning: {}(): "
"`{}` argument is deprecated and will be removed in version {}, "
"please change for `{}.`".format(func_name, alias, end_support_version, new)
)
kwargs[new] = kwargs.pop(alias)
def __init__(
self,
prev_layer,
keras_layer,
keras_args=None,
name='keras_layer',
):
super(KerasLayer, self).__init__(prev_layer=prev_layer, keras_args=keras_args, name=name)
logging.info("KerasLayer %s: %s" % (self.name, keras_layer))
logging.warning("This API will be removed, please use LambdaLayer instead.")
with tf.variable_scope(name) as vs:
self.outputs = keras_layer(self.inputs, **self.keras_args)
variables = tf.get_collection(TF_GRAPHKEYS_VARIABLES, scope=vs.name)
self._add_layers(self.outputs)
self._add_params(variables)
def deprecated_wrapper(wrapped, instance, args, kwargs):
_validate_deprecation_args(date, instructions)
if _PRINT_DEPRECATION_WARNINGS:
class_or_func_name = decorator_utils.get_qualified_name(wrapped)
if class_or_func_name not in _PRINTED_WARNING:
if warn_once:
_PRINTED_WARNING[class_or_func_name] = True
logging.warning(
'From %s: %s (from %s) is deprecated and will be removed %s.\n'
'Instructions for updating: %s\n' % (
_call_location(), class_or_func_name, wrapped.__module__, 'in a future version'
if date is None else ('after %s' % date), instructions
)
)
return wrapped(*args, **kwargs)
def set_name_reuse(enable=True):
logging.warning(
'this method is DEPRECATED and has no effect, please remove it from your code.'
)
def clear_layers_name():
logging.warning(
'this method is DEPRECATED and has no effect, please remove it from your code.'
)
def __init__(
self,
prev_layer,
n_filter=32,
filter_size=(3, 3),
strides=(1, 1),
act=None,
padding='SAME',
use_gemm=False,
W_init=tf.truncated_normal_initializer(stddev=0.02),
b_init=tf.constant_initializer(value=0.0),
W_init_args=None,
b_init_args=None,
use_cudnn_on_gpu=None,
data_format=None,
# act=None,
# shape=(5, 5, 1, 100),
# strides=(1, 1, 1, 1),
# padding='SAME',
# W_init=tf.truncated_normal_initializer(stddev=0.02),
# b_init=tf.constant_initializer(value=0.0),
# W_init_args=None,
# b_init_args=None,
# use_cudnn_on_gpu=None,
# data_format=None,
name='ternary_cnn2d',
):
super(TernaryConv2d, self).__init__(prev_layer=prev_layer,
act=act,
W_init_args=W_init_args,
b_init_args=b_init_args,
name=name)
logging.info(
"TernaryConv2d %s: n_filter:%d filter_size:%s strides:%s pad:%s act:%s"
%
(name, n_filter, str(filter_size), str(strides), padding,
self.act.__name__ if self.act is not None else '- No Activation'))
if len(strides) != 2:
raise ValueError("len(strides) should be 2.")
if use_gemm:
raise Exception(
"TODO. The current version use tf.matmul for inferencing.")
try:
pre_channel = int(prev_layer.outputs.get_shape()[-1])
except Exception: # if pre_channel is ?, it happens when using Spatial Transformer Net
pre_channel = 1
logging.warning("unknow input channels, set to 1")
shape = (filter_size[0], filter_size[1], pre_channel, n_filter)
strides = (1, strides[0], strides[1], 1)
with tf.variable_scope(name):
W = tf.get_variable(name='W_conv2d',
shape=shape,
initializer=W_init,
dtype=LayersConfig.tf_dtype,
**self.W_init_args)
alpha = _compute_alpha(W)
W = _ternary_operation(W)
W = tf.multiply(alpha, W)
self.outputs = tf.nn.conv2d(self.inputs,
W,
strides=strides,
padding=padding,
use_cudnn_on_gpu=use_cudnn_on_gpu,
data_format=data_format)
if b_init:
b = tf.get_variable(name='b_conv2d',
shape=(shape[-1]),
initializer=b_init,
dtype=LayersConfig.tf_dtype,
**self.b_init_args)
self.outputs = tf.nn.bias_add(self.outputs, b, name='bias_add')
self.outputs = self._apply_activation(self.outputs)
self._add_layers(self.outputs)
if b_init:
self._add_params([W, b])
else:
self._add_params(W)
def moses_multi_bleu(hypotheses, references, lowercase=False):
"""Calculate the bleu score for hypotheses and references
using the MOSES ulti-bleu.perl script.
Parameters
------------
hypotheses : numpy.array.string
A numpy array of strings where each string is a single example.
references : numpy.array.string
A numpy array of strings where each string is a single example.
lowercase : boolean
If True, pass the "-lc" flag to the multi-bleu script
Examples
---------
>>> hypotheses = ["a bird is flying on the sky"]
>>> references = ["two birds are flying on the sky", "a bird is on the top of the tree", "an airplane is on the sky",]
>>> score = tl.nlp.moses_multi_bleu(hypotheses, references)
Returns
--------
float
The BLEU score
References
----------
- `Google/seq2seq/metric/bleu <https://github.com/google/seq2seq>`__
"""
if np.size(hypotheses) == 0:
return np.float32(0.0)
# Get MOSES multi-bleu script
try:
multi_bleu_path, _ = urllib.request.urlretrieve(
"https://raw.githubusercontent.com/moses-smt/mosesdecoder/"
"master/scripts/generic/multi-bleu.perl")
os.chmod(multi_bleu_path, 0o755)
except Exception: # pylint: disable=W0702
logging.info("Unable to fetch multi-bleu.perl script, using local.")
metrics_dir = os.path.dirname(os.path.realpath(__file__))
bin_dir = os.path.abspath(os.path.join(metrics_dir, "..", "..", "bin"))
multi_bleu_path = os.path.join(bin_dir, "tools/multi-bleu.perl")
# Dump hypotheses and references to tempfiles
hypothesis_file = tempfile.NamedTemporaryFile()
hypothesis_file.write("\n".join(hypotheses).encode("utf-8"))
hypothesis_file.write(b"\n")
hypothesis_file.flush()
reference_file = tempfile.NamedTemporaryFile()
reference_file.write("\n".join(references).encode("utf-8"))
reference_file.write(b"\n")
reference_file.flush()
# Calculate BLEU using multi-bleu script
with open(hypothesis_file.name, "r") as read_pred:
bleu_cmd = [multi_bleu_path]
if lowercase:
bleu_cmd += ["-lc"]
bleu_cmd += [reference_file.name]
try:
bleu_out = subprocess.check_output(bleu_cmd,
stdin=read_pred,
stderr=subprocess.STDOUT)
bleu_out = bleu_out.decode("utf-8")
bleu_score = re.search(r"BLEU = (.+?),", bleu_out).group(1)
bleu_score = float(bleu_score)
except subprocess.CalledProcessError as error:
if error.output is not None:
logging.warning(
"multi-bleu.perl script returned non-zero exit code")
logging.warning(error.output)
bleu_score = np.float32(0.0)
# Close temp files
hypothesis_file.close()
reference_file.close()
return np.float32(bleu_score)
