利用page rank,hits算法实现的一个简单的文本摘要系统

/Files/rocketfan/Language_Independent_Extractive_Summarization.pdf

/Files/rocketfan/Summarization_readme.pdf

Well,当前仅仅做到将文本中的句子按重要程度排序，可进一步操作生成摘要，仅仅用于英文文本。

仅以该随笔纪念我的第一个JAVA程序:)

//usage

//javac TestSummarizer.java

//java TestSummarizer  <inputFile> <outputFile>  #output file 中将会对句子按重要程度排好序

 1 /**
 2  * The class for getting user command and
 3  * parse the command to set up aprropritae
 4  * Sumarizer who will finish the job of ranking the
 5  * importance of all the input file sentences ,
 6  * sort sentences based on that and then
 7  * write to the output file.
 8  */
 9 public class TestSummarizer {
     
     public static void main(String[] args) {
         
         String rankMethod = args[0];
         String inputFile = args[1];
         String outputFile = args[2];
         //TODO warning not supported method
         Ranker ranker;
         if (rankMethod.equals("-pagerank")) {
             ranker = new PageRankRanker();
         } else if (rankMethod.equals("-hits")) {
             ranker = new HitsRanker();
         } else {
             System.out.println("Not -pagerank or -hits use -pagerank");
             ranker = new PageRankRanker();
         }
         Summarizer summarizer = new Summarizer(inputFile, outputFile, ranker);
         summarizer.fileSummarize();
     }
 } //end of class TestSumarizer

//Summarizer.java是核心部分，通过建立inverted word index 计算出所有句子对的overlap

  1 //import java.util.regex.*;
  2 
  3 import java.util.*;
  4 
  5 import java.io.*;
  6 
  7 import java.text.*;
  8 
  9 //to do how to split also consider ?
 10 
 11 
 12 
 13 /**
 14 
 15  * Summarizer is on charge of caculating 
 16 
 17  * a Matrix A, with A[i][j] represents
 18 
 19  * the overlap of sentence i and j.
 20 
 21  * It will than send the Matrix A to a
 22 
 23  * Ranker who will caculate all the sentence's
 24 
 25  * importance value and send back to Summarizer.
 26 
 27  * Summarizer will sort sentences based on
 28 
 29  * their importance value and write the reult
 30 
 31  * to file.
 32 
 33  *
 34 
 35  * Summarizer is also on charge of spliting doucument
 36 
 37  * content to sentences and split each sentence to
 38 
 39  * words.
 40 
 41  */
 42 
 43 public class Summarizer {
 44 
 45    
 46 
 47     /** 
 48 
 49      * Define Sentence type, it will record the sentence's 
 50 
 51      * start and end postion in fileContentString.
 52 
 53      * Also will record the word number in this sentence.
 54 
 55      */
 56 
 57     private class Sentence {
 58 
 59         public int start;
 60 
 61         public int end;
 62 
 63         public int wordNum;
 64 
 65     }
 66 
 67 
 68 
 69     /** Store which rank aloritm to use*/
 70 
 71     private final Ranker ranker;
 72 
 73     /** Store the name of output file*/
 74 
 75     private final String outputFileName;
 76 
 77     /** The whole file content is stored as a string here*/
 78 
 79     private final String fileContentString;
 80 
 81     /** sotre all the sentences info*/
 82 
 83     private final List<Sentence> sentenceList =  new ArrayList<Sentence> ();;
 84 
 85     /** the dfault stop words we will use*/
 86 
 87     private final static String stopWords[] = 
 88 
 89         {"a", "about", "an", "and", "are", "as", "at", "be", "but", "by",
 90 
 91          "for", "has", "have", "he", "his", "her", "in", "is", "it", "its",
 92 
 93          "of", "on", "or", "she", "that", "the", "their", "they", "this",
 94 
 95          "to", "was", "which", "who", "will", "with", "you"};
 96 
 97     private final Map<String, String> hmStopWord = new HashMap<String, String> ();
 98 
 99    
 
    /**
 
     * Construct of a summarizer 
 
     * Client must provide the inputFileName to sumarize
 
     * and the aimed outputFileName to output,
 
     * Clent also has to choose wich ranker algorithm to use,eg. 
 
     * Summarizer will also get stop words hashing map table set up.
 
     */
 
     public Summarizer(String inputFileName, String outputFileName, Ranker ranker) {
 
         this.outputFileName = outputFileName;
 
         this.fileContentString = readFileToString(inputFileName);
 
         this.ranker = ranker;
 
         initStopWordsMap();
 
     }
 
     /**
 
     * The only interface user can see currently, 
 
     * to sumarize a given file using ranker provided rank algorithm
 
     */
 
     public void fileSummarize() {
 
         initSentenceList();  //first spilit doucument to sentences using BreakIterator 
 
         double[][] A = getSetencesWeightMatrix(); //caculate the wight matrix using overlap score of sentences pair
 
         double[]P = ranker.getRankVec(A); //caculate each sentence importance value
 
         sortAndWriteFile(P); //sort and ouput the sorted sentences
 
     }
 
 
 
     //below are all internal private functions 
 
 
 
     /**
 
      * Caculate the total sentece num and store each sentence 
 
      * info to sentencesList(start, end)
 
      */
 
     private void initSentenceList() {
 
         
 
         Locale currentLocale = new Locale("en", "US");
 
         BreakIterator sentenceIter = BreakIterator.getSentenceInstance(currentLocale); 
 
         sentenceIter.setText(fileContentString);
 
         
 
         int start = sentenceIter.first();
 
         int end = sentenceIter.next();
 
         while (end != sentenceIter.DONE) {
 
             Sentence sentence = new Sentence();
 
             sentence.start = start;
 
             if (fileContentString.charAt(end - 1) == '\n') //we will eliminate the \n if a sentece has
 
                 sentence.end = end - 1;     //[)
 
             else
 
                 sentence.end = end;
 
             sentenceList.add(sentence);
 
             start = end;
 
             end = sentenceIter.next();
 
         }
 
     }
 
    
 
     /** 
 
      * Init of stop words hash map
 
      */
 
     private void initStopWordsMap() {
 
         for (int i = 0; i < stopWords.length; i++) 
 
             hmStopWord.put(stopWords[i], null);
 
     }
 
 
 
     /** 
 
      * This is the key function of Summarizer
 
      * It will caculate the overlap value 
 
      * for each pair of sentences
 
      */
 
     private double[][] getSetencesWeightMatrix( ) {
 
         
 
         Map<String, List<Integer> > hm = new HashMap<String, List<Integer> >();
 
         int sentenceNum = sentenceList.size();
 
         double[][] A = new double[sentenceNum][sentenceNum];
 
         //deal with all the words in each sentence
 
         Locale currentLocale = new Locale("en", "US");
 
         BreakIterator wordIter = BreakIterator.getWordInstance(currentLocale);
 
         
 
         //we do the process twice one forward and one reverse 
 
         //only for the case of repated words in one sentence
 
         //we suppose overlap(i, j) = overlap(j, i)
 
         //if setentce i is "above above ok" sentence j is "above above wrong"
 
         //the overlap is 2 , if sentence j is "above wrong" the overlap is 1.
 
         for (int i = 0; i < sentenceNum; i++) {
 
             Sentence sentence = sentenceList.get(i);
 
             wordIter.setText(fileContentString.substring(sentence.start, sentence.end));
 
              
 
             int start = wordIter.first();
 
             int end = wordIter.next();
 
             int wordNum = 0; 
 
             while (end != wordIter.DONE) {
 
                 String word = fileContentString.substring(sentence.start + start, sentence.start + end);
 
                 if (Character.isLetterOrDigit(word.charAt(0))) {
 
                     wordNum++; //ok, find legal word
 
 
 
                     String token = parseString(word);
 
                     if (hmStopWord.containsKey(token)) {
 
                         start = end;
 
                         end = wordIter.next();
 
                         continue;
 
                     }
 
                     List<Integer> list; 
 
                     if (hm.containsKey(token)) {
 
                         list = hm.get(token);
 
                         int flag = 0;
 
                         for (int j : list) {
 
                             if (i > j)
 
                                 A[i][j] += 1.0;
 
                             else
 
                                 flag = 1;
 
                         }
 
                         if (flag == 0)
 
                             list.add(i);
 
                     } else {
 
                         list = new LinkedList<Integer> ();
 
                         list.add(i);
 
                         hm.put(token, list);
 
                     }
 
                 }
 
                 start = end;
 
                 end = wordIter.next();
 
             }
 
             sentence.wordNum = wordNum;
 
         }
 
         
 
          hm.clear();
 
 
 
         for (int i = sentenceNum - 1; i >= 0; i--) {
 
             Sentence sentence = sentenceList.get(i);
 
             wordIter.setText(fileContentString.substring(sentence.start, sentence.end));
 
              
 
             int start = wordIter.first();
 
             int end = wordIter.next();
 
             while (end != wordIter.DONE) {
 
                 String word = fileContentString.substring(sentence.start + start, sentence.start + end);
 
                 if (Character.isLetterOrDigit(word.charAt(0))) {
 
                     //ok,find a legal word
 
                     String token = parseString(word);
 
                     if (hmStopWord.containsKey(token)) {                       
 
                         start = end;
 
                         end = wordIter.next();
 
                         continue;
 
                     }
 
                     List<Integer> list; 
 
                     if (hm.containsKey(token)) {
 
                         list = hm.get(token);
 
                         int flag = 0;
 
                         for (int j : list) {
 
                             if (i < j)
 
                                 A[i][j] += 1.0;
 
                             else
 
                                 flag = 1;
 
                         }
 
                         if (flag == 0)
 
                             list.add(i);
 
 
 
                     } else {
 
                         list = new LinkedList<Integer> ();
 
                         list.add(i);
 
                         hm.put(token, list);
 
                     }
 
                 }
 
                 start = end;
 
                 end = wordIter.next();
 
             }
 
         }
 
         
 
         //make sure overlap(i, j) = overlap(j, i) when not considering length
 
         for (int i = 0; i < sentenceNum; i++) {
 
             for (int j = 0; j > i && j < sentenceNum; j++) {
 
                 if (A[i][j] > A[j][i])
 
                     A[i][j] = A[j][i];
 
             }
 
         }
 
         
 
         //divide by sentence lenght to avoid promoting long sentences
 
         for (int i = 0; i < sentenceNum; i++) {
 
             for (int j = 0; j < sentenceNum; j++) {
 
                 if (A[i][j] > 0 && sentenceList.get(i).wordNum > 0)
 
                     A[i][j] /= sentenceList.get(i).wordNum;
 
             }
 
         }
 
         
 
         return A;
 
     }
 
     
 
     /** Read the whole input file content*/
 
     private static String readFileToString(String infile) {
 
         try {
 
             BufferedReader reader = new BufferedReader(new FileReader(infile));
 
             String result ="";
 
             String line = reader.readLine();
 
             while (line != null) {
 
                 result = result + line + '\n';
 
                 line = reader.readLine();
 
             }
 
             reader.close();
 
             return result;
 
         } catch(IOException ex) {
 
             System.out.println(ex); //handle file not found by displaying message
 
             return ""; //return the empty string if file not fount
 
         }
 
     }
 
 
 
     /** 
 
      * For each word we will consider it as lowercase
 
      * and delete any non letter character.
 
      */
 
     private static String parseString(String s) {
 
         return s.toLowerCase().replaceAll("\\W", "");
 
     }
 
     
 
     /** 
 
      * Print the sentence which has index i
 
      */
 
     private String getSentenceString(int i) {
 
         Sentence sentence = sentenceList.get(i);
 
         return fileContentString.substring(sentence.start, sentence.end);
 
     }
 
 
 
     /**
 
      * After running rank algorithm, sort the result and output the sentences based
 
      * on their score
 
      */
 
     class CollatorComparator implements Comparator<Double> {  
 
         public int compare(Double element1, Double element2) {
 
             double key1 = element1.doubleValue();
 
             double key2 = element2.doubleValue();
 
             if (key1 == key2)
 
                 return 1;
 
             if (key1 > key2)
 
                 return -1;
 
             else
 
                 return 1;
 
         }  
 
     }  
 
 
 
     private void sortAndWriteFile(double[] P) {
 
         try {
 
             CollatorComparator comparator = new CollatorComparator();
 
             Map<Double,Integer> map = new TreeMap<Double, Integer>(comparator);
 
 
 
             for (int i = 0; i < P.length; i++) 
 
                 map.put(P[i], i);
 
 
 
             Set entries = map.entrySet();//得到关键字/值对的集合
 
             Iterator iter = entries.iterator();
 
             PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(outputFileName))); 
 
             DecimalFormat df = new DecimalFormat("#0.00000");
 
             while(iter.hasNext()) {
 
                 Map.Entry entry = (Map.Entry)iter.next();
 
                 double keyWeight = (Double)entry.getKey();
 
                 int valueIndex = (Integer)entry.getValue();
 
                 writer.write("(");
 
                 writer.write(df.format(keyWeight));
 
                 writer.write(") ");
 
                 writer.write(getSentenceString(valueIndex) + "\n");
 
             }
 
             writer.close();
 
         } catch (IOException ex) {
 
             System.out.println(ex); //handle file not found by displaying message
 
         }
 
     }
 
 
 } // end of class Sumarizer
 

//MatrixHelp.java 内部使用的一些矩阵操作相关函数的实现

  1 /**
  2  * This class has all the independent caculations related to matrix and vector
  3  * that will be used in text sumarization.
  4  * Notice those fuctions for this paticular project useage, does not consider
  5  * more about reuse, the data type all use double and assume two dimessional 
  6  * matrix with same dinmenstion length(square matrix).
  7  */
  8 public class MatrixHelp {
  9    
 10     /** retrun squared distance of vector P1 and P2*/
 11     public static double distance(double[] P1, double[] P2) {
 12         int len = P1.length;  //P1.length must equal to P2.length 
 13         double sum = 0;
 14         for (int i = 0; i < len; i++)
 15             sum += (P1[i] - P2[i]) * (P1[i] - P2[i]);
 16         return sum;
 17     }
 18 
 19     /** say H = transpose([a,b,c]) normal H means let H = transpose([a,b,c]/sqrt(a^2+b^2+c^2))*/
 20     public static void normal(double[] P) {
 21         int len = P.length;  
 22         double sum = 0;
 23         for (int i = 0; i < len; i++)
 24             sum += P[i];
 25         for (int i = 0; i < len; i++)
 26             P[i] /= sum;
 27     }
 28 
 29     /** return value of ||P||*/ 
 30     public static double normValue(double[] P) {
 31         double sum = 0;
 32         for (int i = 0; i < P.length; i++)
 33             sum += Math.abs(P[i]);
 34         return sum;
 35     }
 36 
 37     /** sub return P1 - P2*/
 38     public static double[] subVec(double[] P1, double[] P2) {
 39         int len = P1.length;
 40         double[] Result = new double[len];
 41         for (int i = 0; i < len; i++)
 42             Result[i] = P1[i] - P2[i];
 43         return Result;
 44     }
 45 
 46     /** merge return (P1 + P2)/2.0*/
 47     public static double[] mergeVec(double[] P1, double[] P2) {
 48         int len = P1.length;
 49         double[] Result = new double[len];
 50         for (int i = 0; i < len; i++)
 51             Result[i] = (P1[i] + P2[i])/2.0;
 52         return Result;
 53     }
 54 
 55 
 56     /** normalize all the value in vec P to 0.001-0.0.9995*/
 57     public static void normalize(double[] P) {
 58         double dMaxValue = -1.0;
 59         double dMinValue = 2.0;
 60         int len = P.length;
 61         for (int i = 0; i < len; i++) {
 62             if (P[i] < dMinValue)
 63                 dMinValue = P[i];
 64             if (P[i] > dMaxValue)
 65                 dMaxValue = P[i];
 66         }
 67         if (dMaxValue - dMinValue < 0.0000001)
 68             return;
 69         for (int i = 0; i < P.length; i++) {
 70             if(P[i] <= (dMinValue*1.005)) //do not use boundary value
 71                 P[i]= dMinValue*1.005;
 72             if(P[i] >= (dMaxValue*0.995))
 73                 P[i] = dMaxValue*0.995;
 74             P[i]=(P[i]-dMinValue)/(dMaxValue-dMinValue);
 75             P[i] = ((0.5-0.001)/0.5)*P[i] + 0.001;
 76         }
 77     }
 78     /** return the result matrix of matrix A mutliply (transpose of A)*/ 
 79     public static double[][] matrixMultiply(double[][] A) {
 80         int len = A[0].length;
 81         double[][] Result = new double[len][len]; 
 82         for (int i = 0; i < len; i++)
 83             for (int j = 0; j < len; j++)
 84                 for (int k = 0; k < len; k++)
 85                     Result[i][j] += A[i][k] * A[j][k]; //A[i][k] * AT[k][j]
 86         return Result;
 87     }
 88 
 89     /** return the result matrix of matrix A mutliply matrix B,A and B of same dimention size*/ 
 90     public static double[][] matrixMultiply(double[][] A, double[][] B) {
 91         int len = A[0].length;
 92         double[][] Result = new double[len][len]; 
 93         for (int i = 0; i < len; i++)
 94             for (int j = 0; j < len; j++)
 95                 for (int k = 0; j < len; k++)
 96                     Result[i][j] += A[i][k] * B[k][j];
 97         return Result;
 98     }
 99     /** return the result vector of matrix A mutliply vector P*/ 
     public static double[] matrixMultiplyVector(double[][] A, double[] P) {
         int len = P.length;
         double[] Result = new double[len]; 
         for (int i = 0; i < len; i++)
             for (int j = 0; j < len; j++)
                 Result[i] += A[i][j] * P[j];
         return Result;
     }
 
     
     /** return the result vector  of first transposing matrix A than mutliply vector P*/ 
     public static double[] matrixTransposeMultiplyVector(double[][] A, double[] P) {
         int len = P.length;
         double[] Result = new double[len]; 
         for (int i = 0; i < len; i++)
             for (int j = 0; j < len; j++) {
                 Result[i] += A[j][i] * P[j];
             }
         
         return Result;
     }
 
     /** for debug show all matrix data value*/
     public static void printMatrix(double[][] A) {
         int len = A[0].length;
         for (int i = 0; i < len; i++) {
             for (int j = 0; j < len; j++) {
                 System.out.printf("%.2f", A[i][j]);
                 System.out.print(" ");
             }
             System.out.println("");
         }
     }
 
     /** for debug show all vector data value*/
     public static void printVector(double[] P) {
         for (int i = 0; i < P.length; i++)
              System.out.printf("%.2f", P[i]);
         System.out.println("\n");
     }
 }
 

//Ranker.java

 1 /**
 2  * Ranker an absturct class for calculating rank score of all sentences
 3  * Right now there are two implementations 
 4  * PageRankRanker using pagerank algorithom and HitsRanker using hits
 5  * algorithom.
 6  */
 7 public interface Ranker {
 8     /**
 9      * Given the Weight matrix A
      * return the vec needed after doing iterate algorithm,eg pagerank, hits.
      */
     public double[] getRankVec(double[][] A);    
 }

//PageRankRanker.java

//pager rank 算法的实现

 1 /**
 2  * The implementaion of Ranker based on pagerank algorithm.
 3  */
 4 public class PageRankRanker implements Ranker {
 5     
 6     public double[] getRankVec(double[][] A) {
 7         return  pageRankIterate(getInitMatrix(A), 0.85);  
 8     }
 9 
      
     /** 
      * Kernal of page rank iterate 
      * Taking A as input matrixand d(damping factor,use 0.85 will be ok) 
      * and return the result vector with weight value
      * for each sentence
      */
     public static double[] pageRankIterate(double[][] A, double d) {
         int len = A[0].length;
         double[][] P= new double[2][len];
         int now = 0;
         int other = 1;
         int temp;
         for (int i = 0; i < len; i++)
             P[now][i] = 1.0/len;
         
         double threshould = 0.0000001;  //spell wrong?
         do {
             P[other] = MatrixHelp.matrixMultiplyVector(A, P[now]);
             for (int i = 0; i < len; i++)
                 //P[other][i] = d * P[other][i] + (1 - d);
                 P[other][i] = d * P[other][i] + (1 - d);
             temp = now;
             now = other;
             other = temp;
         } while(MatrixHelp.distance(P[now], P[other]) > threshould);
 
         MatrixHelp.normalize(P[now]);
         return P[now];
     }
 
    /**
     * Get the init matrix for ranker to use based
     * on input weight matrix A.
     */
     private static double[][] getInitMatrix(double[][] A) {
         int len = A[0].length;
         double[][] B = new double[len][len];
         //for page rank init matrix
         double weightSum;
         for (int j = 0; j < len; j++) {
             weightSum = 0.0;
             for(int k = 0; k < len; k++) {
                 //weightSum += A[k][j];
                 weightSum += A[j][k];
             }
             for (int i = 0; i < len; i++) {
                 if (weightSum > 0.0000001) {
                     B[i][j] = A[i][j] / weightSum;
                     //B[i][j] = A[j][i] /weightSum;
                 } else if (i == j) {
                     B[i][j] = 0.0;
                 } else {
                     B[i][j] = 1.00/(len - 1);
                 }
             }
         }
         return B;
     }
 
 }
 

//HitsRanker.java

//hits算法的实现

 1 /**
 2  * The implementation of Ranker based on hits algorithm.
 3  */
 4 public class HitsRanker implements Ranker {
 5     
 6     public double[] getRankVec(double[][] A) {
 7         return hitsIterate(A);
 8     }
 9 
     /** kernal of hits alogrithm*/
     public static double[] hitsIterate(double[][] B) {
         int len = B[0].length;
         double[][] L = MatrixHelp.matrixMultiply(B); //B*BT
 
         double[][] H = new double[2][len]; //hub
         double[][] A = new double[2][len]; //authority
         int now = 0;
         int other = 1;
         int temp;
 
         for (int i = 0; i < len; i++) {
             H[now][i] = A[now][i] = 1.0;
         }
         double threshould = 0.0000001;
         do {
             A[other] = MatrixHelp.matrixTransposeMultiplyVector(L, A[now]);
             H[other] = MatrixHelp.matrixMultiplyVector(L, H[now]);
             MatrixHelp.normal(A[other]);
             MatrixHelp.normal(H[other]);
             //swap now and other
             temp = now;
             now = other;
             other = temp;
         }while(MatrixHelp.normValue(MatrixHelp.subVec(H[now], H[other])) > threshould &&  
                MatrixHelp.normValue((MatrixHelp.subVec(A[now], A[other])))> threshould);
      
         double[] R = MatrixHelp.mergeVec(A[now], H[now]);
         MatrixHelp.normalize(R);
         return R;
     }
 }