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 }