scml.oneshot.agents.rand ======================== .. py:module:: scml.oneshot.agents.rand Classes ------- .. autoapisummary:: scml.oneshot.agents.rand.RandomOneShotAgent scml.oneshot.agents.rand.SyncRandomOneShotAgent scml.oneshot.agents.rand.RandDistOneShotAgent scml.oneshot.agents.rand.EqualDistOneShotAgent scml.oneshot.agents.rand.SingleAgreementRandomAgent Module Contents --------------- .. py:class:: RandomOneShotAgent(*args, p_accept=PROB_ACCEPTANCE, p_end=PROB_END, **kwargs) Bases: :py:obj:`scml.oneshot.agent.OneShotAgent` An agent that randomly leaves the negotiation, accepts or counters with random outcomes .. py:method:: _random_offer(negotiator_id: str) .. py:method:: propose(negotiator_id, state) -> negmas.outcomes.Outcome | None Proposes an offer to one of the partners. :param negotiator_id: ID of the negotiator (and partner) :param state: Mechanism state including current step :returns: an outcome to offer. .. py:method:: respond(negotiator_id, state, source=None) -> negmas.ResponseType Responds to an offer from one of the partners. :param negotiator_id: ID of the negotiator (and partner) :param state: Mechanism state including current step :returns: A response type which can either be reject, accept, or end negotiation. Remarks: default behavior is to accept only if the current offer is the same or has a higher utility compared with what the agent would have proposed in the given state and reject otherwise .. py:class:: SyncRandomOneShotAgent(*args, equal: bool = False, overordering_max: float = 0.2, overordering_min: float = 0.0, overordering_exp: float = 0.4, mismatch_exp: float = 4.0, mismatch_max: float = 0.3, **kwargs) Bases: :py:obj:`scml.oneshot.agent.OneShotSyncAgent` An agent that distributes its needs over its partners randomly. :param equal: If given, it tries to equally distribute its needs over as many of its suppliers/consumers as possible :param overordering_max: Maximum fraction of needs to over-order. For example, it the agent needs 5 items and this is 0.2, it will order 6 in the first negotiation step. :param overordering_min: Minimum fraction of needs to over-order. Used in the last negotiation step. :param overordering_exp: Controls how fast does the over-ordering quantity go from max to min. :param concession_exp: Controls how fast does the agent concedes on matching its needs exactly. :param mismatch_max: Maximum mismtach in quantity allowed between needs and accepted offers. If a fraction, it is will be this fraction of the production capacity (n_lines). .. py:attribute:: equal_distribution :value: False .. py:attribute:: overordering_max :value: 0.2 .. py:attribute:: overordering_min :value: 0.0 .. py:attribute:: overordering_exp :value: 0.4 .. py:attribute:: mismatch_exp :value: 4.0 .. py:attribute:: mismatch_max :value: 0.3 .. py:method:: init() Called once after the AWI is set. Remarks: - Use this for any proactive initialization code. .. py:method:: distribute_needs(t: float) -> dict[str, int] Distributes my needs randomly over all my partners .. py:method:: first_proposals() Gets a set of proposals to use for initializing the negotiation. :returns: A dictionary mapping each negotiator (in self.negotiators dict) to an outcome to be used as the first proposal if the agent is to start a negotiation. .. py:method:: counter_all(offers, states) Calculate a response to all offers from all negotiators (negotiator ID is the key). :param offers: Maps negotiator IDs to offers :param states: Maps negotiator IDs to offers AT the time the offers were made. :returns: A dictionary mapping negotiator ID to an `SAOResponse`. The response per agent consist of a tuple. In case of acceptance or ending the negotiation the second item of the tuple should be None. In case of rejection, the second item should be the counter offer. Remarks: - The response type CANNOT be WAIT. - If the system determines that a loop is formed, the agent may receive this call for a subset of negotiations not all of them. .. py:method:: _allowed_mismatch(r: float) .. py:method:: _overordering_fraction(t: float) .. py:method:: _step_and_price(best_price=False) Returns current step and a random (or max) price .. py:class:: RandDistOneShotAgent(*args, **kwargs) Bases: :py:obj:`SyncRandomOneShotAgent` An agent that distributes its needs over its partners randomly. :param equal: If given, it tries to equally distribute its needs over as many of its suppliers/consumers as possible :param overordering_max: Maximum fraction of needs to over-order. For example, it the agent needs 5 items and this is 0.2, it will order 6 in the first negotiation step. :param overordering_min: Minimum fraction of needs to over-order. Used in the last negotiation step. :param overordering_exp: Controls how fast does the over-ordering quantity go from max to min. :param concession_exp: Controls how fast does the agent concedes on matching its needs exactly. :param mismatch_max: Maximum mismtach in quantity allowed between needs and accepted offers. If a fraction, it is will be this fraction of the production capacity (n_lines). .. py:class:: EqualDistOneShotAgent(*args, **kwargs) Bases: :py:obj:`SyncRandomOneShotAgent` Same as RandDistOneShotAgent but defaulting to equal distribution of needs :param equal: If given, it tries to equally distribute its needs over as many of its suppliers/consumers as possible :param overordering_max: Maximum fraction of needs to over-order. For example, it the agent needs 5 items and this is 0.2, it will order 6 in the first negotiation step. :param overordering_min: Minimum fraction of needs to over-order. Used in the last negotiation step. :param overordering_exp: Controls how fast does the over-ordering quantity go from max to min. :param concession_exp: Controls how fast does the agent concedes on matching its needs exactly. :param mismatch_max: Maximum mismtach in quantity allowed between needs and accepted offers. If a fraction, it is will be this fraction of the production capacity (n_lines). .. py:class:: SingleAgreementRandomAgent(*args, p_accept: float = PROB_ACCEPTANCE, **kwargs) Bases: :py:obj:`scml.oneshot.agent.OneShotSingleAgreementAgent` A controller that agrees randomly to one offer .. py:attribute:: _p_accept :value: 0.1 .. py:method:: is_acceptable(offer: negmas.outcomes.Outcome, source: str, state: negmas.sao.SAOState) -> bool Should decide if the given offer is acceptable :param offer: The offer being tested :param source: The ID of the negotiator that received this offer :param state: The state of the negotiation handled by that negotiator Remarks: - If True is returned, this offer will be accepted and all other negotiations will be ended. .. py:method:: best_offer(offers: dict[str, negmas.outcomes.Outcome]) -> str | None Return the ID of the negotiator with the best offer :param offers: A mapping from negotiator ID to the offer it received :returns: The ID of the negotiator with best offer. Ties should be broken. Return None only if there is no way to calculate the best offer. .. py:method:: is_better(a: negmas.outcomes.Outcome | None, b: negmas.outcomes.Outcome | None, negotiator: str, state: negmas.sao.SAOState) -> bool Compares two outcomes of the same negotiation :param a: "Outcome" :param b: "Outcome" :param negotiator: The negotiator for which the comparison is to be made :param state: Current state of the negotiation :returns: True if utility(a) > utility(b)