ieinterface3.java

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

			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;
		}
			
		String viterbiStr = "";
//		taggedOut.println("testing instance number: " + instancelist.size() );
		for(int i=0; i<instancelist.size(); i++){
//				taggedOut.println("\ntesting instance " + i);
				Instance instance = instancelist.getInstance(i);
				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
				crfStr = viterbiCRFInstance_NBest(instance,sgml);
				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;
*/

		}


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

	}

	//viterbi for all files under a given directory, 
	//if the given directory is a plain file, viterbi for this file
	public void viterbiCRF(String inputDir, boolean sgml, String seperator)
	{

		// if inputDir is a plain file
		File file = new File(inputDir);
		if( file.isFile() ){
			viterbiCRF(file, sgml, seperator);
		}
		else{
			// continue if it is a directory
			FileIterator fileIter = new FileIterator (inputDir);	
			ArrayList fileList = fileIter.getFileArray();

			for(int i=0; i<fileList.size(); i++){
				file = (File) fileList.get(i);
				viterbiCRF(file, sgml, seperator);
			}
		}
	}

	public void viterbiCRF(String inputDir)
	{
		viterbiCRF(inputDir, true);
	}

	public void viterbiCRF(String inputDir, boolean sgml)
	{
		viterbiCRF(inputDir, sgml, seperator);
	}
	
	// cumulative evaluation for N-best list 
	public void cumulativeEvaluate(File inputFile, 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));

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

		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);

		for(int i=0; i<instancelist.size(); i++){
				Instance instance = instancelist.getInstance(i);

				//N-best tagging
				viterbiP_NBest = crf.viterbiPath_NBest((Sequence)instance.getData(), N);//n-best list
				Sequence[] nbestlist = viterbiP_NBest.outputNBest();

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

			        tokenSequence = (TokenSequence)instance.getSource();


				for (int j = 0; j < trueSequence.size(); j++) {

					String tokenStr = tokenSequence.getToken(j).getText();
					if(puntPattern.matcher(tokenStr).matches()){//ignore punct;
						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 evalutation results: N = " + N);

		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)
	{
		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);

		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);
				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);
//				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()){//ignore punct;
						continue;
					}

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

					matrixEntry[trueIndex][predIndex] ++;

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

	
				}

				if(wholeInstanceCorrect) numCorrectWholeInstance ++;
		}



		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();
		}

	}	
}