맞 춤 법 검사 기(자바 버 전)를 어떻게 씁 니까?

다음은 맞 춤 법 검사 기 가 좋 은 글 입 니 다.본 고 는 이 글 을 참조 하여 자바 버 전 을 실현 할 것 입 니 다.
http://blog.youxu.info/spell-correct.html
전체 맞 춤 법 검사 기의 기 초 는 베 이 루스 확률 모델 이다.
나 는 간단하게 그것 의 작업 원 리 를 소개 합 니 다.단 어 를 정 하 는 것 입 니 다.우리 의 임 무 는 그것 과 가장 비슷 한 맞 춤 법 이 정확 한 단 어 를 선택 하 는 것 입 니 다.(이 단어 자체 가 맞 춤 법 이 맞다 면 가장 비슷 한 것 은 바로 그것 자신 입 니 다)물론 비슷 한 단 어 를 절대적 으로 찾 을 수 없습니다.예 를 들 어 주어진 lates 라 는 단 어 는...얘 는 late 로 정정 하지 말 아야 되 나 요,latest 로 정정 하지 말 아야 되 나 요?이러한 어려움 은 우리 에 게 규칙 에 기초 한 판단 이 아니 라 확률론 을 사용 해 야 한 다 는 것 을 알려 준다.우 리 는 한 단어 w 를 정 하고 모든 정확 한 맞 춤 법 단어 중에서 우 리 는 정확 한 단어 c 를 찾 아 w 에 대한 조건 확률 이 가장 크다 고 말한다.즉,
argmax
c P(
c|
w)
대로  베 일 스 이론
 위의 식 은 다음 과 같다.
argmax
c P(
w|
c) P(
c) / P(
w)
사용자 가 모든 단 어 를 잘못 질 수 있 기 때문에 모든 c 에 있어 서 w 가 나타 날 확률 P(w)는 똑 같 습 니 다.그래서 우 리 는 위 에서 이 단 어 를 무시 하고 다음 과 같이 씁 니 다.
argmax
c P(
w|
c) P(
c)
이 식 은 세 부분 이 있 는데 오른쪽 에서 왼쪽으로 각각 다음 과 같다.
1.P(c),문장 에 정확 한 맞 춤 법 단어 c 가 나타 날 확률,즉 영어 문장 에서 c 가 나타 날 확률 은 얼마나 됩 니까?이 확률 은 완전히 영어 라 는 언어 에 의 해 결정 되 기 때문에 우 리 는 그것 을 한다 고 부른다.
언어 모델  P('the')는 상대 적 으로 높 아서 나타난다.  P('zxzxzyy')의 확률 은 0 에 가깝다(후자 도 한 단어 라 고 가정 하면).
2.P(w|c)는 사용자 가 c 를 입력 하고 싶 은 상황 에서 w 로 칠 확률 입 니 다.이것 은 사용자 가 얼마나 큰 확률 로 c 를 w 로 잘못 칠 수 있 는 지 를 나타 내 는 것 이기 때문에 이것 은
오차 모델.
3. argmax
c.모든 가능 한 c 를 매 거 하고 확률 이 가장 높 은 것 을 선택 하 는 데 사용 합 니 다.왜냐하면 우 리 는 하나의(정확 한)단어 가 나타 나 는 빈도 가 높 고 사용자 가 그것 을 다른 잘못된 단어 로 두 드 리 기 쉽다 고 믿 을 이유 가 있 기 때 문 입 니 다.그러면 그 잘못된 단 어 는 이 정확 한 것 으로 수정 되 어야 합 니 다.
누 군 가 는 반드시 물 어 볼 것 이다.너 는 멍청 하 다.왜 가장 간단 한 P(
c
|
w
)두 가지 복잡 한 식 으로 계산 합 니까?답 은 본질 적 으로 P(c|w)는 이 두 가지 와 동시에 관련 되 어 있 기 때문에 두 가지 로 나 누 면 오히려 처리 하기 쉽다.예 를 들 어 하나의 단어 인 thew 가 틀 렸 다.보기에 thaw 는 정확 해 야 한다.왜냐하면 a 를 e 로 쳤 기 때문이다.그러나 사용자 가 원 하 는 것 은 the 일 수도 있다.the 는 영어 에서 흔히 볼 수 있 는 단어 이기 때문이다.또한 타 자 를 칠 때 손 이 부주의 로 e 에서 w 로 미 끄 러 졌 을 가능성 이 높다.따라서 이런 상황 에서 우 리 는 계산 하고 싶다.  P(
c
|
w
)c 가 나타 날 확률 과 c 에서 w 까지 의 확률 을 동시에 고려 해 야 한다.하 나 를 두 가지 로 나 누 면 오히려 이 문 제 를 더욱 명확 하 게 할 수 있다.
사용 한 언어 자료 라 이브 러 리:big.txt.
코드 github:https://github.com/dreamboy127/Spell_java
자바 코드 는 다음 과 같 습 니 다:

import java.util.*;
import java.io.*;
public class SpellCorrect{
    public static void readLines(String file, ArrayList<String> lines) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(new File(file)));
            String line = null;
            while ((line = reader.readLine()) != null) {
                lines.add(line);                                                            
            }                                                    
        } catch (FileNotFoundException e) {
            e.printStackTrace();
                                        
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();                                                          
                }
            }
        }                    
    }
        private static String readText(File file) { 
                String text = null;
                try
                {
                        InputStreamReader read = new InputStreamReader(new FileInputStream(file));
                        BufferedReader br = new BufferedReader(read);    
                        StringBuffer buff = new StringBuffer();     
                        while((text = br.readLine()) != null)
                {    
                                buff.append(text + "\r
");    
                }    
                br.close();         
                text = buff.toString(); 
            }  
                catch(FileNotFoundException e)  
            {   
                        System.out.println(e);  
            }  
            catch(IOException e)  
            {   
                System.out.println(e);  
            }
               return text;
        }
    public static void tokenizeAndLowerCase(String line, ArrayList<String> tokens) {
    // TODO Auto-generated method stub
        StringTokenizer strTok = new StringTokenizer(line,"\r
\t/\\\':\" ()[]{};.,#-_=!@$%^&*+1234567890");
        while (strTok.hasMoreTokens()) {
            String token = strTok.nextToken();
            tokens.add(token.toLowerCase().trim());
        }
    }
    public static void trainPrior(ArrayList<String> str,Map<String,Integer> map)
    {
        for(int i=0;i<str.size();i++)
        {
            if(map.containsKey(str.get(i)))
            {
                int tmp=map.get(str.get(i));
                map.put(str.get(i),1+tmp);
            }
            else
                map.put(str.get(i),1);
        }
    }
    public static Set<String> Edit1(String str){
        Set<String> array=new HashSet<String>();
        for(int i=0;i<str.length();i++)//delete
        {
            String tmpstr=str.substring(0,i)+str.substring(i+1,str.length());
            array.add(tmpstr);
        }
        
        for(int i=0;i<str.length();i++)//insert
        {
            for(char x='a';x<='z';x++)
            {
                String tmpstr=str.substring(0,i)+x+str.substring(i,str.length());
                array.add(tmpstr);
            }   
        }
        for(int i=0;i<str.length()-1;i++)//trans
        {
            String tmpstr=str.substring(0,i)+str.charAt(i+1)+str.charAt(i)+str.substring(i+2,str.length());
            array.add(tmpstr);
        }
        for(int i=0;i<str.length();i++)//convert
        {
            for(char x='a';x<='z';x++)
            {
                String tmpstr=str.substring(0,i)+x+str.substring(i+1,str.length());
                array.add(tmpstr);
            }
        }
        return array;
    }
    public static Set<String> Edit2(String str){
        Set<String> array=new HashSet<String>();
        array=Edit1(str);
        Set<String> array2=new HashSet<String>();
        Iterator<String> iter=array.iterator();
        while(iter.hasNext())
        {
            String str1=iter.next();
            array2.addAll(Edit1(str1));
        }
        return array2;
    }
    public static boolean kowns(Set<String> checkset,Set<String> wordset)
    {
        Iterator<String> iter=checkset.iterator();
        while(iter.hasNext())
        {
            String str=iter.next();
            if(!wordset.contains(str))
                iter.remove();
        }
        return checkset.size()>0;
    }
    public static void main(String[] args){
        String text=readText(new File("big.txt"));
        ArrayList<String> s=new ArrayList<String>();
        tokenizeAndLowerCase(text,s);
        Map<String,Integer> map=new HashMap<String,Integer>();
        trainPrior(s,map);
        Set<String> keys=map.keySet();
 //       System.out.println(map.size());
        Scanner scan=new Scanner(System.in);
        System.out.println("spell correct starting");
        while(true)
        {
            System.out.println("please input a term:");
            String str=scan.next();
            if("q".equals(str))
                break;
            Set<String> edit1=Edit1(str);
            Set<String> edit2=Edit2(str);
            boolean flag=kowns(new HashSet<String>(Arrays.asList(str)),keys);
            if(flag)
                return;
            Set<String> edit=edit1;
            flag=kowns(edit,keys);
            if(!flag)
            {
                edit=edit2;
                flag=kowns(edit,keys);
            }
            Iterator<String> iter=edit.iterator();
            int max=0;
            int tmp=1;
            String maxStr=null;
            while(iter.hasNext())
            {
                String tmpStr = iter.next();
//            System.out.println(tmpStr);
                tmp=map.get(tmpStr);

                if(max<tmp)
                {
                    maxStr=tmpStr;
                    max=tmp;
                }
            }
            System.out.println(maxStr);
        }
        System.out.println("spell correct ending");
//        Set<Map.Entry<String,Integer>> allSet=null;
//        allSet=map.entrySet();
//        for(Map.Entry<String,Integer> me : allSet)
//            System.out.println(me.getKey()+"-->"+me.getValue());
    }
}