cartesian_tournament
- negmas.tournaments.cartesian_tournament(competitors, scenarios, competitor_params=None, rotate_ufuns=True, n_repetitions=1, path=None, njobs=0, mechanism_type=<class 'negmas.sao.mechanism.SAOMechanism'>, mechanism_params=None, plot_fraction=0.0, verbosity=1, self_play=True, randomize_runs=True, save_every=0, save_stats=True, final_score=('advantage', 'mean'))[source]
A simplified version of Cartesian tournaments not using the internal machinay of NegMAS tournaments
- Parameters:
competitors (
list
[type
[Negotiator
] |str
] |tuple
[type
[Negotiator
] |str
,...
]) – A tuple of the competing negotiator types.scenarios (
list
[Scenario
] |tuple
[Scenario
,...
]) – A tuple of base scenarios to use for the tournament.competitor_params (
Optional
[Sequence
[Optional
[dict
]]]) – Either None for no-parameters or a tuple of dictionaries with parameters to initialize the competitors (in order).rotate_ufuns (
bool
) – If True, the ufuns will be rotated over negotiator positions (for bilateral negotiation this leads to two scenarios for each input scenario with reversed ufun order).n_repetitions (
int
) – Number of times to repeat each scenario/partner combinationpath (
Optional
[Path
]) – Path on disk to save the results and details of this tournament. Pass None to disable loggingn_jobs – Number of parallel jobs to run. -1 means running serially (useful for debugging) and 0 means using all cores.
mechanism_type (
type
[Mechanism
]) – The mechanism (protocol) used for all negotiations.mechanism_params (
Optional
[dict
[str
,Any
]]) – Parameters of the mechanism (protocol). Usually you need to pass one or more of the following: time_limit (in seconds), n_steps (in rounds), p_ending (probability of ending the negotiation every step).plot_fraction (
float
) – fraction of negotiations for which plots are to be saved (only if path is not None)verbosity (
int
) – Verbosity level (minimum is 0)self_play (
bool
) – Allow negotiations in which all partners are of the same typerandomize_runs (
bool
) – If True negotiations will be run in random order, otherwise each scenario/partner combination will be finished before starting on the nextsave_every (
int
) – Number of negotiations after which we dump details and scoressave_stats (
bool
) – Whether to calculate and save extra statistics like pareto_optimality, nash_optimality, kalai_optimality, etcfinal_score (
tuple
[str
,str
]) – A tuple of two strings giving the metric used for ordering the negotiators for the final score: First string can be one of the following (advantage, utility, partner_welfare, welfare) or any statistic from the set calculated if save_stats is True. The second string can be mean, median, min, max, or std. The default is (‘advantage’, ‘mean’)
- Return type:
- Returns:
A pandas dataframe with all negotiation results.