081020_文本分类(Text Classification)

About Feature Generator

关于特征生成

1.  Change all the letters to lowercase, with a stemmer manipulation, and remove all the punctuations

    转换所有的字母至小写，进行stemmer处理，去除标点符号

2.  Deal with each feature with TF.IDF, take the features above threshold

    对每个特征进行TF.IDF处理，选取阈值以上的特征

3.  One Algorithm for Stemmer

    一个Stemmer的实例算法

1. package com.featheast.bow;
3. /*
5.  Porter stemmer in Java. The original paper is in
7.  Porter, 1980, An algorithm for suffix stripping, Program, Vol. 14,
8.  no. 3, pp 130-137,
10.  See also http://www.tartarus.org/~martin/PorterStemmer
12.  History:
14.  Release 1
16.  Bug 1 (reported by Gonzalo Parra 16/10/99) fixed as marked below.
17.  The words 'aed', 'eed', 'oed' leave k at 'a' for step 3, and b[k-1]
18.  is then out outside the bounds of b.
20.  Release 2
22.  Similarly,
24.  Bug 2 (reported by Steve Dyrdahl 22/2/00) fixed as marked below.
25.  'ion' by itself leaves j = -1 in the test for 'ion' in step 5, and
26.  b[j] is then outside the bounds of b.
28.  Release 3
30.  Considerably revised 4/9/00 in the light of many helpful suggestions
31.  from Brian Goetz of Quiotix Corporation (brian@quiotix.com).
33.  Release 4
35.  */
37. import java.io.*;
39. /**
40.  * Stemmer, implementing the Porter Stemming Algorithm
41.  * 
42.  * The Stemmer class transforms a word into its root form. The input word can be
43.  * provided a character at time (by calling add()), or at once by calling one of
44.  * the various stem(something) methods.
45.  */
47. class Stemmer {
48.     private char[] b;
50.     private int i, /* offset into b */
51.     i_end, /* offset to end of stemmed word */
52.     j, k;
54.     private static final int INC = 50;
56.     /* unit of size whereby b is increased */
57.     public Stemmer() {
58.         b = new char[INC];
59.         i = 0;
60.         i_end = 0;
61.     }
63.     /**
64.      * Add a character to the word being stemmed. When you are finished adding
65.      * characters, you can call stem(void) to stem the word.
66.      */
68.     public void add(char ch) {
69.         if (i == b.length) {
70.             char[] new_b = new char[i + INC];
71.             for (int c = 0; c < i; c++)
72.                 new_b[c] = b[c];
73.             b = new_b;
74.         }
75.         b[i++] = ch;
76.     }
78.     /**
79.      * Adds wLen characters to the word being stemmed contained in a portion of
80.      * a char[] array. This is like repeated calls of add(char ch), but faster.
81.      */
83.     public void add(char[] w, int wLen) {
84.         if (i + wLen >= b.length) {
85.             char[] new_b = new char[i + wLen + INC];
86.             for (int c = 0; c < i; c++)
87.                 new_b[c] = b[c];
88.             b = new_b;
89.         }
90.         for (int c = 0; c < wLen; c++)
91.             b[i++] = w[c];
92.     }
94.     /**
95.      * After a word has been stemmed, it can be retrieved by toString(), or a
96.      * reference to the internal buffer can be retrieved by getResultBuffer and
97.      * getResultLength (which is generally more efficient.)
98.      */
99.     public String toString() {
100.         return new String(b, 0, i_end);
101.     }
103.     /**
104.      * Returns the length of the word resulting from the stemming process.
105.      */
106.     public int getResultLength() {
107.         return i_end;
108.     }
110.     /**
111.      * Returns a reference to a character buffer containing the results of the
112.      * stemming process. You also need to consult getResultLength() to determine
113.      * the length of the result.
114.      */
115.     public char[] getResultBuffer() {
116.         return b;
117.     }
119.     /* cons(i) is true <=> b[i] is a consonant. */
121.     private final boolean cons(int i) {
122.         switch (b[i]) {
123.         case 'a':
124.         case 'e':
125.         case 'i':
126.         case 'o':
127.         case 'u':
128.             return false;
129.         case 'y':
130.             return (i == 0) ? true : !cons(i - 1);
131.         default:
132.             return true;
133.         }
134.     }
136.     /*
137.      * m() measures the number of consonant sequences between 0 and j. if c is a
138.      * consonant sequence and v a vowel sequence, and <..> indicates arbitrary
139.      * presence,
140.      * 
141.      * <c><v> gives 0 <c>vc<v> gives 1 <c>vcvc<v> gives 2 <c>vcvcvc<v> gives
142.      * 3 ....
143.      */
145.     private final int m() {
146.         int n = 0;
147.         int i = 0;
148.         while (true) {
149.             if (i > j)
150.                 return n;
151.             if (!cons(i))
152.                 break;
153.             i++;
154.         }
155.         i++;
156.         while (true) {
157.             while (true) {
158.                 if (i > j)
159.                     return n;
160.                 if (cons(i))
161.                     break;
162.                 i++;
163.             }
164.             i++;
165.             n++;
166.             while (true) {
167.                 if (i > j)
168.                     return n;
169.                 if (!cons(i))
170.                     break;
171.                 i++;
172.             }
173.             i++;
174.         }
175.     }
177.     /* vowelinstem() is true <=> 0,...j contains a vowel */
179.     private final boolean vowelinstem() {
180.         int i;
181.         for (i = 0; i <= j; i++)
182.             if (!cons(i))
183.                 return true;
184.         return false;
185.     }
187.     /* doublec(j) is true <=> j,(j-1) contain a double consonant. */
189.     private final boolean doublec(int j) {
190.         if (j < 1)
191.             return false;
192.         if (b[j] != b[j - 1])
193.             return false;
194.         return cons(j);
195.     }
197.     /*
198.      * cvc(i) is true <=> i-2,i-1,i has the form consonant - vowel - consonant
199.      * and also if the second c is not w,x or y. this is used when trying to
200.      * restore an e at the end of a short word. e.g.
201.      * 
202.      * cav(e), lov(e), hop(e), crim(e), but snow, box, tray.
203.      * 
204.      */
206.     private final boolean cvc(int i) {
207.         if (i < 2 || !cons(i) || cons(i - 1) || !cons(i - 2))
208.             return false;
209.         {
210.             int ch = b[i];
211.             if (ch == 'w' || ch == 'x' || ch == 'y')
212.                 return false;
213.         }
214.         return true;
215.     }
217.     private final boolean ends(String s) {
218.         int l = s.length();
219.         int o = k - l + 1;
220.         if (o < 0)
221.             return false;
222.         for (int i = 0; i < l; i++)
223.             if (b[o + i] != s.charAt(i))
224.                 return false;
225.         j = k - l;
226.         return true;
227.     }
229.     /*
230.      * setto(s) sets (j+1),...k to the characters in the string s, readjusting
231.      * k.
232.      */
234.     private final void setto(String s) {
235.         int l = s.length();
236.         int o = j + 1;
237.         for (int i = 0; i < l; i++)
238.             b[o + i] = s.charAt(i);
239.         k = j + l;
240.     }
242.     /* r(s) is used further down. */
244.     private final void r(String s) {
245.         if (m() > 0)
246.             setto(s);
247.     }
249.     /*
250.      * step1() gets rid of plurals and -ed or -ing. e.g.
251.      * 
252.      * caresses -> caress ponies -> poni ties -> ti caress -> caress cats -> cat
253.      * 
254.      * feed -> feed agreed -> agree disabled -> disable
255.      * 
256.      * matting -> mat mating -> mate meeting -> meet milling -> mill messing ->
257.      * mess
258.      * 
259.      * meetings -> meet
260.      * 
261.      */
263.     private final void step1() {
264.         if (b[k] == 's') {
265.             if (ends("sses"))
266.                 k -= 2;
267.             else if (ends("ies"))
268.                 setto("i");
269.             else if (b[k - 1] != 's')
270.                 k--;
271.         }
272.         if (ends("eed")) {
273.             if (m() > 0)
274.                 k--;
275.         } else if ((ends("ed") || ends("ing")) && vowelinstem()) {
276.             k = j;
277.             if (ends("at"))
278.                 setto("ate");
279.             else if (ends("bl"))
280.                 setto("ble");
281.             else if (ends("iz"))
282.                 setto("ize");
283.             else if (doublec(k)) {
284.                 k--;
285.                 {
286.                     int ch = b[k];
287.                     if (ch == 'l' || ch == 's' || ch == 'z')
288.                         k++;
289.                 }
290.             } else if (m() == 1 && cvc(k))
291.                 setto("e");
292.         }
293.     }
295.     /* step2() turns terminal y to i when there is another vowel in the stem. */
297.     private final void step2() {
298.         if (ends("y") && vowelinstem())
299.             b[k] = 'i';
300.     }
302.     /*
303.      * step3() maps double suffices to single ones. so -ization ( = -ize plus
304.      * -ation) maps to -ize etc. note that the string before the suffix must
305.      * give m() > 0.
306.      */
308.     private final void step3() {
309.         if (k == 0)
310.             return; /* For Bug 1 */
311.         switch (b[k - 1]) {
312.         case 'a':
313.             if (ends("ational")) {
314.                 r("ate");
315.                 break;
316.             }
317.             if (ends("tional")) {
318.                 r("tion");
319.                 break;
320.             }
321.             break;
322.         case 'c':
323.             if (ends("enci")) {
324.                 r("ence");
325.                 break;
326.             }
327.             if (ends("anci")) {
328.                 r("ance");
329.                 break;
330.             }
331.             break;
332.         case 'e':
333.             if (ends("izer")) {
334.                 r("ize");
335.                 break;
336.             }
337.             break;
338.         case 'l':
339.             if (ends("bli")) {
340.                 r("ble");
341.                 break;
342.             }
343.             if (ends("alli")) {
344.                 r("al");
345.                 break;
346.             }
347.             if (ends("entli")) {
348.                 r("ent");
349.                 break;
350.             }
351.             if (ends("eli")) {
352.                 r("e");
353.                 break;
354.             }
355.             if (ends("ousli")) {
356.                 r("ous");
357.                 break;
358.             }
359.             break;
360.         case 'o':
361.             if (ends("ization")) {
362.                 r("ize");
363.                 break;
364.             }
365.             if (ends("ation")) {
366.                 r("ate");
367.                 break;
368.             }
369.             if (ends("ator")) {
370.                 r("ate");
371.                 break;
372.             }
373.             break;
374.         case 's':
375.             if (ends("alism")) {
376.                 r("al");
377.                 break;
378.             }
379.             if (ends("iveness")) {
380.                 r("ive");
381.                 break;
382.             }
383.             if (ends("fulness")) {
384.                 r("ful");
385.                 break;
386.             }
387.             if (ends("ousness")) {
388.                 r("ous");
389.                 break;
390.             }
391.             break;
392.         case 't':
393.             if (ends("aliti")) {
394.                 r("al");
395.                 break;
396.             }
397.             if (ends("iviti")) {
398.                 r("ive");
399.                 break;
400.             }
401.             if (ends("biliti")) {
402.                 r("ble");
403.                 break;
404.             }
405.             break;
406.         case 'g':
407.             if (ends("logi")) {
408.                 r("log");
409.                 break;
410.             }
411.         }
412.     }
414.     /* step4() deals with -ic-, -full, -ness etc. similar strategy to step3. */
416.     private final void step4() {
417.         switch (b[k]) {
418.         case 'e':
419.             if (ends("icate")) {
420.                 r("ic");
421.                 break;
422.             }
423.             if (ends("ative")) {
424.                 r("");
425.                 break;
426.             }
427.             if (ends("alize")) {
428.                 r("al");
429.                 break;
430.             }
431.             break;
432.         case 'i':
433.             if (ends("iciti")) {
434.                 r("ic");
435.                 break;
436.             }
437.             break;
438.         case 'l':
439.             if (ends("ical")) {
440.                 r("ic");
441.                 break;
442.             }
443.             if (ends("ful")) {
444.                 r("");
445.                 break;
446.             }
447.             break;
448.         case 's':
449.             if (ends("ness")) {
450.                 r("");
451.                 break;
452.             }
453.             break;
454.         }
455.     }
457.     /* step5() takes off -ant, -ence etc., in context <c>vcvc<v>. */
459.     private final void step5() {
460.         if (k == 0)
461.             return; /* for Bug 1 */
462.         switch (b[k - 1]) {
463.         case 'a':
464.             if (ends("al"))
465.                 break;
466.             return;
467.         case 'c':
468.             if (ends("ance"))
469.                 break;
470.             if (ends("ence"))
471.                 break;
472.             return;
473.         case 'e':
474.             if (ends("er"))
475.                 break;
476.             return;
477.         case 'i':
478.             if (ends("ic"))
479.                 break;
480.             return;
481.         case 'l':
482.             if (ends("able"))
483.                 break;
484.             if (ends("ible"))
485.                 break;
486.             return;
487.         case 'n':
488.             if (ends("ant"))
489.                 break;
490.             if (ends("ement"))
491.                 break;
492.             if (ends("ment"))
493.                 break;
494.             /* element etc. not stripped before the m */
495.             if (ends("ent"))
496.                 break;
497.             return;
498.         case 'o':
499.             if (ends("ion") && j >= 0 && (b[j] == 's' || b[j] == 't'))
500.                 break;
501.             /* j >= 0 fixes Bug 2 */
502.             if (ends("ou"))
503.                 break;
504.             return;
505.             /* takes care of -ous */
506.         case 's':
507.             if (ends("ism"))
508.                 break;
509.             return;
510.         case 't':
511.             if (ends("ate"))
512.                 break;
513.             if (ends("iti"))
514.                 break;
515.             return;
516.         case 'u':
517.             if (ends("ous"))
518.                 break;
519.             return;
520.         case 'v':
521.             if (ends("ive"))
522.                 break;
523.             return;
524.         case 'z':
525.             if (ends("ize"))
526.                 break;
527.             return;
528.         default:
529.             return;
530.         }
531.         if (m() > 1)
532.             k = j;
533.     }
535.     /* step6() removes a final -e if m() > 1. */
537.     private final void step6() {
538.         j = k;
539.         if (b[k] == 'e') {
540.             int a = m();
541.             if (a > 1 || a == 1 && !cvc(k - 1))
542.                 k--;
543.         }
544.         if (b[k] == 'l' && doublec(k) && m() > 1)
545.             k--;
546.     }
548.     /**
549.      * Stem the word placed into the Stemmer buffer through calls to add().
550.      * Returns true if the stemming process resulted in a word different from
551.      * the input. You can retrieve the result with
552.      * getResultLength()/getResultBuffer() or toString().
553.      */
554.     public void stem() {
555.         k = i - 1;
556.         if (k > 1) {
557.             step1();
558.             step2();
559.             step3();
560.             step4();
561.             step5();
562.             step6();
563.         }
564.         i_end = k + 1;
565.         i = 0;
566.     }
568.     /**
569.      * Test program for demonstrating the Stemmer. It reads text from a a list
570.      * of files, stems each word, and writes the result to standard output. Note
571.      * that the word stemmed is expected to be in lower case: forcing lower case
572.      * must be done outside the Stemmer class. Usage: Stemmer file-name
573.      * file-name ...
574.      */
575.     public static void main(String[] args) {
576.         char[] w = new char[501];
577.         Stemmer s = new Stemmer();
578.         for (int i = 0; i < args.length; i++)
579.             try {
580.                 FileInputStream in = new FileInputStream(args[i]);
582.                 try {
583.                     while (true)
585.                     {
586.                         int ch = in.read();
587.                         if (Character.isLetter((char) ch)) {
588.                             int j = 0;
589.                             while (true) {
590.                                 ch = Character.toLowerCase((char) ch);
591.                                 w[j] = (char) ch;
592.                                 if (j < 500)
593.                                     j++;
594.                                 ch = in.read();
595.                                 if (!Character.isLetter((char) ch)) {
596.                                     /* to test add(char ch) */
597.                                     for (int c = 0; c < j; c++)
598.                                         s.add(w[c]);
600.                                     /* or, to test add(char[] w, int j) */
601.                                     /* s.add(w, j); */
603.                                     s.stem();
604.                                     {
605.                                         String u;
607.                                         /* and now, to test toString() : */
608.                                         u = s.toString();
610.                                         /*
611.                                          * to test getResultBuffer(),
612.                                          * getResultLength() :
613.                                          */
614.                                         /*
615.                                          * u = new String(s.getResultBuffer(),
616.                                          * 0, s.getResultLength());
617.                                          */
619.                                         System.out.print(u);
620.                                     }
621.                                     break;
622.                                 }
623.                             }
624.                         }
625.                         if (ch < 0)
626.                             break;
627.                         System.out.print((char) ch);
628.                     }
629.                 } catch (IOException e) {
630.                     System.out.println("error reading " + args[i]);
631.                     break;
632.                 }
633.             } catch (FileNotFoundException e) {
634.                 System.out.println("file " + args[i] + " not found");
635.                 break;
636.             }
637.     }
638. }