class Module(object):
"""Mocking module class for name dispatching.
It will register primitives from :mod:`minpy.array_variant`.
Parameters
----------
old : dict
A meta class including info such as name, path, etc.
name : None, or str
Second level name if specified.
name_injector : dict, or dict-like object
An optional dict provides manual dispatching
"""
def __init__(self, old, name=None, name_injector={}):
# Add module itself into global config
minpy.Config['modules'].append(self)
self._registry = Registry()
self._policy = minpy.Config['default_policy']
self._logger = log.get_logger(old['__name__'])
self._logger.info('Initialize module: {}.'.format(old['__name__']))
self._old = old
self._name_injector = name_injector
if len(name_injector) != 0:
self._logger.info('Inject Name Injector {}'.format(name_injector.__name__))
for vname in variants:
if name is None:
modname = 'minpy.array_variants.{}'.format(vname)
else:
modname = 'minpy.array_variants.{}.{}'.format(vname, name)
mod = importlib.import_module(modname)
self._logger.info('Importing from {}.'.format(modname))
primitive_wrapper = lambda func, *args, **kwargs:\
Primitive(func, variants[vname], *args, **kwargs)
# Register all primitives of the module.
before = len(self._registry._reg)
mod.register_primitives(self._registry, primitive_wrapper)
self._logger.info('Got {} primitives from {}'.format(
len(self._registry._reg) - before, modname))
primitive_getter = lambda name: self._registry.get(name, variants[vname])
# Define gradients of primitives.
mod.def_grads(self._registry, primitive_getter)
self._logger.info('Import {} primitives'.format(
len(self._registry._reg)))
def set_policy(self, plc):
"""Set name dispatch policy.
Parameters
----------
plc
New policy.
"""
assert isinstance(
plc, Policy), 'Need an instance of `minpy.dispatch.policy.Policy`.'
self._policy = plc
@property
def policy(self):
"""Get policy of current module"""
return self._policy
def __getattr__(self, name):
"""Fetch attributes from this module.
If the name is contained in the primitive registry,
it will return a primitive selector for further name dispatching.
:param name: Name of attribute.
:return: Primitive selector.
:raises AttributeError: Cannot find attribute.
"""
# Special members for internal use.
if name == '__registry__':
return self._registry
elif name == '__all__':
return self._old.__all__
elif self._registry.has_name(name):
return PrimitiveSelector(name, self._registry, self._policy)
elif name in self._name_injector:
return self._name_injector[name]
elif name in self._old:
self._logger.info(
'No entry found for "{}" in registry, fallback.'.format(name))
return self._old[name]
else:
raise AttributeError('Cannot find name "{}".'.format(name))
class Module(object):
"""Mocking module class for name dispatching.
It will register primitives from :mod:`minpy.array_variant`.
Parameters
----------
old : dict
A meta class including info such as name, path, etc.
name : None, or str
Second level name if specified.
name_injector : dict, or dict-like object
An optional dict provides manual dispatching
"""
def __init__(self, old, name=None, name_injector=None):
# pylint: disable= protected-access, cell-var-from-loop
# Add module itself into global config
minpy.Config['modules'].append(self)
self._registry = Registry(old['__name__'])
self._policy = minpy.Config['default_policy']
self._logger = log.get_logger(old['__name__'])
self._logger.info('Initialize module: %s.', old['__name__'])
self._old = old
self._name_injector = name_injector if name_injector else {}
if len(self._name_injector) != 0:
self._logger.info('Inject Name Injector %s', name_injector.__name__)
for vname in variants:
vtype = variants[vname]
if name is None:
modname = 'minpy.array_variants.{}'.format(vname)
else:
modname = 'minpy.array_variants.{}.{}'.format(vname, name)
mod = importlib.import_module(modname)
self._logger.info('Importing from %s.', modname)
primitive_wrapper = lambda func, *args, **kwargs:\
Primitive(func, vtype, *args, **kwargs)
# Register all primitives of the module.
before = len(self._registry._reg)
mod.register_primitives(self._registry, primitive_wrapper)
self._logger.info('Got %d primitives from %s',
len(self._registry._reg) - before, modname)
primitive_getter = lambda name: self._registry.get(name, vtype)
# Define gradients of primitives.
mod.def_grads(primitive_getter)
self._logger.info('Import %d primitives', len(self._registry._reg))
self._set_attrs()
# pylint: enable= protected-access, cell-var-from-loop
def set_policy(self, plc):
"""Set name dispatch policy.
Parameters
----------
plc
New policy.
"""
assert isinstance(
plc, Policy), 'Need an instance of `minpy.dispatch.policy.Policy`.'
self._policy = plc
@property
def policy(self):
"""Get policy of current module"""
return self._policy
def _set_attrs(self):
"""Set attributes for this module"""
# The latter will override the former, so set attributes in reverse priority order
for k, val in self._old.items():
setattr(self, k, val)
for k in self._name_injector.keys():
setattr(self, k, self._name_injector[k])
for k in self._registry._reg: # pylint: disable= protected-access
fun = PrimitiveSelector(k, self)
setattr(self, k, fun)
if '__all__' in dir(self._old):
setattr(self, '__all__', self._old.__all__)
setattr(self, '__registry__', self._registry)
class Module(object):
"""Mocking module class for name dispatching.
It will register primitives from :mod:`minpy.array_variant`.
Parameters
----------
old : dict
A meta class including info such as name, path, etc.
name : None, or str
Second level name if specified.
name_injector : dict, or dict-like object
An optional dict provides manual dispatching
"""
def __init__(self, old, name=None, name_injector=None):
# pylint: disable= protected-access, cell-var-from-loop
# Add module itself into global config
minpy.Config['modules'].append(self)
self._registry = Registry(old['__name__'])
self._logger = log.get_logger(old['__name__'])
self._logger.info('Initialize module: %s.', old['__name__'])
self._old = old
self._name_injector = name_injector if name_injector else {}
if len(self._name_injector) != 0:
self._logger.info('Inject Name Injector %s', name_injector.__name__)
for vname in variants:
vtype = variants[vname]
if name is None:
modname = 'minpy.array_variants.{}'.format(vname)
else:
modname = 'minpy.array_variants.{}.{}'.format(vname, name)
mod = importlib.import_module(modname)
self._logger.info('Importing from %s.', modname)
primitive_wrapper = lambda func, *args, **kwargs:\
Primitive(func, vtype, *args, **kwargs)
# Register all primitives of the module.
before = len(self._registry._reg)
mod.register_primitives(self._registry, primitive_wrapper)
self._logger.info('Got %d primitives from %s',
len(self._registry._reg) - before, modname)
primitive_getter = lambda name: self._registry.get(name, vtype)
# Define gradients of primitives.
mod.def_grads(primitive_getter)
self._logger.info('Import %d primitives', len(self._registry._reg))
self.generate_attrs(minpy.Config['default_policy'])
# pylint: enable= protected-access, cell-var-from-loop
def set_policy(self, policy):
"""[Deprecated] Set policy for this module."""
self.generate_attrs(policy)
def generate_attrs(self, policy):
"""Generate attributes for this module"""
# The latter will override the former, so set attributes in reverse priority order
for k, val in self._old.items():
setattr(self, k, val)
for k in self._name_injector.keys():
setattr(self, k, self._name_injector[k])
for k, prims in self._registry._reg.items(): # pylint: disable= protected-access
prim_type = policy.decide(prims.values())
if prim_type is not None:
setattr(self, k, prims[prim_type])
if '__all__' in dir(self._old):
setattr(self, '__all__', self._old.__all__)
setattr(self, '__registry__', self._registry)
class Module(object):
"""Mocking module class for name dispatching.
It will register primitives from :mod:`minpy.array_variant`.
"""
def __init__(self, old, name=None):
# Add module itself into global config
minpy.Config['modules'].append(self)
self._registry = Registry()
self._policy = minpy.Config['default_policy']
self._logger = log.get_logger(old['__name__'])
self._logger.info('Initialize module: {}.'.format(old['__name__']))
self._old = old
for vname in variants:
if name is None:
modname = 'minpy.array_variants.{}'.format(vname)
else:
modname = 'minpy.array_variants.{}.{}'.format(vname, name)
mod = importlib.import_module(modname)
self._logger.info('Importing from {}.'.format(modname))
primitive_wrapper = lambda func, *args, **kwargs:\
Primitive(func, variants[vname], *args, **kwargs)
# Register all primitives of the module.
before = len(self._registry._reg)
mod.register_primitives(self._registry, primitive_wrapper)
self._logger.info('Got {} primitives from {}'.format(
len(self._registry._reg) - before, modname))
primitive_getter = lambda name: self._registry.get(
name, variants[vname])
# Define gradients of primitives.
mod.def_grads(self._registry, primitive_getter)
self._logger.info('Import {} primitives'.format(
len(self._registry._reg)))
def set_policy(self, plc):
"""Set name dispatch policy.
:param plc: New policy.
"""
assert isinstance(
plc, Policy), 'Need an instance of `minpy.dispatch.policy.Policy`.'
self._policy = plc
def __getattr__(self, name):
"""Fetch attributes from this module.
If the name is contained in the primitive registry,
it will return a primitive selector for further name dispatching.
:param name: Name of attribute.
:return: Primitive selector.
:raises AttributeError: Cannot find attribute.
"""
# Special members for internal use.
if name == '__registry__':
return self._registry
elif name == '__all__':
return self._old.__all__
elif self._registry.has_name(name):
return PrimitiveSelector(name, self._registry, self._policy)
elif name in self._old:
self._logger.info(
'No entry found for "{}" in registry, fallback.'.format(name))
return self._old[name]
else:
raise AttributeError('Cannot find name "{}".'.format(name))
class Module(object):
"""Mocking module class for name dispatching.
It will register primitives from :mod:`minpy.array_variant`.
Parameters
----------
old : dict
A meta class including info such as name, path, etc.
name : None, or str
Second level name if specified.
name_injector : dict, or dict-like object
An optional dict provides manual dispatching
"""
def __init__(self, old, name=None, name_injector=None):
# pylint: disable= protected-access, cell-var-from-loop
# Add module itself into global config
minpy.Config['modules'].append(self)
self._registry = Registry(old['__name__'])
self._logger = log.get_logger(old['__name__'])
self._logger.info('Initialize module: %s.', old['__name__'])
self._old = old
self._name_injector = name_injector if name_injector else {}
if len(self._name_injector) != 0:
self._logger.info('Inject Name Injector %s', name_injector.__name__)
for vname in variants:
vtype = variants[vname]
if name is None:
modname = 'minpy.array_variants.{}'.format(vname)
else:
modname = 'minpy.array_variants.{}.{}'.format(vname, name)
mod = importlib.import_module(modname)
self._logger.info('Importing from %s.', modname)
primitive_wrapper = lambda func, *args, **kwargs:\
Primitive(func, vtype, *args, **kwargs)
# Register all primitives of the module.
before = len(self._registry._reg)
mod.register_primitives(self._registry, primitive_wrapper)
self._logger.info('Got %d primitives from %s',
len(self._registry._reg) - before, modname)
primitive_getter = lambda name: self._registry.get(name, vtype)
# Define gradients of primitives.
mod.def_grads(primitive_getter)
self._logger.info('Import %d primitives', len(self._registry._reg))
self.generate_attrs(minpy.Config['default_policy'])
# pylint: enable= protected-access, cell-var-from-loop
def set_policy(self, policy):
"""[Deprecated] Set policy for this module."""
self.generate_attrs(policy)
def record_op_stat(self):
"""Record Op Calling Statistics"""
self.generate_attrs(self.policy, True)
def show_op_stat(self):
"""Show Op Calling Statistics"""
self.policy.show_op_stat()
def generate_attrs(self, policy, use_selector=False):
"""Generate attributes for this module"""
self.policy = policy
# The latter will override the former, so set attributes in reverse priority order
for k, val in self._old.items():
setattr(self, k, val)
for k in self._name_injector.keys():
setattr(self, k, self._name_injector[k])
for k, prims in self._registry._reg.items(): # pylint: disable= protected-access
if not use_selector:
prim_type = self.policy.decide(prims.values())
if prim_type is not None:
setattr(self, k, prims[prim_type])
else:
fun = PrimitiveSelector(k, self)
setattr(self, k, fun)
if '__all__' in dir(self._old):
setattr(self, '__all__', self._old.__all__)
setattr(self, '__registry__', self._registry)
