soynlp
0.1.1
Índice
Código Python puro para análise coreana. Ele pretende ser uma abordagem de aprendizado não -mapa que possa encontrar palavras nos dados sem usar dados de aprendizado, desmontar frases com palavras ou discriminar partes da fala.
WordExtractor ou NounExtractor fornecido pela SoynLP Works usando informações estatísticas aprendidas em vários documentos. As abordagens que não são de aprendizado não mapas extraem palavras usando padrões estatísticos, para que funcionem bem no mesmo grupo de documentos (documentos homogêneos) que são um pouco maiores do que em uma frase ou documento. É bom aprender extratores coletando apenas documentos usando as mesmas palavras, como comentários de filmes ou artigos de notícias do dia. Os documentos de grupos heterogêneos não são bem extraídos quando os coletam.
Até o Soynlp = 0.0.46, não havia regras nos nomes dos parâmetros, que requerem o valor mínimo ou máximo, como min_score, minimum_score, l_len_min. Entre o código que você trabalhou até agora, você pode confundir aqueles que definiram parâmetros diretamente, mas modificamos o nome da variável para reduzir o inconveniente que ocorrerá mais tarde antes de ser posterior .
Após 0,0.47, o nome da variável que contém o significado de mínimo e máximo é reduzido a min e máx. Depois disso, escreva um nome para qual item é o parâmetro limite. Unifique o nome do parâmetro com os seguintes padrões: unifique o nome com {min, max} _ {substantivo, palavra} _ {score, limite}. Se o item for óbvio, você pode omiti -lo.
A contagem de substring é frequentemente feita no Soynlp. O parâmetro associado à frequência é unificado com a prequência, não a contagem.
Índice e IDX são unificados com IDX.
Num e n, que significa números, são unificados com num.
$ pip install soynlpComo resultado de várias tentativas de extrair substantivos, V1, notícias e V2 três versões foram criadas. O melhor desempenho é V2.
O WordExtractor deve aprender as pontuações de limites de palavras usando estatísticas e não julgar as partes de cada palavra. Às vezes você precisa conhecer as partes de cada palavra. Além disso, novas palavras são mais comuns em substantivos do que em outras partes da fala. No lado direito do substantivo, certas letras geralmente aparecem, como -Silver, -e e -. Se você olhar para a distribuição de quais letras aparecerão no lado direito da substring no lado esquerdo das palavras (unidade padrão baseada em espaço), poderá determinar se é ou não um substantivo. O Soynlp oferece dois tipos de extratores substantivos. É difícil dizer que algo é melhor porque ambos estão em fase de desenvolvimento, mas o NewsNounExtractor contém mais recursos. No futuro, o extrator substantivo será resumido como uma classe.
from soynlp . noun import LRNounExtractor
noun_extractor = LRNounExtractor ()
nouns = noun_extractor . train_extract ( sentences ) # list of str like
from soynlp . noun import NewsNounExtractor
noun_extractor = NewsNounExtractor ()
nouns = noun_extractor . train_extract ( sentences ) # list of str likeEste é um exemplo de substantivo aprendido com as notícias de 2016-10-20-20.
덴마크 웃돈 너무너무너무 가락동 매뉴얼 지도교수
전망치 강구 언니들 신산업 기뢰전 노스
할리우드 플라자 불법조업 월스트리트저널 2022년 불허
고씨 어플 1987년 불씨 적기 레스
스퀘어 충당금 건축물 뉴질랜드 사각 하나씩
근대 투자주체별 4위 태권 네트웍스 모바일게임
연동 런칭 만성 손질 제작법 현실화
오해영 심사위원들 단점 부장조리 차관급 게시물
인터폰 원화 단기간 편곡 무산 외국인들
세무조사 석유화학 워킹 원피스 서장 공범
Explicações mais detalhadas estão no tutorial.
Soynlp = 0.0.46+ oferece extrator de substantivo versão 2. Esta é uma versão que revisa a precisão da versão anterior dos substantivos, a capacidade de reconhecimento de substantivo sintético e o erro das informações de saída. O uso é semelhante à versão 1.
from soynlp . utils import DoublespaceLineCorpus
from soynlp . noun import LRNounExtractor_v2
corpus_path = '2016-10-20-news'
sents = DoublespaceLineCorpus ( corpus_path , iter_sent = True )
noun_extractor = LRNounExtractor_v2 ( verbose = True )
nouns = noun_extractor . train_extract ( sents )Os substantivos extraídos são {str: nomeado formato}.
print ( nouns [ '뉴스' ]) # NounScore(frequency=4319, score=1.0)_ComPounds_Components armazena informações de substantivos únicos que compõem substantivos complexos. Na verdade, é uma forma complexa, como 'Coréia' e 'crescimento verde', mas se usado como um único substantivo, é reconhecido como um único substantivo.
list ( noun_extractor . _compounds_components . items ())[: 5 ]
# [('잠수함발사탄도미사일', ('잠수함', '발사', '탄도미사일')),
# ('미사일대응능력위원회', ('미사일', '대응', '능력', '위원회')),
# ('글로벌녹색성장연구소', ('글로벌', '녹색성장', '연구소')),
# ('시카고옵션거래소', ('시카고', '옵션', '거래소')),
# ('대한민국특수임무유공', ('대한민국', '특수', '임무', '유공')),O LRGRAPH armazena a estrutura LR da apagar no corpus instruído. Você pode verificar isso usando get_r e get_l.
noun_extractor . lrgraph . get_r ( '아이오아이' )
# [('', 123),
# ('의', 47),
# ('는', 40),
# ('와', 18),
# ('가', 18),
# ('에', 7),
# ('에게', 6),
# ('까지', 2),
# ('랑', 2),
# ('부터', 1)]Mais detalhes estão no tutorial 2.
Em outubro de 2016, há palavras como 'duas vezes' e 'Iowa'. No entanto, nunca vi essas palavras essa palavra. Como novas palavras são sempre feitas, há um problema de palavra não registrado (OOV) que não reconhece as palavras que você não aprendeu. No entanto, se você ler vários artigos de notícias de entretenimento escritos no momento, poderá ver que palavras como 'duas vezes' e 'ioi' aparecem, e as pessoas podem aprender. Se definirmos o calor contínuo da palavra que geralmente aparece no conjunto de documentos, podemos extraí -lo usando estatísticas. Existem muitas maneiras de aprender palavras (limites) com base nas estatísticas. O SoynLP fornece pontuação de coesão, entropia ramificada e variedade de acessadores.
from soynlp . word import WordExtractor
word_extractor = WordExtractor ( min_frequency = 100 ,
min_cohesion_forward = 0.05 ,
min_right_branching_entropy = 0.0
)
word_extractor . train ( sentences ) # list of str or like
words = word_extractor . extract ()O Words é um ditado que detém uma pontuação chamada pontuações.
words [ '아이오아이' ]
Scores ( cohesion_forward = 0.30063636035733476 ,
cohesion_backward = 0 ,
left_branching_entropy = 0 ,
right_branching_entropy = 0 ,
left_accessor_variety = 0 ,
right_accessor_variety = 0 ,
leftside_frequency = 270 ,
rightside_frequency = 0
)Este é um exemplo classificado pela pontuação da palavra (Cohesion * Branking Entropy) aprendida no artigo de notícias de 2016-10-26.
단어 (빈도수, cohesion, branching entropy)
촬영 (2222, 1.000, 1.823)
서울 (25507, 0.657, 2.241)
들어 (3906, 0.534, 2.262)
롯데 (1973, 0.999, 1.542)
한국 (9904, 0.286, 2.729)
북한 (4954, 0.766, 1.729)
투자 (4549, 0.630, 1.889)
떨어 (1453, 0.817, 1.515)
진행 (8123, 0.516, 1.970)
얘기 (1157, 0.970, 1.328)
운영 (4537, 0.592, 1.768)
프로그램 (2738, 0.719, 1.527)
클린턴 (2361, 0.751, 1.420)
뛰어 (927, 0.831, 1.298)
드라마 (2375, 0.609, 1.606)
우리 (7458, 0.470, 1.827)
준비 (1736, 0.639, 1.513)
루이 (1284, 0.743, 1.354)
트럼프 (3565, 0.712, 1.355)
생각 (3963, 0.335, 2.024)
팬들 (999, 0.626, 1.341)
산업 (2203, 0.403, 1.769)
10 (18164, 0.256, 2.210)
확인 (3575, 0.306, 2.016)
필요 (3428, 0.635, 1.279)
문제 (4737, 0.364, 1.808)
혐의 (2357, 0.962, 0.830)
평가 (2749, 0.362, 1.787)
20 (59317, 0.667, 1.171)
스포츠 (3422, 0.428, 1.604)
Mais detalhes estão no tutorial de extração de palavras. As funções fornecidas na versão atual são as seguintes:
Se você aprendeu uma pontuação da palavra com o WordXtractor, pode usá -la para dividir a frase em uma palavra calor ao longo do limite da palavra. Soynlp oferece três cavaleiros de torque. Se você é bom em espaçamento, pode usar o ltokenizer. Eu acho que a estrutura da língua coreana é "L + [r]" como "substantivo + pesquisa".
L As peças podem ser substantivos/verbos/adjetivos/advérbios. Se apenas L reconheça apenas L na palavra, o restante é R Peças. O ltokenizer entra na palavra pontuação de l partes.
from soynlp . tokenizer import LTokenizer
scores = { '데이' : 0.5 , '데이터' : 0.5 , '데이터마이닝' : 0.5 , '공부' : 0.5 , '공부중' : 0.45 }
tokenizer = LTokenizer ( scores = scores )
sent = '데이터마이닝을 공부한다'
print ( tokenizer . tokenize ( sent , flatten = False ))
#[['데이터마이닝', '을'], ['공부', '중이다']]
print ( tokenizer . tokenize ( sent ))
# ['데이터마이닝', '을', '공부', '중이다']Se você calcular as pontuações do Word usando o WordExtractor, poderá criar pontuações escolhendo uma das pontuações das palavras. Abaixo está apenas a pontuação da coesão direta. Além disso, várias pontuações podem ser definidas e usadas.
from soynlp . word import WordExtractor
from soynlp . utils import DoublespaceLineCorpus
file_path = 'your file path'
corpus = DoublespaceLineCorpus ( file_path , iter_sent = True )
word_extractor = WordExtractor (
min_frequency = 100 , # example
min_cohesion_forward = 0.05 ,
min_right_branching_entropy = 0.0
)
word_extractor . train ( sentences )
words = word_extractor . extract ()
cohesion_score = { word : score . cohesion_forward for word , score in words . items ()}
tokenizer = LTokenizer ( scores = cohesion_score )Você também pode usar a pontuação do substantivo e a coesão do extrator substantivo. Por exemplo, se você deseja usar a "pontuação de coesão + pontuação substantiva" como uma pontuação de palavras, poderá trabalhar da seguinte maneira.
from soynlp . noun import LRNounExtractor_2
noun_extractor = LRNounExtractor_v2 ()
nouns = noun_extractor . train_extract ( corpus ) # list of str like
noun_scores = { noun : score . score for noun , score in nouns . items ()}
combined_scores = { noun : score + cohesion_score . get ( noun , 0 )
for noun , score in noun_scores . items ()}
combined_scores . update (
{ subword : cohesion for subword , cohesion in cohesion_score . items ()
if not ( subword in combined_scores )}
)
tokenizer = LTokenizer ( scores = combined_scores )Se o espaçamento não for observado corretamente, a unidade dividida pela base de espaçamento da frase é a estrutura L + [R]. No entanto, as pessoas são notadas a partir de palavras familiares em frases que não são mantidas espaços. O MaxSCORETOKEENIZER, que moveu esse processo para o modelo, também usa uma pontuação do Word.
from soynlp . tokenizer import MaxScoreTokenizer
scores = { '파스' : 0.3 , '파스타' : 0.7 , '좋아요' : 0.2 , '좋아' : 0.5 }
tokenizer = MaxScoreTokenizer ( scores = scores )
print ( tokenizer . tokenize ( '난파스타가좋아요' ))
# ['난', '파스타', '가', '좋아', '요']
print ( tokenizer . tokenize ( '난파스타가 좋아요' , flatten = False ))
# [[('난', 0, 1, 0.0, 1), ('파스타', 1, 4, 0.7, 3), ('가', 4, 5, 0.0, 1)],
# [('좋아', 0, 2, 0.5, 2), ('요', 2, 3, 0.0, 1)]]O MaxScoreTokenizer também usa os resultados do Wordxtractor e usa pontuações adequadamente como o exemplo acima. Se já houver dicionário de palavras conhecidas, essas palavras dão uma pontuação maior do que qualquer outra palavra, e a palavra é cortada em uma palavra.
Você também pode fazer uma palavra calor com base nas regras. No ponto em que a linguagem muda, reconhecemos os limites das palavras. Por exemplo, "Oh haha ㅜ ㅜ realmente?" As palavras são facilmente divididas com [oh, haha, ㅜㅜ, real,?].
from soynlp . tokenizer import RegexTokenizer
tokenizer = RegexTokenizer ()
print ( tokenizer . tokenize ( '이렇게연속된문장은잘리지않습니다만' ))
# ['이렇게연속된문장은잘리지않습니다만']
print ( tokenizer . tokenize ( '숫자123이영어abc에섞여있으면ㅋㅋ잘리겠죠' ))
# ['숫자', '123', '이영어', 'abc', '에섞여있으면', 'ㅋㅋ', '잘리겠죠'] Se a palavra dicionário estiver bem estabelecida, você poderá usá -la para criar uma parte pré -baseada -OF -RESECH Determinante. No entanto, porque não é para analisar morfemas, 'do', 'da', 'e' e 'e' e 'e são todos verbos. Lemmatizer está atualmente em desenvolvimento e organização.
pos_dict = {
'Adverb' : { '너무' , '매우' },
'Noun' : { '너무너무너무' , '아이오아이' , '아이' , '노래' , '오' , '이' , '고양' },
'Josa' : { '는' , '의' , '이다' , '입니다' , '이' , '이는' , '를' , '라' , '라는' },
'Verb' : { '하는' , '하다' , '하고' },
'Adjective' : { '예쁜' , '예쁘다' },
'Exclamation' : { '우와' }
}
from soynlp . postagger import Dictionary
from soynlp . postagger import LRTemplateMatcher
from soynlp . postagger import LREvaluator
from soynlp . postagger import SimpleTagger
from soynlp . postagger import UnknowLRPostprocessor
dictionary = Dictionary ( pos_dict )
generator = LRTemplateMatcher ( dictionary )
evaluator = LREvaluator ()
postprocessor = UnknowLRPostprocessor ()
tagger = SimpleTagger ( generator , evaluator , postprocessor )
sent = '너무너무너무는아이오아이의노래입니다!!'
print ( tagger . tag ( sent ))
# [('너무너무너무', 'Noun'),
# ('는', 'Josa'),
# ('아이오아이', 'Noun'),
# ('의', 'Josa'),
# ('노래', 'Noun'),
# ('입니다', 'Josa'),
# ('!!', None)]O uso mais detalhado é descrito no tutorial e as notas do processo de desenvolvimento são descritas aqui.
Crie o documento na matriz esparsa usando o apavorativo de torque ou usando a reforma do torque. Mínimo / máximo de termo de frequência / frequência de documentos pode ser ajustado. O modo detalhado imprime a situação vetorosa atual.
vectorizer = BaseVectorizer (
tokenizer = tokenizer ,
min_tf = 0 ,
max_tf = 10000 ,
min_df = 0 ,
max_df = 1.0 ,
stopwords = None ,
lowercase = True ,
verbose = True
)
corpus . iter_sent = False
x = vectorizer . fit_transform ( corpus )Se o documento for grande ou não usando imediatamente a matriz esparsa, você poderá salvá -lo como um arquivo sem colocá -lo na memória. FIT_TO_FILE () ou TO_FILE () Registra o termo vetor de frequência para um documento assim que você recebe. Os parâmetros disponíveis no BaseVectorizer são os mesmos.
vectorizer = BaseVectorizer ( min_tf = 1 , tokenizer = tokenizer )
corpus . iter_sent = False
matrix_path = 'YOURS'
vectorizer . fit_to_file ( corpus , matrix_path )Você pode produzir um documento com a lista de int em vez de matriz esparsa. No momento, as palavras que não são aprendidas no vetorizer.vocabulary_ não estarão codificando.
vectorizer . encode_a_doc_to_bow ( '오늘 뉴스는 이것이 전부다' )
# {3: 1, 258: 1, 428: 1, 1814: 1}A lista de int é possível com a lista de str.
vectorizer . decode_from_bow ({ 3 : 1 , 258 : 1 , 428 : 1 , 1814 : 1 })
# {'뉴스': 1, '는': 1, '오늘': 1, '이것이': 1}A codificação também está disponível com o saco de palavras no formato do ditado.
vectorizer . encode_a_doc_to_list ( '오늘의 뉴스는 매우 심각합니다' )
# [258, 4, 428, 3, 333]O saco de palavras no formato Dict pode ser decodificante.
vectorizer . decode_from_list ([ 258 , 4 , 428 , 3 , 333 ])
[ '오늘' , '의' , '뉴스' , '는' , '매우' ]Ele fornece uma função para o resumo dos emoticons repetidos nos dados de conversas, comentários e para deixar apenas coreano ou texto.
from soynlp . normalizer import *
emoticon_normalize ( 'ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ쿠ㅜㅜㅜㅜㅜㅜ' , num_repeats = 3 )
# 'ㅋㅋㅋㅜㅜㅜ'
repeat_normalize ( '와하하하하하하하하하핫' , num_repeats = 2 )
# '와하하핫'
only_hangle ( '가나다ㅏㅑㅓㅋㅋ쿠ㅜㅜㅜabcd123!!아핫' )
# '가나다ㅏㅑㅓㅋㅋ쿠ㅜㅜㅜ 아핫'
only_hangle_number ( '가나다ㅏㅑㅓㅋㅋ쿠ㅜㅜㅜabcd123!!아핫' )
# '가나다ㅏㅑㅓㅋㅋ쿠ㅜㅜㅜ 123 아핫'
only_text ( '가나다ㅏㅑㅓㅋㅋ쿠ㅜㅜㅜabcd123!!아핫' )
# '가나다ㅏㅑㅓㅋㅋ쿠ㅜㅜㅜabcd123!!아핫'Explicações mais detalhadas estão no tutorial.
Ele fornece uma função para calcular a matriz de co-ocorrência para análise de associação e informações mútuas de ponto (PMI).
Você pode criar Matrix usando a função Sent_to_word_contexts_matrix abaixo (Word, Word Words). X é scipy.sparse.csr_matrix, (n_vocabs, n_vocabs). Idx2vocab é uma lista de STR que contém palavras correspondentes a cada linha, coluna de x. Reconheça as palavras das janelas dianteiras e traseiras como um contexto de frase e calcule apenas as palavras que aparecem como a frequência de min_tf ou superior. Dynamic_weight está ponderando inversamente proporcional ao comprimento do contexto. Se o Windows for 3, a co-ocorrência de 1, 2 e 3 quadrados é calculada como 1, 2/3, 1/3.
from soynlp . vectorizer import sent_to_word_contexts_matrix
x , idx2vocab = sent_to_word_contexts_matrix (
corpus ,
windows = 3 ,
min_tf = 10 ,
tokenizer = tokenizer , # (default) lambda x:x.split(),
dynamic_weight = False ,
verbose = True
)Se você inserir X, que é uma matriz de co-ocorrência, no PMI, o PMI é calculado por cada eixo de linha e coluna. PMI_DOK é o formato scipy.sparse.dok_matrix. Somente o valor de min_pmi é armazenado e o padrão é min_pmi = 0, então PMI positivo (ppmi). Alpha é uma entrada de parâmetro de suavização para pmi (x, y) = p (x, y) / (p (p) * (p) + alfa). O processo de cálculo leva muito tempo; portanto, defina -o como verboso = true para produzir o progresso atual.
from soynlp . word import pmi
pmi_dok = pmi (
x ,
min_pmi = 0 ,
alpha = 0.0001 ,
verbose = True
)Explicações mais detalhadas estão no tutorial.
Ele fornece funções para purificar os dados de cavalos de Sejong para o aprendizado de modelo de processamento de linguagem natural. Ele fornece uma função que cria um tipo de dados de aprendizado purificado na forma de morfema e fala, uma função que faz uma tabela e faz uma tabela e uma função que simplifica o sistema de peças e fala de Sejong Malm.
Se houver um erro de espaçamento, pode ser fácil analisar o texto removendo -o. Com base nos dados que você deseja analisar, aprenda o mecanismo de espaçamento e use -os para corrigir o erro de espaçamento.
Sem ter que aprender um knicer de torque ou extrator de palavras, você pode extrair palavras -chave do gráfico de substring usando o algoritmo de hits.
Extrator de palavra -chave. Oferece dois tipos de extratores de palavras -chave, usando modelos e modelos de base estatística usando regressão logística. Ele suporta o formato da matriz esparsa e o formato do arquivo de texto no scipy.sparse.
