def __init__( self, profiles: Dict[int, ConsumptionProfile] = None, negotiator_type=DEFAULT_NEGOTIATOR, consumption_horizon: Optional[int] = 20, immediate_cfp_update: bool = True, name=None, ): super().__init__(name=name) self.negotiator_type = get_class(negotiator_type, scope=globals()) self.profiles: Dict[int, ConsumptionProfile] = defaultdict( ConsumptionProfile) self.secured_quantities: Dict[int, int] = defaultdict(int) if profiles is not None: self.set_profiles(profiles=profiles) self.consumption_horizon = consumption_horizon self.immediate_cfp_update = immediate_cfp_update
def builtin_agent_types(as_str=False): """ Returns all built-in agents. Args: as_str: If true, the full type name will be returned otherwise the type object itself. """ from negmas.helpers import get_class types = [ f"scml.scml2019.agents.{_}" for _ in factory_managers.__all__ if not _.startswith("Java") ] if as_str: return types return [get_class(_) for _ in types]
def __init__( self, *args, negotiator_type: Union[SAONegotiator, str] = AspirationNegotiator, negotiator_params: Optional[Dict[str, Any]] = None, **kwargs, ): super().__init__(*args, **kwargs) # save construction parameters self.negotiator_type = get_class(negotiator_type) self.negotiator_params = (negotiator_params if negotiator_params is not None else dict()) # attributes that will be read during init() from the AWI # ------------------------------------------------------- self.buyer = self.seller = None
def __init__( self, default_negotiator_type: Union[str, Type[PassThroughNegotiator]] = None, default_negotiator_params: Dict[str, Any] = None, parent: Union["Controller", "Agent"] = None, auto_kill: bool = True, **kwargs, ): super().__init__(**kwargs) self._negotiators: Dict[str, NegotiatorInfo] = {} if default_negotiator_params is None: default_negotiator_params = {} if isinstance(default_negotiator_type, str): default_negotiator_type = get_class(default_negotiator_type) self.__default_negotiator_type = default_negotiator_type self.__default_negotiator_params = default_negotiator_params self.__parent = parent self._auto_kill = auto_kill
def __init__( self, *args, negotiator_type: Union[SAONegotiator, str] = MyUtilityNegotiator, negotiator_params: Optional[Dict[str, Any]] = None, seller_model_path=NEG_SELL_PATH, buyer_model_path=NEG_BUY_PATH, **kwargs, ): super().__init__(*args, **kwargs) # TODO: copy into my sync controller!!!!! self.negotiator_type = get_class(negotiator_type) self.negotiator_params = (negotiator_params if negotiator_params is not None else dict()) self.neg_history = {True: {}, False: {}} self.seller_model = load_seller_neg_model(path=seller_model_path) self.buyer_model = load_buyer_neg_model(path=buyer_model_path) self.seller_model.eval() self.buyer_model.eval()
def __init__( self, *args, negotiator_type: Union[SAONegotiator, str] = AspirationNegotiator, negotiator_params: Optional[Dict[str, Any]] = None, **kwargs, ): super().__init__(*args, execution_fraction=0.3, **kwargs) # super().__init__(*args, execution_fraction=0.5, **kwargs) # save construction parameters self.negotiator_type = get_class(negotiator_type) self.negotiator_params = ( negotiator_params if negotiator_params is not None else dict() ) # attributes that will be read during init() from the AWI # ------------------------------------------------------- self.buyers = self.sellers = None """Buyer controllers and seller controllers. Each of them is responsible of covering the
def __init__( self, *args, negotiator_type: Union[SAONegotiator, str] = AspirationNegotiator, negotiator_params: Optional[Dict[str, Any]] = None, horizon=5, predicted_demand: Union[int, np.ndarray] = None, predicted_supply: Union[int, np.ndarray] = None, agreement_fraction: float = 0.5, adapt_prices: bool = False, **kwargs, ): super().__init__(*args, **kwargs) self.adapt_prices = adapt_prices self.predicted_demand = predicted_demand self.predicted_supply = predicted_supply self.negotiator_type = get_class(negotiator_type) self.negotiator_params = ( negotiator_params if negotiator_params is not None else dict() ) self.horizon = horizon self.exogenous_horizon = None self.input_product: int = -1 self.output_product: int = -1 self.process: int = -1 self.pcost: int = -1 self.n_inputs: int = -1 self.n_outputs: int = -1 self.supplies_needed: np.ndarray = None self.sales_needed: np.ndarray = None self.input_cost: np.ndarray = None self.output_price: np.ndarray = None self.supplies_secured: np.ndarray = None self.sales_secured: np.ndarray = None self.production_needed = None self.production_secured = None self.production_factor = 1 self.buyers = self.sellers = None self.catalog_n_equivalent = 0 self.supplies_negotiating = None self.sales_negotiating = None self.agreement_fraction = agreement_fraction self.use_exogenous_contracts = True
def __init__( self, default_negotiator_type: Union[str, Type[PassThroughNegotiator]] = None, default_negotiator_params: Dict[str, Any] = None, parent: Union["Controller", "Agent"] = None, auto_kill: bool = True, name: str = None, ufun: "UtilityFunction" = None, ): super().__init__(name=name, ufun=ufun) self._negotiators: Dict[str, Tuple["PassThroughNegotiator", Any]] = {} if default_negotiator_params is None: default_negotiator_params = {} if isinstance(default_negotiator_type, str): default_negotiator_type = get_class(default_negotiator_type) self.__default_negotiator_type = default_negotiator_type self.__default_negotiator_params = default_negotiator_params self.__parent = parent self._auto_kill = auto_kill
def make_world(self, config=None) -> TrainWorld: # configuration, for Scenario scml if config is None: agent_types = [ get_class(agent_type, ) for agent_type in TRAINING_AGENT_TYPES ] n_steps = N_STEPS world_configuration = SCML2020World.generate( agent_types=agent_types, n_steps=n_steps) else: world_configuration = SCML2020World.generate( agent_types=config['agent_types'], agent_params=config['agent_params'][:-2], n_steps=config['n_steps']) world = TrainWorld(configuration=world_configuration) if config is None: self.reset_world(world) return world
def __init__( self, *args, data, plan, awi, agent, negotiator_type: Union[SAONegotiator, str] = AspirationNegotiator, negotiator_params: Optional[Dict[str, Any]] = None, **kwargs, ): self.data = data self.plan = plan self.awi = awi self.agent = agent self.negotiator_type = get_class(negotiator_type) self.negotiator_params = ( negotiator_params if negotiator_params is not None else dict() ) self._horizon = 5 # TODO: Decide this value
def create_negotiator( self, negotiator_type: Union[str, Type[PassThroughNegotiator]] = None, name: str = None, cntxt: Any = None, **kwargs, ) -> PassThroughNegotiator: """ Creates a negotiator passing it the context Args: negotiator_type: Type of the negotiator to be created name: negotiator name cntxt: The context to be associated with this negotiator. It will not be passed to the negotiator constructor. **kwargs: any key-value pairs to be passed to the negotiator constructor Returns: PassThroughNegotiator: The negotiator to be controlled """ if negotiator_type is None: negotiator_type = self.__default_negotiator_type elif isinstance(negotiator_type, str): negotiator_type = get_class(negotiator_type) if negotiator_type is None: raise ValueError( "No negotiator type is passed and no default negotiator type is defined for this " "controller") args = self.__default_negotiator_params if kwargs: args.update(kwargs) new_negotiator = negotiator_type(name=name, parent=self, **args) if new_negotiator is not None: self._negotiators[new_negotiator.id] = (new_negotiator, cntxt) return new_negotiator
def __init__( self, name=None, simulator_type: Union[str, Type[FactorySimulator]] = FastFactorySimulator, scheduler_type: Union[str, Type[Scheduler]] = GreedyScheduler, scheduler_params: Optional[Dict[str, Any]] = None, optimism: float = 0.0, negotiator_type: Union[str, Type[Negotiator]] = DEFAULT_NEGOTIATOR, negotiator_params: Optional[Dict[str, Any]] = None, n_retrials=5, use_consumer=True, reactive=False, sign_only_guaranteed_contracts=True, riskiness=0.0, max_insurance_premium: float = 0.1, my_reports=[], not_fm=[], mean_score: float = 1000.0, bought={}, sold={}, ): self.my_reports = [] self.not_fm = [] self.mean_score: float = 1000.0 self.bought = bought self.sold = sold super().__init__(name=name, simulator_type=simulator_type) self.negotiator_type = get_class(negotiator_type, scope=globals()) self.negotiator_params = (negotiator_params if negotiator_params is not None else {}) self.optimism = optimism self.ufun_factory: Union[Type[NegotiatorUtility], Callable[[Any, Any], NegotiatorUtility]] if optimism < 1e-6: self.ufun_factory = PessimisticNegotiatorUtility elif optimism > 1 - 1e-6: self.ufun_factory = OptimisticNegotiatorUtility else: self.ufun_factory: NegotiatorUtility = lambda agent, annotation: AveragingNegotiatorUtility( agent=agent, annotation=annotation, optimism=self.optimism) if max_insurance_premium < 0.0: warnings.warn( f"Negative max insurance ({max_insurance_premium}) is deprecated. Set max_insurance_premium = inf " f"for always buying and max_insurance_premium = 0.0 for never buying. Will continue assuming inf" ) max_insurance_premium = float("inf") self.max_insurance_premium = max_insurance_premium self.n_retrials = n_retrials self.n_neg_trials: Dict[str, int] = defaultdict(int) self.consumer = None self.use_consumer = use_consumer self.reactive = reactive self.sign_only_guaranteed_contracts = sign_only_guaranteed_contracts self.contract_schedules: Dict[str, ScheduleInfo] = {} self.riskiness = riskiness self.negotiation_margin = int( round(n_retrials * max(0.0, 1.0 - riskiness))) self.scheduler_type: Type[Scheduler] = get_class(scheduler_type, scope=globals()) self.scheduler: Scheduler = None self.scheduler_params: Dict[ str, Any] = scheduler_params if scheduler_params is not None else {}
def anac2019_world(competitors: Sequence[Union[str, Type[FactoryManager]]] = (), randomize: bool = True, log_file_name: str = None, name: str = None, agent_names_reveal_type: bool = False, n_intermediate: Tuple[int, int] = (1, 4), n_miners=5, n_factories_per_level=11, n_consumers=5, n_lines_per_factory=10, guaranteed_contracts=False, use_consumer=True, max_insurance_premium=100, n_retrials=5, negotiator_type: str = 'negmas.sao.AspirationNegotiator', transportation_delay=0, default_signing_delay=0, max_storage=sys.maxsize, consumption_horizon=15, consumption=(3, 5), negotiation_speed=21, neg_time_limit=60 * 4, neg_n_steps=20, n_steps=100, time_limit=60 * 90, n_default_per_level: int = 5) -> SCMLWorld: """ Creates a world compatible with the ANAC 2019 competition. Note that Args: name: World name to use agent_names_reveal_type: If true, a snake_case version of the agent_type will prefix agent names randomize: If true, managers are assigned to factories randomly otherwise in the order they are giving (cycling). n_intermediate: n_default_per_level: competitors: A list of class names for the competitors n_miners: number of miners of the single raw material n_factories_per_level: number of factories at every production level n_consumers: number of consumers of the final product n_steps: number of simulation steps n_lines_per_factory: number of lines in each factory negotiation_speed: The number of negotiation steps per simulation step. None means infinite default_signing_delay: The number of simulation between contract conclusion and signature neg_n_steps: The maximum number of steps of a single negotiation (that is double the number of rounds) neg_time_limit: The total time-limit of a single negotiation time_limit: The total time-limit of the simulation transportation_delay: The transportation delay n_retrials: The number of retrials the `Miner` and `GreedyFactoryManager` will try if negotiations fail max_insurance_premium: The maximum insurance premium accepted by `GreedyFactoryManager` (-1 to disable) use_consumer: If true, the `GreedyFactoryManager` will use an internal consumer for buying its needs guaranteed_contracts: If true, the `GreedyFactoryManager` will only sign contracts that it can guaratnee not to break. consumption_horizon: The number of steps for which `Consumer` publishes `CFP` s consumption: The consumption schedule will be sampled from a uniform distribution with these limits inclusive log_file_name: File name to store the logs negotiator_type: The negotiation factory used to create all negotiators max_storage: maximum storage capacity for all factory negmas If None then it is unlimited Returns: SCMLWorld ready to run Remarks: - Every production level n has one process only that takes n steps to complete """ competitors = list(competitors) if n_factories_per_level == n_default_per_level and len(competitors) > 0: raise ValueError( f'All factories in all levels are occupied by the default factory manager. Either decrease' f' n_default_per_level ({n_default_per_level}) or increase n_factories_per_level ' f' ({n_factories_per_level})') if isinstance(n_intermediate, Iterable): n_intermediate = list(n_intermediate) else: n_intermediate = [n_intermediate, n_intermediate] max_insurance_premium = None if max_insurance_premium < 0 else max_insurance_premium n_competitors = len(competitors) n_intermediate_levels_min = int( math.ceil(n_competitors / (n_factories_per_level - n_default_per_level))) - 1 if n_intermediate_levels_min > n_intermediate[1]: raise ValueError( f'Need {n_intermediate_levels_min} intermediate levels to run {n_competitors} competitors' ) n_intermediate[0] = max(n_intermediate_levels_min, n_intermediate[0]) competitors = [ get_class(c) if isinstance(c, str) else c for c in competitors ] if len(competitors) < 1: competitors.append(GreedyFactoryManager) world = SCMLWorld.single_path_world( log_file_name=log_file_name, n_steps=n_steps, agent_names_reveal_type=agent_names_reveal_type, negotiation_speed=negotiation_speed, n_intermediate_levels=randint(*n_intermediate), n_miners=n_miners, n_consumers=n_consumers, n_factories_per_level=n_factories_per_level, consumption=consumption, consumer_kwargs={ 'negotiator_type': negotiator_type, 'consumption_horizon': consumption_horizon }, miner_kwargs={ 'negotiator_type': negotiator_type, 'n_retrials': n_retrials }, manager_kwargs={ 'negotiator_type': negotiator_type, 'n_retrials': n_retrials, 'sign_only_guaranteed_contracts': guaranteed_contracts, 'use_consumer': use_consumer, 'max_insurance_premium': max_insurance_premium }, transportation_delay=transportation_delay, time_limit=time_limit, neg_time_limit=neg_time_limit, neg_n_steps=neg_n_steps, default_signing_delay=default_signing_delay, n_lines_per_factory=n_lines_per_factory, max_storage=max_storage, manager_types=competitors, n_default_per_level=n_default_per_level, randomize=randomize, name=name) return world