def _excepthook(self, etype, evalue, etb):
from IPython.core import ultratb
from mayo.util import import_from_string
ultratb.FormattedTB()(etype, evalue, etb)
for exc in self.get('system.pdb.skip', []):
exc = import_from_string(exc)
if issubclass(etype, exc):
sys.exit(-1)
if self.get('system.pdb.use', True):
import ipdb
ipdb.post_mortem(etb)
def _check_type(self, overrider):
o_type = self.info.type
targets = [import_from_string(item) for item in o_type]
# check recentralizer
if isinstance(overrider, Recentralizer):
o = overrider.quantizer
else:
o = overrider
for target in targets:
if isinstance(o, target):
return True
return False
def _config_layer(self, node, params):
# normalizer_fn and activation_fn
for key in ['activation_fn', 'normalizer_fn']:
if key not in params:
continue
fn = params[key]
if isinstance(fn, str):
fn = import_from_string(fn)
params[key] = fn
# insert is_training into normalizer_params
if params.get('normalizer_fn', None):
norm_params = params.setdefault('normalizer_params', {})
norm_params['is_training'] = self.is_training
activation_functions = []
# gradient of error
gradient_overrider = params.get('overrider.gradient.error')
if gradient_overrider and self.is_training:
def gradient_fn(v):
name = '{}/errors'.format(node.formatted_name())
return self._apply_gradient_overrider(
node, name, gradient_overrider, v)
activation_functions.append(gradient_fn)
# activation
activation_overrider = params.get('overrider.activation', None)
if activation_overrider:
override_fn = lambda x: activation_overrider.apply(
node, 'activations', tf.get_variable, x)
activation_functions.append(override_fn)
# produce a default ReLU activation when overriders are used
relu_types = [
'convolution', 'depthwise_separable_convolution',
'fully_connected']
default_fn = None
if activation_functions and node.params.type in relu_types:
default_fn = tf.nn.relu
activation_fn = params.get('activation_fn', default_fn)
if activation_fn:
activation_params = params.pop('activation_params', {})
activation_fn = functools.partial(
activation_fn, **activation_params)
activation_functions.append(activation_fn)
if activation_functions:
params['activation_fn'] = compose_functions(activation_functions)
# set up other parameters
params['scope'] = node.name
try:
params['padding'] = params['padding'].upper()
except (KeyError, AttributeError):
pass
def _eval(self, n):
if isinstance(n, ast.Num):
return n.n
if isinstance(n, ast.Call):
op = import_from_string(self._eval(n.func))
args = (self._eval(a) for a in n.args)
return op(*args)
if isinstance(n, ast.Attribute):
obj = self._eval(n.value)
if isinstance(obj, str):
return '{}.{}'.format(obj, n.attr)
return getattr(obj, n.attr)
if isinstance(n, ast.Name):
return n.id
if isinstance(n, ast.Str):
return n.s
if isinstance(n, ast.Compare):
ops = n.ops
rhs = n.comparators
if len(ops) > 1 or len(rhs) > 1:
raise NotImplementedError(
'We support only one comparator for now.')
op = self._eval_expr_map[type(ops[0])]
return op(self._eval(n.left), self._eval(rhs[0]))
if isinstance(n, ast.IfExp):
if self._eval(n.test):
return self._eval(n.body)
else:
return self._eval(n.orelse)
if isinstance(n, ast.NameConstant):
return n.value
if isinstance(n, ast.List):
return [self._eval(e) for e in n.elts]
if not isinstance(n, (ast.UnaryOp, ast.BinOp, ast.BoolOp)):
raise TypeError('Unrecognized operator node {}'.format(n))
op = self._eval_expr_map[type(n.op)]
if isinstance(n, ast.UnaryOp):
return op(self._eval(n.operand))
if isinstance(n, ast.BoolOp):
return op(*(self._eval(e) for e in n.values))
return op(self._eval(n.left), self._eval(n.right))