ieinterface.java

这是一个matlab的java实现。里面有许多内容。请大家慢慢捉摸。

						continue;
					}

					totalTokens ++;

					Object trueO = trueSequence.get(j);
					int trueIndex = targets.lookupIndex(trueO);
					numTrueSegments[trueIndex] ++;
			
					int predIndex = 0;
					for(int k=0; k<nbestlist.length; k++){
						Object predO = nbestlist[k].get(j);
						predIndex = targets.lookupIndex(predO);
						if(predIndex == trueIndex) break;
					}

					numPredictedSegments[predIndex] ++;
					matrixEntry[trueIndex][predIndex] ++;

					if(predIndex == trueIndex){
						numCorrectTokens ++;
						numCorrectSegments[trueIndex] ++;
					}
					else{				
						wholeInstanceCorrect = false;
					}

	
				}

				if(wholeInstanceCorrect) numCorrectWholeInstance ++;
		}


		System.out.println("\n\ncumulative at token level evalutation results: N = " + N);

		double macro_average_p=0;
		double macro_average_r=0;
		double macro_average_f=0;
		double micro_average_p=0;
		double micro_average_r=0;
		double micro_average_f=0;
		int micro_numCorrectSegments = 0;
		int micro_numPredictedSegments = 0;
		int micro_numTrueSegments = 0;
		int classNum=0;
                for(int t=0; t<targets.size(); t++){
                        double precision = numPredictedSegments[t] == 0 ? 1 : ((double)numCorrectSegments[t]) / numPredictedSegments[t];
                        double recall = numTrueSegments[t] == 0 ? 1 : ((double)numCorrectSegments[t]) / numTrueSegments[t];
                        double f1 = recall+precision == 0.0 ? 0.0 : (2.0 * recall * precision) / (recall + precision);
                        double accuracy_individual = (double)(totalTokens-numPredictedSegments[t]-numTrueSegments[t] + 2*numCorrectSegments[t] )/totalTokens;

                        System.out.println (targets.lookupObject(t) + " precision="+precision+" recall="+recall+" f1="+f1 + " accuracy=" + accuracy_individual);
                        System.out.println ("segments true="+numTrueSegments[t]+" pred="+numPredictedSegments[t]+" correct="+numCorrectSegments[t]+" misses="+(numTrueSegments[t]-numCorrectSegments[t])+" alarms="+(numPredictedSegments[t]-numCorrectSegments[t]) + "\n");

			if(!targets.lookupObject(t).equals("O")){
				classNum++;
				
				macro_average_p += precision;
				macro_average_r += recall;
				macro_average_f += f1;

				micro_numCorrectSegments += numCorrectSegments[t];
				micro_numPredictedSegments += numPredictedSegments[t];
				micro_numTrueSegments +=  numTrueSegments[t];
			}
                }

		micro_average_p = (double)micro_numCorrectSegments/micro_numPredictedSegments;
		micro_average_r = (double)micro_numCorrectSegments/micro_numTrueSegments;
		micro_average_f =  micro_average_r + micro_average_p == 0.0 ? 0.0 : (2.0 * micro_average_r * micro_average_p) / (micro_average_r + micro_average_p);

		macro_average_p /= classNum;
		macro_average_r /= classNum;
		macro_average_f /= classNum;

                System.out.println("\n Confusion Matrix (row: true label, col: predicted label)");
                System.out.print("\t");
                for(int t=0; t<targets.size(); t++){
                        System.out.print(targets.lookupObject(t) + "\t");
                }
                System.out.println();

                for(int t=0; t< targets.size(); t++){
                        System.out.print(targets.lookupObject(t)+"\t");
                        for(int tt=0; tt<targets.size(); tt++){
                                System.out.print(matrixEntry[t][tt] + "\t");
                        }
                        System.out.println();
                }

		// print out the overall performance
                double accuracy = (double)numCorrectTokens/totalTokens;
                System.out.println ("\n" +" accuracy=" + numCorrectTokens +"/"+ totalTokens + " = " +accuracy);

                double wholeInstanceAccuracy = (double)numCorrectWholeInstance/instancelist.size();
                System.out.println ("Whole instance accuracy = " + numCorrectWholeInstance + "/" + instancelist.size() + " = " + wholeInstanceAccuracy);

		System.out.println("\nMacro Average");
		System.out.println("macro precision : " + macro_average_p);
		System.out.println("macro recall: " + macro_average_r);
		System.out.println("macro f : " + macro_average_f);

		System.out.println("\nMicro Average");
		System.out.println("micro precision : " + micro_average_p);
		System.out.println("micro recall: " + micro_average_r);
		System.out.println("micro f : " + micro_average_f);

/*
		double accuracy = (double)numCorrectTokens/totalTokens;
                System.out.println ("\n" +" accuracy=" + numCorrectTokens +"/"+ totalTokens + " = " +accuracy);

		double wholeInstanceAccuracy = (double)numCorrectWholeInstance/instancelist.size();
		System.out.println ("Whole instance accuracy = " + numCorrectWholeInstance + "/" + instancelist.size() + " = " + wholeInstanceAccuracy);

		for(int t=0; t<targets.size(); t++){
			double precision = numPredictedSegments[t] == 0 ? 1 : ((double)numCorrectSegments[t]) / numPredictedSegments[t];
			double recall = numTrueSegments[t] == 0 ? 1 : ((double)numCorrectSegments[t]) / numTrueSegments[t];
			double f1 = recall+precision == 0.0 ? 0.0 : (2.0 * recall * precision) / (recall + precision);
			double accuracy_individual = (double)(totalTokens-numPredictedSegments[t]-numTrueSegments[t] + 2*numCorrectSegments[t] )/totalTokens;

                        System.out.println (targets.lookupObject(t) + " precision="+precision+" recall="+recall+" f1="+f1 + " accuracy=" + accuracy_individual);
			System.out.println ("segments true="+numTrueSegments[t]+" pred="+numPredictedSegments[t]+" correct="+numCorrectSegments[t]+" misses="+(numTrueSegments[t]-numCorrectSegments[t])+" alarms="+(numPredictedSegments[t]-numCorrectSegments[t]) + "\n");

		}


		System.out.println("\n Confusion Matrix (row: true label, col: predicted label)");
		System.out.print("\t");
		for(int t=0; t<targets.size(); t++){
			System.out.print(targets.lookupObject(t) + "\t");
		}
		System.out.println();

		for(int t=0; t< targets.size(); t++){
			System.out.print(targets.lookupObject(t)+"\t");
			for(int tt=0; tt<targets.size(); tt++){
				System.out.print(matrixEntry[t][tt] + "\t");
			}
			System.out.println();
		}
*/

	}

	// offline test, inputFile is labeled
	public void offLineEvaluate(File inputFile, boolean sgml, String seperator, int N)
	{
		assert(pipe!= null);
		InstanceList instancelist = new InstanceList (pipe);

		Reader reader;
		try {
			reader = new FileReader (inputFile);
		} catch (Exception e) {
			throw new IllegalArgumentException ("Can't read file "+inputFile);
		}
		
		instancelist.add (new LineGroupIterator (reader, Pattern.compile(seperator), true));

		String outputFileStr = inputFile.toString() + "_tagged";
		
		System.out.println(inputFile.toString() + " ---> " + outputFileStr);

		PrintStream taggedOut = null;
		try{
			FileOutputStream fos = new FileOutputStream (outputFileStr);
			taggedOut = new PrintStream (fos);
		} catch (IOException e) {
			logger.warning ("Couldn't open output file '"+ outputFileStr+"'");
		}
		
		if(taggedOut == null){
			taggedOut = System.out;
		}

		Alphabet targets = (this.pipe).getTargetAlphabet();
                assert(targets != null);

		System.out.println("target size: " +  targets.size());

		System.out.print ("State labels:");
		for (int i = 0; i < targets.size(); i++)
			System.out.print (" " + targets.lookupObject(i));
		System.out.println ("");

		int numCorrectTokens = 0, totalTokens = 0;
		int[] numTrueSegments, numPredictedSegments, numCorrectSegments;
		int[] numCorrectSegmentsInVocabulary, numCorrectSegmentsOOV;
		int[] numIncorrectSegmentsInVocabulary, numIncorrectSegmentsOOV;
		int[][] matrixEntry;
		int numCorrectWholeInstance = 0;

		numTrueSegments = new int[targets.size()];
		numPredictedSegments = new int[targets.size()];
		numCorrectSegments = new int[targets.size()];
		matrixEntry = new int[targets.size()][targets.size()];


//        	String PUNT = "[,\\.;:?!()*]";
//	        Pattern puntPattern = Pattern.compile(PUNT);

		String viterbiStr = "";
//		taggedOut.println("testing instance number: " + instancelist.size() );
		for(int i=0; i<instancelist.size(); i++){
//				taggedOut.println("\ntesting instance " + i);
//				System.out.println("\ntesting instance " + i);

				Instance instance = instancelist.getInstance(i);

				//viterbi decoding
/*				String crfStr = viterbiCRFInstance(instance,sgml);
				taggedOut.println(seperator);
//				taggedOut.println("confidence = " + confidence + " instance accuracy= " 
//					+ instance_error_num + "/" + instance_size + "=" + instance_accuracy);
				taggedOut.println(crfStr);
				viterbiStr += crfStr;
*/


				//N-best tagging
				String crfStr = viterbiCRFInstance_NBest(instance,sgml, N);
//				taggedOut.println("N-best result:");
				taggedOut.println(seperator);
//				taggedOut.println("confidence = " + confidence + " instance accuracy= " 
//					+ instance_error_num + "/" + instance_size + "=" + instance_accuracy);
				taggedOut.println(crfStr);

				viterbiStr += crfStr;


				boolean wholeInstanceCorrect = true;
				Sequence trueSequence = (Sequence)instance.getTarget();
				assert(trueSequence.size() == viterbiSequence.size() );

				for (int j = 0; j < trueSequence.size(); j++) {
				
					Object predO = viterbiSequence.get(j);
					Object trueO = trueSequence.get(j);
//					System.out.println(predO + "/" + trueO);
					int predIndex = targets.lookupIndex(predO);
					int trueIndex = targets.lookupIndex(trueO);
				
					String tokenStr = tokenSequence.getToken(j).getText();
					if(puntPattern.matcher(tokenStr).matches() && ignorePunct){//ignore punct;
						continue;
					}

					totalTokens ++;
					numTrueSegments[trueIndex] ++;
					numPredictedSegments[predIndex] ++;

					matrixEntry[trueIndex][predIndex] ++;

					if(predIndex == trueIndex){
						numCorrectTokens ++;
						numCorrectSegments[trueIndex] ++;
					}
					else{				
						wholeInstanceCorrect = false;
					}

	
				}

				if(wholeInstanceCorrect) numCorrectWholeInstance ++;
		}


		double macro_average_p=0;
		double macro_average_r=0;
		double macro_average_f=0;
		double micro_average_p=0;
		double micro_average_r=0;
		double micro_average_f=0;
		int micro_numCorrectSegments = 0;
		int micro_numPredictedSegments = 0;
		int micro_numTrueSegments = 0;
		int classNum=0;
                for(int t=0; t<targets.size(); t++){
                        double precision = numPredictedSegments[t] == 0 ? 1 : ((double)numCorrectSegments[t]) / numPredictedSegments[t];
                        double recall = numTrueSegments[t] == 0 ? 1 : ((double)numCorrectSegments[t]) / numTrueSegments[t];
                        double f1 = recall+precision == 0.0 ? 0.0 : (2.0 * recall * precision) / (recall + precision);
                        double accuracy_individual = (double)(totalTokens-numPredictedSegments[t]-numTrueSegments[t] + 2*numCorrectSegments[t] )/totalTokens;

                        System.out.println (targets.lookupObject(t) + " precision="+precision+" recall="+recall+" f1="+f1 + " accuracy=" + accuracy_individual);
                        System.out.println ("segments true="+numTrueSegments[t]+" pred="+numPredictedSegments[t]+" correct="+numCorrectSegments[t]+" misses="+(numTrueSegments[t]-numCorrectSegments[t])+" alarms="+(numPredictedSegments[t]-numCorrectSegments[t]) + "\n");

			if(!targets.lookupObject(t).equals("O")){
				classNum++;
				
				macro_average_p += precision;
				macro_average_r += recall;
				macro_average_f += f1;

				micro_numCorrectSegments += numCorrectSegments[t];
				micro_numPredictedSegments += numPredictedSegments[t];
				micro_numTrueSegments +=  numTrueSegments[t];
			}
                }

		micro_average_p = (double)micro_numCorrectSegments/micro_numPredictedSegments;
		micro_average_r = (double)micro_numCorrectSegments/micro_numTrueSegments;
		micro_average_f =  micro_average_r + micro_average_p == 0.0 ? 0.0 : (2.0 * micro_average_r * micro_average_p) / (micro_average_r + micro_average_p);

		macro_average_p /= classNum;
		macro_average_r /= classNum;
		macro_average_f /= classNum;

                System.out.println("\n Confusion Matrix (row: true label, col: predicted label)");
                System.out.print("\t");
                for(int t=0; t<targets.size(); t++){
                        System.out.print(targets.lookupObject(t) + "\t");
                }
                System.out.println();

                for(int t=0; t< targets.size(); t++){
                        System.out.print(targets.lookupObject(t)+"\t");
                        for(int tt=0; tt<targets.size(); tt++){
                                System.out.print(matrixEntry[t][tt] + "\t");
                        }
                        System.out.println();
                }

		// print out the overall performance
                double accuracy = (double)numCorrectTokens/totalTokens;
                System.out.println ("\n" +" accuracy=" + numCorrectTokens +"/"+ totalTokens + " = " +accuracy);

                double wholeInstanceAccuracy = (double)numCorrectWholeInstance/instancelist.size();
                System.out.println ("Whole instance accuracy = " + numCorrectWholeInstance + "/" + instancelist.size() + " = " + wholeInstanceAccuracy);

		System.out.println("\nMacro Average");
		System.out.println("macro precision : " + macro_average_p);
		System.out.println("macro recall: " + macro_average_r);
		System.out.println("macro f : " + macro_average_f);

		System.out.println("\nMicro Average");
		System.out.println("micro precision : " + micro_average_p);
		System.out.println("micro recall: " + micro_average_r);
		System.out.println("micro f : " + micro_average_f);


/*

		double accuracy = (double)numCorrectTokens/totalTokens;
                System.out.println ("\n" +" accuracy=" + numCorrectTokens +"/"+ totalTokens + " = " +accuracy);

		double wholeInstanceAccuracy = (double)numCorrectWholeInstance/instancelist.size();
		System.out.println ("Whole instance accuracy = " + numCorrectWholeInstance + "/" + instancelist.size() + " = " + wholeInstanceAccuracy);

		for(int t=0; t<targets.size(); t++){
			double precision = numPredictedSegments[t] == 0 ? 1 : ((double)numCorrectSegments[t]) / numPredictedSegments[t];
			double recall = numTrueSegments[t] == 0 ? 1 : ((double)numCorrectSegments[t]) / numTrueSegments[t];
			double f1 = recall+precision == 0.0 ? 0.0 : (2.0 * recall * precision) / (recall + precision);
			double accuracy_individual = (double)(totalTokens-numPredictedSegments[t]-numTrueSegments[t] + 2*numCorrectSegments[t] )/totalTokens;

                        System.out.println (targets.lookupObject(t) + " precision="+precision+" recall="+recall+" f1="+f1 + " accuracy=" + accuracy_individual);
			System.out.println ("segments true="+numTrueSegments[t]+" pred="+numPredictedSegments[t]+" correct="+numCorrectSegments[t]+" misses="+(numTrueSegments[t]-numCorrectSegments[t])+" alarms="+(numPredictedSegments[t]-numCorrectSegments[t]) + "\n");

		}


		System.out.println("\n Confusion Matrix (row: true label, col: predicted label)");
		System.out.print("\t");
		for(int t=0; t<targets.size(); t++){
			System.out.print(targets.lookupObject(t) + "\t");
		}
		System.out.println();

		for(int t=0; t< targets.size(); t++){
			System.out.print(targets.lookupObject(t)+"\t");
			for(int tt=0; tt<targets.size(); tt++){
				System.out.print(matrixEntry[t][tt] + "\t");
			}
			System.out.println();
		}

*/

		if(taggedOut != System.out){
			taggedOut.close();
		}

	}	

}