def from_config(cls: Type[T],
config_dict: Dict,
merge_default: bool = True) -> T:
"""
Instantiate a new instance of this class given the configuration
JSON-compliant dictionary encapsulating initialization arguments.
:param config_dict: JSON compliant dictionary encapsulating
a configuration.
:type config_dict: dict
:param merge_default: Merge the given configuration on top of the
default provided by ``get_default_config``.
:type merge_default: bool
:return: Constructed instance from the provided config.
:rtype: MemoryKeyValueStore
"""
# Copy top-level of config in order to not modify input instance.
c = config_dict.copy()
# Simplify specification for "no cache element"
if 'cache_element' not in c or \
c['cache_element'] is None or \
c['cache_element']['type'] is None:
c['cache_element'] = None
else:
# Create from nested config.
c['cache_element'] = \
from_config_dict(config_dict['cache_element'],
DataElement.get_impls())
return super(MemoryKeyValueStore, cls).from_config(c)
def from_config(cls: Type[T],
config_dict: Dict,
merge_default: bool = True) -> T:
if merge_default:
config_dict = merge_dict(cls.get_default_config(), config_dict)
data_elem_impl_set = DataElement.get_impls()
# Translate prototext and model sub-configs into DataElement instances.
config_dict['network_prototxt'] = \
from_config_dict(config_dict['network_prototxt'],
data_elem_impl_set)
config_dict['network_model'] = \
from_config_dict(config_dict['network_model'],
data_elem_impl_set)
# Translate optionally provided image mean sub-config into a
# DataElement instance. May have been provided as ``None`` or a
# configuration dictionary with type ``None`.
# None, dict[type=None], dict[type=str]
if config_dict['image_mean'] is None \
or config_dict['image_mean'].get('type', None) is None:
config_dict['image_mean'] = None
else:
config_dict['image_mean'] = \
from_config_dict(config_dict['image_mean'], data_elem_impl_set)
return super(CaffeDescriptorGenerator,
cls).from_config(config_dict, merge_default=False)
def get_default_config(cls) -> Dict[str, Any]:
"""
Generate and return a default configuration dictionary for this class.
This will be primarily used for generating what the configuration
dictionary would look like for this class without instantiating it.
By default, we observe what this class's constructor takes as
arguments, turning those argument names into configuration dictionary
keys. If any of those arguments have defaults, we will add those
values into the configuration dictionary appropriately. The dictionary
returned should only contain JSON compliant value types.
It is not be guaranteed that the configuration dictionary returned
from this method is valid for construction of an instance of this
class.
:return: Default configuration dictionary for the class.
"""
default = super(FaissNearestNeighborsIndex, cls).get_default_config()
data_element_default_config = \
make_default_config(DataElement.get_impls())
default['index_element'] = data_element_default_config
default['index_param_element'] = deepcopy(data_element_default_config)
di_default = make_default_config(DescriptorSet.get_impls())
default['descriptor_set'] = di_default
kvs_default = make_default_config(KeyValueStore.get_impls())
default['idx2uid_kvs'] = kvs_default
default['uid2idx_kvs'] = deepcopy(kvs_default)
return default
def from_config(
cls: Type[MDS],
config_dict: Dict,
merge_default: bool = True
) -> MDS:
"""
Instantiate a new instance of this class given the configuration
JSON-compliant dictionary encapsulating initialization arguments.
:param config_dict: JSON compliant dictionary encapsulating
a configuration.
:param merge_default: Merge the given configuration on top of the
default provided by ``get_default_config``.
:return: Constructed instance from the provided config.
"""
if merge_default:
config_dict = merge_dict(cls.get_default_config(), config_dict)
# Optionally construct cache element from sub-config.
if config_dict['cache_element'] \
and config_dict['cache_element']['type']:
e = from_config_dict(config_dict['cache_element'],
DataElement.get_impls())
config_dict['cache_element'] = e
else:
config_dict['cache_element'] = None
return super(MemoryDescriptorSet, cls).from_config(config_dict, False)
def from_config(cls: Type[T_IF],
config_dict: Dict,
merge_default: bool = True) -> T_IF:
"""
Instantiate a new instance of this class given the JSON-compliant
configuration dictionary encapsulating initialization arguments.
:param config_dict: JSON compliant dictionary encapsulating
a configuration.
:param merge_default: Merge the given configuration on top of the
default provided by ``get_default_config``.
:return: Constructed instance from the provided config.
"""
if merge_default:
config_dict = merge_dict(cls.get_default_config(), config_dict)
data_element_impls = DataElement.get_impls()
# Mean vector cache element.
mean_vec_cache = None
if config_dict['mean_vec_cache'] and \
config_dict['mean_vec_cache']['type']:
mean_vec_cache = from_config_dict(config_dict['mean_vec_cache'],
data_element_impls)
config_dict['mean_vec_cache'] = mean_vec_cache
# Rotation matrix cache element.
rotation_cache = None
if config_dict['rotation_cache'] and \
config_dict['rotation_cache']['type']:
rotation_cache = from_config_dict(config_dict['rotation_cache'],
data_element_impls)
config_dict['rotation_cache'] = rotation_cache
return super(ItqFunctor, cls).from_config(config_dict, False)
def get_config(self) -> Dict[str, Any]:
# Recursively get config from data element if we have one.
if self._cache_element is not None:
elem_config = to_config_dict(self._cache_element)
else:
# No cache element, output default config with no type.
elem_config = make_default_config(DataElement.get_impls())
return {'cache_element': elem_config}
def from_config(cls: Type[T_FNNI],
config_dict: Dict,
merge_default: bool = True) -> T_FNNI:
"""
Instantiate a new instance of this class given the configuration
JSON-compliant dictionary encapsulating initialization arguments.
This method should not be called via super unless and instance of the
class is desired.
:param config_dict: JSON compliant dictionary encapsulating
a configuration.
:param merge_default: Merge the given configuration on top of the
default provided by ``get_default_config``.
:return: Constructed instance from the provided config.
"""
if merge_default:
cfg = cls.get_default_config()
merge_dict(cfg, config_dict)
else:
cfg = config_dict
cfg['descriptor_set'] = from_config_dict(cfg['descriptor_set'],
DescriptorSet.get_impls())
cfg['uid2idx_kvs'] = from_config_dict(cfg['uid2idx_kvs'],
KeyValueStore.get_impls())
cfg['idx2uid_kvs'] = from_config_dict(cfg['idx2uid_kvs'],
KeyValueStore.get_impls())
if (cfg['index_element'] and cfg['index_element']['type']):
index_element = from_config_dict(cfg['index_element'],
DataElement.get_impls())
cfg['index_element'] = index_element
else:
cfg['index_element'] = None
if (cfg['index_param_element'] and cfg['index_param_element']['type']):
index_param_element = from_config_dict(cfg['index_param_element'],
DataElement.get_impls())
cfg['index_param_element'] = index_param_element
else:
cfg['index_param_element'] = None
return super(FaissNearestNeighborsIndex, cls).from_config(cfg, False)
def __setstate__(self, state: Mapping[str, Any]) -> None:
# This ``__dict__.update`` works because configuration parameters
# exactly match up with instance attributes currently.
self.__dict__.update(state)
# Translate nested Configurable instance configurations into actual
# object instances.
self.network_prototxt = from_config_dict(state["network_prototxt"],
DataElement.get_impls())
# noinspection PyTypeChecker
self.network_model = from_config_dict(state["network_model"],
DataElement.get_impls())
state_image_mean = state["image_mean"]
if state_image_mean is not None:
# noinspection PyTypeChecker
self.image_mean = from_config_dict(state_image_mean,
DataElement.get_impls())
self._setup_network()
def get_default_config(cls) -> Dict[str, Any]:
default = super(CaffeDescriptorGenerator, cls).get_default_config()
data_elem_impl_set = DataElement.get_impls()
# Need to make copies of dict so changes to one does not effect others.
default['network_prototxt'] = \
make_default_config(data_elem_impl_set)
default['network_model'] = make_default_config(data_elem_impl_set)
default['image_mean'] = make_default_config(data_elem_impl_set)
return default
def get_default_config(cls) -> Dict[str, Any]:
default = super(ItqFunctor, cls).get_default_config()
# Cache element parameters need to be split out into sub-configurations
data_element_default_config = \
make_default_config(DataElement.get_impls())
default['mean_vec_cache'] = data_element_default_config
# Need to deepcopy source to prevent modifications on one sub-config
# from reflecting in the other.
default['rotation_cache'] = deepcopy(data_element_default_config)
return default
def from_config(cls: Type[T],
config_dict: Dict,
merge_default: bool = True) -> T:
if merge_default:
config_dict = merge_dict(cls.get_default_config(), config_dict)
cache_element = None
if config_dict['cache_element'] and config_dict['cache_element'][
'type']:
cache_element = from_config_dict(config_dict['cache_element'],
DataElement.get_impls())
config_dict['cache_element'] = cache_element
return super(DataMemorySet, cls).from_config(config_dict, False)
def get_default_config(cls) -> Dict[str, Any]:
"""
Generate and return a default configuration dictionary for this class.
This will be primarily used for generating what the configuration
dictionary would look like for this class without instantiating it.
It is not be guaranteed that the configuration dictionary returned
from this method is valid for construction of an instance of this class.
:return: Default configuration dictionary for the class.
:rtype: dict
"""
default = super(MemoryKeyValueStore, cls).get_default_config()
default['cache_element'] = make_default_config(DataElement.get_impls())
return default
def get_default_config(cls) -> Dict[str, Any]:
"""
Generate and return a default configuration dictionary for this class.
This will be primarily used for generating what the configuration
dictionary would look like for this class without instantiating it.
By default, we observe what this class's constructor takes as arguments,
turning those argument names into configuration dictionary keys. If any
of those arguments have defaults, we will add those values into the
configuration dictionary appropriately. The dictionary returned should
only contain JSON compliant value types.
It is not be guaranteed that the configuration dictionary returned
from this method is valid for construction of an instance of this class.
:return: Default configuration dictionary for the class.
"""
c = super(MemoryDescriptorSet, cls).get_default_config()
c['cache_element'] = make_default_config(DataElement.get_impls())
return c
def from_config(
cls: Type[T],
config_dict: Dict,
merge_default: bool = True
) -> T:
"""
Instantiate a new instance of this class given the configuration
JSON-compliant dictionary encapsulating initialization arguments.
This method should not be called via super unless an instance of the
class is desired.
:param config_dict: JSON compliant dictionary encapsulating
a configuration.
:type config_dict: dict
:param merge_default: Merge the given configuration on top of the
default provided by ``get_default_config``.
:type merge_default: bool
:return: Constructed instance from the provided config.
:rtype: SkLearnBallTreeHashIndex
"""
if merge_default:
config_dict = merge_dict(cls.get_default_config(), config_dict)
# Parse ``cache_element`` configuration if set.
cache_element = None
if config_dict['cache_element'] and \
config_dict['cache_element']['type']:
cache_element = \
from_config_dict(config_dict['cache_element'],
DataElement.get_impls())
config_dict['cache_element'] = cache_element
return super(SkLearnBallTreeHashIndex, cls).from_config(config_dict,
False)
