def test_works_with_registered(self):
class CustomClass(object):
def value(self):
return tf.convert_to_tensor(42.)
tf.register_tensor_conversion_function(
CustomClass, lambda value, **_: value.value())
tf_utils.register_symbolic_tensor_type(CustomClass)
if tf.executing_eagerly():
self.assertFalse(
tf_utils.is_symbolic_tensor(
tf.Variable(name='blah', initial_value=0.)))
self.assertFalse(
tf_utils.is_symbolic_tensor(tf.convert_to_tensor(0.)))
self.assertFalse(
tf_utils.is_symbolic_tensor(
tf.SparseTensor(indices=[[0, 0], [1, 2]],
values=[1, 2],
dense_shape=[3, 4])))
self.assertFalse(tf_utils.is_symbolic_tensor(CustomClass()))
else:
self.assertTrue(
tf_utils.is_symbolic_tensor(
tf.Variable(name='blah', initial_value=0.)))
self.assertTrue(
tf_utils.is_symbolic_tensor(tf.convert_to_tensor(0.)))
self.assertTrue(
tf_utils.is_symbolic_tensor(
tf.SparseTensor(indices=[[0, 0], [1, 2]],
values=[1, 2],
dense_shape=[3, 4])))
self.assertTrue(tf_utils.is_symbolic_tensor(CustomClass()))
def register_tensor_wrapper_class(cls):
"""
Register a sub-class of :class:`TensorWrapper` into TensorFlow type system.
Args:
cls: The subclass of :class:`TensorWrapper` to be registered.
"""
if not isinstance(cls, six.class_types) or \
not issubclass(cls, TensorWrapper):
raise TypeError('`{}` is not a type, or not a subclass of '
'`TensorWrapper`'.format(cls))
def to_tensor(value, dtype=None, name=None, as_ref=False):
if dtype and not dtype.is_compatible_with(value.dtype):
raise ValueError('Incompatible type conversion requested to type '
'{} for tensor of type {}'.format(
dtype.name, value.dtype.name))
if as_ref: # pragma: no cover
raise ValueError('{!r}: Ref type not supported'.format(value))
return value.tensor
tf.register_tensor_conversion_function(cls, to_tensor)
# bring support for session.run(StochasticTensor), and for using as keys
# in feed_dict.
register_session_run_conversion_functions(
cls,
fetch_function=lambda t: ([t.tensor], lambda val: val[0]),
feed_function=lambda t, v: [(t.tensor, v)],
feed_function_for_partial_run=lambda t: [t.tensor])
def register_tensor_wrapper_class(cls):
"""Register the specified TensorWrapper type into TensorFlow type system.
Parameters
----------
cls : type
A subclass of `TensorWrapper`, which is to be registered.
"""
if not isinstance(cls, six.class_types) or \
not issubclass(cls, TensorWrapper):
raise TypeError('`%s` is not a type, or not a subclass of '
'`TensorWrapper`.' % (cls, ))
def to_tensor(value, dtype=None, name=None, as_ref=False):
if dtype and not dtype.is_compatible_with(value.dtype):
raise ValueError('Incompatible type conversion requested to type '
'%s for tensor of type %s' %
(dtype.name, value.dtype.name))
if as_ref:
raise ValueError('%r: Ref type not supported.' % value)
return value.__wrapped__
tf.register_tensor_conversion_function(cls, to_tensor)
# bring support for session.run(StochasticTensor), and for using as keys
# in feed_dict.
register_session_run_conversion_functions(
cls,
fetch_function=lambda t:
([getattr(t, '__wrapped__')], lambda val: val[0]),
feed_function=lambda t, v: [(getattr(t, '__wrapped__'), v)],
feed_function_for_partial_run=lambda t: [getattr(t, '__wrapped__')])
def __new__(mcs, name, bases, attrs):
# Embed Tensor-like attributes into the mcs class.
attrs.update(_get_tensor_like_attributes())
attrs['_value'] = _value
cls = super(_TensorCoercibleMeta, mcs).__new__(mcs, name, bases, attrs)
def _tensorize(d, dtype=None, name=None, as_ref=False):
return d._value(dtype, name, as_ref) # pylint: disable=protected-access
tf.register_tensor_conversion_function(cls, conversion_func=_tensorize)
return cls
def testFullDelegationControlUsingRegistry(self):
class NumpyArraySubclass(np.ndarray):
def __radd__(self, lhs):
return "Works!"
def raise_to_delegate(value, dtype=None, name=None, as_ref=False):
raise TypeError
register_tensor_conversion_function(NumpyArraySubclass, raise_to_delegate,
priority=0)
tensor = ops.convert_to_tensor([[10.0, 20.0]])
rhs = NumpyArraySubclass(shape=(1,2), buffer=np.array([1.0, 2.0]))
res = tensor + rhs
self.assertEqual(res, "Works!")
def testFullDelegationControlUsingRegistry(self):
class NumpyArraySubclass(np.ndarray):
def __radd__(self, lhs):
return "Works!"
def raise_to_delegate(value, dtype=None, name=None, as_ref=False):
raise TypeError
register_tensor_conversion_function(NumpyArraySubclass,
raise_to_delegate,
priority=0)
tensor = ops.convert_to_tensor([[10.0, 20.0]])
rhs = NumpyArraySubclass(shape=(1, 2), buffer=np.array([1.0, 2.0]))
res = tensor + rhs
self.assertEqual(res, "Works!")
functools.update_wrapper(_run_op, tensor_oper)
setattr(cls, operator, _run_op)
# NOTE(mrry): This enables the Variable's overloaded "right" binary
# operators to run when the left operand is an ndarray, because it
# accords the Variable class higher priority than an ndarray, or a
# numpy matrix.
# TODO(mrry): Convert this to using numpy's __numpy_ufunc__
# mechanism, which allows more control over how Variables interact
# with ndarrays.
__array_priority__ = 100
# Parameter._OverloadAllOperators()
tf.register_tensor_conversion_function(Parameter,
lambda x, *args, **kwds: x.value)
# def _cast_to_dtype(
# value: TensorData, dtype: Optional[DType] = None
# ) -> Union[tf.Tensor, tf.Variable]:
# if dtype is None:
# dtype = default_float()
# if tf.is_tensor(value):
# # NOTE(awav) TF2.2 resolves issue with cast.
# # From TF2.2, `tf.cast` can be used alone instead of this auxiliary function.
# # workaround for https://github.com/tensorflow/tensorflow/issues/35938
# return tf.cast(value, dtype)
# else:
# return tf.convert_to_tensor(value, dtype=dtype)
def train_and_evaluate(hparams, model_dir, train_source_files,
train_target_files, eval_source_files,
eval_target_files, use_multi_gpu):
if hparams.half_precision:
def conversion_func(value, dtype=None, name=None, as_ref=False):
if dtype and dtype == tf.float16 and not dtype.is_compatible_with(
value.dtype):
tf.logging.info(
f"Automatic tensor conversion into {dtype.name} is performed for {str(value)}"
)
return tf.cast(value, dtype=dtype)
else:
return NotImplemented
tf.register_tensor_conversion_function((tf.Variable, tf.Tensor),
conversion_func,
priority=-1)
backend.set_epsilon(1e-4)
interleave_parallelism = get_parallelism(
hparams.interleave_cycle_length_cpu_factor,
hparams.interleave_cycle_length_min,
hparams.interleave_cycle_length_max)
tf.logging.info("Interleave parallelism is %d.", interleave_parallelism)
def train_input_fn():
source_and_target_files = list(
zip(train_source_files, train_target_files))
shuffle(source_and_target_files)
source = [s for s, _ in source_and_target_files]
target = [t for _, t in source_and_target_files]
dataset = create_from_tfrecord_files(
source,
target,
hparams,
cycle_length=interleave_parallelism,
buffer_output_elements=hparams.interleave_buffer_output_elements,
prefetch_input_elements=hparams.interleave_prefetch_input_elements)
zipped = dataset.prepare_and_zip()
batched = zipped.filter_by_max_output_length().repeat(
count=None).shuffle(
hparams.suffle_buffer_size).group_by_batch().prefetch(
hparams.prefetch_buffer_size)
batched = batched.half_precision(
) if hparams.half_precision else batched
return batched.dataset
def eval_input_fn():
source_and_target_files = list(
zip(eval_source_files, eval_target_files))
shuffle(source_and_target_files)
source = tf.data.TFRecordDataset(
[s for s, _ in source_and_target_files])
target = tf.data.TFRecordDataset(
[t for _, t in source_and_target_files])
dataset = dataset_factory(source, target, hparams)
zipped = dataset.prepare_and_zip()
batched = zipped.filter_by_max_output_length().repeat().group_by_batch(
batch_size=1)
dataset = batched.half_precision(
) if hparams.half_precision else batched
return dataset.dataset
distribution = tf.contrib.distribute.MirroredStrategy(
) if use_multi_gpu else None
run_config = tf.estimator.RunConfig(
save_summary_steps=hparams.save_summary_steps,
save_checkpoints_steps=hparams.save_checkpoints_steps,
keep_checkpoint_max=hparams.keep_checkpoint_max,
log_step_count_steps=hparams.log_step_count_steps,
train_distribute=distribution)
ws = tf.estimator.WarmStartSettings(
ckpt_to_initialize_from=hparams.ckpt_to_initialize_from,
vars_to_warm_start=hparams.vars_to_warm_start
) if hparams.warm_start else None
estimator = model_factory(hparams, model_dir, run_config, ws)
train_spec = tf.estimator.TrainSpec(input_fn=train_input_fn)
eval_spec = tf.estimator.EvalSpec(
input_fn=eval_input_fn,
steps=hparams.num_evaluation_steps,
throttle_secs=hparams.eval_throttle_secs,
start_delay_secs=hparams.eval_start_delay_secs)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
return operator.__floordiv__(self._tensor, value)
def __pow__(self, value):
return operator.__pow__(self._tensor, value)
def __hash__(self):
raise TypeError(f'TensorVariable {self!r} is unhashable. Instead, use '
'tensorvariable.ref() as the key.')
def __repr__(self) -> str:
return f'<TensorVariable: {self._tensor}>'
def __array__(self):
return np.array(self._tensor)
def create_tensor_variable(next_creator_fn, **kwargs):
del next_creator_fn # Unused.
initial_value = kwargs.pop('initial_value')
return TensorVariable(initial_value, **kwargs)
def _convert_tensor_variable_to_tensor(value, *args, **kwargs):
del args # unused
del kwargs # unused
return value.read_value()
tf.register_tensor_conversion_function(TensorVariable,
_convert_tensor_variable_to_tensor)
self.assertIs(type(kernel), type(new_kernel))
if 'store_parameters_in_results' in new_kernel.parameters:
self.assertTrue(
new_kernel.parameters['store_parameters_in_results'])
def testNoParameters(self):
kernel = FakeInnerNoParameters()
new_kernel = util.enable_store_parameters_in_results(kernel)
self.assertIs(kernel, new_kernel)
class TensorConvertible(object):
pass
tf.register_tensor_conversion_function(
TensorConvertible, conversion_func=lambda *args: tf.constant(0))
class SimpleTensorWarningTest(tf.test.TestCase, parameterized.TestCase):
# We must defer creating the TF objects until the body of the test.
# pylint: disable=unnecessary-lambda
@parameterized.parameters([lambda: tf.Variable(0)],
[lambda: tf.compat.v2.Variable(0)],
[lambda: TensorConvertible()])
def testWarn(self, tensor_callable):
tensor = tensor_callable()
warnings.simplefilter('always')
with warnings.catch_warnings(record=True) as triggered:
util.warn_if_parameters_are_not_simple_tensors({'a': tensor})
self.assertTrue(
"'{}' for variable of type '{}'".format(
dtype.name, value.dtype.name))
if as_ref:
raise ValueError("{}: Ref type not supported.".format(value))
return value.tensor
def _as_graph_element(self, allow_tensor=True, allow_operation=True):
# this method brings support to ``session.run(...)`` and other
# related methods which expects a graph element.
if not allow_tensor:
raise RuntimeError('Can not convert a `StochasticTensor` into a '
'Operation.')
return self.tensor
tf.register_tensor_conversion_function(StochasticTensor,
StochasticTensor._to_tensor)
class BayesianNet(Context):
"""
The :class:`BayesianNet` class is a context class supporting model
construction in ZhuSuan as Bayesian Networks (Directed graphical models).
A `BayesianNet` represents a DAG with two kinds of nodes:
* Deterministic nodes, made up of any tensorflow operations.
* Stochastic nodes, constructed by :class:`StochasticTensor`.
To start a :class:`BayesianNet` context::
import zhusuan as zs
with zs.BayesianNet() as model:
@property
def shape(self):
return self.data.shape
@property
def dtype(self):
return self.data.dtype
def fail_on_convert(x, **kwargs):
_ = x
_ = kwargs
raise TypeError('Cannot convert DummyArrayLike to a tensor')
tf.register_tensor_conversion_function(DummyArrayLike, fail_on_convert)
class DataAdapterTestBase(keras_parameterized.TestCase):
def setUp(self):
super(DataAdapterTestBase, self).setUp()
self.batch_size = 5
self.numpy_input = np.zeros((50, 10))
self.numpy_target = np.ones(50)
self.tensor_input = tf.constant(2.0, shape=(50, 10))
self.tensor_target = tf.ones((50, ))
self.arraylike_input = DummyArrayLike(self.numpy_input)
self.arraylike_target = DummyArrayLike(self.numpy_target)
self.dataset_input = tf.data.Dataset.from_tensor_slices(
(self.numpy_input,
self.numpy_target)).shuffle(50).batch(self.batch_size)
def _session_run_conversion_fetch_function(tensor):
return ([tensor.value], lambda val: val[0])
def _session_run_conversion_feed_function(feed, feed_val):
return [(feed.value, feed_val)]
def _session_run_conversion_feed_function_for_partial_run(feed):
return [feed.value]
def _tensor_conversion_function(v, dtype=None, name=None, as_ref=False):
del name, as_ref # unused
if dtype and not dtype.is_compatible_with(v.dtype):
raise ValueError(
"Incompatible type conversion requested to type '%s' for variable "
"of type '%s'" % (dtype.name, v.dtype.name))
return v.value
tf_session.register_session_run_conversion_functions( # enable sess.run, eval
RandomVariable, _session_run_conversion_fetch_function,
_session_run_conversion_feed_function,
_session_run_conversion_feed_function_for_partial_run)
tf.register_tensor_conversion_function( # enable tf.convert_to_tensor
RandomVariable, _tensor_conversion_function)
def _session_run_conversion_fetch_function(tensor):
return ([tensor.value], lambda val: val[0])
def _session_run_conversion_feed_function(feed, feed_val):
return [(feed.value, feed_val)]
def _session_run_conversion_feed_function_for_partial_run(feed):
return [feed.value]
def _tensor_conversion_function(v, dtype=None, name=None, as_ref=False):
del name, as_ref # unused
if dtype and not dtype.is_compatible_with(v.dtype):
raise ValueError(
"Incompatible type conversion requested to type '%s' for variable "
"of type '%s'" % (dtype.name, v.dtype.name))
return v.value
tf_session.register_session_run_conversion_functions( # enable sess.run, eval
RandomVariable,
_session_run_conversion_fetch_function,
_session_run_conversion_feed_function,
_session_run_conversion_feed_function_for_partial_run)
tf.register_tensor_conversion_function( # enable tf.convert_to_tensor
RandomVariable, _tensor_conversion_function)
def tensor_to_ndarray(tensor):
return ndarray(tensor._shape_tuple(), dtype=tensor.dtype, buffer=tensor) # pylint: disable=protected-access
def ndarray_to_tensor(arr, dtype=None, name=None, as_ref=False):
if as_ref:
raise ValueError('as_ref is not supported.')
if dtype and tf.as_dtype(arr.dtype) != dtype:
return tf.cast(arr.data, dtype)
result_t = arr.data
if name:
result_t = tf.identity(result_t, name=name)
return result_t
tf.register_tensor_conversion_function(ndarray, ndarray_to_tensor)
# Don't use a namedtuple since nest considers that a tuple and unflattens and
# flattens it.
class ShardedNdArray(object):
"""Wrapper over ndarray that can contain tensors on multiple devices.
This is returned by extensions.pmap, and contains the individual tensors on
different devices.
"""
def __init__(self, tensors):
"""Initializes the ShardedNdArray.
Note that the tensors should be ordered in the way the pmap producing these
'''Loss that punishes values being larger than a given value.
.. math::
loss = func(x - reference)
'''
def loss_eval(self, x, reference, mask):
return self._func(x - reference)
def __init__(self,
x,
reference,
mask=None,
func=tf.nn.softplus,
name='GreaterThanLoss'):
super(GreaterThan, self).__init__(x=x,
reference=reference,
func=func,
name=name)
def convert_loss_to_tensor(value, dtype=None, name=None, as_ref=False):
if dtype is None:
return value.value
else:
return tf.convert_to_tensor(value.value, dtype=dtype, name=name)
tf.register_tensor_conversion_function((Loss, EmpiricalLossWrapper),
conversion_func=convert_loss_to_tensor,
priority=100)
Return the Tensor representing the value of the variational objective.
:return: A Tensor.
"""
if not hasattr(self, '_tensor'):
self._tensor = self._objective()
return self._tensor
@staticmethod
def _to_tensor(value, dtype=None, name=None, as_ref=False):
tensor = value.tensor
if dtype and not dtype.is_compatible_with(tensor.dtype):
raise ValueError("Incompatible type conversion requested to type "
"'{}' for variable of type '{}'".format(
dtype.name, tensor.dtype.name))
if as_ref:
raise ValueError("{}: Ref type not supported.".format(value))
return tensor
tf.register_tensor_conversion_function(VariationalObjective,
VariationalObjective._to_tensor)
# bring support for session.run(VariationalObjective), and for using as keys
# in feed_dict.
register_session_run_conversion_functions(
VariationalObjective,
fetch_function=lambda t: ([t.tensor], lambda val: val[0]),
feed_function=lambda t, v: [(t.tensor, v)],
feed_function_for_partial_run=lambda t: [t.tensor])
# register the variable, which is used to detect dependencies
contextmanager.randvar_registry.register_parameter(self)
contextmanager.randvar_registry.update_graph()
def _tensor_conversion_function(p, dtype=None, name=None, as_ref=False):
"""
Function that converts the inferpy variable into a Tensor.
This will enable the use of enable tf.convert_to_tensor(rv)
If the variable needs to be broadcast_to, do it right now
"""
return tf.convert_to_tensor(p.var)
# register the conversion function into a tensor
tf.register_tensor_conversion_function( # enable tf.convert_to_tensor
Parameter, _tensor_conversion_function)
def _session_run_conversion_fetch_function(p):
"""
This will enable run and operations with other tensors
"""
return ([tf.convert_to_tensor(p)], lambda val: val[0])
tf_session.register_session_run_conversion_functions( # enable sess.run, eval
Parameter, _session_run_conversion_fetch_function)
def __getitem__(self, key):
return self.as_tensor()[key]
def as_tensor(self, dtype=None, name=None, as_ref=False):
with tf.name_scope(name, "PartitionedTensor.as_tensor", self.tensors):
assert not as_ref
assert dtype in [None, self.dtype]
result = tf.concat(self.tensors, axis=0)
# Cache 'result' if we haven't already cached a value for this device.
if result.device not in self._concats:
self._concats[result.device] = result
return self._concats[result.device]
@property
def device(self):
# PartitionedTensors in general do not live on a single device. If the
# device cannot be determined unambiguously this property will return None.
device = self.tensors[0].device
if all(tensor.device == device for tensor in self.tensors):
return device
return None
tf.register_tensor_conversion_function(
PartitionedTensor,
lambda val, dtype, name, as_ref: val.as_tensor(dtype, name, as_ref))
# TODO(b/69623235): Add a function for finding tensors that share gradients
# to eliminate redundant fisher factor computations.
@property
def dtype(self):
return self.value.dtype
def _to_tensor(value, dtype=None, name=None, as_ref=False):
if dtype and not dtype.is_compatible_with(value.dtype):
raise ValueError('Incompatible type conversion requested to type '
'%s for variable of type %s' %
(dtype.name, value.dtype.name))
if as_ref:
raise ValueError('%r: Ref type not supported.' % value)
return value.value
tf.register_tensor_conversion_function(_SimpleTensor, _to_tensor)
class ArithMixinTestCase(tf.test.TestCase):
def test_prerequisite(self):
if six.PY2:
self.assertAlmostEqual(regular_div(3, 2), 1)
self.assertAlmostEqual(regular_div(3.3, 1.6), 2.0625)
else:
self.assertAlmostEqual(regular_div(3, 2), 1.5)
self.assertAlmostEqual(regular_div(3.3, 1.6), 2.0625)
self.assertAlmostEqual(true_div(3, 2), 1.5)
self.assertAlmostEqual(true_div(3.3, 1.6), 2.0625)
self.assertAlmostEqual(floor_div(3, 2), 1)
self.assertAlmostEqual(floor_div(3.3, 1.6), 2.0)
# -*- coding:utf8 -*- # File : __init__.py # Author : Jiayuan Mao # Email : [email protected] # Date : 12/29/16 # # This file is part of TensorArtist. from .tfutils import TArtGraphKeys from .graph import * from . import opr, optimizer, summary, train import tensorflow as tf def varnode_to_tftensor(varnode, *args, **kwargs): v = varnode.impl if isinstance(v, tf.Variable): return tf.convert_to_tensor(v) return v tf.register_tensor_conversion_function(VarNode, varnode_to_tftensor)
from tensorflow.python.framework import test_util
from tensorflow_estimator.python.estimator.export import export
class LabeledTensorMock(object):
"""Mock class emulating LabeledTensor."""
def __init__(self):
self.tensor = tf.constant([1])
def _convert_labeled_tensor_mock_to_tensor(value, *args, **kwargs):
return ops.internal_convert_to_tensor(value.tensor, *args, **kwargs)
tf.register_tensor_conversion_function(LabeledTensorMock,
_convert_labeled_tensor_mock_to_tensor)
class ServingInputReceiverTest(tf.test.TestCase):
def test_serving_input_receiver_constructor(self):
"""Tests that no errors are raised when input is expected."""
features = {
"feature0": tf.constant([0]),
u"feature1": tf.constant([1]),
"feature2": tf.sparse.SparseTensor(
indices=[[0, 0]], values=[1], dense_shape=[1, 1]),
# ints are allowed only in the `features` dict
42: tf.constant([3]),
}
receiver_tensors = {
def __init__(self, value):
self._value = value
def to_tensor(self, dtype=None, name=None, as_ref=False):
return tf.convert_to_tensor(self._value, dtype=dtype, name=name)
@property
def value(self):
return self._value
@value.setter
def value(self, value):
self._value = value
tf.register_tensor_conversion_function(TensorRef,
conversion_func=TensorRef.to_tensor)
class AdaptStepResults(
collections.namedtuple(
"AdaptStepResults",
"inner_results, step_size, num_leapfrog_steps, cur_step")):
__slots__ = ()
class AdaptStep(tfp.mcmc.TransitionKernel):
def __init__(self, inner_kernel, step_size, num_leapfrog_steps,
trajectory_length, target_accept_rate, gain, num_adapt_steps):
self.inner_kernel = inner_kernel
self.step_size = step_size
self.num_leapfrog_steps = num_leapfrog_steps
def test_enables_nontensor_plumbing(self):
if tf.executing_eagerly():
self.skipTest('`compile` functionality changed.')
# Setup.
class Foo(object):
def __init__(self, input_):
self._input = input_
self.value = tf.convert_to_tensor([[42.]])
@property
def dtype(self):
return self.value.dtype
tf.register_tensor_conversion_function(
Foo, lambda x, *args, **kwargs: x.value)
tf_utils.register_symbolic_tensor_type(Foo)
class PlumbingLayer(keras.layers.Lambda):
def __init__(self, fn, **kwargs):
def _fn(*fargs, **fkwargs):
d = fn(*fargs, **fkwargs)
x = tf.convert_to_tensor(d)
d.shape = x.shape
d.get_shape = x.get_shape
return d, x
super(PlumbingLayer, self).__init__(_fn, **kwargs)
self._enter_dunder_call = False
def __call__(self, inputs, *args, **kwargs):
self._enter_dunder_call = True
d, _ = super(PlumbingLayer,
self).__call__(inputs, *args, **kwargs)
self._enter_dunder_call = False
return d
def call(self, inputs, *args, **kwargs):
d, v = super(PlumbingLayer, self).call(inputs, *args, **kwargs)
if self._enter_dunder_call:
return d, v
return d
# User-land.
model = keras.Sequential([
keras.layers.InputLayer((1, )),
PlumbingLayer(Foo), # Makes a `Foo` object.
])
# Let's ensure Keras graph history is preserved by composing the models.
model = keras.Model(model.inputs, model(model.outputs))
# Now we instantiate the model and verify we have a `Foo` object, not a
# `Tensor`.
y = model(tf.convert_to_tensor([[7.]]))
self.assertIsInstance(y, Foo)
# Confirm that (custom) loss sees `Foo` instance, not Tensor.
obtained_prediction_box = [None]
def custom_loss(y_obs, y_pred):
del y_obs
obtained_prediction_box[0] = y_pred
return y_pred
# Apparently `compile` calls the loss function enough to trigger the
# side-effect.
model.compile('SGD', loss=custom_loss)
self.assertIsInstance(obtained_prediction_box[0], Foo)
"""
if in_layers is None:
in_layers = self.in_layers
if not isinstance(in_layers, Sequence):
in_layers = [in_layers]
tensors = []
for input in in_layers:
tensors.append(tf.convert_to_tensor(input))
return tensors
def _convert_layer_to_tensor(value, dtype=None, name=None, as_ref=False):
return tf.convert_to_tensor(value.out_tensor, dtype=dtype, name=name)
tf.register_tensor_conversion_function(Layer, _convert_layer_to_tensor)
class Dense(Layer):
def __init__(
self,
out_channels,
activation_fn=None,
biases_initializer=tf.zeros_initializer,
weights_initializer=tf.contrib.layers.variance_scaling_initializer,
**kwargs):
"""Create a dense layer.
The weight and bias initializers are specified by callable objects that construct
and return a Tensorflow initializer when invoked with no arguments. This will typically
be either the initializer class itself (if the constructor does not require arguments),
"""PyMC4."""
from ._model import *
from .random_variables import *
import tensorflow as _tf
from ._template_contexts import get_context as _get_context
from .random_variables import RandomVariable as _RandomVariable
__version__ = "0.0.1"
def _convert_rv_to_backend(d, dtype=None, name=None, as_ref=False):
if isinstance(d, _RandomVariable):
return d.as_tensor()
return d
_tf.register_tensor_conversion_function(
_RandomVariable, conversion_func=_convert_rv_to_backend, priority=0
)
raise ValueError(error_msg.format(x.shape))
@staticmethod
def validate_type(x):
"""Raise a type error if the dtype of x is not float."""
if not x.dtype.is_floating:
raise TypeError("Quaternion: dtype must be one of float16/32/64.")
@scope_wrapper
def norm(self, keepdims=True):
"""Return the norm of the quaternion."""
return tf.reduce_sum(tf.square(self._q), axis=-1)
@scope_wrapper
def abs(self, keepdims=True):
"""Return the square root of the norm of the quaternion."""
return tf.sqrt(self.norm(keepdims))
# ____________________________________________________________________________
# quaternion to tensor conversion
def quaternion_to_tensor(x, dtype=None, name=None, as_ref=None):
"""Convert a Quaternion to a `tf.Tensor`."""
# Todo(phil): handle as_ref correctly
return tf.convert_to_tensor(x.value(), dtype, name)
tf.register_tensor_conversion_function(Quaternion,
quaternion_to_tensor,
priority=100)
@_handle_name.setter
def _handle_name(self, handle_name):
self.latent_variable._handle_name = handle_name
@property
def _initializer_op(self):
return self.latent_variable._initializer_op
@_initializer_op.setter
def _initializer_op(self, initializer_op):
self.latent_variable._initializer_op = initializer_op
def _as_graph_element(self):
if self.quantizer and context.should_quantize():
return self.quantizer(self.latent_variable)
graph_element = self.latent_variable._as_graph_element()
if graph_element is None:
return self._op
return graph_element
QuantizedVariable._OverloadAllOperators()
tf.register_tensor_conversion_function(
QuantizedVariable, QuantizedVariable._dense_var_to_tensor
)
try:
ops.register_dense_tensor_like_type(QuantizedVariable)
except AttributeError:
pass
""" Neural ordinary differential equations module. """
from types import FunctionType
import tensorflow as tf
tf.register_tensor_conversion_function(
FunctionType, lambda value, *args, **kwargs: tf.zeros(0))
tf.register_tensor_conversion_function(
tf.keras.Model, lambda value, *args, **kwargs: tf.zeros(0))
def _flatten(tensors):
""" Flattens given tensor or a collection of tensors. """
if not isinstance(tensors, (list, tuple)): # given single tensor
return tf.reshape(tensors, (-1, ))
return (tf.concat([tf.reshape(t, (-1, )) for t in tensors], 0)
if tensors else tf.convert_to_tensor([]))
def _unflatten(tensor, shapes):
""" Splits given tensor and reshapes results using given shapes. """
split = tf.split(tensor, [tf.reduce_prod(s) for s in shapes])
return [tf.reshape(t, s) for t, s in zip(split, shapes)]
def odeint_grad(grad_output,
func,
yt,
t,
variables=None,
rtol=1e-6,
atol=1e-12):
return self.read_value().__matmul__(o)
except AttributeError:
# See https://docs.python.org/3/library/constants.html#NotImplemented
return NotImplemented
def __rmatmul__(self, o):
try:
return self.read_value().__rmatmul__(o)
except AttributeError:
# See https://docs.python.org/3/library/constants.html#NotImplemented
return NotImplemented
# pylint: enable=multiple-statements
tf.register_tensor_conversion_function(AutoCastVariable,
AutoCastVariable._dense_var_to_tensor) # pylint:disable=protected-access
def create_autocast_variable(variable, op=None):
"""Creates an AutoCastVariable that wraps another variable.
This typically just returns `AutoCastVariable(variable)`. But, if the variable
is a DistributedVariable or one of its subclasses, we instead dynamically
create a class that subclasses from both AutoCastVariable and
variable.__class__. This is so the returned variable will still pass
`isinstance(variable, variable.__class__)`, which is required for
DistributedVariables and its subclasses to work properly.
Args:
variable: A floating-point resource variable to wrap.
op: Optional operation of this variable.
def set_weights(self, weights):
if len(weights) != len(self.variables):
raise ValueError(
f"set_weights() expects a list of {len(self.variables)} arrays, "
f"received {len(weights)}.")
tf.keras.backend.batch_set_value(zip(self.variables, weights))
def _parameter_conversion_func(value, dtype=None, name=None, as_ref=False):
if as_ref:
raise ValueError("as_ref=True is not supported.")
return tf.convert_to_tensor(value(), dtype=dtype, name=name)
tf.register_tensor_conversion_function(
Parameter,
_parameter_conversion_func,
)
@tf.keras.utils.register_keras_serializable(package="tensorflow_compression")
class RDFTParameter(Parameter):
"""RDFT reparameterization of a convolution kernel.
This uses the real-input discrete Fourier transform (RDFT) of a kernel as
its parameterization. The inverse RDFT is applied to the variable to produce
the kernel.
(see https://en.wikipedia.org/wiki/Discrete_Fourier_transform)
Attributes:
dc: Boolean. The `dc` parameter provided on initialization.
return ([tensor.value()], lambda val: val[0])
@staticmethod
def _session_run_conversion_feed_function(feed, feed_val):
return [(feed.value(), feed_val)]
@staticmethod
def _session_run_conversion_feed_function_for_partial_run(feed):
return [feed.value()]
@staticmethod
def _tensor_conversion_function(v, dtype=None, name=None, as_ref=False):
_ = name
if dtype and not dtype.is_compatible_with(v.dtype):
raise ValueError(
"Incompatible type conversion requested to type '%s' for variable "
"of type '%s'" % (dtype.name, v.dtype.name))
if as_ref:
raise ValueError("%s: Ref type is not supported." % v)
return v.value()
register_session_run_conversion_functions(
RandomVariable,
RandomVariable._session_run_conversion_fetch_function,
RandomVariable._session_run_conversion_feed_function,
RandomVariable._session_run_conversion_feed_function_for_partial_run)
tf.register_tensor_conversion_function(
RandomVariable, RandomVariable._tensor_conversion_function)
return ([tensor.value()], lambda val: val[0])
@staticmethod
def _session_run_conversion_feed_function(feed, feed_val):
return [(feed.value(), feed_val)]
@staticmethod
def _session_run_conversion_feed_function_for_partial_run(feed):
return [feed.value()]
@staticmethod
def _tensor_conversion_function(v, dtype=None, name=None, as_ref=False):
_ = name, as_ref
if dtype and not dtype.is_compatible_with(v.dtype):
raise ValueError(
"Incompatible type conversion requested to type '%s' for variable "
"of type '%s'" % (dtype.name, v.dtype.name))
return v.value()
RandomVariable._overload_all_operators()
register_session_run_conversion_functions(
RandomVariable,
RandomVariable._session_run_conversion_fetch_function,
RandomVariable._session_run_conversion_feed_function,
RandomVariable._session_run_conversion_feed_function_for_partial_run)
tf.register_tensor_conversion_function(
RandomVariable, RandomVariable._tensor_conversion_function)
