crossvalidation.java

GUI Ant-Miner is a tool for extracting classification rules from data. It is an updated version of a

													termOccurs = true;
											}
											//if trainingSet doesn't contain term ij then...
											if(!termOccurs)
												greatestValue = log2(numClasses);
											double tempVar;
											if(greatestValue == -9999)
												tempVar = ((Double) temp).doubleValue();
											else
												tempVar = greatestValue;
											
											li2.next();
											
											//if all cases with term ij belong to the same class, then infoTij should be zero
											liTraining = trainingSet.listIterator();
											String instanceClass = "";
											boolean isEqual = true;
											temp2 = null;
											while(liTraining.hasNext() && isEqual){
												temp2 = liTraining.next();
												if(((DataInstance) temp2).getValues().get(i).equals(((List) ((Attribute) attributesList.get(i)).getTypes()).get(j))){
													if(instanceClass.compareTo("") != 0){
														//compare the last instance class with the current instance class
														if(instanceClass.compareTo( ((DataInstance) temp2).getValues().get( ((DataInstance) temp2).getValues().size()-1 ).toString() ) == 0 )
															isEqual = true;
														else
															isEqual = false;
													}
													instanceClass = ((DataInstance) temp2).getValues().get( ((DataInstance) temp2).getValues().size()-1 ).toString();
												}
											}
											if(isEqual)
												tempVar = 0.0;
											
											li2.set(new Double( (log2(numClasses) - tempVar) / sum ));
											
										}else{
											li2.next();
											li2.set(new Double(0));
										}
										j++;
									}
									i++;
								}
								
								//Pij = nij * tij(t) / S xm * (S hmn * tmn(t))
								calculateProbabilities(currentAnt, hList, pheroTempList, probabilityList);
								
								
								float randomNumber = (random.nextInt() << 1 >>> 1) % 101;
								randomNumber /= 100;
								boolean found = false;
								
								
								i=j=0;
								sum = 0.0;
								li = probabilityList.listIterator();
								while(li.hasNext() && !found){
									li2 = ((List) li.next()).listIterator();
									j=0;
									while(li2.hasNext() && !found){
										temp = li2.next();
										sum += ((Double) temp).doubleValue();
										
										if(sum >= randomNumber){
											if(!ruleConstructor(currentAnt, i, j)){
												unusablesList.add(String.valueOf(i)+String.valueOf(j));
												attDistinctLeft[i]--;
												((List) pheroTempList.get(i)).set(j, new Double(0));
											}else{
												attDistinctLeft[i] = -1;
											}
											found = true;
										}
										j++;
									}
									i++;
								}
								
								//determine if ant already tried to use all values of attribute x
								for(int x=0;x<attributesList.size();x++){
									if(attDistinctLeft[x] == 0){
										currentAnt.getMemory()[x] = 2;
									}
								}
								
								
								goOn = false;
								int x=0;
								do{
									if(currentAnt.getMemory()[x] == 0)
										goOn = true;
									x++;
								}while(!goOn && x < attributesList.size()-1);
								
							}
							
							determineRuleConsequent(currentAnt);
							calculateRuleQuality(currentAnt);
							
							double currentRuleQuality;
							double greatestQuality;
							Ant antWithBestPrunedRule = new Ant(attributesList.size());
							
							//prune rule
							Ant currentAntClone;
							int originalRuleSize = currentAnt.getRulesList().size();
							int ruleSize;
							if(originalRuleSize > 1){
								for(int index2=0;index2<originalRuleSize;index2++){
									ruleSize = currentAnt.getRulesList().size();
									if(ruleSize > 1){
										currentRuleQuality = currentAnt.getRuleQuality();
										greatestQuality = currentRuleQuality;
										for(int index=0;index<ruleSize;index++){
											//try{
											
											currentAntClone = (Ant) currentAnt.clone();
											currentAntClone.getRulesList().remove(index);
											
											//re-insert terms into rule to update instancesIndexList
											temp = currentAntClone.getRulesList().clone();
											currentAntClone.getRulesList().clear();
											currentAntClone.getInstancesIndexList().clear();
											li = ((List) temp).listIterator();
											while(li.hasNext()){
												temp2 = li.next();
												ruleConstructor(currentAntClone, ((int[]) temp2)[0], ((int[]) temp2)[1]);
											}
											
											determineRuleConsequent(currentAntClone);
											
											calculateRuleQuality(currentAntClone);
											if(currentAntClone.getRuleQuality() >= greatestQuality){
												greatestQuality = currentAntClone.getRuleQuality(); 
												antWithBestPrunedRule = (Ant) currentAntClone.clone(); 
											}
											
											//}catch(CloneNotSupportedException e){e.printStackTrace();}
										}
										if(greatestQuality >= currentRuleQuality){
											//try{
											currentAnt = (Ant) antWithBestPrunedRule.clone();
											antsList.set(antIndex, currentAnt);
											//}catch(Exception e){e.printStackTrace();}
										}else //rule could not be improved, so leave block
											index2 = originalRuleSize;
									}
								}
							}						
							
							//TODO
							if(currentAnt.getRuleQuality() >= bestQuality){
								bestQuality = currentAnt.getRuleQuality();
								bestAntIndex = antIndex;
							}
							
							antIndex++;
						}
						
						//try{
						bestIterationAntsList.add(((Ant) antsList.get(bestAntIndex)).clone());
						//}catch(Exception e){e.printStackTrace();}
						
						//check if rule quality has stagnated by comparing the last best quality with the previous one
						if(bestIterationAntsList.size() > 1){
							if(((Ant) bestIterationAntsList.get(bestIterationAntsList.size()-1)).getRuleQuality() == ((Ant) bestIterationAntsList.get(bestIterationAntsList.size()-2)).getRuleQuality())
								deltaCount++;
							else
								deltaCount = 0;
						}else
							deltaCount++;
						
						//update pheromone for used terms
						
						li = ((Ant) antsList.get(bestAntIndex)).getRulesList().listIterator();
						while(li.hasNext()){
							temp = li.next();
							double currentValue = ((Double) ((List) pheromoneList.get(((int[]) temp)[0])).get(((int[]) temp)[1])).doubleValue();
							((List) pheromoneList.get(((int[]) temp)[0])).set(((int[]) temp)[1], new Double(currentValue + currentValue*((Ant) antsList.get(bestAntIndex)).getRuleQuality()));
						}
						//normalize pheromone
						double sum=0;
						li = pheromoneList.listIterator();
						while(li.hasNext()){
							li2 = ((List) li.next()).listIterator();
							while(li2.hasNext()){
								sum += ((Double) li2.next()).doubleValue();
							}
						}
						int i=0,j;
						li = pheromoneList.listIterator();
						while(li.hasNext()){
							j=0;
							li2 = ((List) li.next()).listIterator();
							while(li2.hasNext()){
								temp = li2.next();
								li2.set(new Double(((Double) temp).doubleValue() / sum));
								j++;
							}
							i++;
						}
						
						iteration++;
					} //end of iterations
					
					//determine which ant has the best quality
					li = bestIterationAntsList.listIterator();
					int index=0;
					bestAntIndex=0;
					double bestQuality = 0.0;
					while(li.hasNext()){
						temp = li.next();
						if(((Ant) temp).getRuleQuality() >= bestQuality){
							bestQuality = ((Ant) temp).getRuleQuality();
							bestAntIndex = index;
						}
						index++;
					}
					
					//try{
					antsFoundRuleList.add(((Ant) bestIterationAntsList.get(bestAntIndex)).clone());
					//}catch(Exception e){e.printStackTrace();}
					
					
					//remove covered cases from trainingSet
					if(bestAntIndex != -1){
						li = ((Ant) bestIterationAntsList.get(bestAntIndex)).getInstancesIndexList().listIterator(((Ant) bestIterationAntsList.get(bestAntIndex)).getInstancesIndexList().size());
						while(li.hasPrevious()){
							temp = li.previous();
							trainingSet.remove(((Integer) temp).intValue());
						}
					}
					
				}
				
				caller.getJTextArea1().append("\n------------------ Cross Validation #"+(PS+1)+"------------------\n\n");
				caller.getJTextArea1().append("Cases in the training set: "+trainingSetClone.size()+"\n");
				
				if(caller.getJCheckBox3IsSelected()){
					caller.getJTextArea1().append("\n");
					li = trainingSetClone.listIterator();
					while(li.hasNext()){
						DataInstance tempxx = (DataInstance) li.next();
						li2 = tempxx.getValues().listIterator();
						while(li2.hasNext()){
							caller.getJTextArea1().append(String.valueOf(li2.next()));
							if(li2.hasNext())
								caller.getJTextArea1().append(", ");
						}
						caller.getJTextArea1().append("\n");
					}
				}
				
				caller.getJTextArea1().append("\nCases in the test set:     "+testSet.size()+"\n");
				
				if(caller.getJCheckBox2IsSelected()){
					caller.getJTextArea1().append("\n");
					li = testSet.listIterator();
					while(li.hasNext()){
						DataInstance tempxx = (DataInstance) li.next();
						li2 = tempxx.getValues().listIterator();
						while(li2.hasNext()){
							caller.getJTextArea1().append(String.valueOf(li2.next()));
							if(li2.hasNext())
								caller.getJTextArea1().append(", ");
						}
						caller.getJTextArea1().append("\n");
					}
				}
				
				numberOfRulesList.add(new Double((double)(antsFoundRuleList.size()+1)));
				
				int sum=0;
				li = antsFoundRuleList.listIterator();
				while(li.hasNext()){
					temp = li.next();
					sum += ((Ant) temp).getRulesList().size();
				}
				numberOfTermsList.add(new Double((double)sum));
				
				caller.getJTextArea1().append("\nRules: "+(antsFoundRuleList.size()+1)+"\n\n");
				System.out.println("\nRules: "+(antsFoundRuleList.size()+1));
				
				li = antsFoundRuleList.listIterator();
				while(li.hasNext()){
					temp = li.next();
					caller.getJTextArea1().append(((Ant) temp).getRuleString(attributesList)+/*" Quality: "+((Ant) temp).getRuleQuality()+*/"\n");
				}
				
				int [] freqT2 = new int[numClasses];
				int greatest=0, defaultClassIndex=0;
				//initializes freqT2, which contains the number of cases that identify a class in the trainingSet
				li = trainingSet.listIterator();
				while(li.hasNext()){
					List tempList = ((DataInstance) li.next()).getValues();
					int classIndex = ((Attribute) attributesList.get(attributesList.size()-1)).getTypes().indexOf(tempList.get(tempList.size()-1));
					freqT2[classIndex]++;
					if(freqT2[classIndex] > greatest){
						greatest = freqT2[classIndex];
						defaultClassIndex = classIndex;
					}
				}
				caller.getJTextArea1().append("Default rule: "+((Attribute) attributesList.get(attributesList.size()-1)).getTypes().get(defaultClassIndex)+"\n");
				
				double trainingAccuracyRate = calculateAccuracyRate(trainingSetClone, antsFoundRuleList, defaultClassIndex);
				totalTrainingAccuracyRate += trainingAccuracyRate;