source: geniuswebcore/geniusweb/opponentmodel/FrequencyOpponentModel.py@ 99

from geniusweb.profile.utilityspace.UtilitySpace import UtilitySpace
from geniusweb.opponentmodel.OpponentModel import OpponentModel 
from decimal import Decimal
from geniusweb.issuevalue.Domain import Domain
from geniusweb.issuevalue.Bid import Bid
from typing import Dict, Optional
from geniusweb.issuevalue.Value import Value
from geniusweb.actions.Action import Action
from geniusweb.progress.Progress import Progress
from geniusweb.actions.Offer import Offer
from geniusweb.references.Parameters import Parameters
from geniusweb.utils import val, HASH, toStr

class FrequencyOpponentModel(UtilitySpace, OpponentModel):
        '''
        implements an {@link OpponentModel} by counting frequencies of bids placed by
        the opponent.
        <p>
        NOTE: {@link NumberValue}s are also treated as 'discrete', so the frequency
        of one value does not influence the influence the frequency of nearby values
        (as you might expect as {@link NumberValueSetUtilities} is only affected by
        the endpoints).
        <p>
        immutable.
        '''

        _DECIMALS = 4 # accuracy of our computations.

        def __init__(self, domain:Optional[Domain],
                        freqs:Dict[str, Dict[Value, int]] ,  total:int,
                        resBid:Optional[Bid] ) :
                '''
                internal constructor. DO NOT USE, see create. Assumes the freqs keyset is 
                equal to the available issues.
                
                @param domain the domain. Should not be None
                @param freqs  the observed frequencies for all issue values. This map is
                              assumed to be a fresh private-access only copy.
                @param total  the total number of bids contained in the freqs map. This
                              must be equal to the sum of the Integer values in the
                              {@link #bidFrequencies} for each issue (this is not
                              checked).
                @param resBid the reservation bid. Can be null
                '''
                self._domain = domain
                self._bidFrequencies = freqs
                self._totalBids = total
                self._resBid = resBid

        @staticmethod
        def create() -> "FrequencyOpponentModel":
                return FrequencyOpponentModel(None, {}, 0 ,None )

        #Override
        def  With(self, newDomain:Domain,  newResBid:Optional[Bid]) -> "FrequencyOpponentModel":
                if newDomain == None:
                        raise ValueError("domain is not initialized")
                # FIXME merge already available frequencies?
                return FrequencyOpponentModel(newDomain,
                                { iss: {} for iss in newDomain.getIssues() },                                   
                                0, newResBid)

        #Override
        def getUtility(self,bid:Bid ) -> Decimal:
                if self._domain == None: 
                        raise ValueError("domain is not initialized")
                if self._totalBids == 0:
                        return Decimal(1)
                sum = Decimal(0)
                # Assume all issues have equal weight.
                for issue in val(self._domain).getIssues():
                        if issue in bid.getIssues():
                                sum = sum + self._getFraction(issue, val(bid.getValue(issue)))
                return round(sum  / len(self._bidFrequencies), FrequencyOpponentModel._DECIMALS)

        #Override
        def getName(self)->str:
                if self._domain == None:
                        raise ValueError("domain is not initialized")
                return "FreqOppModel" + str(hash(self)) + "For" + str(self._domain)

        #Override
        def getDomain(self)->Domain :
                return val(self._domain)

        #Override
        def WithAction(self,  action:Action,  progress:Progress) ->"FrequencyOpponentModel":
                if self._domain == None:
                        raise ValueError("domain is not initialized")

                if not isinstance(action,Offer):
                        return self

                bid:Bid = action.getBid()
                newFreqs:Dict[str, Dict[Value, int]] = self.cloneMap(self._bidFrequencies)
                for issue in self._domain.getIssues(): #type:ignore
                        freqs:Dict[Value, int]  = newFreqs[issue]
                        value = bid.getValue(issue)
                        if value != None:
                                oldfreq=0
                                if value in freqs:
                                        oldfreq = freqs[value]
                                freqs[value]=oldfreq + 1 #type:ignore

                return FrequencyOpponentModel(self._domain, newFreqs,
                                self._totalBids+1, self._resBid)

        def getCounts(self, issue:str) -> Dict[Value, int] :
                '''
                @param issue the issue to get frequency info for
                @return a map containing a map of values and the number of times that
                        value was used in previous bids. Values that are possible but not
                        in the map have frequency 0.
                '''
                if self._domain == None:
                        raise ValueError("domain is not initialized")
                if not  issue in self._bidFrequencies:
                        return {}
                return dict(self._bidFrequencies.get(issue)) #type:ignore

        #Override
        def WithParameters(self,parameters:Parameters ) ->OpponentModel :
                return self # ignore parameters

        def _getFraction(self, issue:str, value:Value ) -> Decimal :
                '''
                @param issue the issue to check
                @param value the value to check
                @return the fraction of the total cases that bids contained given value
                        for the issue.
                '''
                if self._totalBids == 0:
                        return Decimal(1)
                if not (issue in self._bidFrequencies and value in self._bidFrequencies[issue]):
                        return Decimal(0)
                freq:int = self._bidFrequencies[issue][value]
                return round(Decimal(freq) / self._totalBids, FrequencyOpponentModel._DECIMALS) #type:ignore

        @staticmethod
        def cloneMap(freqs: Dict[str, Dict[Value, int]]) -> Dict[str, Dict[Value, int]] :
                '''
                @param freqs
                @return deep copy of freqs map.
                '''
                map:Dict[str, Dict[Value, int]] = {}
                for issue in freqs:
                        map[issue]=dict(freqs[issue])
                return map

        #Override
        def getReservationBid(self) -> Optional[Bid] :
                return self._resBid


        def __eq__(self, other):
                return isinstance(other, self.__class__) and \
                         self._domain == other._domain and\
                         self._bidFrequencies == other._bidFrequencies and\
                         self._totalBids == other._totalBids and\
                         self._resBid == other._resBid


        def __hash__(self):
                return HASH((self._domain, self._bidFrequencies, self._totalBids, self._resBid))
        #Override

        #Override
        def __repr__(self)->str:
                return "FrequencyOpponentModel[" + str(self._totalBids) + "," + \
                        toStr(self._bidFrequencies) + "]"