001    package jcolibri.method.maintenance;
002    
003    import java.util.Collection;
004    import java.util.HashMap;
005    import java.util.Iterator;
006    import java.util.LinkedList;
007    
008    import jcolibri.cbrcore.CBRCase;
009    import jcolibri.method.retrieve.RetrievalResult;
010    import jcolibri.method.retrieve.KNNretrieval.KNNConfig;
011    import jcolibri.method.retrieve.KNNretrieval.KNNretrievalMethod;
012    
013    /**
014     * Calculates coverage, reachability and liability sets
015     * 
016     * @author Lisa Cummins
017     */
018    public class VotesCalculator {
019    
020            /**
021             * Gets all cases retrieved for each of the given cases 
022             */
023            public HashMap<CBRCase, LinkedList<CBRCase>> getAllRetrievedCasesForWholeCB(Collection<CBRCase> cases, KNNConfig simConfig)
024            {       HashMap<CBRCase, LinkedList<CBRCase>> retrievedCases = new HashMap<CBRCase, LinkedList<CBRCase>>(); 
025                                    
026                    LinkedList<CBRCase> caseList = new LinkedList<CBRCase>();
027                    for(Iterator<CBRCase> caseIter = cases.iterator(); caseIter.hasNext();)
028                    {       caseList.add(caseIter.next());
029                    }
030    
031                    for(int i=0; i<caseList.size(); i++)
032                    {       CBRCase query = caseList.remove(i);
033                            
034                            Collection<RetrievalResult> allRetrieved = KNNretrievalMethod.evaluateSimilarity(cases, query, simConfig);
035                            
036                            LinkedList<CBRCase> allCasesRetrieved = new LinkedList<CBRCase>();
037                            
038                            for(Iterator<RetrievalResult> cIter = allRetrieved.iterator(); cIter.hasNext(); )
039                            {       RetrievalResult c = cIter.next();
040                                    allCasesRetrieved.addLast(c.get_case());
041                            }
042                            retrievedCases.put(query, allCasesRetrieved);
043                            caseList.add(i, query);
044                    }
045                    return retrievedCases;
046            }
047            
048            /**
049             * Gets all cases retrieved for the query in the context
050             */
051            public LinkedList<CBRCase> getAllRetrievedCasesForQuery(Collection<CBRCase> cases, CBRCase query, KNNConfig simConfig)
052            {       LinkedList<CBRCase> retrievedCases = new LinkedList<CBRCase>(); 
053                    
054                    Collection<RetrievalResult> allRetrieved = KNNretrievalMethod.evaluateSimilarity(cases, query, simConfig);
055                    for(RetrievalResult c: allRetrieved)
056                    {       retrievedCases.addLast(c.get_case());
057    //                      System.out.println("Case: " + c.get_case() + "  Sim: " + c.getEval());
058                    }
059                    return retrievedCases;
060            }
061    
062            /**
063             * Gets the top k cases retrieved for each case in the context
064             */
065            public HashMap<CBRCase, LinkedList<CBRCase>> getkRetrievedCasesForWholeCB(Collection<CBRCase> cases, KNNConfig simConfig, int k)
066            {       HashMap<CBRCase, LinkedList<CBRCase>> allRetrievedCases = 
067                            getAllRetrievedCasesForWholeCB(cases, simConfig);
068                    HashMap<CBRCase, LinkedList<CBRCase>> kRetrievedCases = 
069                            new HashMap<CBRCase, LinkedList<CBRCase>>();
070                    for(Iterator<CBRCase> cIter=allRetrievedCases.keySet().iterator(); cIter.hasNext(); )
071                    {       CBRCase c = cIter.next();
072                            LinkedList<CBRCase> retrievedForC = allRetrievedCases.get(c);
073                            
074                            while(retrievedForC.size()>k)
075                            {       retrievedForC.removeLast();
076                            }
077                            kRetrievedCases.put(c, retrievedForC);
078                    }
079                    return kRetrievedCases;
080            }
081    
082            /**
083             * Gets the top k cases retrieved for each case in the context
084             */
085            public LinkedList<CBRCase> getkRetrievedCasesForQuery(LinkedList<CBRCase> cases, CBRCase query, KNNConfig simConfig, int k)
086            {       LinkedList<CBRCase> allRetrievedCases = getAllRetrievedCasesForQuery(cases, query, simConfig);
087                    
088                    LinkedList<CBRCase> kRetrievedCases = new LinkedList<CBRCase>();
089                    
090                    for(int i=0; i<allRetrievedCases.size() && i<k; i++ )
091                    {       kRetrievedCases.add(allRetrievedCases.get(i));
092                    }
093                    return kRetrievedCases;
094            }
095            
096            /**
097             * Classifies the predicted classes of each of the cases based on 
098             * the given retrieved cases for each cases 
099             * @param retrievedCases the cases contributing to the prediction
100             * for each case
101             * @return the predicted classes of each of the cases
102             */
103            public HashMap<CBRCase, String> getPredictedClasses(HashMap<CBRCase, LinkedList<CBRCase>> retrievedCases)
104            {       HashMap<CBRCase, String> votes = new HashMap<CBRCase, String>();
105                    
106                    for(Iterator<CBRCase> caseIter = retrievedCases.keySet().iterator(); caseIter.hasNext(); )
107                    {       CBRCase c = caseIter.next();
108                            LinkedList<CBRCase> retrieved = retrievedCases.get(c);
109                            String winner = getPredictedClass(retrieved); 
110                            votes.put(c, winner);
111                    }
112                    return votes;
113            }
114    
115            /**
116             * Classifies the predicted class based on the given retrieved cases.
117             * The classification is performed using a simple count of the votes,
118             * the class with the most votes is the predicted class 
119             * @param retrievedCases the cases contributing to the prediction
120             * @return the predicted class
121             */
122            public String getPredictedClass(LinkedList<CBRCase> retrievedCases)
123            {       HashMap<String, Integer> caseVotes = new HashMap<String, Integer>(); 
124                    for(int i=0; i<retrievedCases.size(); i++)
125                    {       CBRCase ret = retrievedCases.get(i);
126                            String retSolution = ret.getSolution().toString(); 
127                            if (caseVotes.containsKey(retSolution))
128                {   caseVotes.put(retSolution, caseVotes.get(retSolution)+1);
129                }
130                else
131                {   caseVotes.put(retSolution, 1);
132                }
133                    }
134                    int topVotes = -1;
135                    String winner = null;
136                    for(Iterator<String> iter=caseVotes.keySet().iterator(); iter.hasNext(); )
137                    {       String current = iter.next();
138                            Integer currentVote = caseVotes.get(current);
139                            if(currentVote > topVotes)
140                            {       topVotes = currentVote;
141                                    winner = current;
142                            }
143                    }
144                    return winner;
145            }
146    
147    }