def prepare_for_estimate(self, specification_dict=None, specification_storage=None, specification_table=None, events_for_estimation_storage=None, events_for_estimation_table=None, agents_filter='', compute_variables=[], data_objects={}): specification = get_specification_for_estimation( specification_dict, specification_storage, specification_table) projects = None # create agents for estimation if events_for_estimation_storage is not None: projects = Dataset(in_storage=events_for_estimation_storage, in_table_name=events_for_estimation_table, id_name=[], dataset_name='development_project') if compute_variables: projects.compute_variables(compute_variables, resources=Resources(data_objects)) # needs to be a primary attribute because of the join method below #projects.add_primary_attribute(estimation_set.get_attribute(location_id_variable), # VariableName(location_id_variable).get_alias()) if agents_filter: values = projects.compute_variables( agents_filter, resources=Resources(data_objects)) index = where(values > 0)[0] projects.subset_by_index(index, flush_attributes_if_not_loaded=False) return (specification, projects)
def prepare_for_estimate(self, specification_dict = None, specification_storage=None, specification_table=None, events_for_estimation_storage=None, events_for_estimation_table=None, agents_filter='', compute_variables=[], data_objects={}): specification = get_specification_for_estimation(specification_dict, specification_storage, specification_table) projects = None # create agents for estimation if events_for_estimation_storage is not None: projects = Dataset(in_storage = events_for_estimation_storage, in_table_name= events_for_estimation_table, id_name=[], dataset_name='development_project' ) if compute_variables: projects.compute_variables(compute_variables, resources=Resources(data_objects)) # needs to be a primary attribute because of the join method below #projects.add_primary_attribute(estimation_set.get_attribute(location_id_variable), # VariableName(location_id_variable).get_alias()) if agents_filter: values = projects.compute_variables(agents_filter, resources=Resources(data_objects)) index = where(values > 0)[0] projects.subset_by_index(index, flush_attributes_if_not_loaded=False) return (specification, projects)
def prepare_for_estimate(self, specification_dict=None, specification_storage=None, specification_table=None, events_for_estimation_storage=None, events_for_estimation_table=None, urbansim_constant=None, base_year=0, categories=None): from opus_core.model import get_specification_for_estimation specification = get_specification_for_estimation( specification_dict, specification_storage, specification_table) projects = None # create agents for estimation if events_for_estimation_storage is not None: event_set = DevelopmentEventDataset( in_storage=events_for_estimation_storage, in_table_name=events_for_estimation_table) event_set.remove_non_recent_data(base_year, urbansim_constant['recent_years']) projects = DevelopmentProjectCreator( ).create_projects_from_history(event_set, self.project_type, self.units, categories) return (specification, projects)
def prepare_for_estimate(self, specification_dict = None, specification_storage=None, specification_table=None): from opus_core.model import get_specification_for_estimation return get_specification_for_estimation(specification_dict, specification_storage, specification_table)
def prepare_for_estimate(self, dataset=None, dataset_filter=None, filter_threshold=0, **kwargs): spec = get_specification_for_estimation(**kwargs) if (dataset is not None) and (dataset_filter is not None): filter_values = dataset.compute_variables([dataset_filter], dataset_pool=self.dataset_pool) index = where(filter_values > filter_threshold)[0] else: index = None return (spec, index)
def prepare_for_estimate(self, specification_dict = None, specification_storage=None, specification_table=None): from opus_core.model import get_specification_for_estimation return get_specification_for_estimation(specification_dict, specification_storage, specification_table)
def prepare_for_estimate(self, specification_dict=None, specification_storage=None, specification_table=None, agent_set=None, agents_for_estimation_storage=None, agents_for_estimation_table=None, join_datasets=False, index_to_unplace=None, portion_to_unplace=1.0, agent_filter=None, data_objects={}): from opus_core.model import get_specification_for_estimation specification = get_specification_for_estimation( specification_dict, specification_storage, specification_table) if (agent_set is not None) and (index_to_unplace is not None): if self.location_id_string is not None: agent_set.compute_variables(self.location_id_string, resources=Resources(data_objects)) if portion_to_unplace < 1: unplace_size = int(portion_to_unplace * index_to_unplace.size) end_index_to_unplace = sample_noreplace( index_to_unplace, unplace_size) else: end_index_to_unplace = index_to_unplace logger.log_status("Unplace " + str(end_index_to_unplace.size) + " agents.") agent_set.modify_attribute(self.choice_set.get_id_name()[0], -1 * ones(end_index_to_unplace.size), end_index_to_unplace) # create agents for estimation if agents_for_estimation_storage is not None: estimation_set = Dataset(in_storage=agents_for_estimation_storage, in_table_name=agents_for_estimation_table, id_name=agent_set.get_id_name(), dataset_name=agent_set.get_dataset_name()) if agent_filter is not None: estimation_set.compute_variables( agent_filter, resources=Resources(data_objects)) index = where( estimation_set.get_attribute(agent_filter) > 0)[0] estimation_set.subset_by_index( index, flush_attributes_if_not_loaded=False) if join_datasets: agent_set.join_by_rows(estimation_set, require_all_attributes=False, change_ids_if_not_unique=True) index = arange(agent_set.size() - estimation_set.size(), agent_set.size()) else: index = agent_set.get_id_index( estimation_set.get_id_attribute()) else: index = arange(agent_set.size()) return (specification, index)
def prepare_for_estimate(specification_dict=None, specification_storage=None, specification_table=None, agent_set=None, household_set=None, agents_for_estimation_storage=None, agents_for_estimation_table=None, households_for_estimation_table=None, join_datasets=False, filter=None, data_objects=None): specification = get_specification_for_estimation(specification_dict, specification_storage, specification_table) if agents_for_estimation_storage is not None: estimation_set = Dataset(in_storage=agents_for_estimation_storage, in_table_name=agents_for_estimation_table, id_name=agent_set.get_id_name(), dataset_name=agent_set.get_dataset_name()) hh_estimation_set = None if households_for_estimation_table is not None: hh_estimation_set = Dataset( in_storage=agents_for_estimation_storage, in_table_name=households_for_estimation_table, id_name=household_set.get_id_name(), dataset_name=household_set.get_dataset_name()) filter_index = arange(estimation_set.size()) if filter: estimation_set.compute_variables(filter, resources=Resources(data_objects)) filter_index = where(estimation_set.get_attribute(filter) > 0)[0] #estimation_set.subset_by_index(index, flush_attributes_if_not_loaded=False) if join_datasets: if hh_estimation_set is not None: household_set.join_by_rows(hh_estimation_set, require_all_attributes=False, change_ids_if_not_unique=True) agent_set.join_by_rows(estimation_set, require_all_attributes=False, change_ids_if_not_unique=True) index = arange(agent_set.size() - estimation_set.size(), agent_set.size())[filter_index] else: index = agent_set.get_id_index( estimation_set.get_id_attribute()[filter_index]) else: if agent_set is not None: index = arange(agent_set.size()) else: index = None return (specification, index)
def prepare_for_estimate(self, specification_dict = None, specification_storage=None, specification_table=None, dataset=None, filter_variable="urbansim.gridcell.total_land_value", threshold=0): from opus_core.model import get_specification_for_estimation specification = get_specification_for_estimation(specification_dict, specification_storage, specification_table) index = None if dataset is not None: dataset.compute_variables(filter_variable) index = where(dataset.get_attribute(filter_variable) >= threshold)[0] return (specification, index)
def prepare_for_estimate(self, estimation_storage=None, estimation_table=None, dataset_filter=None, filter_threshold=0, **kwargs): spec = get_specification_for_estimation(**kwargs) if estimation_storage is not None and estimation_table is not None: dataset = Dataset(in_storage = estimation_storage, in_table_name=estimation_table, id_name='proposal_id', dataset_name='development_project_proposal') if (dataset is not None) and (dataset_filter is not None): filter_values = dataset.compute_variables([dataset_filter], dataset_pool=self.dataset_pool) index = where(filter_values > filter_threshold)[0] else: index = None return (dataset, spec, index)
def prepare_for_estimate(self, dataset=None, dataset_filter=None, filter_threshold=0, **kwargs): spec = get_specification_for_estimation(**kwargs) if (dataset is not None) and (dataset_filter is not None): filter_values = dataset.compute_variables( [dataset_filter], dataset_pool=self.dataset_pool) index = where(filter_values > filter_threshold)[0] else: index = None return (spec, index)
def prepare_for_estimate(self, specification_dict = None, specification_storage=None, specification_table=None, dataset=None, filter_variable="urbansim.gridcell.fraction_residential_land"): from opus_core.model import get_specification_for_estimation specification = get_specification_for_estimation(specification_dict, specification_storage, specification_table) index = None if dataset is not None: dataset.compute_variables(filter_variable) tmp = where(dataset.get_attribute(filter_variable) > 0, 1, 0) tmp = logical_and(tmp, where(dataset.get_attribute(filter_variable) < 1, 1, 0)) index = where(tmp)[0] return (specification, index)
def prepare_for_estimate(specification_dict = None, specification_storage=None, specification_table=None, agent_set=None, household_set=None, agents_for_estimation_storage=None, agents_for_estimation_table=None, households_for_estimation_table=None, join_datasets=False, filter=None, data_objects=None): specification = get_specification_for_estimation(specification_dict, specification_storage, specification_table) if agents_for_estimation_storage is not None: estimation_set = Dataset(in_storage = agents_for_estimation_storage, in_table_name=agents_for_estimation_table, id_name=agent_set.get_id_name(), dataset_name=agent_set.get_dataset_name()) hh_estimation_set = None if households_for_estimation_table is not None: hh_estimation_set = Dataset(in_storage = agents_for_estimation_storage, in_table_name=households_for_estimation_table, id_name=household_set.get_id_name(), dataset_name=household_set.get_dataset_name()) filter_index = arange(estimation_set.size()) if filter: estimation_set.compute_variables(filter, resources=Resources(data_objects)) filter_index = where(estimation_set.get_attribute(filter) > 0)[0] #estimation_set.subset_by_index(index, flush_attributes_if_not_loaded=False) if join_datasets: if hh_estimation_set is not None: household_set.join_by_rows(hh_estimation_set, require_all_attributes=False, change_ids_if_not_unique=True) agent_set.join_by_rows(estimation_set, require_all_attributes=False, change_ids_if_not_unique=True) index = arange(agent_set.size() - estimation_set.size(), agent_set.size())[filter_index] else: index = agent_set.get_id_index(estimation_set.get_id_attribute()[filter_index]) else: if agent_set is not None: index = arange(agent_set.size()) else: index = None return (specification, index)
def prepare_for_estimate(self, specification_dict=None, specification_storage=None, specification_table=None, dataset=None, filter_variable="housing_price", threshold=0): from opus_core.model import get_specification_for_estimation specification = get_specification_for_estimation( specification_dict, specification_storage, specification_table) index = None if dataset is not None: dataset.compute_variables(filter_variable) index = where( dataset.get_attribute(filter_variable) >= threshold)[0] return (specification, index)
def prepare_for_estimate(self, dataset=None, dataset_for_estimation_storage=None, dataset_for_estimation_table=None, join_datasets=False, **kwargs): from opus_core.model import get_specification_for_estimation from opus_core.datasets.dataset import Dataset spec = get_specification_for_estimation(**kwargs) if (dataset_for_estimation_storage is not None) and (dataset_for_estimation_table is not None): estimation_set = Dataset(in_storage = dataset_for_estimation_storage, in_table_name=dataset_for_estimation_table, id_name=dataset.get_id_name(), dataset_name=dataset.get_dataset_name()) if join_datasets: dataset.join_by_rows(estimation_set, require_all_attributes=False, change_ids_if_not_unique=True) index = arange(dataset.size()-estimation_set.size(),dataset.size()) else: index = dataset.get_id_index(estimation_set.get_id_attribute()) else: index = None return (spec, index)
def prepare_for_estimate(self,specification_dict = None, specification_storage=None, specification_table=None, events_for_estimation_storage=None, events_for_estimation_table=None): from opus_core.model import get_specification_for_estimation specification = get_specification_for_estimation(specification_dict, specification_storage, specification_table) development = None # create agents for estimation if events_for_estimation_storage is not None: event_set = DevelopmentEventDataset(in_storage = events_for_estimation_storage, in_table_name= events_for_estimation_table) development = create_landuse_developments_from_history(event_set) return (specification, development)
def __init__(self, config, model=None, model_group=None, specification=None, scenario_name=None): self.factory = VariableFactory() lib = config.get_expression_library() self.factory.set_expression_library(lib) self.model = model self.model_group = model_group if model is not None: if specification is None: specification_dict = config.get_estimation_specification(model, model_group) spec = get_specification_for_estimation(specification_dict) else: spec = specification model_prefix = '' if model_group is not None: model_prefix = '%s_' % model_group self.model_name = '%s%s' % (model_prefix, model) self.var_list = spec.get_distinct_long_variable_names().tolist() #check other model nodes, such as agents_filter, submodel_string or filter config_node_path = "model_manager/models/model[@name='%s']" % self.model model_node = config._find_node(config_node_path) controller = config._convert_model_to_dict(model_node) addvars = [] addvars.append(controller.get('init', {}).get('arguments', {}).get('filter', None)) addvars.append(controller.get('init', {}).get('arguments', {}).get('submodel_string', None)) addvars.append(controller.get('init', {}).get('arguments', {}).get('choice_attribute_name', None)) addvars.append(controller.get('prepare_for_run', {}).get('arguments', {}).get('agent_filter', None)) for var in addvars: if isinstance(var, str): self.var_list.append(eval(var)) # eval because these entries are in double quotes, e.g. "'attribute'" self.var_tree = [] l = [] for var in self.var_list: l.append((var, [])) self.var_tree.append((self.model_name, l)) else: # this is meant to be for all models but is not working yet #self.config = config.get_run_configuration(scenario_name) self.var_list = [] self.var_tree = []
def prepare_for_estimate(self, specification_dict = None, specification_storage=None, specification_table=None, agent_set=None, agents_for_estimation_storage=None, agents_for_estimation_table=None, filter_for_estimation_set=None, data_objects=None): specification = get_specification_for_estimation(specification_dict, specification_storage, specification_table) if self.filter is not None: agents_index = where( self.proposal_set.compute_variables(self.filter) )[0] id_attribute_name = ['parcel_id', 'template_id', 'is_redevelopment'] if agents_for_estimation_storage is not None: estimation_set = Dataset(in_storage = agents_for_estimation_storage, in_table_name=agents_for_estimation_table, id_name=id_attribute_name, dataset_name=agent_set.get_dataset_name()) filter_index = arange(estimation_set.size()) if filter_for_estimation_set: filter_index = where(estimation_set.compute_variables(filter_for_estimation_set, resources=Resources(data_objects)))[0] estimation_set.subset_by_index(filter_index, flush_attributes_if_not_loaded=False) id_attributes = None for attr_name in id_attribute_name: attr_value = agent_set.get_attribute_as_column(attr_name) if id_attributes == None: id_attributes = attr_value else: id_attributes = concatenate((id_attributes, attr_value), axis=1) id_index = estimation_set.try_get_id_index(id_attributes, return_value_if_not_found=-1) status_id = 2 * ones(agent_set.size(), dtype="int8") status_id[where(id_index != -1)] = 1 name = self.choice_attribute_name.get_alias() if name in agent_set.get_known_attribute_names(): agent_set.set_values_of_one_attribute(name, status_id[where(id_index != -1)], where(id_index!=-1)[0]) else: agent_set.add_primary_attribute(status_id, name) return (specification, agents_index)
def prepare_for_estimate( self, specification_dict=None, specification_storage=None, specification_table=None, dataset=None, filter_variable="urbansim.gridcell.fraction_residential_land"): from opus_core.model import get_specification_for_estimation specification = get_specification_for_estimation( specification_dict, specification_storage, specification_table) index = None if dataset is not None: dataset.compute_variables(filter_variable) tmp = where(dataset.get_attribute(filter_variable) > 0, 1, 0) tmp = logical_and( tmp, where(dataset.get_attribute(filter_variable) < 1, 1, 0)) index = where(tmp)[0] return (specification, index)
def prepare_for_estimate(self, specification_dict=None, specification_storage=None, specification_table=None, events_for_estimation_storage=None, events_for_estimation_table=None): from opus_core.model import get_specification_for_estimation specification = get_specification_for_estimation( specification_dict, specification_storage, specification_table) development = None # create agents for estimation if events_for_estimation_storage is not None: event_set = DevelopmentEventDataset( in_storage=events_for_estimation_storage, in_table_name=events_for_estimation_table) development = create_landuse_developments_from_history(event_set) return (specification, development)
def prepare_for_estimate(self, specification_dict = None, specification_storage=None, specification_table=None, events_for_estimation_storage=None, events_for_estimation_table=None, urbansim_constant=None, base_year=0, categories=None): from opus_core.model import get_specification_for_estimation specification = get_specification_for_estimation(specification_dict, specification_storage, specification_table) projects = None # create agents for estimation if events_for_estimation_storage is not None: event_set = DevelopmentEventDataset(in_storage = events_for_estimation_storage, in_table_name= events_for_estimation_table) event_set.remove_non_recent_data(base_year, urbansim_constant['recent_years']) projects = DevelopmentProjectCreator().create_projects_from_history( event_set, self.project_type, self.units, categories) return (specification, projects)
def prepare_for_estimate(self, specification_dict = None, specification_storage=None, specification_table=None, agent_set=None, agents_for_estimation_storage=None, agents_for_estimation_table=None, join_datasets=False, index_to_unplace=None, portion_to_unplace=1.0, agent_filter=None, data_objects={}): from opus_core.model import get_specification_for_estimation specification = get_specification_for_estimation(specification_dict, specification_storage, specification_table) if (agent_set is not None) and (index_to_unplace is not None): if self.location_id_string is not None: agent_set.compute_variables(self.location_id_string, resources=Resources(data_objects)) if portion_to_unplace < 1: unplace_size = int(portion_to_unplace*index_to_unplace.size) end_index_to_unplace = sample_noreplace(index_to_unplace, unplace_size) else: end_index_to_unplace = index_to_unplace logger.log_status("Unplace " + str(end_index_to_unplace.size) + " agents.") agent_set.modify_attribute(self.choice_set.get_id_name()[0], -1*ones(end_index_to_unplace.size), end_index_to_unplace) # create agents for estimation if agents_for_estimation_storage is not None: estimation_set = Dataset(in_storage = agents_for_estimation_storage, in_table_name=agents_for_estimation_table, id_name=agent_set.get_id_name(), dataset_name=agent_set.get_dataset_name()) if agent_filter is not None: estimation_set.compute_variables(agent_filter, resources=Resources(data_objects)) index = where(estimation_set.get_attribute(agent_filter) > 0)[0] estimation_set.subset_by_index(index, flush_attributes_if_not_loaded=False) if join_datasets: agent_set.join_by_rows(estimation_set, require_all_attributes=False, change_ids_if_not_unique=True) index = arange(agent_set.size()-estimation_set.size(),agent_set.size()) else: index = agent_set.get_id_index(estimation_set.get_id_attribute()) else: index = arange(agent_set.size()) return (specification, index)
def prepare_for_estimate(self, add_member_prefix=True, specification_dict=None, specification_storage=None, specification_table=None, building_set=None, buildings_for_estimation_storage=None, buildings_for_estimation_table=None, constants=None, base_year=0, building_categories=None, location_id_variable=None, join_datasets=False, data_objects=None, **kwargs): # buildings = None if (building_set is not None): if location_id_variable is not None: building_set.compute_variables( location_id_variable, resources=Resources(data_objects)) # create agents for estimation if buildings_for_estimation_storage is not None: estimation_set = Dataset( in_storage=buildings_for_estimation_storage, in_table_name=buildings_for_estimation_table, id_name=building_set.get_id_name(), dataset_name=building_set.get_dataset_name()) if location_id_variable: estimation_set.compute_variables( location_id_variable, resources=Resources(data_objects)) # needs to be a primary attribute because of the join method below estimation_set.add_primary_attribute( estimation_set.get_attribute(location_id_variable), VariableName(location_id_variable).alias()) years = estimation_set.get_attribute("scheduled_year") recent_years = constants['recent_years'] indicator = zeros(estimation_set.size()) for year in range(base_year - recent_years, base_year + 1): indicator = logical_or(indicator, years == year) idx = where(logical_not(indicator))[0] estimation_set.remove_elements(idx) #if filter: #estimation_set.compute_variables(filter, resources=Resources(data_objects)) #index = where(estimation_set.get_attribute(filter) > 0)[0] #estimation_set.subset_by_index(index, flush_attributes_if_not_loaded=False) if join_datasets: building_set.join_by_rows(estimation_set, require_all_attributes=False, change_ids_if_not_unique=True) index = arange(building_set.size() - estimation_set.size(), agent_set.size()) else: index = building_set.get_id_index( estimation_set.get_id_attribute()) else: if building_set is not None: index = arange(building_set.size()) else: index = None if add_member_prefix: specification_table = self.group_member.add_member_prefix_to_table_names( [specification_table]) from opus_core.model import get_specification_for_estimation #from urbansim.functions import compute_supply_and_add_to_location_set specification = get_specification_for_estimation( specification_dict, specification_storage, specification_table) #specification, dummy = AgentLocationChoiceModelMember.prepare_for_estimate(self, add_member_prefix, #specification_dict, specification_storage, #specification_table, #location_id_variable=location_id_variable, #data_objects=data_objects, **kwargs) return (specification, index)
def prepare_for_estimate(self, specification_dict = None, specification_storage=None, specification_table=None, agent_set=None, agents_for_estimation_storage=None, agents_for_estimation_table=None, join_datasets=False, index_to_unplace=None, portion_to_unplace=1.0, compute_lambda=False, grouping_location_set=None, movers_variable=None, movers_index=None, filter=None, location_id_variable=None, data_objects={}): """Put 'location_id_variable' always in, if the location id is to be computed on the estimation set, i.e. if it is not a primary attribute of the estimation set. Set 'index_to_unplace' to None, if 'compute_lambda' is True. In such a case, the annual supply is estimated without unplacing agents. 'grouping_location_set', 'movers_variable' and 'movers_index' must be given, if 'compute_lambda' is True. """ from opus_core.model import get_specification_for_estimation from urbansim.functions import compute_supply_and_add_to_location_set specification = get_specification_for_estimation(specification_dict, specification_storage, specification_table) if (agent_set is not None) and (index_to_unplace is not None): if self.location_id_string is not None: agent_set.compute_variables(self.location_id_string, resources=Resources(data_objects)) if portion_to_unplace < 1: unplace_size = int(portion_to_unplace*index_to_unplace.size) end_index_to_unplace = sample_noreplace(index_to_unplace, unplace_size) else: end_index_to_unplace = index_to_unplace logger.log_status("Unplace " + str(end_index_to_unplace.size) + " agents.") agent_set.modify_attribute(self.choice_set.get_id_name()[0], resize(array([-1]), end_index_to_unplace.size), end_index_to_unplace) if compute_lambda: movers = zeros(agent_set.size(), dtype="bool8") if movers_index is not None: movers[movers_index] = 1 agent_set.add_primary_attribute(movers, "potential_movers") self.estimate_config["weights_for_estimation_string"] = self.estimate_config["weights_for_estimation_string"]+"_from_lambda" compute_supply_and_add_to_location_set(self.choice_set, grouping_location_set, self.run_config["number_of_units_string"], self.run_config["capacity_string"], movers_variable, self.estimate_config["weights_for_estimation_string"], resources=Resources(data_objects)) # create agents for estimation if (agents_for_estimation_storage is not None) and (agents_for_estimation_table is not None): estimation_set = Dataset(in_storage = agents_for_estimation_storage, in_table_name=agents_for_estimation_table, id_name=agent_set.get_id_name(), dataset_name=agent_set.get_dataset_name()) if location_id_variable is not None: estimation_set.compute_variables(location_id_variable, resources=Resources(data_objects)) # needs to be a primary attribute because of the join method below estimation_set.add_primary_attribute(estimation_set.get_attribute(location_id_variable), VariableName(location_id_variable).get_alias()) if filter: values = estimation_set.compute_variables(filter, resources=Resources(data_objects)) index = where(values > 0)[0] estimation_set.subset_by_index(index, flush_attributes_if_not_loaded=False) if join_datasets: agent_set.join_by_rows(estimation_set, require_all_attributes=False, change_ids_if_not_unique=True) index = arange(agent_set.size()-estimation_set.size(),agent_set.size()) else: index = agent_set.get_id_index(estimation_set.get_id_attribute()) else: if agent_set is not None: if filter is not None: values = agent_set.compute_variables(filter, resources=Resources(data_objects)) index = where(values > 0)[0] else: index = arange(agent_set.size()) else: index = None return (specification, index)
def prepare_for_estimate(self, specification_dict=None, specification_storage=None, specification_table=None, agent_set=None, agents_for_estimation_storage=None, agents_for_estimation_table=None, join_datasets=False, index_to_unplace=None, portion_to_unplace=1.0, compute_lambda=False, grouping_location_set=None, movers_variable=None, movers_index=None, filter=None, location_id_variable=None, data_objects={}): """Put 'location_id_variable' always in, if the location id is to be computed on the estimation set, i.e. if it is not a primary attribute of the estimation set. Set 'index_to_unplace' to None, if 'compute_lambda' is True. In such a case, the annual supply is estimated without unplacing agents. 'grouping_location_set', 'movers_variable' and 'movers_index' must be given, if 'compute_lambda' is True. """ from opus_core.model import get_specification_for_estimation from urbansim.functions import compute_supply_and_add_to_location_set specification = get_specification_for_estimation( specification_dict, specification_storage, specification_table) if (agent_set is not None) and (index_to_unplace is not None): if self.location_id_string is not None: agent_set.compute_variables(self.location_id_string, resources=Resources(data_objects)) if portion_to_unplace < 1: unplace_size = int(portion_to_unplace * index_to_unplace.size) end_index_to_unplace = sample_noreplace( index_to_unplace, unplace_size) else: end_index_to_unplace = index_to_unplace logger.log_status("Unplace " + str(end_index_to_unplace.size) + " agents.") agent_set.modify_attribute( self.choice_set.get_id_name()[0], resize(array([-1]), end_index_to_unplace.size), end_index_to_unplace) if compute_lambda: movers = zeros(agent_set.size(), dtype="bool8") if movers_index is not None: movers[movers_index] = 1 agent_set.add_primary_attribute(movers, "potential_movers") self.estimate_config[ "weights_for_estimation_string"] = self.estimate_config[ "weights_for_estimation_string"] + "_from_lambda" compute_supply_and_add_to_location_set( self.choice_set, grouping_location_set, self.run_config["number_of_units_string"], self.run_config["capacity_string"], movers_variable, self.estimate_config["weights_for_estimation_string"], resources=Resources(data_objects)) # create agents for estimation if (agents_for_estimation_storage is not None) and (agents_for_estimation_table is not None): estimation_set = Dataset(in_storage=agents_for_estimation_storage, in_table_name=agents_for_estimation_table, id_name=agent_set.get_id_name(), dataset_name=agent_set.get_dataset_name()) if location_id_variable is not None: estimation_set.compute_variables( location_id_variable, resources=Resources(data_objects)) # needs to be a primary attribute because of the join method below estimation_set.add_primary_attribute( estimation_set.get_attribute(location_id_variable), VariableName(location_id_variable).get_alias()) if filter: values = estimation_set.compute_variables( filter, resources=Resources(data_objects)) index = where(values > 0)[0] estimation_set.subset_by_index( index, flush_attributes_if_not_loaded=False) if join_datasets: agent_set.join_by_rows(estimation_set, require_all_attributes=False, change_ids_if_not_unique=True) index = arange(agent_set.size() - estimation_set.size(), agent_set.size()) else: index = agent_set.get_id_index( estimation_set.get_id_attribute()) else: if agent_set is not None: if filter is not None: values = agent_set.compute_variables( filter, resources=Resources(data_objects)) index = where(values > 0)[0] else: index = arange(agent_set.size()) else: index = None return (specification, index)
def __init__(self, config, model=None, model_group=None, specification=None, scenario_name=None): self.factory = VariableFactory() lib = config.get_expression_library() self.factory.set_expression_library(lib) self.model = model self.model_group = model_group if model is not None: if specification is None: specification_dict = config.get_estimation_specification( model, model_group) spec = get_specification_for_estimation(specification_dict) else: spec = specification model_prefix = '' if model_group is not None: model_prefix = '%s_' % model_group self.model_name = '%s%s' % (model_prefix, model) self.var_list = spec.get_distinct_long_variable_names().tolist() #check other model nodes, such as agents_filter, submodel_string or filter config_node_path = "model_manager/models/model[@name='%s']" % self.model model_node = config._find_node(config_node_path) controller = config._convert_model_to_dict(model_node) addvars = [] addvars.append( controller.get('init', {}).get('arguments', {}).get('filter', None)) addvars.append( controller.get('init', {}).get('arguments', {}).get('submodel_string', None)) addvars.append( controller.get('init', {}).get('arguments', {}).get('choice_attribute_name', None)) addvars.append( controller.get('prepare_for_run', {}).get('arguments', {}).get('agent_filter', None)) for var in addvars: if isinstance(var, str): self.var_list.append( eval(var) ) # eval because these entries are in double quotes, e.g. "'attribute'" self.var_tree = [] l = [] for var in self.var_list: l.append((var, [])) self.var_tree.append((self.model_name, l)) else: # this is meant to be for all models but is not working yet #self.config = config.get_run_configuration(scenario_name) self.var_list = [] self.var_tree = []
def prepare_for_estimate( self, add_member_prefix=True, specification_dict=None, specification_storage=None, specification_table=None, building_set=None, buildings_for_estimation_storage=None, buildings_for_estimation_table=None, constants=None, base_year=0, building_categories=None, location_id_variable=None, join_datasets=False, data_objects=None, **kwargs ): # buildings = None if building_set is not None: if location_id_variable is not None: building_set.compute_variables(location_id_variable, resources=Resources(data_objects)) # create agents for estimation if buildings_for_estimation_storage is not None: estimation_set = Dataset( in_storage=buildings_for_estimation_storage, in_table_name=buildings_for_estimation_table, id_name=building_set.get_id_name(), dataset_name=building_set.get_dataset_name(), ) if location_id_variable: estimation_set.compute_variables(location_id_variable, resources=Resources(data_objects)) # needs to be a primary attribute because of the join method below estimation_set.add_primary_attribute( estimation_set.get_attribute(location_id_variable), VariableName(location_id_variable).alias() ) years = estimation_set.get_attribute("scheduled_year") recent_years = constants["recent_years"] indicator = zeros(estimation_set.size(), dtype="int32") for year in range(base_year - recent_years, base_year + 1): indicator = logical_or(indicator, years == year) idx = where(logical_not(indicator))[0] estimation_set.remove_elements(idx) # if filter: # estimation_set.compute_variables(filter, resources=Resources(data_objects)) # index = where(estimation_set.get_attribute(filter) > 0)[0] # estimation_set.subset_by_index(index, flush_attributes_if_not_loaded=False) if join_datasets: building_set.join_by_rows(estimation_set, require_all_attributes=False, change_ids_if_not_unique=True) index = arange(building_set.size() - estimation_set.size(), building_set.size()) else: index = building_set.get_id_index(estimation_set.get_id_attribute()) else: if building_set is not None: index = arange(building_set.size()) else: index = None if add_member_prefix: specification_table = self.group_member.add_member_prefix_to_table_names([specification_table]) from opus_core.model import get_specification_for_estimation # from urbansim.functions import compute_supply_and_add_to_location_set specification = get_specification_for_estimation(specification_dict, specification_storage, specification_table) # specification, dummy = AgentLocationChoiceModelMember.prepare_for_estimate(self, add_member_prefix, # specification_dict, specification_storage, # specification_table, # location_id_variable=location_id_variable, # data_objects=data_objects, **kwargs) return (specification, index)