001package es.ucm.fdi.gaia.jcolibri.evaluation.evaluators;
002
003import java.io.BufferedReader;
004import java.io.BufferedWriter;
005import java.io.FileReader;
006import java.io.FileWriter;
007import java.util.ArrayList;
008import java.util.Collection;
009import java.util.Date;
010import java.util.Iterator;
011import java.util.List;
012
013import org.apache.logging.log4j.LogManager;
014
015import es.ucm.fdi.gaia.jcolibri.casebase.CachedLinealCaseBase;
016import es.ucm.fdi.gaia.jcolibri.cbraplications.StandardCBRApplication;
017import es.ucm.fdi.gaia.jcolibri.cbrcore.CBRCase;
018import es.ucm.fdi.gaia.jcolibri.cbrcore.CBRCaseBase;
019import es.ucm.fdi.gaia.jcolibri.evaluation.EvaluationReport;
020import es.ucm.fdi.gaia.jcolibri.evaluation.Evaluator;
021import es.ucm.fdi.gaia.jcolibri.exception.ExecutionException;
022import es.ucm.fdi.gaia.jcolibri.util.FileIO;
023import es.ucm.fdi.gaia.jcolibri.util.ProgressController;
024
025/**
026 * This method splits the case base in two sets: one used for testing where each
027 * case is used as query, and another that acts as normal case base.
028 * <br>
029 * This method is different of the other evaluators beacuse the split is stored in a file that can be used in following evaluations.
030 * This way, the same set is used as queries for each evaluation.
031 * <br>
032 * The generateSplit() method does the initial random split and saves the query set in a file. 
033 * Later, the  HoldOutfromFile() method uses that file to load the queries set and perform the evaluation.
034 * 
035 * @author Juan A. Recio GarcĂ­a & Lisa Cummins
036 * @version 2.0
037 */
038
039public class SameSplitEvaluator extends Evaluator {
040
041        protected StandardCBRApplication app;
042
043        public void init(StandardCBRApplication cbrApp) {
044
045                report = new EvaluationReport();
046                app = cbrApp;
047                try {
048                        app.configure();
049                } catch (ExecutionException e) {
050                        LogManager.getLogger().error(e);
051                }
052        }
053
054        public void generateSplit(int testPercent,  String filename)
055        {
056                //Run the precycle to load the case base
057                LogManager.getLogger().info("Running precycle()");
058                CBRCaseBase caseBase = null;
059                try {
060                        caseBase = app.preCycle();
061                } catch (ExecutionException e) {
062                        LogManager.getLogger().error(e);
063                }
064
065                if (!(caseBase instanceof CachedLinealCaseBase))
066                        LogManager.getLogger().warn(
067                                                        "Evaluation should be executed using a cached case base");
068
069                ArrayList<CBRCase> originalCases = new ArrayList<CBRCase>(
070                                caseBase.getCases());
071                                
072                ArrayList<CBRCase> querySet = new ArrayList<CBRCase>();
073                ArrayList<CBRCase> caseBaseSet = new ArrayList<CBRCase>();
074                        
075                // Split the case base
076                splitCaseBase(originalCases, querySet, caseBaseSet, testPercent);
077                
078                save(querySet, filename);
079        }
080        
081        protected void save(Collection<CBRCase> queries, String filename)
082        {
083                try {
084                        BufferedWriter br = null;
085                        br = new BufferedWriter(new FileWriter(filename));
086                        //if (br == null)
087                        //      throw new Exception("Error opening file for writing: "+ filename);
088                        
089                        for (CBRCase _case : queries) {
090                                br.write(_case.getID().toString());
091                                br.newLine();
092                        }
093                        br.close();
094                } catch (Exception e) {
095                        LogManager.getLogger().error(e);
096                }
097                        
098
099        }
100        
101        public void HoldOutfromFile(String file) {
102                try {
103                        // Obtain the time
104                        long t = (new Date()).getTime();
105                        int numberOfCycles = 0;
106
107                        // Run the precycle to load the case base
108                        LogManager.getLogger().info("Running precycle()");
109                        CBRCaseBase caseBase = app.preCycle();
110
111                        if (!(caseBase instanceof CachedLinealCaseBase))
112                                LogManager.getLogger().warn(
113                                                                "Evaluation should be executed using a cached case base");
114
115                        ArrayList<CBRCase> originalCases = new ArrayList<CBRCase>(caseBase.getCases());
116                        ArrayList<CBRCase> querySet = new ArrayList<CBRCase>();
117                        ArrayList<CBRCase> caseBaseSet = new ArrayList<CBRCase>();
118                        
119                        // Split the case base
120                        splitCaseBaseFromFile(originalCases, querySet, caseBaseSet, file);
121                        
122                        int totalSteps = querySet.size();
123                        ProgressController.init(getClass(),
124                                        "Same Split - Hold Out Evaluation", totalSteps);
125
126
127                        // Clear the caseBase
128                        caseBase.forgetCases(originalCases);
129
130                        // Set the cases that acts as case base in this repetition
131                        caseBase.learnCases(caseBaseSet);
132
133                        // Run cycle for each case in querySet
134                        for (CBRCase c : querySet) {
135                                // Run the cycle
136                                LogManager.getLogger().info(
137                                                "Running cycle() " + numberOfCycles);
138                                app.cycle(c);
139
140                                ProgressController.step(getClass());
141                                numberOfCycles++;
142                        }
143
144                        ProgressController.finish(getClass());
145
146                        // Revert case base to original state
147                        caseBase.forgetCases(originalCases);
148                        caseBase.learnCases(originalCases);
149
150                        // Run the poscycle to finish the application
151                        LogManager.getLogger().info("Running postcycle()");
152                        app.postCycle();
153
154                        t = (new Date()).getTime() - t;
155
156                        // Obtain and complete the evaluation result
157                        report.setTotalTime(t);
158                        report.setNumberOfCycles(numberOfCycles);
159
160                } catch (Exception e) {
161                        LogManager.getLogger().error(e);
162                }
163
164        }
165
166        /**
167         * Splits the case base in two sets: queries and case base
168         * 
169         * @param wholeCaseBase
170         *            Complete original case base
171         * @param querySet
172         *            Output param where queries are stored
173         * @param casebaseSet
174         *            Output param where case base is stored
175         * @param testPercent
176         *            Percentage of cases used as queries
177         */
178        protected void splitCaseBase(Collection<CBRCase> wholeCaseBase,
179                        List<CBRCase> querySet, List<CBRCase> casebaseSet, int testPercent) {
180                querySet.clear();
181                casebaseSet.clear();
182
183                int querySetSize = (wholeCaseBase.size() * testPercent) / 100;
184                casebaseSet.addAll(wholeCaseBase);
185
186                for (int i = 0; i < querySetSize; i++) {
187                        int random = (int) (Math.random() * casebaseSet.size());
188                        CBRCase _case = casebaseSet.get(random);
189                        casebaseSet.remove(random);
190                        querySet.add(_case);
191                }
192        }
193        
194        protected void splitCaseBaseFromFile(Collection<CBRCase> wholeCaseBase,
195                        List<CBRCase> querySet, List<CBRCase> casebaseSet, String filename)
196        {
197                querySet.clear();
198                casebaseSet.clear();
199                
200                casebaseSet.addAll(wholeCaseBase);
201                
202                try {
203                        BufferedReader br = null;
204                        br = new BufferedReader(new FileReader(FileIO.findFile(filename).getFile()));
205                        //if (br == null)
206                        //      throw new Exception("Error opening file: " + filename);
207
208                        String line = "";
209                        while ((line = br.readLine()) != null) {
210                                CBRCase c = null;
211                                int pos=0;
212                                boolean found = false;
213                                for(Iterator<CBRCase> iter = casebaseSet.iterator(); iter.hasNext() && (!found); )
214                                {
215                                        c = iter.next();
216                                        if(c.getID().toString().equals(line))
217                                                found = true;
218                                        else
219                                                pos++;
220                                }
221                                if(c==null)
222                                {
223                                        LogManager.getLogger().error("Case "+line+" not found into case base");
224                                        continue;
225                                }
226                                
227                                casebaseSet.remove(pos);
228                                querySet.add(c);
229                        }
230                        br.close();
231                } catch (Exception e) {
232                        LogManager.getLogger().error(e);
233                }
234        }
235
236}