black

Author: m-richards

activitysim/abm/models/location_choice.py

@@ -793,7 +793,9 @@ def run_location_choice(
             continue
         # using land use rather than size terms in case something goes 0 base -> nonzero project, double
         # check if that would be in dest_size_terms as a zero
-        alts_context = AltsContext.from_series(dest_size_terms.index) # index zone_id, not ALT_DEST_COL_NAME
+        alts_context = AltsContext.from_series(
+            dest_size_terms.index
+        )  # index zone_id, not ALT_DEST_COL_NAME
         # assumes that dest_size_terms will always contain zeros for non-attractive zones, i.e. it will have the
         # same length as land_use
 

activitysim/abm/models/parking_location_choice.py

@@ -229,7 +229,7 @@ def choose_parking_location(
         chunk_size=chunk_size,
         trace_hh_id=trace_hh_id,
         trace_label=trace_label,
-        alts_context=alts_context
+        alts_context=alts_context,
     )
 
     if want_sample_table:

activitysim/abm/models/trip_scheduling_choice.py

@@ -315,7 +315,9 @@ def run_trip_scheduling_choice(
                 estimator=None,
                 chunk_sizer=chunk_sizer,
                 compute_settings=model_settings.compute_settings,
-                alts_context= AltsContext(schedules[SCHEDULE_ID].min(), schedules[SCHEDULE_ID].max()),
+                alts_context=AltsContext(
+                    schedules[SCHEDULE_ID].min(), schedules[SCHEDULE_ID].max()
+                ),
             )
 
             assert len(choices.index) == len(choosers.index)

activitysim/core/interaction_sample.py

@@ -22,6 +22,7 @@
 from activitysim.core.exceptions import SegmentedSpecificationError
 from activitysim.core.skim_dataset import DatasetWrapper
 from activitysim.core.skim_dictionary import SkimWrapper
+
 if typing.TYPE_CHECKING:
     from activitysim.core.random import Random
 
@@ -36,7 +37,7 @@ def _poisson_sample_alternatives_inner(
     poisson_inclusion_probs: pd.DataFrame,
     rng: Random,
     trace_label: str | None,
-    chunk_sizer:ChunkSizer,
+    chunk_sizer: ChunkSizer,
 ) -> pd.DataFrame:
     rands = rng.random_for_df(probs, n=alternative_count)
     chunk_sizer.log_df(trace_label, "rands", rands)
@@ -54,8 +55,8 @@ def make_sample_choices_utility_based(
     alternative_count,
     alt_col_name,
     allow_zero_probs,
-    trace_label:str,
-    chunk_sizer:ChunkSizer,
+    trace_label: str,
+    chunk_sizer: ChunkSizer,
 ):
     assert isinstance(utilities, pd.DataFrame)
     assert utilities.shape == (len(choosers), alternative_count)
@@ -87,8 +88,9 @@ def make_sample_choices_utility_based(
         overflow_protection=not allow_zero_probs,
         trace_choosers=choosers,
     )
-    inclusion_probs, sampled_alternatives = _poisson_sample_alternatives(alternative_count, chunk_sizer, probs,
-                                                                         sample_size, state, trace_label)
+    inclusion_probs, sampled_alternatives = _poisson_sample_alternatives(
+        alternative_count, chunk_sizer, probs, sample_size, state, trace_label
+    )
 
     # Stack removes the NaNs (the ones that weren't sampled)
     # and gives us a multi-index of (person_id, alt_id)
@@ -109,8 +111,14 @@ def make_sample_choices_utility_based(
     return choices_df, inclusion_probs
 
 
-def _poisson_sample_alternatives(alternative_count, chunk_sizer: ChunkSizer, probs: pd.DataFrame, sample_size,
-                                 state: workflow.State, trace_label: str) -> tuple[pd.DataFrame, pd.DataFrame]:
+def _poisson_sample_alternatives(
+    alternative_count,
+    chunk_sizer: ChunkSizer,
+    probs: pd.DataFrame,
+    sample_size,
+    state: workflow.State,
+    trace_label: str,
+) -> tuple[pd.DataFrame, pd.DataFrame]:
     # compute the inclusion probability as the reciprocal of alt never being drawn
     #  -- these are common, so compute once upfront
     exclusion_probs = (1 - probs) ** sample_size
@@ -119,21 +127,31 @@ def _poisson_sample_alternatives(alternative_count, chunk_sizer: ChunkSizer, pro
     n = 0
     probs_subset = probs
     inclusion_probs_subset = inclusion_probs
-    sampled_alternatives = pd.DataFrame(0.0, index=inclusion_probs.index, columns=inclusion_probs.columns)
+    sampled_alternatives = pd.DataFrame(
+        0.0, index=inclusion_probs.index, columns=inclusion_probs.columns
+    )
     while True:
         sampled_results_subset = _poisson_sample_alternatives_inner(
-            alternative_count, probs_subset, inclusion_probs_subset, state.get_rn_generator(), trace_label, chunk_sizer
+            alternative_count,
+            probs_subset,
+            inclusion_probs_subset,
+            state.get_rn_generator(),
+            trace_label,
+            chunk_sizer,
         )
         no_alts_sampled_mask = sampled_results_subset.isna().all(axis=1)
         alts_with_sampled_alternatives = sampled_results_subset[~no_alts_sampled_mask]
-        sampled_alternatives.loc[alts_with_sampled_alternatives.index, :] = alts_with_sampled_alternatives
+        sampled_alternatives.loc[
+            alts_with_sampled_alternatives.index, :
+        ] = alts_with_sampled_alternatives
         if no_alts_sampled_mask.any():
             # TODO if this happens in base but the project case is such that something is picked, random numbers won't
             #  be consistent - we're asserting that this is very rare models where the sample size is not too small
             logger.info(f"Poisson sampling of alternatives failed with {n=}, retrying")
             # TODO put this behind a debug guard, because it will be slow
             logger.info(
-                f"Sampled size was {sample_size}, poisson method mean expected sample size was {inclusion_probs.sum(axis=1).mean():.1f}, actual sampled mean was {(sampled_alternatives > 0).sum(axis=1).mean():.1f} and highest zero selection prob was {(exclusion_probs).product(axis=1).max():.2g}")
+                f"Sampled size was {sample_size}, poisson method mean expected sample size was {inclusion_probs.sum(axis=1).mean():.1f}, actual sampled mean was {(sampled_alternatives > 0).sum(axis=1).mean():.1f} and highest zero selection prob was {(exclusion_probs).product(axis=1).max():.2g}"
+            )
             probs_subset = probs[no_alts_sampled_mask]
             inclusion_probs_subset = inclusion_probs[no_alts_sampled_mask]
 
@@ -143,8 +161,10 @@ def _poisson_sample_alternatives(alternative_count, chunk_sizer: ChunkSizer, pro
         n += 1
         if n == 10:
             choosers_no_alts_sampled = sampled_results_subset[no_alts_sampled_mask]
-            msg = (f"Poisson choice set sampling failed after 10 attempts for these cases:\n"
-                   f"{choosers_no_alts_sampled}\n{probs_subset}")
+            msg = (
+                f"Poisson choice set sampling failed after 10 attempts for these cases:\n"
+                f"{choosers_no_alts_sampled}\n{probs_subset}"
+            )
             raise ValueError(msg)
 
     chunk_sizer.log_df(trace_label, "sampled_alternatives", sampled_alternatives)
@@ -260,7 +280,7 @@ def _interaction_sample(
     locals_d=None,
     trace_label=None,
     zone_layer=None,
-    chunk_sizer: ChunkSizer|None=None,
+    chunk_sizer: ChunkSizer | None = None,
     compute_settings: ComputeSettings | None = None,
 ):
     """
@@ -325,7 +345,9 @@ def _interaction_sample(
         pick_count : int
             number of duplicate picks for chooser, alt
     """
-    assert chunk_sizer is not None, "chunk_sizer cannot be None but old nullable signature is preserved"
+    assert (
+        chunk_sizer is not None
+    ), "chunk_sizer cannot be None but old nullable signature is preserved"
     # TODO it's probably safe to reorder these arguments to make chunk_sizer mandatory since
     #   _interaction_sample is private?
 

activitysim/core/interaction_sample_simulate.py

@@ -283,7 +283,7 @@ def _interaction_sample_simulate(
     if alts_context is not None:
         alt_nrs_df = pd.DataFrame(padded_alt_nrs, index=choosers.index)
     else:
-        alt_nrs_df = None # if we don't provide the number of dense alternatives, assume that we'll use the old approach
+        alt_nrs_df = None  # if we don't provide the number of dense alternatives, assume that we'll use the old approach
     chunk_sizer.log_df(trace_label, "utilities_df", utilities_df)
 
     del padded_utilities
@@ -330,8 +330,12 @@ def _interaction_sample_simulate(
         # positions is series with the chosen alternative represented as a column index in utilities_df
         # which is an integer between zero and num alternatives in the alternative sample
         positions, rands = logit.make_choices_utility_based(
-            state, utilities_df, trace_label=trace_label, trace_choosers=choosers, alts_context=alts_context,
-            alt_nrs_df=alt_nrs_df
+            state,
+            utilities_df,
+            trace_label=trace_label,
+            trace_choosers=choosers,
+            alts_context=alts_context,
+            alt_nrs_df=alt_nrs_df,
         )
 
         del utilities_df

activitysim/core/logit.py

@@ -345,11 +345,14 @@ def utils_to_probs(
         return probs, logsums
     return probs
 
+
 FREEZE_RANDOM_NUMBERS_FOR_DENSE_ALTERNATIVE_SET = True
 
+
 @dataclass
 class AltsContext:
     """Representation of the alternatives without carrying around that full array."""
+
     min_alt_id: int
     max_alt_id: int
 
@@ -359,55 +362,67 @@ def __post_init__(self):
         self.n_rands_to_sample = max(self.max_alt_id, self.n_alts_to_cover_max_id)
 
     @classmethod
-    def from_series(cls, ser:Union[pd.Series,pd.Index])->"AltsContext":
+    def from_series(cls, ser: Union[pd.Series, pd.Index]) -> "AltsContext":
         min_alt_id = ser.min()
         max_alt_id = ser.max()
         return cls(min_alt_id, max_alt_id)
 
     @classmethod
-    def from_num_alts(cls, num_alts:int, zero_based:bool=True)->"AltsContext":
+    def from_num_alts(cls, num_alts: int, zero_based: bool = True) -> "AltsContext":
         if zero_based:
             offset = -1
         else:
-            offset =0
-        return cls(min_alt_id=1+offset, max_alt_id=num_alts+offset )
-
+            offset = 0
+        return cls(min_alt_id=1 + offset, max_alt_id=num_alts + offset)
 
     @property
     def n_alts_to_cover_max_id(self) -> int:
         """If zones were non-consecutive, this could be a big over-estimate."""
-        return self.max_alt_id+1
+        return self.max_alt_id + 1
 
 
 # TODO-EET: add doc string, tracing
-def add_ev1_random(state: workflow.State, df: pd.DataFrame, alt_info: AltsContext | None = None,
-                   alt_nrs_df: pd.DataFrame | None = None, ):
+def add_ev1_random(
+    state: workflow.State,
+    df: pd.DataFrame,
+    alt_info: AltsContext | None = None,
+    alt_nrs_df: pd.DataFrame | None = None,
+):
 
     nest_utils_for_choice = df.copy()
     assert (alt_info is None) == (
-            alt_nrs_df is None), "n_zones and alt_nrs_df must both be provided or omitted together"
+        alt_nrs_df is None
+    ), "n_zones and alt_nrs_df must both be provided or omitted together"
 
     if alt_nrs_df is not None and FREEZE_RANDOM_NUMBERS_FOR_DENSE_ALTERNATIVE_SET:
-        assert alt_info is not None # narrowing for mypy
+        assert alt_info is not None  # narrowing for mypy
 
         idx_array = alt_nrs_df.values
         mask = idx_array == -999
-        safe_idx = np.where(mask, 1, idx_array)  # replace -999 with a temp value inbounds
+        safe_idx = np.where(
+            mask, 1, idx_array
+        )  # replace -999 with a temp value inbounds
         # generate random number for all alts - this is wasteful, but ensures that the same zone
         #  gets the same random number if the sampled choice set changes between base and project
         # (alternatively, one could seed a channel for (persons x zones) and use the zone seed to ensure consistency.
         # Trade off is needing to seed (persons x zones) rows and multiindex channels to
         # avoid extra random numbers generated here. Quick benchmark suggests seeding per row is likely slower
-        rands_dense = state.get_rn_generator().gumbel_for_df(nest_utils_for_choice, n=alt_info.n_alts_to_cover_max_id)
+        rands_dense = state.get_rn_generator().gumbel_for_df(
+            nest_utils_for_choice, n=alt_info.n_alts_to_cover_max_id
+        )
         # generate n=alt_info.max_alt_id+1 rather than n_alts so that indexing works
         # (this is drawing a random number for a redundant zeroth zone in 1 based zoning systems)
         # TODO deal with non 0->n-1 indexed land use more efficiently? ideally do where alt_nrs_df is constructed,
         #  not on the fly here. Potentially via state.get_injectable('network_los').get_skim_dict('taz').zone_ids
         rands = np.take_along_axis(rands_dense, safe_idx, axis=1)
-        rands[mask] = 0 # zero out the masked zones so they don't have the util adjustment of alt 0
+        rands[
+            mask
+        ] = 0  # zero out the masked zones so they don't have the util adjustment of alt 0
     else:
         # old behaviour, to remove
-        rands = state.get_rn_generator().gumbel_for_df(nest_utils_for_choice, n=nest_utils_for_choice.shape[1])
+        rands = state.get_rn_generator().gumbel_for_df(
+            nest_utils_for_choice, n=nest_utils_for_choice.shape[1]
+        )
 
     nest_utils_for_choice += rands
     return nest_utils_for_choice
@@ -461,10 +476,13 @@ def make_choices_explicit_error_term_nl(
 
 
 # TODO-EET: add doc string, tracing
-def make_choices_explicit_error_term_mnl(state, utilities, trace_label,
-                                         alts_context: AltsContext | None = None,
-                                         alt_nrs_df: pd.DataFrame | None = None,
-                                         ):
+def make_choices_explicit_error_term_mnl(
+    state,
+    utilities,
+    trace_label,
+    alts_context: AltsContext | None = None,
+    alt_nrs_df: pd.DataFrame | None = None,
+):
     utilities_incl_unobs = add_ev1_random(state, utilities, alts_context, alt_nrs_df)
     choices = np.argmax(utilities_incl_unobs.to_numpy(), axis=1)
     # TODO-EET: reporting like for zero probs
@@ -474,13 +492,19 @@ def make_choices_explicit_error_term_mnl(state, utilities, trace_label,
 
 
 def make_choices_explicit_error_term(
-    state, utilities, alt_order_array, nest_spec=None, trace_label=None,
-        alts_context: AltsContext | None = None,
-        alt_nrs_df: pd.DataFrame | None = None,
+    state,
+    utilities,
+    alt_order_array,
+    nest_spec=None,
+    trace_label=None,
+    alts_context: AltsContext | None = None,
+    alt_nrs_df: pd.DataFrame | None = None,
 ):
     trace_label = tracing.extend_trace_label(trace_label, "make_choices_eet")
     if nest_spec is None:
-        choices = make_choices_explicit_error_term_mnl(state, utilities, trace_label, alts_context, alt_nrs_df)
+        choices = make_choices_explicit_error_term_mnl(
+            state, utilities, trace_label, alts_context, alt_nrs_df
+        )
     else:
         choices = make_choices_explicit_error_term_nl(
             state, utilities, alt_order_array, nest_spec, trace_label

activitysim/core/simulate.py

@@ -42,6 +42,7 @@
     SPEC_EXPRESSION_NAME,
     SPEC_LABEL_NAME,
 )
+
 if typing.TYPE_CHECKING:
     from activitysim.core.estimation import Estimator