source: src/main/java/agents/ai2014/group5/OpponentModel.java@ 127

package agents.ai2014.group5;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;

import genius.core.Bid;

/**
 * An opponent model constructs a model of an opponent's negotiation profile so
 * that the opponent's utilities of bids can be estimated. These models make use
 * of a reinforcement learning method to learn the opponents' profiles from the
 * bids made by the opponents. This method is described in the paper for the
 * agent HardHeaded from the ANAC 2011 competition.
 */
class OpponentModel {
        // Weight increment during learning
        private static final double EPSILON = 0.1;

        // The last bid offered by the opponent
        private Bid lastBid;

        // Issue weights
        private List<Double> weights;

        // Issue values
        private List<List<Integer>> values;

        // Map of issue value names to indexes for each issue
        private List<Map<String, Integer>> valueNames;

        // Issue indexes-1 and their names
        private List<String> issueNames;

        private Group5 agent;

        @SuppressWarnings("unchecked")
        public OpponentModel(List<String> issueNames,
                        List<Map<String, Integer>> valueNames, Group5 agent) {
                lastBid = null;
                this.valueNames = valueNames;
                this.issueNames = issueNames;
                this.agent = agent;

                // Uniformly distribute the weights
                weights = new ArrayList<Double>(Collections.nCopies(issueNames.size(),
                                1.0 / issueNames.size()));

                // Initialize issue values
                values = new ArrayList<List<Integer>>();
                for (int i = 0; i < issueNames.size(); i++) {
                        ArrayList<Integer> tmp = new ArrayList<Integer>(
                                        Collections.nCopies(valueNames.get(i).size(), 1));
                        values.add((List<Integer>) tmp.clone());
                }
        }

        /**
         * Updates the model given the new bid received from the opponent. If an
         * issue value has changed since the last bid then the weight for the
         * corresponding issue and the issue value will be changed.
         */
        public void updateModel(Bid bid) {
                if (bid == null) {
                        // The bid does not exists, the action was therefore not an offer
                        return;
                }

                if (lastBid != null) {
                        // This is not the first bid, so update the model
                        for (int i = 0; i < issueNames.size(); i++) {
                                String prevV = null, newV = null;
                                try {
                                        prevV = lastBid.getValue(i + 1).toString();
                                        newV = bid.getValue(i + 1).toString();
                                } catch (Exception e) {
                                        agent.println("Error in \"updateModel\": getValue(" + i + 1
                                                        + ") fails for bid " + bid + " or bid " + lastBid);
                                }

                                if (prevV != null && newV != null && prevV.equals(newV)) {
                                        // Update weight and issue value for this issue
                                        int vi = valueNames.get(i).get(newV);
                                        weights.set(i, weights.get(i) + EPSILON);
                                        values.get(i).set(vi, values.get(i).get(vi) + 1);
                                }
                        }

                        // Normalize weights
                        double norm = 0.0;
                        for (double w : weights) {
                                norm += w;
                        }
                        for (int i = 0; i < weights.size(); i++) {
                                weights.set(i, weights.get(i) / norm);
                        }
                }

                lastBid = bid;
        }

        /**
         * Calculates the expected utility of a bid.
         * 
         * @param Bid
         *            to calculate utility of
         * @return Utility of bid for the opponent of this model
         */
        public double expectedUtilityOf(Bid bid) {
                double u = 0.0;
                for (int i = 0; i < issueNames.size(); i++) {
                        String tmp = null;
                        try {
                                // Get the name of the issue value used in the bid
                                tmp = bid.getValue(i + 1).toString();
                        } catch (Exception e) {
                                agent.println("Error in \"expectedUtiliyOf\": getValue(" + i
                                                + 1 + ") fails for bid " + bid);
                        }
                        if (tmp != null) {
                                // Calculate and normalize estimated chosen issue value
                                int eIndex = valueNames.get(i).get(tmp);
                                int eNorm = 0;
                                for (int v = 0; v < values.get(i).size(); v++) {
                                        eNorm += values.get(i).get(v);
                                }
                                double e = ((double) values.get(i).get(eIndex)) / eNorm;

                                // Increment utility for this issue
                                u += weights.get(i) * e;
                        }
                }
                return u;
        }
}