def __call__(self, **params): p = ParamOverrides(self, params) measured_sheets = [s for s in topo.sim.objects(CFSheet).values() if hasattr(s,'measure_maps') and s.measure_maps] results = AttrTree() # Could easily be extended to measure CoG of all projections # and e.g. register them using different names (e.g. "Afferent # XCoG"), but then it's not clear how the PlotGroup would be # able to find them automatically (as it currently supports # only a fixed-named plot). requested_proj=p.proj_name for sheet in measured_sheets: for proj in sheet.in_connections: if (proj.name == requested_proj) or \ (requested_proj == '' and (proj.src != sheet)): cog_data = self._update_proj_cog(p, proj) for key, data in cog_data.items(): name = proj.name[0].upper() + proj.name[1:] results.set_path((key, name), data) if p.measurement_storage_hook: p.measurement_storage_hook(results) return results
def __init__(self, **params): """ Initialize this object as an EventProcessor, then also as a SheetCoordinateSystem with equal xdensity and ydensity. views is an AttrTree, which stores associated measurements, i.e. representations of the sheet for use by analysis or plotting code. """ EventProcessor.__init__(self, **params) # Initialize this object as a SheetCoordinateSystem, with # the same density along y as along x. SheetCoordinateSystem.__init__(self, self.nominal_bounds, self.nominal_density) n_units = round((self.lbrt[2] - self.lbrt[0]) * self.xdensity, 0) if n_units < 1: raise ValueError( "Sheet bounds and density must be specified such that the "+ \ "sheet has at least one unit in each direction; " \ +self.name+ " does not.") # setup the activity matrix self.activity = zeros(self.shape, activity_type) # For non-plastic inputs self.__saved_activity = [] self._plasticity_setting_stack = [] self.views = AttrTree() self.views.Maps = AttrTree() self.views.Curves = AttrTree()
def __call__(self, **params): p = ParamOverrides(self, params) measured_sheets = [ s for s in topo.sim.objects(CFSheet).values() if hasattr(s, 'measure_maps') and s.measure_maps ] results = AttrTree() # Could easily be extended to measure CoG of all projections # and e.g. register them using different names (e.g. "Afferent # XCoG"), but then it's not clear how the PlotGroup would be # able to find them automatically (as it currently supports # only a fixed-named plot). requested_proj = p.proj_name for sheet in measured_sheets: for proj in sheet.in_connections: if (proj.name == requested_proj) or \ (requested_proj == '' and (proj.src != sheet)): cog_data = self._update_proj_cog(p, proj) for key, data in cog_data.items(): name = proj.name[0].upper() + proj.name[1:] results.set_path((key, name), data) if p.measurement_storage_hook: p.measurement_storage_hook(results) return results
def __init__(self, model, properties): self.training_patterns = AttrTree() self.sheets = AttrTree() self.projections = AttrTree() self._instantiated = False self.properties = properties super(ModelSpec, self).__init__(model) self.model = model
def __init__(self, setup_options=True, register=True, time_dependent=True, **params): numbergen.TimeAware.time_dependent = time_dependent if register: self._register_global_params(params) super(Model,self).__init__(**params) self._sheet_types = {} self._projection_types = {} self.attrs = AttrTree() self.training_patterns = AttrTree() self.sheets = AttrTree() self.projections = AttrTree() self.setup(setup_options)
def load(self, path_filters=[], merge=True): """ Load and filter the file contents for the selected parameter space. If merge is set to True all AttrTrees are merged, otherwise an NdMapping containing all the AttrTrees is returned. """ constant_dims = self.constant_dims ndmapping = NdMapping(dimensions=self.dimensions) for key, filename in self.items(): file_data = self.filetype.data(filename) attrtree = self._filter_attrtree(file_data[self.filetype.data_key], path_filters) if merge: dim_keys = zip(self.dimension_labels, key) varying_keys = [(d, k) for d, k in dim_keys if d not in constant_dims] constant_keys = [(d, k) for d, k in dim_keys if d in constant_dims] attrtree = self._add_dimensions(attrtree, varying_keys, dict(constant_keys)) ndmapping[key] = attrtree if merge: return AttrTree.merge(ndmapping.values()) return ndmapping
def __call__(self): """ Calls the collector specified by the user in the run_batch context. Invoked as an analysis function by RunBatchCommand. """ from dataviews.collector import AttrTree self.collector.interval_hook = topo.sim.run topo_time = topo.sim.time() filename = '%s%s_%s' % (self._info.batch_name, ('[%s]' % self._info.batch_tag if self._info.batch_tag else ''), topo_time) viewtree = AttrTree() viewtree = self.collector(viewtree, times=[topo_time]) spec_metadata = [(key, self._info.specs[key]) for key in self.metadata if '.' not in key] path_metadata = [(key, viewtree.path_items.get(tuple(key.split('.')), float('nan'))) for key in self.metadata if '.' in key] ViewFile(directory=param.normalize_path.prefix, hash_suffix=False).save( filename, viewtree, metadata=dict(spec_metadata + path_metadata + [('time', topo_time)]))
def load(self, path_filters=[], merge=True): """ Load and filter the file contents for the selected parameter space. If merge is set to True all AttrTrees are merged, otherwise an NdMapping containing all the AttrTrees is returned. """ constant_dims = self.constant_dims ndmapping = NdMapping(dimensions=self.dimensions) for key, filename in self.items(): file_data = self.filetype.data(filename) attrtree = self._filter_attrtree(file_data[self.filetype.data_key], path_filters) if merge: dim_keys = zip(self.dimension_labels, key) varying_keys = [(d, k) for d, k in dim_keys if d not in constant_dims] constant_keys = [(d, k) for d, k in dim_keys if d in constant_dims] attrtree = self._add_dimensions(attrtree, varying_keys, dict(constant_keys)) ndmapping[key] = attrtree if merge: return AttrTree.merge(ndmapping.values()) return ndmapping
def _filter_attrtree(self, attrtree, path_filters): """ Filters the loaded AttrTree using the supplied path_filters. """ if not path_filters: return attrtree # Convert string path filters path_filters = [tuple(pf.split('.')) if not isinstance(pf, tuple) else pf for pf in path_filters] # Search for substring matches between paths and path filters new_attrtree = AttrTree() for path, item in attrtree.path_items.items(): if any([all([subpath in path for subpath in pf]) for pf in path_filters]): new_attrtree.set_path(path, item) return new_attrtree
def __init__(self, register=True, time_dependent=True, **params): numbergen.TimeAware.time_dependent = time_dependent if register: self._register_global_params(params) super(Model, self).__init__(**params) self.specification = None self.properties = {} # Training patterns need to be accessed by GeneratorSheets self.properties['training_patterns'] = AttrTree()
def _filter_attrtree(self, attrtree, path_filters): """ Filters the loaded AttrTree using the supplied path_filters. """ if not path_filters: return attrtree # Convert string path filters path_filters = [ tuple(pf.split('.')) if not isinstance(pf, tuple) else pf for pf in path_filters ] # Search for substring matches between paths and path filters new_attrtree = AttrTree() for path, item in attrtree.path_items.items(): if any([ all([subpath in path for subpath in pf]) for pf in path_filters ]): new_attrtree.set_path(path, item) return new_attrtree
def __init__(self, initialize_cfs=True, **params): """ Initialize the Projection with a set of cf_type objects (typically ConnectionFields), each located at the location in the source sheet corresponding to the unit in the target sheet. The cf_type objects are stored in the 'cfs' array. The nominal_bounds_template specified may be altered: the bounds must be fitted to the Sheet's matrix, and the weights matrix must have odd dimensions. These altered bounds are passed to the individual connection fields. A mask for the weights matrix is constructed. The shape is specified by cf_shape; the size defaults to the size of the nominal_bounds_template. """ super(CFProjection, self).__init__(**params) self.weights_generator.set_dynamic_time_fn(None, sublistattr='generators') # get the actual bounds_template by adjusting a copy of the # nominal_bounds_template to ensure an odd slice, and to be # cropped to sheet if necessary self._slice_template = Slice(copy(self.nominal_bounds_template), self.src, force_odd=True, min_matrix_radius=self.min_matrix_radius) self.bounds_template = self._slice_template.compute_bounds(self.src) self.mask_template = _create_mask(self.cf_shape, self.bounds_template, self.src, self.autosize_mask, self.mask_threshold) self.n_units = self._calc_n_units() if initialize_cfs: self._create_cfs() if self.apply_output_fns_init: self.apply_learn_output_fns(active_units_mask=False) ### JCALERT! We might want to change the default value of the ### input value to self.src.activity; but it fails, raising a ### type error. It probably has to be clarified why this is ### happening self.input_buffer = None self.activity = np.array(self.dest.activity) if 'cfs' not in self.dest.views: self.dest.views.CFs = AttrTree() self.dest.views.CFs[self.name] = self._cf_grid()
def __init__(self, setup_options=True, register=True, time_dependent=True, **params): numbergen.TimeAware.time_dependent = time_dependent if register: self._register_global_params(params) super(Model, self).__init__(**params) self._sheet_types = {} self._projection_types = {} self.attrs = AttrTree() self.training_patterns = AttrTree() self.sheets = AttrTree() self.projections = AttrTree() self.setup(setup_options)
def _reset_views(sheet): if hasattr(sheet.views,'Maps'): sheet.views.Maps = AttrTree() if hasattr(sheet.views,'Curves'): sheet.views.Curves = AttrTree()
class Model(param.Parameterized): """ The available setup options are: :'training_patterns': fills the training_patterns AttrTree with pattern generator instances. The path is the name of the input sheet. Usually calls PatternCoordinator to do this. :'setup_sheets': determines the number of sheets, their types and names sets sheet parameters according to the registered methods in level sets sheet matchconditions according to the registered methods in matchconditions :'projections': determines which connections should be present between the sheets according to the matchconditions of SheetSpec objects, using connect to specify the connection type and sets their parameters according to the registered methods in connect The available instantiate options are: :'sheets': instantiates all sheets and registers them in topo.sim :'projections': instantiates all projections and registers them in topo.sim """ __abstract = True matchconditions = MatchConditions() sheet_decorators = set() projection_decorators = set() @classmethod def register_decorator(cls, object_type): name = object_type.name decorator = ClassDecorator(name, object_type) setattr(cls, name, decorator) if issubclass(object_type, topo.sheet.Sheet): cls.sheet_decorators.add(decorator) if issubclass(object_type, topo.projection.Projection): cls.projection_decorators.add(decorator) @classmethod def _collect(cls, decorators, name): """ Given a list of ClassDecorators (e.g self.sheet_decorators or self.projection_decorators), collate the named attribute (i.e. 'types' or 'labels') across the decorators according to priority. """ flattened = [el for d in decorators for el in getattr(d, name).items()] return dict((k,v) for (k, (_, v)) in sorted(flattened, key=lambda x: x[1][0])) @property def sheet_labels(self): "The mapping of level method to corresponding label" return self._collect(self.sheet_decorators, 'labels') @property def sheet_types(self): "The mapping of level label to sheet type" return self._collect(self.sheet_decorators, 'types') @property def projection_labels(self): "The mapping of projection method to corresponding label" return self._collect(self.projection_decorators, 'labels') @property def projection_types(self): "The mapping of projection label to projection type" return self._collect(self.projection_decorators, 'types') @property def modified_parameters(self): "Dictionary of modified model parameters" return {k:v for k,v in self.get_param_values(onlychanged=True)} def __init__(self, setup_options=True, register=True, time_dependent=True, **params): numbergen.TimeAware.time_dependent = time_dependent if register: self._register_global_params(params) super(Model,self).__init__(**params) self._sheet_types = {} self._projection_types = {} self.attrs = AttrTree() self.training_patterns = AttrTree() self.sheets = AttrTree() self.projections = AttrTree() self.setup(setup_options) def _register_global_params(self, params): """ Register the parameters of this object as global parameters available for users to set from the command line. Values supplied as global parameters will override those of the given dictionary of params. """ for name,obj in self.params().items(): global_params.add(**{name:obj}) for name,val in params.items(): global_params.params(name).default=val params.update(global_params.get_param_values()) params["name"]=self.name #==============================================# # Public methods to be implemented by modelers # #==============================================# def setup_attributes(self, attrs): """ Method to precompute any useful attributes from the class parameters. For instance, if there is a ``num_lags`` parameter, this method could compute the actual projection delays and store it as attrs.lags. The return value is the updated attrs AttrTree. In addition, this method can be used to configure class attributes of the model components. """ return attrs def setup_training_patterns(self, **overrides): """ Returns a dictionary of PatternGenerators to be added to self.training_patterns, with the target sheet name keys and pattern generator values. The overrides keywords can be used by a subclass to parameterize the training patterns e.g. override the default parameters of a PatternCoordinator object. """ raise NotImplementedError def setup_sheets(self): """ Returns a dictionary of properties or equivalent Lancet.Args object. Each outer key must be the level name and the values are lists of property dictionaries for the sheets at that level (or equivalent Lancet Args object). For instance, two LGN sheets at the 'LGN' level could be defined by either: {'LGN':[{'polarity':'ON'}, {'polarity':'OFF'}]} OR {'LGN':lancet.List('polarity', ['ON', 'OFF'])} The specified properties are used to initialize the sheets AttrTree with SheetSpec objects. """ raise NotImplementedError def setup_analysis(self): """ Set up appropriate defaults for analysis functions in topo.analysis.featureresponses. """ pass #====================================================# # Remaining methods should not need to be overridden # #====================================================# def setup(self,setup_options): """ This method can be used to setup certain parts of the submodel. If setup_options=True, all setup methods are called. setup_options can also be a list, whereas all list items of available_setup_options are accepted. Available setup options are: 'training_patterns','sheets','projections' and 'analysis'. Please consult the docstring of the Model class for more information about each setup option. """ available_setup_options = ['attributes', 'training_patterns', 'sheets', 'projections', 'analysis'] if setup_options==True: setup_options = available_setup_options if 'attributes' in setup_options: self.attrs = self.setup_attributes(self.attrs) if 'training_patterns' in setup_options: training_patterns = self.setup_training_patterns() for name, training_pattern in training_patterns.items(): self.training_patterns.set_path(name, training_pattern) if 'sheets' in setup_options: sheet_properties = self.setup_sheets() enumeration = enumerate(sheet_properties.items()) for (ordering, (level, property_list)) in enumeration: sheet_type = self.sheet_types[level] if isinstance(property_list, lancet.Identity): property_list = [{}] elif isinstance(property_list, lancet.Args): property_list = property_list.specs # If an empty list or Args() elif not property_list: continue for properties in property_list: spec_properties = dict(level=level, **properties) sheet_spec = SheetSpec(sheet_type, spec_properties) sheet_spec.sort_precedence = ordering self.sheets.set_path(str(sheet_spec), sheet_spec) self._update_sheet_spec_parameters() if 'projections' in setup_options: self._compute_projection_specs() if 'analysis' in setup_options: self._setup_analysis() def _update_sheet_spec_parameters(self): for sheet_spec in self.sheets.path_items.values(): param_method = self.sheet_labels.get(sheet_spec.level, None) if not param_method: raise Exception("Parameters for sheet level %r not specified" % sheet_spec.level) updated_params = param_method(self,sheet_spec.properties) sheet_spec.update(**updated_params) def _matchcondition_holds(self, matchconditions, src_sheet): """ Given a dictionary of properties to match and a target sheet spec, return True if the matchcondition holds else False. """ matches=True if matchconditions is None: return False for incoming_key, incoming_value in matchconditions.items(): if incoming_key in src_sheet.properties and \ str(src_sheet.properties[incoming_key]) not in str(incoming_value): matches=False break return matches def _compute_projection_specs(self): """ Loop through all possible combinations of SheetSpec objects in self.sheets If the src_sheet fulfills all criteria specified in dest_sheet.matchconditions, create a new ProjectionSpec object and add this item to self.projections. """ sheetspec_product = itertools.product(self.sheets.path_items.values(), self.sheets.path_items.values()) for src_sheet, dest_sheet in sheetspec_product: has_matchcondition = (dest_sheet.level in self.matchconditions) conditions = (self.matchconditions.compute_conditions( dest_sheet.level, self,dest_sheet.properties) if has_matchcondition else {}) for matchname, matchconditions in conditions.items(): if self._matchcondition_holds(matchconditions, src_sheet): proj = ProjectionSpec(self.projection_types[matchname], src_sheet, dest_sheet) paramsets = self.projection_labels[matchname](self, src_sheet.properties, dest_sheet.properties) paramsets = [paramsets] if isinstance(paramsets, dict) else paramsets for paramset in paramsets: proj = ProjectionSpec(self.projection_types[matchname], src_sheet, dest_sheet) proj.update(**paramset) # Only used when time_dependent=False # (which is to be deprecated) proj.matchname = matchname path = (str(dest_sheet), paramset['name']) self.projections.set_path(path, proj) def __call__(self,instantiate_options=True, verbose=False): """ Instantiates all sheets or projections in self.sheets or self.projections and registers them in the topo.sim instance. If instantiate_options=True, all items are initialised instantiate_options can also be a list, whereas all list items of available_instantiate_options are accepted. Available instantiation options are: 'sheets' and 'projections'. Please consult the docstring of the Model class for more information about each instantiation option. """ msglevel = self.message if verbose else self.debug available_instantiate_options = ['sheets','projections'] if instantiate_options==True: instantiate_options=available_instantiate_options if 'sheets' in instantiate_options: for sheet_spec in self.sheets.path_items.itervalues(): msglevel('Level ' + sheet_spec.level + ': Sheet ' + str(sheet_spec)) sheet_spec() if 'projections' in instantiate_options: for proj in sorted(self.projections): msglevel('Match: ' + proj.matchname + ': Connection ' + str(proj.src) + \ '->' + str(proj.dest) + ' ' + proj.parameters['name']) proj() def summary(self, printed=True): heading_line = '=' * len(self.name) summary = [heading_line, self.name, heading_line, ''] for sheet_spec in sorted(self.sheets): summary.append(sheet_spec.summary(printed=False)) projections = [proj for proj in self.projections if str(proj).startswith(str(sheet_spec))] for projection_spec in sorted(projections, key=lambda p: str(p)): summary.append(" " + projection_spec.summary(printed=False)) summary.append('') if printed: print "\n".join(summary) else: return "\n".join(summary) def __str__(self): return self.name def _repr_pretty_(self, p, cycle): p.text(self.summary(printed=False)) def modifications(self, components=['model', 'sheets', 'projections']): """ Display the names of all modified parameters for the specified set of components. By default all modified parameters are listed - first with the model parameters, then the sheet parameters and lastly the projection parameters. """ mapping = {'model': [self], 'sheets':self.sheets, 'projections':self.projections} lines = [] for component in components: heading = "=" * len(component) lines.extend([heading, component.capitalize(), heading, '']) specs = mapping[component] padding = max(len(str(spec)) for spec in specs) for spec in sorted(specs): modified = [str(el) for el in sorted(spec.modified_parameters)] lines.append("%s : [%s]" % (str(spec).ljust(padding), ", ".join(modified))) lines.append('') print "\n".join(lines)
class Model(param.Parameterized): """ The available setup options are: :'training_patterns': fills the training_patterns AttrTree with pattern generator instances. The path is the name of the input sheet. Usually calls PatternCoordinator to do this. :'setup_sheets': determines the number of sheets, their types and names sets sheet parameters according to the registered methods in level sets sheet matchconditions according to the registered methods in matchconditions :'projections': determines which connections should be present between the sheets according to the matchconditions of SheetSpec objects, using connect to specify the connection type and sets their parameters according to the registered methods in connect The available instantiate options are: :'sheets': instantiates all sheets and registers them in topo.sim :'projections': instantiates all projections and registers them in topo.sim """ __abstract = True matchconditions = MatchConditions() sheet_decorators = set() projection_decorators = set() @classmethod def register_decorator(cls, object_type): name = object_type.name decorator = ClassDecorator(name, object_type) setattr(cls, name, decorator) if issubclass(object_type, topo.sheet.Sheet): cls.sheet_decorators.add(decorator) if issubclass(object_type, topo.projection.Projection): cls.projection_decorators.add(decorator) @classmethod def _collect(cls, decorators, name): """ Given a list of ClassDecorators (e.g self.sheet_decorators or self.projection_decorators), collate the named attribute (i.e. 'types' or 'labels') across the decorators according to priority. """ flattened = [el for d in decorators for el in getattr(d, name).items()] return dict( (k, v) for (k, (_, v)) in sorted(flattened, key=lambda x: x[1][0])) @property def sheet_labels(self): "The mapping of level method to corresponding label" return self._collect(self.sheet_decorators, 'labels') @property def sheet_types(self): "The mapping of level label to sheet type" return self._collect(self.sheet_decorators, 'types') @property def projection_labels(self): "The mapping of projection method to corresponding label" return self._collect(self.projection_decorators, 'labels') @property def projection_types(self): "The mapping of projection label to projection type" return self._collect(self.projection_decorators, 'types') @property def modified_parameters(self): "Dictionary of modified model parameters" return {k: v for k, v in self.get_param_values(onlychanged=True)} def __init__(self, setup_options=True, register=True, time_dependent=True, **params): numbergen.TimeAware.time_dependent = time_dependent if register: self._register_global_params(params) super(Model, self).__init__(**params) self._sheet_types = {} self._projection_types = {} self.attrs = AttrTree() self.training_patterns = AttrTree() self.sheets = AttrTree() self.projections = AttrTree() self.setup(setup_options) def _register_global_params(self, params): """ Register the parameters of this object as global parameters available for users to set from the command line. Values supplied as global parameters will override those of the given dictionary of params. """ for name, obj in self.params().items(): global_params.add(**{name: obj}) for name, val in params.items(): global_params.params(name).default = val params.update(global_params.get_param_values()) params["name"] = self.name #==============================================# # Public methods to be implemented by modelers # #==============================================# def setup_attributes(self, attrs): """ Method to precompute any useful attributes from the class parameters. For instance, if there is a ``num_lags`` parameter, this method could compute the actual projection delays and store it as attrs.lags. The return value is the updated attrs AttrTree. In addition, this method can be used to configure class attributes of the model components. """ return attrs def setup_training_patterns(self, **overrides): """ Returns a dictionary of PatternGenerators to be added to self.training_patterns, with the target sheet name keys and pattern generator values. The overrides keywords can be used by a subclass to parameterize the training patterns e.g. override the default parameters of a PatternCoordinator object. """ raise NotImplementedError def setup_sheets(self): """ Returns a dictionary of properties or equivalent Lancet.Args object. Each outer key must be the level name and the values are lists of property dictionaries for the sheets at that level (or equivalent Lancet Args object). For instance, two LGN sheets at the 'LGN' level could be defined by either: {'LGN':[{'polarity':'ON'}, {'polarity':'OFF'}]} OR {'LGN':lancet.List('polarity', ['ON', 'OFF'])} The specified properties are used to initialize the sheets AttrTree with SheetSpec objects. """ raise NotImplementedError def setup_analysis(self): """ Set up appropriate defaults for analysis functions in topo.analysis.featureresponses. """ pass #====================================================# # Remaining methods should not need to be overridden # #====================================================# def setup(self, setup_options): """ This method can be used to setup certain parts of the submodel. If setup_options=True, all setup methods are called. setup_options can also be a list, whereas all list items of available_setup_options are accepted. Available setup options are: 'training_patterns','sheets','projections' and 'analysis'. Please consult the docstring of the Model class for more information about each setup option. """ available_setup_options = [ 'attributes', 'training_patterns', 'sheets', 'projections', 'analysis' ] if setup_options == True: setup_options = available_setup_options if 'attributes' in setup_options: self.attrs = self.setup_attributes(self.attrs) if 'training_patterns' in setup_options: training_patterns = self.setup_training_patterns() for name, training_pattern in training_patterns.items(): self.training_patterns.set_path(name, training_pattern) if 'sheets' in setup_options: sheet_properties = self.setup_sheets() enumeration = enumerate(sheet_properties.items()) for (ordering, (level, property_list)) in enumeration: sheet_type = self.sheet_types[level] if isinstance(property_list, lancet.Identity): property_list = [{}] elif isinstance(property_list, lancet.Args): property_list = property_list.specs # If an empty list or Args() elif not property_list: continue for properties in property_list: spec_properties = dict(level=level, **properties) sheet_spec = SheetSpec(sheet_type, spec_properties) sheet_spec.sort_precedence = ordering self.sheets.set_path(str(sheet_spec), sheet_spec) self._update_sheet_spec_parameters() if 'projections' in setup_options: self._compute_projection_specs() if 'analysis' in setup_options: self._setup_analysis() def _update_sheet_spec_parameters(self): for sheet_spec in self.sheets.path_items.values(): param_method = self.sheet_labels.get(sheet_spec.level, None) if not param_method: raise Exception("Parameters for sheet level %r not specified" % sheet_spec.level) updated_params = param_method(self, sheet_spec.properties) sheet_spec.update(**updated_params) def _matchcondition_holds(self, matchconditions, src_sheet): """ Given a dictionary of properties to match and a target sheet spec, return True if the matchcondition holds else False. """ matches = True if matchconditions is None: return False for incoming_key, incoming_value in matchconditions.items(): if incoming_key in src_sheet.properties and \ str(src_sheet.properties[incoming_key]) not in str(incoming_value): matches = False break return matches def _compute_projection_specs(self): """ Loop through all possible combinations of SheetSpec objects in self.sheets If the src_sheet fulfills all criteria specified in dest_sheet.matchconditions, create a new ProjectionSpec object and add this item to self.projections. """ sheetspec_product = itertools.product(self.sheets.path_items.values(), self.sheets.path_items.values()) for src_sheet, dest_sheet in sheetspec_product: has_matchcondition = (dest_sheet.level in self.matchconditions) conditions = (self.matchconditions.compute_conditions( dest_sheet.level, self, dest_sheet.properties) if has_matchcondition else {}) for matchname, matchconditions in conditions.items(): if self._matchcondition_holds(matchconditions, src_sheet): proj = ProjectionSpec(self.projection_types[matchname], src_sheet, dest_sheet) paramsets = self.projection_labels[matchname]( self, src_sheet.properties, dest_sheet.properties) paramsets = [paramsets] if isinstance(paramsets, dict) else paramsets for paramset in paramsets: proj = ProjectionSpec(self.projection_types[matchname], src_sheet, dest_sheet) proj.update(**paramset) # Only used when time_dependent=False # (which is to be deprecated) proj.matchname = matchname path = (str(dest_sheet), paramset['name']) self.projections.set_path(path, proj) def __call__(self, instantiate_options=True, verbose=False): """ Instantiates all sheets or projections in self.sheets or self.projections and registers them in the topo.sim instance. If instantiate_options=True, all items are initialised instantiate_options can also be a list, whereas all list items of available_instantiate_options are accepted. Available instantiation options are: 'sheets' and 'projections'. Please consult the docstring of the Model class for more information about each instantiation option. """ msglevel = self.message if verbose else self.debug available_instantiate_options = ['sheets', 'projections'] if instantiate_options == True: instantiate_options = available_instantiate_options if 'sheets' in instantiate_options: for sheet_spec in self.sheets.path_items.itervalues(): msglevel('Level ' + sheet_spec.level + ': Sheet ' + str(sheet_spec)) sheet_spec() if 'projections' in instantiate_options: for proj in sorted(self.projections): msglevel('Match: ' + proj.matchname + ': Connection ' + str(proj.src) + \ '->' + str(proj.dest) + ' ' + proj.parameters['name']) proj() def summary(self, printed=True): heading_line = '=' * len(self.name) summary = [heading_line, self.name, heading_line, ''] for sheet_spec in sorted(self.sheets): summary.append(sheet_spec.summary(printed=False)) projections = [ proj for proj in self.projections if str(proj).startswith(str(sheet_spec)) ] for projection_spec in sorted(projections, key=lambda p: str(p)): summary.append(" " + projection_spec.summary(printed=False)) summary.append('') if printed: print "\n".join(summary) else: return "\n".join(summary) def __str__(self): return self.name def _repr_pretty_(self, p, cycle): p.text(self.summary(printed=False)) def modifications(self, components=['model', 'sheets', 'projections']): """ Display the names of all modified parameters for the specified set of components. By default all modified parameters are listed - first with the model parameters, then the sheet parameters and lastly the projection parameters. """ mapping = { 'model': [self], 'sheets': self.sheets, 'projections': self.projections } lines = [] for component in components: heading = "=" * len(component) lines.extend([heading, component.capitalize(), heading, '']) specs = mapping[component] padding = max(len(str(spec)) for spec in specs) for spec in sorted(specs): modified = [str(el) for el in sorted(spec.modified_parameters)] lines.append("%s : [%s]" % (str(spec).ljust(padding), ", ".join(modified))) lines.append('') print "\n".join(lines)
def __init__(self, **params): super(ProjectionSheet,self).__init__(**params) self.new_input = False self.mask.sheet = self self.old_a = self.activity.copy()*0.0 self.views['RFs'] = AttrTree()