source: src/main/java/agents/anac/y2019/minf/etc/HardHeadedFrequencyModel.java

package agents.anac.y2019.minf.etc;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.Iterator;

import genius.core.Bid;
import genius.core.bidding.BidDetails;
import genius.core.boaframework.BOAparameter;
import genius.core.boaframework.NegotiationSession;
import genius.core.boaframework.OpponentModel;
import genius.core.issue.Issue;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.Objective;
import genius.core.issue.Value;
import genius.core.issue.ValueDiscrete;
import genius.core.utility.AdditiveUtilitySpace;
import genius.core.utility.Evaluator;
import genius.core.utility.EvaluatorDiscrete;

/**
 * BOA framework implementation of the HardHeaded Frequecy Model.
 * 
 * Default: learning coef l = 0.2; learnValueAddition v = 1.0
 * 
 * paper: https://ii.tudelft.nl/sites/default/files/boa.pdf
 */
public class HardHeadedFrequencyModel extends OpponentModel {

        /*
         * the learning coefficient is the weight that is added each turn to the
         * issue weights which changed. It's a trade-off between concession speed
         * and accuracy.
         */
        private double learnCoef;
        /*
         * value which is added to a value if it is found. Determines how fast the
         * value weights converge.
         */
        private int learnValueAddition;
        private int amountOfIssues;
        private double goldenValue;
        private double gamma;

        private AdditiveUtilitySpace opponentUtilCount;

        @Override
        public void init(NegotiationSession negotiationSession,
                        Map<String, Double> parameters) {
                this.negotiationSession = negotiationSession;
                if (parameters != null && parameters.get("l") != null) {
                        learnCoef = parameters.get("l");
                } else {
                        learnCoef = 0.2;
                }
                learnValueAddition = 1;
                gamma = 0.25;
                opponentUtilitySpace = (AdditiveUtilitySpace) negotiationSession
                                .getUtilitySpace().copy();
                amountOfIssues = opponentUtilitySpace.getDomain().getIssues().size();
                /*
                 * This is the value to be added to weights of unchanged issues before
                 * normalization. Also the value that is taken as the minimum possible
                 * weight, (therefore defining the maximum possible also).
                 */
                goldenValue = learnCoef / amountOfIssues;

                initializeModel();

        }

        @Override
        public void updateModel(Bid opponentBid, double time) {
                if (negotiationSession.getOpponentBidHistory().size() < 2) {
                        return;
                }
                int numberOfUnchanged = 0;
                BidDetails oppBid = negotiationSession.getOpponentBidHistory()
                                .getHistory()
                                .get(negotiationSession.getOpponentBidHistory().size() - 1);
                BidDetails prevOppBid = negotiationSession.getOpponentBidHistory()
                                .getHistory()
                                .get(negotiationSession.getOpponentBidHistory().size() - 2);
                HashMap<Integer, Integer> lastDiffSet = determineDifference(prevOppBid,
                                oppBid);

                // System.out.println(lastDiffSet);

                // count the number of changes in value
                for (Integer i : lastDiffSet.keySet()) {
                        if (lastDiffSet.get(i) == 0)
                                numberOfUnchanged++;
                }

                // The total sum of weights before normalization.
                double totalSum = 1D + goldenValue * numberOfUnchanged;
                // The maximum possible weight
                double maximumWeight = 1D - (amountOfIssues) * goldenValue / totalSum;

                // re-weighing issues while making sure that the sum remains 1
                for (Integer i : lastDiffSet.keySet()) {
                        Objective issue = opponentUtilitySpace.getDomain()
                                        .getObjectivesRoot().getObjective(i);
                        double weight = opponentUtilitySpace.getWeight(i);
                        double newWeight;

                        if (lastDiffSet.get(i) == 0 && weight < maximumWeight) {
                                newWeight = (weight + goldenValue) / totalSum;
                        } else {
                                newWeight = weight / totalSum;
                        }
                        opponentUtilitySpace.setWeight(issue, newWeight);
                }

                // Then for each issue value that has been offered last time, a constant
                // value is added to its corresponding ValueDiscrete.
                try {
                        for (Iterator<Entry<Objective, Evaluator>> itr1 = opponentUtilitySpace.getEvaluators().iterator(),
                                 itr2 = opponentUtilCount.getEvaluators().iterator(); itr1.hasNext() && itr2.hasNext();){
                                Entry<Objective, Evaluator> e1 = itr1.next();
                                Entry<Objective, Evaluator> e2 = itr2.next();

                                EvaluatorDiscrete value_util = (EvaluatorDiscrete) e1.getValue();
                                EvaluatorDiscrete value_cnt = (EvaluatorDiscrete) e2.getValue();
                                IssueDiscrete issue = ((IssueDiscrete) e1.getKey());

                                ValueDiscrete issuevalue = (ValueDiscrete) oppBid.getBid()
                                                .getValue(issue.getNumber());

                                Integer eval = value_cnt.getEvaluationNotNormalized(issuevalue);
                                value_cnt.setEvaluation(issuevalue, (learnValueAddition + eval));

                                value_util.setEvaluationDouble(issuevalue, Math.pow(1+learnValueAddition+eval, gamma));
                        }
                } catch (Exception ex) {
                        ex.printStackTrace();
                }
        }

        @Override
        public double getBidEvaluation(Bid bid) {
                double result = 0;
                try {
                        result = opponentUtilitySpace.getUtility(bid);
                } catch (Exception e) {
                        e.printStackTrace();
                }
                return result;
        }

        @Override
        public String getName() {
                return "HardHeaded Frequency Model";
        }

        @Override
        public Set<BOAparameter> getParameterSpec() {
                Set<BOAparameter> set = new HashSet<BOAparameter>();
                set.add(new BOAparameter("l", 0.2,
                                "The learning coefficient determines how quickly the issue weights are learned"));
                return set;
        }

        /**
         * Init to flat weight and flat evaluation distribution
         */
        private void initializeModel() {
                double commonWeight = 1D / amountOfIssues;

                for (Entry<Objective, Evaluator> e : opponentUtilitySpace
                                .getEvaluators()) {

                        opponentUtilitySpace.unlock(e.getKey());

                        e.getValue().setWeight(commonWeight);
                        try {
                                // set all value weights to one (they are normalized when
                                // calculating the utility)
                                for (ValueDiscrete vd : ((IssueDiscrete) e.getKey())
                                                .getValues())
                                        ((EvaluatorDiscrete) e.getValue()).setEvaluation(vd, 1);
                        } catch (Exception ex) {
                                ex.printStackTrace();
                        }
                }
                opponentUtilCount = (AdditiveUtilitySpace) opponentUtilitySpace.copy();
        }

        private HashMap<Integer, Integer> determineDifference(BidDetails first,
                        BidDetails second) {

                HashMap<Integer, Integer> diff = new HashMap<Integer, Integer>();
                try {
                        for (Issue i : opponentUtilitySpace.getDomain().getIssues()) {
                                Value value1 = first.getBid().getValue(i.getNumber());
                                Value value2 = second.getBid().getValue(i.getNumber());
                                diff.put(i.getNumber(), (value1.equals(value2)) ? 0 : 1);
                        }
                } catch (Exception ex) {
                        ex.printStackTrace();
                }

                return diff;
        }

}