Code review changes

activitysim/abm/models/joint_tour_participation.py

@@ -219,18 +219,18 @@ def participants_chooser(
  # anybody with probability > 0 is forced to join the joint tour
  if state.settings.use_explicit_error_terms:
  # need "is valid choice" such that we certainly choose those with non-zero values,
- # and do not choose others. Let's use 3.0 as large value here.
+ # and do not choose others.
  probs_or_utils[choice_col] = np.where(
  probs_or_utils[choice_col] > logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  non_choice_col = [
  col for col in probs_or_utils.columns if col != choice_col
  ][0]
  probs_or_utils[non_choice_col] = np.where(
  probs_or_utils[choice_col] <= logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  else:

activitysim/core/interaction_sample_simulate.py

@@ -337,9 +337,7 @@ def _interaction_sample_simulate(
  if zero_probs.any():
  # copied from proabability below, fix when that gets fixed
  # FIXME this is kind of gnarly, but we force choice of first alt
- utilities_df.loc[
- zero_probs, 0
- ] = 3.0 # arbitrary value much larger than UTIL_UNAVAILABLE
+ utilities_df.loc[zero_probs, 0] = logit.UTIL_LARGE_ENOUGH
 
  # 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
@@ -430,9 +428,6 @@ def _interaction_sample_simulate(
  # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
  choices = alternatives[choice_column].take(positions + first_row_offsets)
 
- # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
- choices = alternatives[choice_column].take(positions + first_row_offsets)
-
  # create a series with index from choosers and the index of the chosen alternative
  choices = pd.Series(choices, index=choosers.index)
 

activitysim/core/logit.py

@@ -29,6 +29,13 @@
 UTIL_MIN = np.log(EXP_UTIL_MIN, dtype=np.float64)
 UTIL_UNAVAILABLE = 1000.0 * (UTIL_MIN - 1.0)
 
+# Utility assigned to an alternative that must be chosen over UTIL_UNAVAILABLE
+# alternatives, e.g. when forcing a choice for a chooser that would otherwise
+# have no available alternative. Any finite value works: the gap to
+# UTIL_UNAVAILABLE is many orders of magnitude larger than the EV1 error terms
+# added by the explicit error term choice methods.
+UTIL_LARGE_ENOUGH = 3.0
+
 PROB_MIN = 0.0
 PROB_MAX = 1.0
 
@@ -640,6 +647,7 @@ def make_choices_utility_based(
  nest_spec=None,
  alts_context: AltsContext | None = None,
  alt_nrs_df: pd.DataFrame | None = None,
+ allow_zero_probs: bool = False,
 ) -> tuple[pd.Series, pd.Series]:
  """
  Make choices for each chooser from among a set of alternatives based on utilities by adding
@@ -666,6 +674,11 @@ def make_choices_utility_based(
  the alt_nrs for each alternative for each chooser. This is used to index into the random numbers when sampling
  EET terms for multinomial logit models, and should contain -999 for any alternatives that are not available
  for a given chooser. Should be provided along with `alts_context`.
+ allow_zero_probs : bool
+ If False, report choosers that have no available alternative at all. This is the
+ utility-space counterpart of `allow_bad_probs` in `make_choices`, and takes the
+ name `allow_zero_probs` because the condition it suppresses is the same one that
+ `validate_utils` and `utils_to_probs` describe by that name.
 
  Returns
  -------
@@ -677,14 +690,36 @@ def make_choices_utility_based(
 
  Notes
  -----
- Bad-row reporting (e.g., a chooser whose alternatives are all `UTIL_UNAVAILABLE`) is the
- responsibility of `validate_utils()`, which is invoked at every EET call site
- (interaction_sample, interaction_sample_simulate, simulate.eval_mnl, simulate.eval_nl)
- BEFORE this function is called. EET argmax always returns a valid integer position;
- we do not re-check here.
+ An argmax always returns a position, so a chooser with no available alternative gets a
+ choice here rather than an error: with every utility at `UTIL_UNAVAILABLE` the alternatives
+ are tied and the error terms decide, and with every utility at `-inf` the first column wins.
+ The Monte Carlo path does not go quiet in that situation -- `make_choices` reports it unless
+ `allow_bad_probs` is set -- so this function reports it too. Most callers reach here having
+ already run `validate_utils`, which makes the same check; the duplication is deliberate and
+ mirrors `make_choices` re-checking what `utils_to_probs` has already looked at.
  """
  trace_label = tracing.extend_trace_label(trace_label, "make_choices_utility_based")
 
+ if not allow_zero_probs:
+ # An alternative counts as available when its utility exceeds UTIL_MIN, which is the
+ # same threshold validate_utils uses before clamping to UTIL_UNAVAILABLE. Testing the
+ # threshold directly rather than testing the row sum against a multiple of
+ # UTIL_UNAVAILABLE means this also holds for callers that arrive without having run
+ # validate_utils, where unavailable alternatives may still carry their raw value.
+ no_available_alts = ~(utilities.to_numpy() > UTIL_MIN).any(axis=1)
+ if no_available_alts.any():
+ report_bad_choices(
+ state,
+ no_available_alts,
+ utilities,
+ state.settings.skip_failed_choices,
+ trace_label=tracing.extend_trace_label(
+ trace_label, "no_available_alts"
+ ),
+ msg="no alternative is available",
+ trace_choosers=trace_choosers,
+ )
+
  if nest_spec is None:
  choices = make_choices_explicit_error_term_mnl(
  state,

activitysim/core/random.py

@@ -441,7 +441,9 @@ def gumbel_choice_positions_for_df(
  alt_nrs_df : pandas.DataFrame, optional
  DataFrame aligned to `utilities` whose values identify which dense alternative
  each utility column corresponds to. Use `MASKED_ALT_ID` (-999) for masked or
- unavailable positions; any other negative value raises ValueError.
+ unavailable positions; any other negative value raises ValueError. A row that
+ is masked in every column is taken to mean the chooser has no alternative to
+ choose from, and returns position 0.
  n_rands : int, optional
  Number of EV1 draws to generate per chooser row. Required when `alt_nrs_df`
  is provided and may exceed the visible number of utility columns.
@@ -461,7 +463,12 @@ def gumbel_choice_positions_for_df(
  positions = np.empty(n_rows, dtype=np.int64)
 
  if alt_nrs_df is not None:
- assert alt_nrs_df.shape == utilities.shape
+ assert alt_nrs_df.index.equals(
+ utilities.index
+ ), "alt_nrs_df and utilities must share the same index"
+ assert alt_nrs_df.columns.equals(
+ utilities.columns
+ ), "alt_nrs_df and utilities must share the same columns"
  if n_rands is None:
  raise ValueError("n_rands is required when alt_nrs_df is provided")
  alt_nr_values = alt_nrs_df.to_numpy()
@@ -474,6 +481,7 @@ def gumbel_choice_positions_for_df(
  f"{MASKED_ALT_ID} sentinel: {offenders}"
  )
  masked = alt_nr_values == MASKED_ALT_ID
+ active_mask = ~masked
  safe_alt_nrs = np.where(masked, 0, alt_nr_values)
  else:
  if n_rands is None:
@@ -482,7 +490,7 @@ def gumbel_choice_positions_for_df(
  raise ValueError(
  "n_rands must equal utilities.shape[1] when alt_nrs_df is omitted"
  )
- alt_nr_values = masked = safe_alt_nrs = None
+ alt_nr_values = masked = active_mask = safe_alt_nrs = None
 
  generators = self._generators_for_df(utilities)
 
@@ -495,16 +503,21 @@ def gumbel_choice_positions_for_df(
  utility_row - np.log(-np.log(row_randoms))
  )
  else:
- # Masked positions are set to -inf so they cannot win argmax,
- # and the gumbel transform is skipped for them entirely.
- row_mask = masked[row_num]
- candidate_values = np.full(n_alts, -np.inf, dtype=np.float64)
- active = ~row_mask
- if active.any():
- candidate_values[active] = utility_row[active] - np.log(
- -np.log(row_randoms[safe_alt_nrs[row_num, active]])
- )
- positions[row_num] = np.argmax(candidate_values)
+ # Masked positions can never be chosen, so apply the gumbel transform and argmax
+ # only to the active ones. flatnonzero returns ascending indices, so ties resolve
+ # to the lowest column position, which is what a full-width argmax would have done.
+ active = np.flatnonzero(active_mask[row_num])
+ if active.size == 0:
+ # The chooser has no alternative available at all. Return the first
+ # column by convention. Note that logit.make_choices_utility_based filters
+ # out choosers with no available alternatives, so this case will only occur
+ # when explicitly allowed by the caller.
+ positions[row_num] = 0
+ continue
+ gumbel = utility_row[active] - np.log(
+ -np.log(row_randoms[safe_alt_nrs[row_num, active]])
+ )
+ positions[row_num] = active[np.argmax(gumbel)]
 
  self.row_states.loc[utilities.index, "offset"] += n_rands
  return positions

activitysim/core/simulate.py

@@ -1553,7 +1553,7 @@ def eval_nl(
 
  if state.settings.use_explicit_error_terms:
  raw_utilities = logit.validate_utils(
- state, raw_utilities, allow_zero_probs=True, trace_label=trace_label
+ state, raw_utilities, trace_label=trace_label
  )
 
  if custom_chooser:

activitysim/abm/models/joint_tour_participation.py

@@ -219,18 +219,18 @@ def participants_chooser(
  # anybody with probability > 0 is forced to join the joint tour
  if state.settings.use_explicit_error_terms:
  # need "is valid choice" such that we certainly choose those with non-zero values,
- # and do not choose others. Let's use 3.0 as large value here.
+ # and do not choose others.
  probs_or_utils[choice_col] = np.where(
  probs_or_utils[choice_col] > logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  non_choice_col = [
  col for col in probs_or_utils.columns if col != choice_col
  ][0]
  probs_or_utils[non_choice_col] = np.where(
  probs_or_utils[choice_col] <= logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  else:

activitysim/core/interaction_sample_simulate.py

@@ -337,9 +337,7 @@ def _interaction_sample_simulate(
  if zero_probs.any():
  # copied from proabability below, fix when that gets fixed
  # FIXME this is kind of gnarly, but we force choice of first alt
- utilities_df.loc[
- zero_probs, 0
- ] = 3.0 # arbitrary value much larger than UTIL_UNAVAILABLE
+ utilities_df.loc[zero_probs, 0] = logit.UTIL_LARGE_ENOUGH
 
  # 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
@@ -430,9 +428,6 @@ def _interaction_sample_simulate(
  # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
  choices = alternatives[choice_column].take(positions + first_row_offsets)
 
- # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
- choices = alternatives[choice_column].take(positions + first_row_offsets)
-
  # create a series with index from choosers and the index of the chosen alternative
  choices = pd.Series(choices, index=choosers.index)
 

activitysim/core/logit.py

@@ -29,6 +29,13 @@
 UTIL_MIN = np.log(EXP_UTIL_MIN, dtype=np.float64)
 UTIL_UNAVAILABLE = 1000.0 * (UTIL_MIN - 1.0)
 
+# Utility assigned to an alternative that must be chosen over UTIL_UNAVAILABLE
+# alternatives, e.g. when forcing a choice for a chooser that would otherwise
+# have no available alternative. Any finite value works: the gap to
+# UTIL_UNAVAILABLE is many orders of magnitude larger than the EV1 error terms
+# added by the explicit error term choice methods.
+UTIL_LARGE_ENOUGH = 3.0
+
 PROB_MIN = 0.0
 PROB_MAX = 1.0
 
@@ -640,6 +647,7 @@ def make_choices_utility_based(
  nest_spec=None,
  alts_context: AltsContext | None = None,
  alt_nrs_df: pd.DataFrame | None = None,
+ allow_zero_probs: bool = False,
 ) -> tuple[pd.Series, pd.Series]:
  """
  Make choices for each chooser from among a set of alternatives based on utilities by adding
@@ -666,6 +674,11 @@ def make_choices_utility_based(
  the alt_nrs for each alternative for each chooser. This is used to index into the random numbers when sampling
  EET terms for multinomial logit models, and should contain -999 for any alternatives that are not available
  for a given chooser. Should be provided along with `alts_context`.
+ allow_zero_probs : bool
+ If False, report choosers that have no available alternative at all. This is the
+ utility-space counterpart of `allow_bad_probs` in `make_choices`, and takes the
+ name `allow_zero_probs` because the condition it suppresses is the same one that
+ `validate_utils` and `utils_to_probs` describe by that name.
 
  Returns
  -------
@@ -677,14 +690,36 @@ def make_choices_utility_based(
 
  Notes
  -----
- Bad-row reporting (e.g., a chooser whose alternatives are all `UTIL_UNAVAILABLE`) is the
- responsibility of `validate_utils()`, which is invoked at every EET call site
- (interaction_sample, interaction_sample_simulate, simulate.eval_mnl, simulate.eval_nl)
- BEFORE this function is called. EET argmax always returns a valid integer position;
- we do not re-check here.
+ An argmax always returns a position, so a chooser with no available alternative gets a
+ choice here rather than an error: with every utility at `UTIL_UNAVAILABLE` the alternatives
+ are tied and the error terms decide, and with every utility at `-inf` the first column wins.
+ The Monte Carlo path does not go quiet in that situation -- `make_choices` reports it unless
+ `allow_bad_probs` is set -- so this function reports it too. Most callers reach here having
+ already run `validate_utils`, which makes the same check; the duplication is deliberate and
+ mirrors `make_choices` re-checking what `utils_to_probs` has already looked at.
  """
  trace_label = tracing.extend_trace_label(trace_label, "make_choices_utility_based")
 
+ if not allow_zero_probs:
+ # An alternative counts as available when its utility exceeds UTIL_MIN, which is the
+ # same threshold validate_utils uses before clamping to UTIL_UNAVAILABLE. Testing the
+ # threshold directly rather than testing the row sum against a multiple of
+ # UTIL_UNAVAILABLE means this also holds for callers that arrive without having run
+ # validate_utils, where unavailable alternatives may still carry their raw value.
+ no_available_alts = ~(utilities.to_numpy() > UTIL_MIN).any(axis=1)
+ if no_available_alts.any():
+ report_bad_choices(
+ state,
+ no_available_alts,
+ utilities,
+ state.settings.skip_failed_choices,
+ trace_label=tracing.extend_trace_label(
+ trace_label, "no_available_alts"
+ ),
+ msg="no alternative is available",
+ trace_choosers=trace_choosers,
+ )
+
  if nest_spec is None:
  choices = make_choices_explicit_error_term_mnl(
  state,

activitysim/core/random.py

@@ -441,7 +441,9 @@ def gumbel_choice_positions_for_df(
  alt_nrs_df : pandas.DataFrame, optional
  DataFrame aligned to `utilities` whose values identify which dense alternative
  each utility column corresponds to. Use `MASKED_ALT_ID` (-999) for masked or
- unavailable positions; any other negative value raises ValueError.
+ unavailable positions; any other negative value raises ValueError. A row that
+ is masked in every column is taken to mean the chooser has no alternative to
+ choose from, and returns position 0.
  n_rands : int, optional
  Number of EV1 draws to generate per chooser row. Required when `alt_nrs_df`
  is provided and may exceed the visible number of utility columns.
@@ -461,7 +463,12 @@ def gumbel_choice_positions_for_df(
  positions = np.empty(n_rows, dtype=np.int64)
 
  if alt_nrs_df is not None:
- assert alt_nrs_df.shape == utilities.shape
+ assert alt_nrs_df.index.equals(
+ utilities.index
+ ), "alt_nrs_df and utilities must share the same index"
+ assert alt_nrs_df.columns.equals(
+ utilities.columns
+ ), "alt_nrs_df and utilities must share the same columns"
  if n_rands is None:
  raise ValueError("n_rands is required when alt_nrs_df is provided")
  alt_nr_values = alt_nrs_df.to_numpy()
@@ -474,6 +481,7 @@ def gumbel_choice_positions_for_df(
  f"{MASKED_ALT_ID} sentinel: {offenders}"
  )
  masked = alt_nr_values == MASKED_ALT_ID
+ active_mask = ~masked
  safe_alt_nrs = np.where(masked, 0, alt_nr_values)
  else:
  if n_rands is None:
@@ -482,7 +490,7 @@ def gumbel_choice_positions_for_df(
  raise ValueError(
  "n_rands must equal utilities.shape[1] when alt_nrs_df is omitted"
  )
- alt_nr_values = masked = safe_alt_nrs = None
+ alt_nr_values = masked = active_mask = safe_alt_nrs = None
 
  generators = self._generators_for_df(utilities)
 
@@ -495,16 +503,21 @@ def gumbel_choice_positions_for_df(
  utility_row - np.log(-np.log(row_randoms))
  )
  else:
- # Masked positions are set to -inf so they cannot win argmax,
- # and the gumbel transform is skipped for them entirely.
- row_mask = masked[row_num]
- candidate_values = np.full(n_alts, -np.inf, dtype=np.float64)
- active = ~row_mask
- if active.any():
- candidate_values[active] = utility_row[active] - np.log(
- -np.log(row_randoms[safe_alt_nrs[row_num, active]])
- )
- positions[row_num] = np.argmax(candidate_values)
+ # Masked positions can never be chosen, so apply the gumbel transform and argmax
+ # only to the active ones. flatnonzero returns ascending indices, so ties resolve
+ # to the lowest column position, which is what a full-width argmax would have done.
+ active = np.flatnonzero(active_mask[row_num])
+ if active.size == 0:
+ # The chooser has no alternative available at all. Return the first
+ # column by convention. Note that logit.make_choices_utility_based filters
+ # out choosers with no available alternatives, so this case will only occur
+ # when explicitly allowed by the caller.
+ positions[row_num] = 0
+ continue
+ gumbel = utility_row[active] - np.log(
+ -np.log(row_randoms[safe_alt_nrs[row_num, active]])
+ )
+ positions[row_num] = active[np.argmax(gumbel)]
 
  self.row_states.loc[utilities.index, "offset"] += n_rands
  return positions

activitysim/core/simulate.py

@@ -1553,7 +1553,7 @@ def eval_nl(
 
  if state.settings.use_explicit_error_terms:
  raw_utilities = logit.validate_utils(
- state, raw_utilities, allow_zero_probs=True, trace_label=trace_label
+ state, raw_utilities, trace_label=trace_label
  )
 
  if custom_chooser:

activitysim/abm/models/joint_tour_participation.py

@@ -219,18 +219,18 @@ def participants_chooser(
  # anybody with probability > 0 is forced to join the joint tour
  if state.settings.use_explicit_error_terms:
  # need "is valid choice" such that we certainly choose those with non-zero values,
- # and do not choose others. Let's use 3.0 as large value here.
+ # and do not choose others.
  probs_or_utils[choice_col] = np.where(
  probs_or_utils[choice_col] > logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  non_choice_col = [
  col for col in probs_or_utils.columns if col != choice_col
  ][0]
  probs_or_utils[non_choice_col] = np.where(
  probs_or_utils[choice_col] <= logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  else:

activitysim/core/interaction_sample_simulate.py

@@ -337,9 +337,7 @@ def _interaction_sample_simulate(
  if zero_probs.any():
  # copied from proabability below, fix when that gets fixed
  # FIXME this is kind of gnarly, but we force choice of first alt
- utilities_df.loc[
- zero_probs, 0
- ] = 3.0 # arbitrary value much larger than UTIL_UNAVAILABLE
+ utilities_df.loc[zero_probs, 0] = logit.UTIL_LARGE_ENOUGH
 
  # 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
@@ -430,9 +428,6 @@ def _interaction_sample_simulate(
  # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
  choices = alternatives[choice_column].take(positions + first_row_offsets)
 
- # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
- choices = alternatives[choice_column].take(positions + first_row_offsets)
-
  # create a series with index from choosers and the index of the chosen alternative
  choices = pd.Series(choices, index=choosers.index)
 

activitysim/core/logit.py

@@ -29,6 +29,13 @@
 UTIL_MIN = np.log(EXP_UTIL_MIN, dtype=np.float64)
 UTIL_UNAVAILABLE = 1000.0 * (UTIL_MIN - 1.0)
 
+# Utility assigned to an alternative that must be chosen over UTIL_UNAVAILABLE
+# alternatives, e.g. when forcing a choice for a chooser that would otherwise
+# have no available alternative. Any finite value works: the gap to
+# UTIL_UNAVAILABLE is many orders of magnitude larger than the EV1 error terms
+# added by the explicit error term choice methods.
+UTIL_LARGE_ENOUGH = 3.0
+
 PROB_MIN = 0.0
 PROB_MAX = 1.0
 
@@ -640,6 +647,7 @@ def make_choices_utility_based(
  nest_spec=None,
  alts_context: AltsContext | None = None,
  alt_nrs_df: pd.DataFrame | None = None,
+ allow_zero_probs: bool = False,
 ) -> tuple[pd.Series, pd.Series]:
  """
  Make choices for each chooser from among a set of alternatives based on utilities by adding
@@ -666,6 +674,11 @@ def make_choices_utility_based(
  the alt_nrs for each alternative for each chooser. This is used to index into the random numbers when sampling
  EET terms for multinomial logit models, and should contain -999 for any alternatives that are not available
  for a given chooser. Should be provided along with `alts_context`.
+ allow_zero_probs : bool
+ If False, report choosers that have no available alternative at all. This is the
+ utility-space counterpart of `allow_bad_probs` in `make_choices`, and takes the
+ name `allow_zero_probs` because the condition it suppresses is the same one that
+ `validate_utils` and `utils_to_probs` describe by that name.
 
  Returns
  -------
@@ -677,14 +690,36 @@ def make_choices_utility_based(
 
  Notes
  -----
- Bad-row reporting (e.g., a chooser whose alternatives are all `UTIL_UNAVAILABLE`) is the
- responsibility of `validate_utils()`, which is invoked at every EET call site
- (interaction_sample, interaction_sample_simulate, simulate.eval_mnl, simulate.eval_nl)
- BEFORE this function is called. EET argmax always returns a valid integer position;
- we do not re-check here.
+ An argmax always returns a position, so a chooser with no available alternative gets a
+ choice here rather than an error: with every utility at `UTIL_UNAVAILABLE` the alternatives
+ are tied and the error terms decide, and with every utility at `-inf` the first column wins.
+ The Monte Carlo path does not go quiet in that situation -- `make_choices` reports it unless
+ `allow_bad_probs` is set -- so this function reports it too. Most callers reach here having
+ already run `validate_utils`, which makes the same check; the duplication is deliberate and
+ mirrors `make_choices` re-checking what `utils_to_probs` has already looked at.
  """
  trace_label = tracing.extend_trace_label(trace_label, "make_choices_utility_based")
 
+ if not allow_zero_probs:
+ # An alternative counts as available when its utility exceeds UTIL_MIN, which is the
+ # same threshold validate_utils uses before clamping to UTIL_UNAVAILABLE. Testing the
+ # threshold directly rather than testing the row sum against a multiple of
+ # UTIL_UNAVAILABLE means this also holds for callers that arrive without having run
+ # validate_utils, where unavailable alternatives may still carry their raw value.
+ no_available_alts = ~(utilities.to_numpy() > UTIL_MIN).any(axis=1)
+ if no_available_alts.any():
+ report_bad_choices(
+ state,
+ no_available_alts,
+ utilities,
+ state.settings.skip_failed_choices,
+ trace_label=tracing.extend_trace_label(
+ trace_label, "no_available_alts"
+ ),
+ msg="no alternative is available",
+ trace_choosers=trace_choosers,
+ )
+
  if nest_spec is None:
  choices = make_choices_explicit_error_term_mnl(
  state,

activitysim/core/random.py

@@ -441,7 +441,9 @@ def gumbel_choice_positions_for_df(
  alt_nrs_df : pandas.DataFrame, optional
  DataFrame aligned to `utilities` whose values identify which dense alternative
  each utility column corresponds to. Use `MASKED_ALT_ID` (-999) for masked or
- unavailable positions; any other negative value raises ValueError.
+ unavailable positions; any other negative value raises ValueError. A row that
+ is masked in every column is taken to mean the chooser has no alternative to
+ choose from, and returns position 0.
  n_rands : int, optional
  Number of EV1 draws to generate per chooser row. Required when `alt_nrs_df`
  is provided and may exceed the visible number of utility columns.
@@ -461,7 +463,12 @@ def gumbel_choice_positions_for_df(
  positions = np.empty(n_rows, dtype=np.int64)
 
  if alt_nrs_df is not None:
- assert alt_nrs_df.shape == utilities.shape
+ assert alt_nrs_df.index.equals(
+ utilities.index
+ ), "alt_nrs_df and utilities must share the same index"
+ assert alt_nrs_df.columns.equals(
+ utilities.columns
+ ), "alt_nrs_df and utilities must share the same columns"
  if n_rands is None:
  raise ValueError("n_rands is required when alt_nrs_df is provided")
  alt_nr_values = alt_nrs_df.to_numpy()
@@ -474,6 +481,7 @@ def gumbel_choice_positions_for_df(
  f"{MASKED_ALT_ID} sentinel: {offenders}"
  )
  masked = alt_nr_values == MASKED_ALT_ID
+ active_mask = ~masked
  safe_alt_nrs = np.where(masked, 0, alt_nr_values)
  else:
  if n_rands is None:
@@ -482,7 +490,7 @@ def gumbel_choice_positions_for_df(
  raise ValueError(
  "n_rands must equal utilities.shape[1] when alt_nrs_df is omitted"
  )
- alt_nr_values = masked = safe_alt_nrs = None
+ alt_nr_values = masked = active_mask = safe_alt_nrs = None
 
  generators = self._generators_for_df(utilities)
 
@@ -495,16 +503,21 @@ def gumbel_choice_positions_for_df(
  utility_row - np.log(-np.log(row_randoms))
  )
  else:
- # Masked positions are set to -inf so they cannot win argmax,
- # and the gumbel transform is skipped for them entirely.
- row_mask = masked[row_num]
- candidate_values = np.full(n_alts, -np.inf, dtype=np.float64)
- active = ~row_mask
- if active.any():
- candidate_values[active] = utility_row[active] - np.log(
- -np.log(row_randoms[safe_alt_nrs[row_num, active]])
- )
- positions[row_num] = np.argmax(candidate_values)
+ # Masked positions can never be chosen, so apply the gumbel transform and argmax
+ # only to the active ones. flatnonzero returns ascending indices, so ties resolve
+ # to the lowest column position, which is what a full-width argmax would have done.
+ active = np.flatnonzero(active_mask[row_num])
+ if active.size == 0:
+ # The chooser has no alternative available at all. Return the first
+ # column by convention. Note that logit.make_choices_utility_based filters
+ # out choosers with no available alternatives, so this case will only occur
+ # when explicitly allowed by the caller.
+ positions[row_num] = 0
+ continue
+ gumbel = utility_row[active] - np.log(
+ -np.log(row_randoms[safe_alt_nrs[row_num, active]])
+ )
+ positions[row_num] = active[np.argmax(gumbel)]
 
  self.row_states.loc[utilities.index, "offset"] += n_rands
  return positions

activitysim/core/simulate.py

@@ -1553,7 +1553,7 @@ def eval_nl(
 
  if state.settings.use_explicit_error_terms:
  raw_utilities = logit.validate_utils(
- state, raw_utilities, allow_zero_probs=True, trace_label=trace_label
+ state, raw_utilities, trace_label=trace_label
  )
 
  if custom_chooser:

activitysim/abm/models/joint_tour_participation.py

@@ -219,18 +219,18 @@ def participants_chooser(
  # anybody with probability > 0 is forced to join the joint tour
  if state.settings.use_explicit_error_terms:
  # need "is valid choice" such that we certainly choose those with non-zero values,
- # and do not choose others. Let's use 3.0 as large value here.
+ # and do not choose others.
  probs_or_utils[choice_col] = np.where(
  probs_or_utils[choice_col] > logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  non_choice_col = [
  col for col in probs_or_utils.columns if col != choice_col
  ][0]
  probs_or_utils[non_choice_col] = np.where(
  probs_or_utils[choice_col] <= logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  else:

activitysim/core/interaction_sample_simulate.py

@@ -337,9 +337,7 @@ def _interaction_sample_simulate(
  if zero_probs.any():
  # copied from proabability below, fix when that gets fixed
  # FIXME this is kind of gnarly, but we force choice of first alt
- utilities_df.loc[
- zero_probs, 0
- ] = 3.0 # arbitrary value much larger than UTIL_UNAVAILABLE
+ utilities_df.loc[zero_probs, 0] = logit.UTIL_LARGE_ENOUGH
 
  # 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
@@ -430,9 +428,6 @@ def _interaction_sample_simulate(
  # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
  choices = alternatives[choice_column].take(positions + first_row_offsets)
 
- # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
- choices = alternatives[choice_column].take(positions + first_row_offsets)
-
  # create a series with index from choosers and the index of the chosen alternative
  choices = pd.Series(choices, index=choosers.index)
 

activitysim/core/logit.py

@@ -29,6 +29,13 @@
 UTIL_MIN = np.log(EXP_UTIL_MIN, dtype=np.float64)
 UTIL_UNAVAILABLE = 1000.0 * (UTIL_MIN - 1.0)
 
+# Utility assigned to an alternative that must be chosen over UTIL_UNAVAILABLE
+# alternatives, e.g. when forcing a choice for a chooser that would otherwise
+# have no available alternative. Any finite value works: the gap to
+# UTIL_UNAVAILABLE is many orders of magnitude larger than the EV1 error terms
+# added by the explicit error term choice methods.
+UTIL_LARGE_ENOUGH = 3.0
+
 PROB_MIN = 0.0
 PROB_MAX = 1.0
 
@@ -640,6 +647,7 @@ def make_choices_utility_based(
  nest_spec=None,
  alts_context: AltsContext | None = None,
  alt_nrs_df: pd.DataFrame | None = None,
+ allow_zero_probs: bool = False,
 ) -> tuple[pd.Series, pd.Series]:
  """
  Make choices for each chooser from among a set of alternatives based on utilities by adding
@@ -666,6 +674,11 @@ def make_choices_utility_based(
  the alt_nrs for each alternative for each chooser. This is used to index into the random numbers when sampling
  EET terms for multinomial logit models, and should contain -999 for any alternatives that are not available
  for a given chooser. Should be provided along with `alts_context`.
+ allow_zero_probs : bool
+ If False, report choosers that have no available alternative at all. This is the
+ utility-space counterpart of `allow_bad_probs` in `make_choices`, and takes the
+ name `allow_zero_probs` because the condition it suppresses is the same one that
+ `validate_utils` and `utils_to_probs` describe by that name.
 
  Returns
  -------
@@ -677,14 +690,36 @@ def make_choices_utility_based(
 
  Notes
  -----
- Bad-row reporting (e.g., a chooser whose alternatives are all `UTIL_UNAVAILABLE`) is the
- responsibility of `validate_utils()`, which is invoked at every EET call site
- (interaction_sample, interaction_sample_simulate, simulate.eval_mnl, simulate.eval_nl)
- BEFORE this function is called. EET argmax always returns a valid integer position;
- we do not re-check here.
+ An argmax always returns a position, so a chooser with no available alternative gets a
+ choice here rather than an error: with every utility at `UTIL_UNAVAILABLE` the alternatives
+ are tied and the error terms decide, and with every utility at `-inf` the first column wins.
+ The Monte Carlo path does not go quiet in that situation -- `make_choices` reports it unless
+ `allow_bad_probs` is set -- so this function reports it too. Most callers reach here having
+ already run `validate_utils`, which makes the same check; the duplication is deliberate and
+ mirrors `make_choices` re-checking what `utils_to_probs` has already looked at.
  """
  trace_label = tracing.extend_trace_label(trace_label, "make_choices_utility_based")
 
+ if not allow_zero_probs:
+ # An alternative counts as available when its utility exceeds UTIL_MIN, which is the
+ # same threshold validate_utils uses before clamping to UTIL_UNAVAILABLE. Testing the
+ # threshold directly rather than testing the row sum against a multiple of
+ # UTIL_UNAVAILABLE means this also holds for callers that arrive without having run
+ # validate_utils, where unavailable alternatives may still carry their raw value.
+ no_available_alts = ~(utilities.to_numpy() > UTIL_MIN).any(axis=1)
+ if no_available_alts.any():
+ report_bad_choices(
+ state,
+ no_available_alts,
+ utilities,
+ state.settings.skip_failed_choices,
+ trace_label=tracing.extend_trace_label(
+ trace_label, "no_available_alts"
+ ),
+ msg="no alternative is available",
+ trace_choosers=trace_choosers,
+ )
+
  if nest_spec is None:
  choices = make_choices_explicit_error_term_mnl(
  state,

activitysim/core/random.py

@@ -441,7 +441,9 @@ def gumbel_choice_positions_for_df(
  alt_nrs_df : pandas.DataFrame, optional
  DataFrame aligned to `utilities` whose values identify which dense alternative
  each utility column corresponds to. Use `MASKED_ALT_ID` (-999) for masked or
- unavailable positions; any other negative value raises ValueError.
+ unavailable positions; any other negative value raises ValueError. A row that
+ is masked in every column is taken to mean the chooser has no alternative to
+ choose from, and returns position 0.
  n_rands : int, optional
  Number of EV1 draws to generate per chooser row. Required when `alt_nrs_df`
  is provided and may exceed the visible number of utility columns.
@@ -461,7 +463,12 @@ def gumbel_choice_positions_for_df(
  positions = np.empty(n_rows, dtype=np.int64)
 
  if alt_nrs_df is not None:
- assert alt_nrs_df.shape == utilities.shape
+ assert alt_nrs_df.index.equals(
+ utilities.index
+ ), "alt_nrs_df and utilities must share the same index"
+ assert alt_nrs_df.columns.equals(
+ utilities.columns
+ ), "alt_nrs_df and utilities must share the same columns"
  if n_rands is None:
  raise ValueError("n_rands is required when alt_nrs_df is provided")
  alt_nr_values = alt_nrs_df.to_numpy()
@@ -474,6 +481,7 @@ def gumbel_choice_positions_for_df(
  f"{MASKED_ALT_ID} sentinel: {offenders}"
  )
  masked = alt_nr_values == MASKED_ALT_ID
+ active_mask = ~masked
  safe_alt_nrs = np.where(masked, 0, alt_nr_values)
  else:
  if n_rands is None:
@@ -482,7 +490,7 @@ def gumbel_choice_positions_for_df(
  raise ValueError(
  "n_rands must equal utilities.shape[1] when alt_nrs_df is omitted"
  )
- alt_nr_values = masked = safe_alt_nrs = None
+ alt_nr_values = masked = active_mask = safe_alt_nrs = None
 
  generators = self._generators_for_df(utilities)
 
@@ -495,16 +503,21 @@ def gumbel_choice_positions_for_df(
  utility_row - np.log(-np.log(row_randoms))
  )
  else:
- # Masked positions are set to -inf so they cannot win argmax,
- # and the gumbel transform is skipped for them entirely.
- row_mask = masked[row_num]
- candidate_values = np.full(n_alts, -np.inf, dtype=np.float64)
- active = ~row_mask
- if active.any():
- candidate_values[active] = utility_row[active] - np.log(
- -np.log(row_randoms[safe_alt_nrs[row_num, active]])
- )
- positions[row_num] = np.argmax(candidate_values)
+ # Masked positions can never be chosen, so apply the gumbel transform and argmax
+ # only to the active ones. flatnonzero returns ascending indices, so ties resolve
+ # to the lowest column position, which is what a full-width argmax would have done.
+ active = np.flatnonzero(active_mask[row_num])
+ if active.size == 0:
+ # The chooser has no alternative available at all. Return the first
+ # column by convention. Note that logit.make_choices_utility_based filters
+ # out choosers with no available alternatives, so this case will only occur
+ # when explicitly allowed by the caller.
+ positions[row_num] = 0
+ continue
+ gumbel = utility_row[active] - np.log(
+ -np.log(row_randoms[safe_alt_nrs[row_num, active]])
+ )
+ positions[row_num] = active[np.argmax(gumbel)]
 
  self.row_states.loc[utilities.index, "offset"] += n_rands
  return positions

activitysim/core/simulate.py

@@ -1553,7 +1553,7 @@ def eval_nl(
 
  if state.settings.use_explicit_error_terms:
  raw_utilities = logit.validate_utils(
- state, raw_utilities, allow_zero_probs=True, trace_label=trace_label
+ state, raw_utilities, trace_label=trace_label
  )
 
  if custom_chooser:

activitysim/abm/models/joint_tour_participation.py

@@ -219,18 +219,18 @@ def participants_chooser(
  # anybody with probability > 0 is forced to join the joint tour
  if state.settings.use_explicit_error_terms:
  # need "is valid choice" such that we certainly choose those with non-zero values,
- # and do not choose others. Let's use 3.0 as large value here.
+ # and do not choose others.
  probs_or_utils[choice_col] = np.where(
  probs_or_utils[choice_col] > logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  non_choice_col = [
  col for col in probs_or_utils.columns if col != choice_col
  ][0]
  probs_or_utils[non_choice_col] = np.where(
  probs_or_utils[choice_col] <= logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  else:

activitysim/core/interaction_sample_simulate.py

@@ -337,9 +337,7 @@ def _interaction_sample_simulate(
  if zero_probs.any():
  # copied from proabability below, fix when that gets fixed
  # FIXME this is kind of gnarly, but we force choice of first alt
- utilities_df.loc[
- zero_probs, 0
- ] = 3.0 # arbitrary value much larger than UTIL_UNAVAILABLE
+ utilities_df.loc[zero_probs, 0] = logit.UTIL_LARGE_ENOUGH
 
  # 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
@@ -430,9 +428,6 @@ def _interaction_sample_simulate(
  # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
  choices = alternatives[choice_column].take(positions + first_row_offsets)
 
- # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
- choices = alternatives[choice_column].take(positions + first_row_offsets)
-
  # create a series with index from choosers and the index of the chosen alternative
  choices = pd.Series(choices, index=choosers.index)
 

activitysim/core/logit.py

@@ -29,6 +29,13 @@
 UTIL_MIN = np.log(EXP_UTIL_MIN, dtype=np.float64)
 UTIL_UNAVAILABLE = 1000.0 * (UTIL_MIN - 1.0)
 
+# Utility assigned to an alternative that must be chosen over UTIL_UNAVAILABLE
+# alternatives, e.g. when forcing a choice for a chooser that would otherwise
+# have no available alternative. Any finite value works: the gap to
+# UTIL_UNAVAILABLE is many orders of magnitude larger than the EV1 error terms
+# added by the explicit error term choice methods.
+UTIL_LARGE_ENOUGH = 3.0
+
 PROB_MIN = 0.0
 PROB_MAX = 1.0
 
@@ -640,6 +647,7 @@ def make_choices_utility_based(
  nest_spec=None,
  alts_context: AltsContext | None = None,
  alt_nrs_df: pd.DataFrame | None = None,
+ allow_zero_probs: bool = False,
 ) -> tuple[pd.Series, pd.Series]:
  """
  Make choices for each chooser from among a set of alternatives based on utilities by adding
@@ -666,6 +674,11 @@ def make_choices_utility_based(
  the alt_nrs for each alternative for each chooser. This is used to index into the random numbers when sampling
  EET terms for multinomial logit models, and should contain -999 for any alternatives that are not available
  for a given chooser. Should be provided along with `alts_context`.
+ allow_zero_probs : bool
+ If False, report choosers that have no available alternative at all. This is the
+ utility-space counterpart of `allow_bad_probs` in `make_choices`, and takes the
+ name `allow_zero_probs` because the condition it suppresses is the same one that
+ `validate_utils` and `utils_to_probs` describe by that name.
 
  Returns
  -------
@@ -677,14 +690,36 @@ def make_choices_utility_based(
 
  Notes
  -----
- Bad-row reporting (e.g., a chooser whose alternatives are all `UTIL_UNAVAILABLE`) is the
- responsibility of `validate_utils()`, which is invoked at every EET call site
- (interaction_sample, interaction_sample_simulate, simulate.eval_mnl, simulate.eval_nl)
- BEFORE this function is called. EET argmax always returns a valid integer position;
- we do not re-check here.
+ An argmax always returns a position, so a chooser with no available alternative gets a
+ choice here rather than an error: with every utility at `UTIL_UNAVAILABLE` the alternatives
+ are tied and the error terms decide, and with every utility at `-inf` the first column wins.
+ The Monte Carlo path does not go quiet in that situation -- `make_choices` reports it unless
+ `allow_bad_probs` is set -- so this function reports it too. Most callers reach here having
+ already run `validate_utils`, which makes the same check; the duplication is deliberate and
+ mirrors `make_choices` re-checking what `utils_to_probs` has already looked at.
  """
  trace_label = tracing.extend_trace_label(trace_label, "make_choices_utility_based")
 
+ if not allow_zero_probs:
+ # An alternative counts as available when its utility exceeds UTIL_MIN, which is the
+ # same threshold validate_utils uses before clamping to UTIL_UNAVAILABLE. Testing the
+ # threshold directly rather than testing the row sum against a multiple of
+ # UTIL_UNAVAILABLE means this also holds for callers that arrive without having run
+ # validate_utils, where unavailable alternatives may still carry their raw value.
+ no_available_alts = ~(utilities.to_numpy() > UTIL_MIN).any(axis=1)
+ if no_available_alts.any():
+ report_bad_choices(
+ state,
+ no_available_alts,
+ utilities,
+ state.settings.skip_failed_choices,
+ trace_label=tracing.extend_trace_label(
+ trace_label, "no_available_alts"
+ ),
+ msg="no alternative is available",
+ trace_choosers=trace_choosers,
+ )
+
  if nest_spec is None:
  choices = make_choices_explicit_error_term_mnl(
  state,

activitysim/core/random.py

@@ -441,7 +441,9 @@ def gumbel_choice_positions_for_df(
  alt_nrs_df : pandas.DataFrame, optional
  DataFrame aligned to `utilities` whose values identify which dense alternative
  each utility column corresponds to. Use `MASKED_ALT_ID` (-999) for masked or
- unavailable positions; any other negative value raises ValueError.
+ unavailable positions; any other negative value raises ValueError. A row that
+ is masked in every column is taken to mean the chooser has no alternative to
+ choose from, and returns position 0.
  n_rands : int, optional
  Number of EV1 draws to generate per chooser row. Required when `alt_nrs_df`
  is provided and may exceed the visible number of utility columns.
@@ -461,7 +463,12 @@ def gumbel_choice_positions_for_df(
  positions = np.empty(n_rows, dtype=np.int64)
 
  if alt_nrs_df is not None:
- assert alt_nrs_df.shape == utilities.shape
+ assert alt_nrs_df.index.equals(
+ utilities.index
+ ), "alt_nrs_df and utilities must share the same index"
+ assert alt_nrs_df.columns.equals(
+ utilities.columns
+ ), "alt_nrs_df and utilities must share the same columns"
  if n_rands is None:
  raise ValueError("n_rands is required when alt_nrs_df is provided")
  alt_nr_values = alt_nrs_df.to_numpy()
@@ -474,6 +481,7 @@ def gumbel_choice_positions_for_df(
  f"{MASKED_ALT_ID} sentinel: {offenders}"
  )
  masked = alt_nr_values == MASKED_ALT_ID
+ active_mask = ~masked
  safe_alt_nrs = np.where(masked, 0, alt_nr_values)
  else:
  if n_rands is None:
@@ -482,7 +490,7 @@ def gumbel_choice_positions_for_df(
  raise ValueError(
  "n_rands must equal utilities.shape[1] when alt_nrs_df is omitted"
  )
- alt_nr_values = masked = safe_alt_nrs = None
+ alt_nr_values = masked = active_mask = safe_alt_nrs = None
 
  generators = self._generators_for_df(utilities)
 
@@ -495,16 +503,21 @@ def gumbel_choice_positions_for_df(
  utility_row - np.log(-np.log(row_randoms))
  )
  else:
- # Masked positions are set to -inf so they cannot win argmax,
- # and the gumbel transform is skipped for them entirely.
- row_mask = masked[row_num]
- candidate_values = np.full(n_alts, -np.inf, dtype=np.float64)
- active = ~row_mask
- if active.any():
- candidate_values[active] = utility_row[active] - np.log(
- -np.log(row_randoms[safe_alt_nrs[row_num, active]])
- )
- positions[row_num] = np.argmax(candidate_values)
+ # Masked positions can never be chosen, so apply the gumbel transform and argmax
+ # only to the active ones. flatnonzero returns ascending indices, so ties resolve
+ # to the lowest column position, which is what a full-width argmax would have done.
+ active = np.flatnonzero(active_mask[row_num])
+ if active.size == 0:
+ # The chooser has no alternative available at all. Return the first
+ # column by convention. Note that logit.make_choices_utility_based filters
+ # out choosers with no available alternatives, so this case will only occur
+ # when explicitly allowed by the caller.
+ positions[row_num] = 0
+ continue
+ gumbel = utility_row[active] - np.log(
+ -np.log(row_randoms[safe_alt_nrs[row_num, active]])
+ )
+ positions[row_num] = active[np.argmax(gumbel)]
 
  self.row_states.loc[utilities.index, "offset"] += n_rands
  return positions

activitysim/core/simulate.py

@@ -1553,7 +1553,7 @@ def eval_nl(
 
  if state.settings.use_explicit_error_terms:
  raw_utilities = logit.validate_utils(
- state, raw_utilities, allow_zero_probs=True, trace_label=trace_label
+ state, raw_utilities, trace_label=trace_label
  )
 
  if custom_chooser:

activitysim/abm/models/joint_tour_participation.py

@@ -219,18 +219,18 @@ def participants_chooser(
  # anybody with probability > 0 is forced to join the joint tour
  if state.settings.use_explicit_error_terms:
  # need "is valid choice" such that we certainly choose those with non-zero values,
- # and do not choose others. Let's use 3.0 as large value here.
+ # and do not choose others.
  probs_or_utils[choice_col] = np.where(
  probs_or_utils[choice_col] > logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  non_choice_col = [
  col for col in probs_or_utils.columns if col != choice_col
  ][0]
  probs_or_utils[non_choice_col] = np.where(
  probs_or_utils[choice_col] <= logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  else:

activitysim/core/interaction_sample_simulate.py

@@ -337,9 +337,7 @@ def _interaction_sample_simulate(
  if zero_probs.any():
  # copied from proabability below, fix when that gets fixed
  # FIXME this is kind of gnarly, but we force choice of first alt
- utilities_df.loc[
- zero_probs, 0
- ] = 3.0 # arbitrary value much larger than UTIL_UNAVAILABLE
+ utilities_df.loc[zero_probs, 0] = logit.UTIL_LARGE_ENOUGH
 
  # 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
@@ -430,9 +428,6 @@ def _interaction_sample_simulate(
  # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
  choices = alternatives[choice_column].take(positions + first_row_offsets)
 
- # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
- choices = alternatives[choice_column].take(positions + first_row_offsets)
-
  # create a series with index from choosers and the index of the chosen alternative
  choices = pd.Series(choices, index=choosers.index)
 

activitysim/core/logit.py

@@ -29,6 +29,13 @@
 UTIL_MIN = np.log(EXP_UTIL_MIN, dtype=np.float64)
 UTIL_UNAVAILABLE = 1000.0 * (UTIL_MIN - 1.0)
 
+# Utility assigned to an alternative that must be chosen over UTIL_UNAVAILABLE
+# alternatives, e.g. when forcing a choice for a chooser that would otherwise
+# have no available alternative. Any finite value works: the gap to
+# UTIL_UNAVAILABLE is many orders of magnitude larger than the EV1 error terms
+# added by the explicit error term choice methods.
+UTIL_LARGE_ENOUGH = 3.0
+
 PROB_MIN = 0.0
 PROB_MAX = 1.0
 
@@ -640,6 +647,7 @@ def make_choices_utility_based(
  nest_spec=None,
  alts_context: AltsContext | None = None,
  alt_nrs_df: pd.DataFrame | None = None,
+ allow_zero_probs: bool = False,
 ) -> tuple[pd.Series, pd.Series]:
  """
  Make choices for each chooser from among a set of alternatives based on utilities by adding
@@ -666,6 +674,11 @@ def make_choices_utility_based(
  the alt_nrs for each alternative for each chooser. This is used to index into the random numbers when sampling
  EET terms for multinomial logit models, and should contain -999 for any alternatives that are not available
  for a given chooser. Should be provided along with `alts_context`.
+ allow_zero_probs : bool
+ If False, report choosers that have no available alternative at all. This is the
+ utility-space counterpart of `allow_bad_probs` in `make_choices`, and takes the
+ name `allow_zero_probs` because the condition it suppresses is the same one that
+ `validate_utils` and `utils_to_probs` describe by that name.
 
  Returns
  -------
@@ -677,14 +690,36 @@ def make_choices_utility_based(
 
  Notes
  -----
- Bad-row reporting (e.g., a chooser whose alternatives are all `UTIL_UNAVAILABLE`) is the
- responsibility of `validate_utils()`, which is invoked at every EET call site
- (interaction_sample, interaction_sample_simulate, simulate.eval_mnl, simulate.eval_nl)
- BEFORE this function is called. EET argmax always returns a valid integer position;
- we do not re-check here.
+ An argmax always returns a position, so a chooser with no available alternative gets a
+ choice here rather than an error: with every utility at `UTIL_UNAVAILABLE` the alternatives
+ are tied and the error terms decide, and with every utility at `-inf` the first column wins.
+ The Monte Carlo path does not go quiet in that situation -- `make_choices` reports it unless
+ `allow_bad_probs` is set -- so this function reports it too. Most callers reach here having
+ already run `validate_utils`, which makes the same check; the duplication is deliberate and
+ mirrors `make_choices` re-checking what `utils_to_probs` has already looked at.
  """
  trace_label = tracing.extend_trace_label(trace_label, "make_choices_utility_based")
 
+ if not allow_zero_probs:
+ # An alternative counts as available when its utility exceeds UTIL_MIN, which is the
+ # same threshold validate_utils uses before clamping to UTIL_UNAVAILABLE. Testing the
+ # threshold directly rather than testing the row sum against a multiple of
+ # UTIL_UNAVAILABLE means this also holds for callers that arrive without having run
+ # validate_utils, where unavailable alternatives may still carry their raw value.
+ no_available_alts = ~(utilities.to_numpy() > UTIL_MIN).any(axis=1)
+ if no_available_alts.any():
+ report_bad_choices(
+ state,
+ no_available_alts,
+ utilities,
+ state.settings.skip_failed_choices,
+ trace_label=tracing.extend_trace_label(
+ trace_label, "no_available_alts"
+ ),
+ msg="no alternative is available",
+ trace_choosers=trace_choosers,
+ )
+
  if nest_spec is None:
  choices = make_choices_explicit_error_term_mnl(
  state,

activitysim/core/random.py

@@ -441,7 +441,9 @@ def gumbel_choice_positions_for_df(
  alt_nrs_df : pandas.DataFrame, optional
  DataFrame aligned to `utilities` whose values identify which dense alternative
  each utility column corresponds to. Use `MASKED_ALT_ID` (-999) for masked or
- unavailable positions; any other negative value raises ValueError.
+ unavailable positions; any other negative value raises ValueError. A row that
+ is masked in every column is taken to mean the chooser has no alternative to
+ choose from, and returns position 0.
  n_rands : int, optional
  Number of EV1 draws to generate per chooser row. Required when `alt_nrs_df`
  is provided and may exceed the visible number of utility columns.
@@ -461,7 +463,12 @@ def gumbel_choice_positions_for_df(
  positions = np.empty(n_rows, dtype=np.int64)
 
  if alt_nrs_df is not None:
- assert alt_nrs_df.shape == utilities.shape
+ assert alt_nrs_df.index.equals(
+ utilities.index
+ ), "alt_nrs_df and utilities must share the same index"
+ assert alt_nrs_df.columns.equals(
+ utilities.columns
+ ), "alt_nrs_df and utilities must share the same columns"
  if n_rands is None:
  raise ValueError("n_rands is required when alt_nrs_df is provided")
  alt_nr_values = alt_nrs_df.to_numpy()
@@ -474,6 +481,7 @@ def gumbel_choice_positions_for_df(
  f"{MASKED_ALT_ID} sentinel: {offenders}"
  )
  masked = alt_nr_values == MASKED_ALT_ID
+ active_mask = ~masked
  safe_alt_nrs = np.where(masked, 0, alt_nr_values)
  else:
  if n_rands is None:
@@ -482,7 +490,7 @@ def gumbel_choice_positions_for_df(
  raise ValueError(
  "n_rands must equal utilities.shape[1] when alt_nrs_df is omitted"
  )
- alt_nr_values = masked = safe_alt_nrs = None
+ alt_nr_values = masked = active_mask = safe_alt_nrs = None
 
  generators = self._generators_for_df(utilities)
 
@@ -495,16 +503,21 @@ def gumbel_choice_positions_for_df(
  utility_row - np.log(-np.log(row_randoms))
  )
  else:
- # Masked positions are set to -inf so they cannot win argmax,
- # and the gumbel transform is skipped for them entirely.
- row_mask = masked[row_num]
- candidate_values = np.full(n_alts, -np.inf, dtype=np.float64)
- active = ~row_mask
- if active.any():
- candidate_values[active] = utility_row[active] - np.log(
- -np.log(row_randoms[safe_alt_nrs[row_num, active]])
- )
- positions[row_num] = np.argmax(candidate_values)
+ # Masked positions can never be chosen, so apply the gumbel transform and argmax
+ # only to the active ones. flatnonzero returns ascending indices, so ties resolve
+ # to the lowest column position, which is what a full-width argmax would have done.
+ active = np.flatnonzero(active_mask[row_num])
+ if active.size == 0:
+ # The chooser has no alternative available at all. Return the first
+ # column by convention. Note that logit.make_choices_utility_based filters
+ # out choosers with no available alternatives, so this case will only occur
+ # when explicitly allowed by the caller.
+ positions[row_num] = 0
+ continue
+ gumbel = utility_row[active] - np.log(
+ -np.log(row_randoms[safe_alt_nrs[row_num, active]])
+ )
+ positions[row_num] = active[np.argmax(gumbel)]
 
  self.row_states.loc[utilities.index, "offset"] += n_rands
  return positions

activitysim/core/simulate.py

@@ -1553,7 +1553,7 @@ def eval_nl(
 
  if state.settings.use_explicit_error_terms:
  raw_utilities = logit.validate_utils(
- state, raw_utilities, allow_zero_probs=True, trace_label=trace_label
+ state, raw_utilities, trace_label=trace_label
  )
 
  if custom_chooser:

activitysim/abm/models/joint_tour_participation.py

@@ -219,18 +219,18 @@ def participants_chooser(
  # anybody with probability > 0 is forced to join the joint tour
  if state.settings.use_explicit_error_terms:
  # need "is valid choice" such that we certainly choose those with non-zero values,
- # and do not choose others. Let's use 3.0 as large value here.
+ # and do not choose others.
  probs_or_utils[choice_col] = np.where(
  probs_or_utils[choice_col] > logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  non_choice_col = [
  col for col in probs_or_utils.columns if col != choice_col
  ][0]
  probs_or_utils[non_choice_col] = np.where(
  probs_or_utils[choice_col] <= logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  else:

activitysim/core/interaction_sample_simulate.py

@@ -337,9 +337,7 @@ def _interaction_sample_simulate(
  if zero_probs.any():
  # copied from proabability below, fix when that gets fixed
  # FIXME this is kind of gnarly, but we force choice of first alt
- utilities_df.loc[
- zero_probs, 0
- ] = 3.0 # arbitrary value much larger than UTIL_UNAVAILABLE
+ utilities_df.loc[zero_probs, 0] = logit.UTIL_LARGE_ENOUGH
 
  # 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
@@ -430,9 +428,6 @@ def _interaction_sample_simulate(
  # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
  choices = alternatives[choice_column].take(positions + first_row_offsets)
 
- # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
- choices = alternatives[choice_column].take(positions + first_row_offsets)
-
  # create a series with index from choosers and the index of the chosen alternative
  choices = pd.Series(choices, index=choosers.index)
 

activitysim/core/logit.py

@@ -29,6 +29,13 @@
 UTIL_MIN = np.log(EXP_UTIL_MIN, dtype=np.float64)
 UTIL_UNAVAILABLE = 1000.0 * (UTIL_MIN - 1.0)
 
+# Utility assigned to an alternative that must be chosen over UTIL_UNAVAILABLE
+# alternatives, e.g. when forcing a choice for a chooser that would otherwise
+# have no available alternative. Any finite value works: the gap to
+# UTIL_UNAVAILABLE is many orders of magnitude larger than the EV1 error terms
+# added by the explicit error term choice methods.
+UTIL_LARGE_ENOUGH = 3.0
+
 PROB_MIN = 0.0
 PROB_MAX = 1.0
 
@@ -640,6 +647,7 @@ def make_choices_utility_based(
  nest_spec=None,
  alts_context: AltsContext | None = None,
  alt_nrs_df: pd.DataFrame | None = None,
+ allow_zero_probs: bool = False,
 ) -> tuple[pd.Series, pd.Series]:
  """
  Make choices for each chooser from among a set of alternatives based on utilities by adding
@@ -666,6 +674,11 @@ def make_choices_utility_based(
  the alt_nrs for each alternative for each chooser. This is used to index into the random numbers when sampling
  EET terms for multinomial logit models, and should contain -999 for any alternatives that are not available
  for a given chooser. Should be provided along with `alts_context`.
+ allow_zero_probs : bool
+ If False, report choosers that have no available alternative at all. This is the
+ utility-space counterpart of `allow_bad_probs` in `make_choices`, and takes the
+ name `allow_zero_probs` because the condition it suppresses is the same one that
+ `validate_utils` and `utils_to_probs` describe by that name.
 
  Returns
  -------
@@ -677,14 +690,36 @@ def make_choices_utility_based(
 
  Notes
  -----
- Bad-row reporting (e.g., a chooser whose alternatives are all `UTIL_UNAVAILABLE`) is the
- responsibility of `validate_utils()`, which is invoked at every EET call site
- (interaction_sample, interaction_sample_simulate, simulate.eval_mnl, simulate.eval_nl)
- BEFORE this function is called. EET argmax always returns a valid integer position;
- we do not re-check here.
+ An argmax always returns a position, so a chooser with no available alternative gets a
+ choice here rather than an error: with every utility at `UTIL_UNAVAILABLE` the alternatives
+ are tied and the error terms decide, and with every utility at `-inf` the first column wins.
+ The Monte Carlo path does not go quiet in that situation -- `make_choices` reports it unless
+ `allow_bad_probs` is set -- so this function reports it too. Most callers reach here having
+ already run `validate_utils`, which makes the same check; the duplication is deliberate and
+ mirrors `make_choices` re-checking what `utils_to_probs` has already looked at.
  """
  trace_label = tracing.extend_trace_label(trace_label, "make_choices_utility_based")
 
+ if not allow_zero_probs:
+ # An alternative counts as available when its utility exceeds UTIL_MIN, which is the
+ # same threshold validate_utils uses before clamping to UTIL_UNAVAILABLE. Testing the
+ # threshold directly rather than testing the row sum against a multiple of
+ # UTIL_UNAVAILABLE means this also holds for callers that arrive without having run
+ # validate_utils, where unavailable alternatives may still carry their raw value.
+ no_available_alts = ~(utilities.to_numpy() > UTIL_MIN).any(axis=1)
+ if no_available_alts.any():
+ report_bad_choices(
+ state,
+ no_available_alts,
+ utilities,
+ state.settings.skip_failed_choices,
+ trace_label=tracing.extend_trace_label(
+ trace_label, "no_available_alts"
+ ),
+ msg="no alternative is available",
+ trace_choosers=trace_choosers,
+ )
+
  if nest_spec is None:
  choices = make_choices_explicit_error_term_mnl(
  state,

activitysim/core/random.py

@@ -441,7 +441,9 @@ def gumbel_choice_positions_for_df(
  alt_nrs_df : pandas.DataFrame, optional
  DataFrame aligned to `utilities` whose values identify which dense alternative
  each utility column corresponds to. Use `MASKED_ALT_ID` (-999) for masked or
- unavailable positions; any other negative value raises ValueError.
+ unavailable positions; any other negative value raises ValueError. A row that
+ is masked in every column is taken to mean the chooser has no alternative to
+ choose from, and returns position 0.
  n_rands : int, optional
  Number of EV1 draws to generate per chooser row. Required when `alt_nrs_df`
  is provided and may exceed the visible number of utility columns.
@@ -461,7 +463,12 @@ def gumbel_choice_positions_for_df(
  positions = np.empty(n_rows, dtype=np.int64)
 
  if alt_nrs_df is not None:
- assert alt_nrs_df.shape == utilities.shape
+ assert alt_nrs_df.index.equals(
+ utilities.index
+ ), "alt_nrs_df and utilities must share the same index"
+ assert alt_nrs_df.columns.equals(
+ utilities.columns
+ ), "alt_nrs_df and utilities must share the same columns"
  if n_rands is None:
  raise ValueError("n_rands is required when alt_nrs_df is provided")
  alt_nr_values = alt_nrs_df.to_numpy()
@@ -474,6 +481,7 @@ def gumbel_choice_positions_for_df(
  f"{MASKED_ALT_ID} sentinel: {offenders}"
  )
  masked = alt_nr_values == MASKED_ALT_ID
+ active_mask = ~masked
  safe_alt_nrs = np.where(masked, 0, alt_nr_values)
  else:
  if n_rands is None:
@@ -482,7 +490,7 @@ def gumbel_choice_positions_for_df(
  raise ValueError(
  "n_rands must equal utilities.shape[1] when alt_nrs_df is omitted"
  )
- alt_nr_values = masked = safe_alt_nrs = None
+ alt_nr_values = masked = active_mask = safe_alt_nrs = None
 
  generators = self._generators_for_df(utilities)
 
@@ -495,16 +503,21 @@ def gumbel_choice_positions_for_df(
  utility_row - np.log(-np.log(row_randoms))
  )
  else:
- # Masked positions are set to -inf so they cannot win argmax,
- # and the gumbel transform is skipped for them entirely.
- row_mask = masked[row_num]
- candidate_values = np.full(n_alts, -np.inf, dtype=np.float64)
- active = ~row_mask
- if active.any():
- candidate_values[active] = utility_row[active] - np.log(
- -np.log(row_randoms[safe_alt_nrs[row_num, active]])
- )
- positions[row_num] = np.argmax(candidate_values)
+ # Masked positions can never be chosen, so apply the gumbel transform and argmax
+ # only to the active ones. flatnonzero returns ascending indices, so ties resolve
+ # to the lowest column position, which is what a full-width argmax would have done.
+ active = np.flatnonzero(active_mask[row_num])
+ if active.size == 0:
+ # The chooser has no alternative available at all. Return the first
+ # column by convention. Note that logit.make_choices_utility_based filters
+ # out choosers with no available alternatives, so this case will only occur
+ # when explicitly allowed by the caller.
+ positions[row_num] = 0
+ continue
+ gumbel = utility_row[active] - np.log(
+ -np.log(row_randoms[safe_alt_nrs[row_num, active]])
+ )
+ positions[row_num] = active[np.argmax(gumbel)]
 
  self.row_states.loc[utilities.index, "offset"] += n_rands
  return positions

activitysim/core/simulate.py

@@ -1553,7 +1553,7 @@ def eval_nl(
 
  if state.settings.use_explicit_error_terms:
  raw_utilities = logit.validate_utils(
- state, raw_utilities, allow_zero_probs=True, trace_label=trace_label
+ state, raw_utilities, trace_label=trace_label
  )
 
  if custom_chooser:

activitysim/abm/models/joint_tour_participation.py

@@ -219,18 +219,18 @@ def participants_chooser(
  # anybody with probability > 0 is forced to join the joint tour
  if state.settings.use_explicit_error_terms:
  # need "is valid choice" such that we certainly choose those with non-zero values,
- # and do not choose others. Let's use 3.0 as large value here.
+ # and do not choose others.
  probs_or_utils[choice_col] = np.where(
  probs_or_utils[choice_col] > logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  non_choice_col = [
  col for col in probs_or_utils.columns if col != choice_col
  ][0]
  probs_or_utils[non_choice_col] = np.where(
  probs_or_utils[choice_col] <= logit.UTIL_MIN,
-3.0,
+logit.UTIL_LARGE_ENOUGH,
  logit.UTIL_UNAVAILABLE,
  )
  else:

activitysim/core/interaction_sample_simulate.py

@@ -337,9 +337,7 @@ def _interaction_sample_simulate(
  if zero_probs.any():
  # copied from proabability below, fix when that gets fixed
  # FIXME this is kind of gnarly, but we force choice of first alt
- utilities_df.loc[
- zero_probs, 0
- ] = 3.0 # arbitrary value much larger than UTIL_UNAVAILABLE
+ utilities_df.loc[zero_probs, 0] = logit.UTIL_LARGE_ENOUGH
 
  # 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
@@ -430,9 +428,6 @@ def _interaction_sample_simulate(
  # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
  choices = alternatives[choice_column].take(positions + first_row_offsets)
 
- # resulting pandas Int64Index has one element per chooser row and is in same order as choosers
- choices = alternatives[choice_column].take(positions + first_row_offsets)
-
  # create a series with index from choosers and the index of the chosen alternative
  choices = pd.Series(choices, index=choosers.index)
 

activitysim/core/logit.py

@@ -29,6 +29,13 @@
 UTIL_MIN = np.log(EXP_UTIL_MIN, dtype=np.float64)
 UTIL_UNAVAILABLE = 1000.0 * (UTIL_MIN - 1.0)
 
+# Utility assigned to an alternative that must be chosen over UTIL_UNAVAILABLE
+# alternatives, e.g. when forcing a choice for a chooser that would otherwise
+# have no available alternative. Any finite value works: the gap to
+# UTIL_UNAVAILABLE is many orders of magnitude larger than the EV1 error terms
+# added by the explicit error term choice methods.
+UTIL_LARGE_ENOUGH = 3.0
+
 PROB_MIN = 0.0
 PROB_MAX = 1.0
 
@@ -640,6 +647,7 @@ def make_choices_utility_based(
  nest_spec=None,
  alts_context: AltsContext | None = None,
  alt_nrs_df: pd.DataFrame | None = None,
+ allow_zero_probs: bool = False,
 ) -> tuple[pd.Series, pd.Series]:
  """
  Make choices for each chooser from among a set of alternatives based on utilities by adding
@@ -666,6 +674,11 @@ def make_choices_utility_based(
  the alt_nrs for each alternative for each chooser. This is used to index into the random numbers when sampling
  EET terms for multinomial logit models, and should contain -999 for any alternatives that are not available
  for a given chooser. Should be provided along with `alts_context`.
+ allow_zero_probs : bool
+ If False, report choosers that have no available alternative at all. This is the
+ utility-space counterpart of `allow_bad_probs` in `make_choices`, and takes the
+ name `allow_zero_probs` because the condition it suppresses is the same one that
+ `validate_utils` and `utils_to_probs` describe by that name.
 
  Returns
  -------
@@ -677,14 +690,36 @@ def make_choices_utility_based(
 
  Notes
  -----
- Bad-row reporting (e.g., a chooser whose alternatives are all `UTIL_UNAVAILABLE`) is the
- responsibility of `validate_utils()`, which is invoked at every EET call site
- (interaction_sample, interaction_sample_simulate, simulate.eval_mnl, simulate.eval_nl)
- BEFORE this function is called. EET argmax always returns a valid integer position;
- we do not re-check here.
+ An argmax always returns a position, so a chooser with no available alternative gets a
+ choice here rather than an error: with every utility at `UTIL_UNAVAILABLE` the alternatives
+ are tied and the error terms decide, and with every utility at `-inf` the first column wins.
+ The Monte Carlo path does not go quiet in that situation -- `make_choices` reports it unless
+ `allow_bad_probs` is set -- so this function reports it too. Most callers reach here having
+ already run `validate_utils`, which makes the same check; the duplication is deliberate and
+ mirrors `make_choices` re-checking what `utils_to_probs` has already looked at.
  """
  trace_label = tracing.extend_trace_label(trace_label, "make_choices_utility_based")
 
+ if not allow_zero_probs:
+ # An alternative counts as available when its utility exceeds UTIL_MIN, which is the
+ # same threshold validate_utils uses before clamping to UTIL_UNAVAILABLE. Testing the
+ # threshold directly rather than testing the row sum against a multiple of
+ # UTIL_UNAVAILABLE means this also holds for callers that arrive without having run
+ # validate_utils, where unavailable alternatives may still carry their raw value.
+ no_available_alts = ~(utilities.to_numpy() > UTIL_MIN).any(axis=1)
+ if no_available_alts.any():
+ report_bad_choices(
+ state,
+ no_available_alts,
+ utilities,
+ state.settings.skip_failed_choices,
+ trace_label=tracing.extend_trace_label(
+ trace_label, "no_available_alts"
+ ),
+ msg="no alternative is available",
+ trace_choosers=trace_choosers,
+ )
+
  if nest_spec is None:
  choices = make_choices_explicit_error_term_mnl(
  state,

activitysim/core/random.py

@@ -441,7 +441,9 @@ def gumbel_choice_positions_for_df(
  alt_nrs_df : pandas.DataFrame, optional
  DataFrame aligned to `utilities` whose values identify which dense alternative
  each utility column corresponds to. Use `MASKED_ALT_ID` (-999) for masked or
- unavailable positions; any other negative value raises ValueError.
+ unavailable positions; any other negative value raises ValueError. A row that
+ is masked in every column is taken to mean the chooser has no alternative to
+ choose from, and returns position 0.
  n_rands : int, optional
  Number of EV1 draws to generate per chooser row. Required when `alt_nrs_df`
  is provided and may exceed the visible number of utility columns.
@@ -461,7 +463,12 @@ def gumbel_choice_positions_for_df(
  positions = np.empty(n_rows, dtype=np.int64)
 
  if alt_nrs_df is not None:
- assert alt_nrs_df.shape == utilities.shape
+ assert alt_nrs_df.index.equals(
+ utilities.index
+ ), "alt_nrs_df and utilities must share the same index"
+ assert alt_nrs_df.columns.equals(
+ utilities.columns
+ ), "alt_nrs_df and utilities must share the same columns"
  if n_rands is None:
  raise ValueError("n_rands is required when alt_nrs_df is provided")
  alt_nr_values = alt_nrs_df.to_numpy()
@@ -474,6 +481,7 @@ def gumbel_choice_positions_for_df(
  f"{MASKED_ALT_ID} sentinel: {offenders}"
  )
  masked = alt_nr_values == MASKED_ALT_ID
+ active_mask = ~masked
  safe_alt_nrs = np.where(masked, 0, alt_nr_values)
  else:
  if n_rands is None:
@@ -482,7 +490,7 @@ def gumbel_choice_positions_for_df(
  raise ValueError(
  "n_rands must equal utilities.shape[1] when alt_nrs_df is omitted"
  )
- alt_nr_values = masked = safe_alt_nrs = None
+ alt_nr_values = masked = active_mask = safe_alt_nrs = None
 
  generators = self._generators_for_df(utilities)
 
@@ -495,16 +503,21 @@ def gumbel_choice_positions_for_df(
  utility_row - np.log(-np.log(row_randoms))
  )
  else:
- # Masked positions are set to -inf so they cannot win argmax,
- # and the gumbel transform is skipped for them entirely.
- row_mask = masked[row_num]
- candidate_values = np.full(n_alts, -np.inf, dtype=np.float64)
- active = ~row_mask
- if active.any():
- candidate_values[active] = utility_row[active] - np.log(
- -np.log(row_randoms[safe_alt_nrs[row_num, active]])
- )
- positions[row_num] = np.argmax(candidate_values)
+ # Masked positions can never be chosen, so apply the gumbel transform and argmax
+ # only to the active ones. flatnonzero returns ascending indices, so ties resolve
+ # to the lowest column position, which is what a full-width argmax would have done.
+ active = np.flatnonzero(active_mask[row_num])
+ if active.size == 0:
+ # The chooser has no alternative available at all. Return the first
+ # column by convention. Note that logit.make_choices_utility_based filters
+ # out choosers with no available alternatives, so this case will only occur
+ # when explicitly allowed by the caller.
+ positions[row_num] = 0
+ continue
+ gumbel = utility_row[active] - np.log(
+ -np.log(row_randoms[safe_alt_nrs[row_num, active]])
+ )
+ positions[row_num] = active[np.argmax(gumbel)]
 
  self.row_states.loc[utilities.index, "offset"] += n_rands
  return positions

activitysim/core/simulate.py

@@ -1553,7 +1553,7 @@ def eval_nl(
 
  if state.settings.use_explicit_error_terms:
  raw_utilities = logit.validate_utils(
- state, raw_utilities, allow_zero_probs=True, trace_label=trace_label
+ state, raw_utilities, trace_label=trace_label
  )
 
  if custom_chooser: