source: anac2020/BlingBling/src/main/java/geniusweb/blingbling/MyUtilityModel.java

package geniusweb.blingbling;

// old one, not used.
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;

import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.factory.Nd4j;

import geniusweb.blingbling.Ranknet.NeuralRankNet;
import geniusweb.blingbling.Ranknet.*;

import geniusweb.profile.DefaultPartialOrdering;
import geniusweb.profile.Profile;
import geniusweb.profile.utilityspace.UtilitySpace;
import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.Value;

public class MyUtilityModel {
        //model param
        private NeuralRankNet ann;
        private double LearningRate = 0.001;
        private int Epoch = 500;
        private int inputcount = 0;
        private int hiddencount = 30;
        
        //train data
        private List<INDArray> Input1 = new ArrayList<>();
        private List<INDArray> Input2 = new ArrayList<>();
        
        //negotiation param
        private Domain domain;
        private List<Bid> bidlist = new ArrayList<>();
        private Bid reservationbid;
        private Bid maxBid;
        private Bid minBid;
        private HashMap<String, HashMap<Value, Integer>> valuePosition = new HashMap<String, HashMap<Value, Integer>>();
        
        //for elicit compare
        private HashMap<String, HashMap<Value, Integer>> valuefrequency = new HashMap<String, HashMap<Value, Integer>>();//new？or null?
        
        public MyUtilityModel(Profile profile) {
                DefaultPartialOrdering prof = (DefaultPartialOrdering) profile;

                this.domain = prof.getDomain();
                this.bidlist = prof.getBids();
                this.reservationbid = prof.getReservationBid();
                
                //get input size.       
                for (String issue: domain.getIssues()) {
                        int num = domain.getValues(issue).size().intValue();
                        inputcount = inputcount+num;            
                }

                buildRankModel(prof.getDomain(), hiddencount);
                
//              if (true) {
//                      throw new RuntimeException("ttt done"+ inputcount);
//              }
                getValueind();
                constructdata(profile);
                train();
        }
        
        public void buildRankModel(Domain domain, int Hiddencount) {
//              Set<String> issueset = domain.getIssues();
                ann = NeuralRankNet.Builder().setLearningRate(LearningRate)
                                .addLayer(Layer.Builder().setInCount(inputcount).setOutCount(Hiddencount).setActivationFunction(SigmoidActivationFunction.INSTANCE).build())
                                .addLayer(Layer.Builder().setInCount(Hiddencount).setOutCount(Hiddencount).setActivationFunction(SigmoidActivationFunction.INSTANCE).build())
                                .addLayer(Layer.Builder().setInCount(Hiddencount).setOutCount(1).setActivationFunction(SigmoidActivationFunction.INSTANCE).build())
                                .build();
        }
        
        public void constructdata(Profile profile) {
                DefaultPartialOrdering prof = (DefaultPartialOrdering) profile;
                int ind = 0;
                for(int i = 0; i < bidlist.size(); i++) {
                        for (int j = i+1; j < bidlist.size(); j++) {
                                Bid bid1 = bidlist.get(i);
                                Bid bid2 = bidlist.get(j);
                                
                                if(prof.isPreferredOrEqual(bid1, bid2)) {
                                        Input1.add(ind, bidtoArray(bid1));
                                        Input2.add(ind, bidtoArray(bid2));
                                        ind ++;
                                }
                                if (prof.isPreferredOrEqual(bid2, bid1)) {
                                        Input1.add(ind, bidtoArray(bid2));
                                        Input2.add(ind, bidtoArray(bid1));
                                        ind ++;
                                }
                        }
                }
//              return null;
        }
        
        public void getValueind() {//get the input position of a value
                
                int valueind = 0;
                for(String issue: domain.getIssues()) {
                        HashMap<Value, Integer> temp = new HashMap<Value, Integer>();
                        for (Value value: domain.getValues(issue)) {
                                temp.put(value, valueind);
                                valuePosition.put(issue, temp);
                                valueind ++;
                        }
                }
        }
        
        public INDArray bidtoArray(Bid bid) {//input the bid, return a indarray vector.
                
                INDArray features = Nd4j.zeros(1, inputcount);
                for (String issue: domain.getIssues()) {
                        Value v = bid.getValue(issue);
                        int valuepos = valuePosition.get(issue).get(v);
                        features.putScalar(0, valuepos, 1.0);
                }
//              features.putScalar(row, col, value)
                return features;
        }
        
        
        public void train() {
                
                for (int epoch = 0; epoch< Epoch; epoch++) {
                        for (int ind= 0; ind < Input1.size(); ind++) {
                                ann.train(Input1.get(ind), Input2.get(ind), Nd4j.scalar(1));
                        }
                }
        }
        
        public void update(Bid bid, List<Bid> betterBids, List<Bid> worseBids) {
                
        }
        
        public double getUtility(Bid bid) {
                //get the utility from the model.
                List<INDArray> feedForward = ann.feedForward(bidtoArray(bid));
                return feedForward.get(feedForward.size() - 1).getDouble(0);
        }
        
        public void setvaluefrequency(List<Bid> inbidlist) {//init and update the valuefrequency.
                
                for (Bid bid: inbidlist) {
                        for (String issue: bid.getIssues()) {
                                Value v =  bid.getValue(issue);
                                HashMap<Value, Integer> temp = valuefrequency.get(issue);
                                int cnt = temp.get(v);
                                temp.put(v, cnt+1);
                                valuefrequency.put(issue, temp);
                        }
                }
        }
        
        public HashMap<String, List<Value>> getmostinformative(){//return a map contains the 

                HashMap<String, List<Value>> infovalue = new HashMap<String, List<Value>>();
                for (String issue : domain.getIssues()) {
                        List<Value> elicitvalueset = new ArrayList<Value>();
                        int minfreq = 0;
                        for (Value value: domain.getValues(issue)) {
                                int freq = valuefrequency.get(issue).get(value);
                                if (elicitvalueset.isEmpty()) {
                                        elicitvalueset.add(value);
                                        minfreq = freq;
                                }else {
                                        if (freq<minfreq) {
                                                elicitvalueset.clear();
                                                elicitvalueset.add(value);
                                        }else if(freq == minfreq) {
                                                elicitvalueset.add(value);
                                        }
                                }
                        }
                        infovalue.put(issue, elicitvalueset);

                }
                return infovalue;
        }
        
        public Domain getDomain() {
                return this.domain;
        }
        
        public Bid getBestBid() {
                return this.maxBid;
        }
        
        public Bid getWorstBid() {
                return this.minBid;
        }
        
        public Bid getReservationBid() {
                return this.reservationbid;
        }
        public List<Bid> getBidlist(){
                return this.bidlist;
        }
        public NeuralRankNet getann() {
                return this.ann;
        }
        
}