[위 에] NLTK 학습 노트 (5): 어휘 분류 및 표기

품사 표시 기

표기 어 료 라 이브 러 리

표 시 된 식별 자 nltktagstr2tupleword 형식

표 시 된 언어 자료 실 읽 기

명사 동사 형용사 등

각 명사 유형 중 가장 빈번 한 명 사 를 찾아내 려 고 시도 한다

표 시 된 언어 자료 실 탐색

자동 표시

기본 표시 기

정규 표현 식 표시 기

검색 표시 기

N - gram 레이 블

기초 의 일원 표시 기

일반적인 N - gram 표시 기

조합 표시 기

문장 경계 표시

전환 기반 레이 블 Brill 레이 블 러

품사 표시 기
이후 의 많은 일 들 이 표 시 된 어 휘 를 필요 로 한다.nltk 자체 영문 레이 블 러 pos_tag

import nltk
text = nltk.word_tokenize("And now for something compleyely difference")
print(text)
print(nltk.pos_tag(text))

레이 블 어 료 라 이브 러 리
표 시 된 식별 자 를 표시 합 니 다. nltk.tag.str2tuple('word/ ')

text = "The/AT grand/JJ is/VBD ."
print([nltk.tag.str2tuple(t) for t in text.split()])

표 시 된 언어 자료 실 읽 기
nltk 언어 자료 실 ue 배꼽 은 통 일 된 인 터 페 이 스 를 제공 하 므 로 서로 다른 파일 형식 에 신경 쓰 지 않 아 도 된다.형식: .tagged_word()/tagged_sents().인 자 는 categories 와 fields 를 지정 할 수 있 습 니 다.

print(nltk.corpus.brown.tagged_words())

명사, 동사, 형용사 등
여기

from nltk.corpus import brown
word_tag = nltk.FreqDist(brown.tagged_words(categories="news"))
print([word+'/'+tag for (word,tag)in word_tag if tag.startswith('V')])
################     money     #################################
wsj = brown.tagged_words(categories="news")
cfd = nltk.ConditionalFreqDist(wsj)
print(cfd['money'].keys())

모든 명사 유형 중 가장 빈번 한 명 사 를 찾 아 보 세 요.

def findtag(tag_prefix,tagged_text):
    cfd = nltk.ConditionalFreqDist((tag,word) for (word,tag) in tagged_text if tag.startswith(tag_prefix))
    return dict((tag,list(cfd[tag].keys())[:5]) for tag in cfd.conditions())#         list        

tagdict = findtag('NN',nltk.corpus.brown.tagged_words(categories="news"))
for tag in sorted(tagdict):
    print(tag,tagdict[tag])

표 시 된 언어 자료 실 탐색
필요 nltk.bigrams() 와 nltk.trigrams() 는 각각 2 - gram 모델 과 3 - gram 모델 에 대응 해 야 한다.

brown_tagged = brown.tagged_words(categories="learned")
tags = [b[1] for (a,b) in nltk.bigrams(brown_tagged) if a[0]=="often"]
fd = nltk.FreqDist(tags)
fd.tabulate()

자동 표시
기본 표시 기
가장 간단 한 레이 블 러 는 모든 식별 자 에 게 통일 적 인 표 시 를 분배 하 는 것 이다.다음은 모든 단 어 를 NN 으로 바 꾸 는 레이 블 러 다.그리고 evaluate() 로 검 사 를 한다.많은 단어 가 명사 일 때 첫 번 째 분석 과 안정성 을 향상 시 키 는 데 유리 하 다.

brown_tagged_sents = brown.tagged_sents(categories="news")

raw = 'I do not like eggs and ham, I do not like them Sam I am'
tokens = nltk.word_tokenize(raw)
default_tagger = nltk.DefaultTagger('NN')#     
print(default_tagger.tag(tokens)) #   tag()      
print(default_tagger.evaluate(brown_tagged_sents))

정규 표현 식 레이 블
이 규칙 은 고정 되 어 있 음 을 주의 하 세 요.규칙 이 점점 완벽 해 질 때 정확도 가 높아진다.

patterns = [
    (r'.*ing$','VBG'),
    (r'.*ed$','VBD'),
    (r'.*es$','VBZ'),
    (r'.*','NN')#    ，      
]
regexp_tagger = nltk.RegexpTagger(patterns)
regexp_tagger.evaluate(brown_tagged_sents)

조회 표시 기
여기 와 책 은 차이 가 있 습 니 다. python 2 와 달리 디 버 깅 에 주의 하 세 요.검색 표시 기 는 가장 가능 한 표 시 를 저장 하고 backoff 인 자 를 설정 할 수 있 으 며 표시 할 수 없 는 경우 이 표시 기 를 사용 합 니 다 (이 과정 은 후퇴 입 니 다).

fd = nltk.FreqDist(brown.words(categories="news"))
cfd = nltk.ConditionalFreqDist(brown.tagged_words(categories="news"))
##############################################python2 3   #########
most_freq_words = fd.most_common(100)
likely_tags = dict((word,cfd[word].max()) for (word,times) in most_freq_words)
#######################################################################
baseline_tagger = nltk.UnigramTagger(model=likely_tags,backoff=nltk.DefaultTagger('NN'))
baseline_tagger.evaluate(brown_tagged_sents)

N - gram 레이 블
기본 1 원 레이 블
1 원 레이 블 러 의 행동 은 레이 블 러 를 찾 는 것 과 비슷 하 며 1 원 레이 블 러 를 만 드 는 기술 을 훈련 시 킵 니 다.여기 서 우리 의 레이 블 기 는 일반 모델 을 만 드 는 것 이 아니 라 기억 훈련 집 일 뿐 잘 맞 지만 새로운 텍스트 로 보급 할 수 없습니다.

size = int(len(brown_tagged_sents)*0.9)
train_sents = brown_tagged_sents[:size]
test_sents = brown_tagged_sents[size+1:]
unigram_tagger = nltk.UnigramTagger(train_sents)
unigram_tagger.evaluate(test_sents)

일반적인 N - gram 표시 기
N 원 레이 블 러 는 index = n 의 워드 를 검색 하고 n - N < = index < = n - 1 의 tag 를 검색 합 니 다.즉, 앞 단어의 tag 라벨 을 통 해 현재 단어의 tag 를 확인 하 는 것 입 니 다.nltk.UnigramTagger() 와 유사 하 며, 자체 적 으로 가지 고 있 는 이원 레이 블 기 는: nltk.BigramTagger() 용법 이 일치 합 니 다.
조합 표시 기
커버 범위 가 넓 은 알고리즘 이 정밀도 가 높 은 알고리즘 보다 더 유용 할 때 가 많다.backoff 리 턴 레이 블 러 를 사용 하여 레이 블 러 의 조합 을 실현 합 니 다.한편, 매개 변수 cutoff 의 명시 적 성명 은 int 형 이 고 1 - n 번 만 나타 나 는 문맥 을 자동 으로 버 립 니 다.

t0 = nltk.DefaultTagger('NN')
t1 = nltk.UnigramTagger(train_sents,backoff=t0)
t2 = nltk.BigramTagger(train_sents,backoff=t1)
t2.evaluate(test_sents)

원래 와 비교 해 보면 정확도 가 현저히 높 아 졌 다 는 것 을 알 수 있다.
문장 경계 표시
문장 첫머리 의 단어 에 대해 서 는 n 개의 단어 가 없다.해결 방법: 표 시 된 taggedsents 가 레이 블 기 를 훈련 시 킵 니 다.
변환 기반 레이 블: Brill 레이 블
위의 것 보다 우수 하 다.실현 의 사고: 큰 것 으로 시작 한 다음 에 디 테 일 을 복원 하고 조금씩 세밀 하 게 변화 한다.메모리 가 작 을 뿐만 아니 라 관련 문맥 도 작 아 지고 문제 에 따라 실시 간 으로 오 류 를 수정 합 니 다. 변 함 없 는 것 이 아 닙 니 다.물론 python 3 과 python 2 의 호출 은 다르다.

from nltk.tag import brill
brill.nltkdemo18plus()
brill.nltkdemo18()

본 박문 과 관련 된 내용 을 더 교류 하 는 것 을 환영 합 니 다: 블 로그 원 주소:http://www.cnblogs.com/AsuraDong/ CSDN 주소:http://blog.csdn.net/asuradong 편 지 를 보 내 교류 할 수도 있다[email protected]전 재 를 환영 하지만 출처 를 밝 혀 주세요. :  )