contextualized topic models
1.0.0
Os modelos de tópicos contextualizados (CTM) são uma família de modelos de tópicos que usam representações pré-treinadas da linguagem (por exemplo, BERT) para apoiar a modelagem de tópicos. Veja os papéis para obter detalhes:
Nossa nova família de modelagem de tópicos suporta muitos idiomas diferentes (ou seja, o apoiado pelos modelos Huggingface) e vem em duas versões: o ComminedTM combina incorporações contextuais com o bom e velho saco de palavras para criar tópicos mais coerentes; ZerosHottm é o modelo de tópico perfeito para a tarefa em que você pode ter palavras ausentes nos dados do teste e também, se treinado com incorporações multilíngues, herda a propriedade de ser um modelo de tópico multilíngue!
A grande vantagem é que você pode usar diferentes incorporações para CTMs. Assim, quando um novo método de incorporação sai, você pode usá -lo no código e melhorar seus resultados. Não estamos mais limitados pelo arco.
Nós também temos Kitty! Um novo submódulo que pode ser usado para criar um classificador humano no loop para classificar rapidamente seus documentos e criar clusters nomeados.
Você pode olhar para a nossa postagem de blog médio ou começar de um de nossos tutoriais do Colab:
| Nome | Link |
|---|---|
| TM combinado nos dados da Wikipedia (Preproc+Saving+viz) (estável v2.3.0 ) | |
| Modelagem de tópicos transfronscular zero (pré-Proc+viz) (estável v2.3.0 ) | |
| Kitty: Humano no classificador de loop (uso de alto nível) (estável v2.2.0 ) | |
| Superctm e β-CTM (uso de alto nível) (estável v2.2.0 ) |
IMPORTANTE : Se você deseja usar o CUDA, precisa instalar a versão correta dos sistemas CUDA que corresponde à sua distribuição, consulte Pytorch.
Instale o pacote usando PIP
pip install -U contextualized_topic_modelsUm aspecto importante a levar em consideração é qual rede você deseja usar: aquele que combina incorporações contextualizadas e o arco (combinadotm) ou o que apenas usa incorporações contextualizadas (Zeroshottm)
Mas lembre-se de que você pode fazer uma modelagem de tópicos transfronscular zero apenas com o modelo ZerosHottm.
Os modelos de tópicos contextualizados também suportam a supervisão (superctm). Você pode ler mais sobre isso na documentação.
Também temos Kitty: um utilitário que você pode usar para fazer um humano mais simples na classificação do loop de seus documentos. Isso pode ser muito útil para fazer a filtragem de documentos. Ele também funciona em configuração cruzada e, portanto, você poderá filtrar documentos em um idioma que não conhece!
Se você achar isso útil, pode citar os seguintes papéis :)
ZerosHottm
@Inproecedings {Bianchi-Etal-2021-Cross,
Title = "Modelos de tópicos contextualizados entre leguminosas com aprendizado de tiro zero",
autor = "Bianchi, Federico e Terragni, Silvia e Hovy, Dirk e
Nozza, Debora e Fersini, Elisabetta ",
Booktitle = "Anais da 16ª Conferência do Capítulo Europeu da Associação de Linguística Computacional: Principal Volume",
mês = abril,
ano = "2021",
endereço = "online",
publisher = "Association for Computational Linguistics",
url = "https://www.aclweb.org/anthology/2021.eacl-main.143",
páginas = "1676--1683",
}
Combinedtm
@InProedings {Bianchi-Etal-2021-PRE,
Title = "Pré-treinamento é um tópico quente: incorporação contextualizada de documentos melhora a coerência do tópico",
autor = "Bianchi, Federico e
Terragni, Silvia e
Hovy, Dirk ",
Booktitle = "Anais da 59ª Reunião Anual da Associação de Linguística Computacional e da 11ª Conferência Internacional Conjunto sobre Processamento de Linguagem Natural (Volume 2: Papéis curtos)",
mês = agosto,
ano = "2021",
endereço = "online",
publisher = "Association for Computational Linguistics",
url = "https://aclanthology.org/2021.acl-hort.96",
doi = "10.18653/v1/2021.acl-short.96",
páginas = "759--766",
}
Alguns dos exemplos abaixo usam um modelo de incorporação multilíngue paraphrase-multilingual-mpnet-base-v2 . Isso significa que as representações que você usará são mutLilingule. No entanto, você pode precisar de uma cobertura mais ampla de idiomas ou apenas um idioma específico. Consulte a página na documentação para ver como escolher um modelo para outro idioma. Nesse caso, você pode verificar Sbert para encontrar o modelo perfeito para usar.
Aqui, você pode ler mais sobre o idioma específico e mulitlingual.
Definitivamente, você deve dar uma olhada na documentação para entender melhor como esses modelos de tópicos funcionam.
Aqui está como você pode usar o CombinedTM. Este é um modelo de tópico padrão que também usa incorporações contextualizadas. O bom do CombinedTM é que ele torna seu tópico muito mais coerente (consulte o artigo https://arxiv.org/abs/2004.03974). N_COMPONENTS = 50 Especifica o número de tópicos.
from contextualized_topic_models . models . ctm import CombinedTM
from contextualized_topic_models . utils . data_preparation import TopicModelDataPreparation
from contextualized_topic_models . utils . data_preparation import bert_embeddings_from_file
qt = TopicModelDataPreparation ( "all-mpnet-base-v2" )
training_dataset = qt . fit ( text_for_contextual = list_of_unpreprocessed_documents , text_for_bow = list_of_preprocessed_documents )
ctm = CombinedTM ( bow_size = len ( qt . vocab ), contextual_size = 768 , n_components = 50 ) # 50 topics
ctm . fit ( training_dataset ) # run the model
ctm . get_topics ( 2 )Notas avançadas: a TM combinada combina o arco com Sbert, um processo que parece aumentar a coerência dos tópicos previstos (https://arxiv.org/pdf/2004.03974.pdf).
Nosso ZerosHottm pode ser usado para modelagem de tópicos com tiro zero. Pode lidar com palavras que não são usadas durante a fase de treinamento. Mais interessante, esse modelo pode ser usado para modelagem de tópicos cruzados (consulte as próximas seções)! Veja o artigo (https://www.aclweb.org/anthology/2021.eacl-main.143)
from contextualized_topic_models . models . ctm import ZeroShotTM
from contextualized_topic_models . utils . data_preparation import TopicModelDataPreparation
from contextualized_topic_models . utils . data_preparation import bert_embeddings_from_file
text_for_contextual = [
"hello, this is unpreprocessed text you can give to the model" ,
"have fun with our topic model" ,
]
text_for_bow = [
"hello unpreprocessed give model" ,
"fun topic model" ,
]
qt = TopicModelDataPreparation ( "paraphrase-multilingual-mpnet-base-v2" )
training_dataset = qt . fit ( text_for_contextual = text_for_contextual , text_for_bow = text_for_bow )
ctm = ZeroShotTM ( bow_size = len ( qt . vocab ), contextual_size = 768 , n_components = 50 )
ctm . fit ( training_dataset ) # run the model
ctm . get_topics ( 2 )Como você pode ver, a API de alto nível para lidar com o texto é muito fácil de usar; text_for_bert deve ser usado para passar para o modelo uma lista de documentos que não são pré -processados. Em vez disso, para text_for_bow, você deve passar no texto pré -processado usado para construir o arco.
Notas avançadas: Dessa maneira, o SBERT pode usar todas as informações do texto para gerar as representações.
Depois que o modelo é treinado, é muito fácil obter os tópicos!
ctm . get_topics ()O método de transformação cuidará da maioria das coisas para você, por exemplo, a geração de um arco correspondente, considerando apenas as palavras que o modelo viu no treinamento. No entanto, isso vem com alguns solavancos ao lidar com o ZerosHottm, como se o SE na próxima seção.
Você pode, no entanto, carregar manualmente as incorporações, se quiser (consulte a parte avançada desta documentação).
Se você usar o combinado, precisará incluir o texto do teste para o arco:
testing_dataset = qt . transform ( text_for_contextual = testing_text_for_contextual , text_for_bow = testing_text_for_bow )
# n_sample how many times to sample the distribution (see the doc)
ctm . get_doc_topic_distribution ( testing_dataset , n_samples = 20 ) # returns a (n_documents, n_topics) matrix with the topic distribution of each documentSe você usar o ZerosHottm, não precisará usar o teste_text_for_bow, porque se estiver usando um conjunto diferente de documentos de teste, isso criará um arco de um tamanho diferente. Assim, a melhor maneira de fazer isso é passar apenas o texto que será fornecido na entrada do modelo contexual:
testing_dataset = qt . transform ( text_for_contextual = testing_text_for_contextual )
# n_sample how many times to sample the distribution (see the doc)
ctm . get_doc_topic_distribution ( testing_dataset , n_samples = 20 )Depois de treinar o modelo ZerosHottm com incorporações multilíngues, você pode usar este pipeline simples para prever os tópicos para documentos em um idioma diferente (desde que esse idioma seja coberto por parafrase-multilingual-mPNet-Base-V2 ).
# here we have a Spanish document
testing_text_for_contextual = [
"hola, bienvenido" ,
]
# since we are doing multilingual topic modeling, we do not need the BoW in
# ZeroShotTM when doing cross-lingual experiments (it does not make sense, since we trained with an english Bow
# to use the spanish BoW)
testing_dataset = qt . transform ( testing_text_for_contextual )
# n_sample how many times to sample the distribution (see the doc)
ctm . get_doc_topic_distribution ( testing_dataset , n_samples = 20 ) # returns a (n_documents, n_topics) matrix with the topic distribution of each documentNotas avançadas: não precisamos passar pelo saco de palavras espanholas: o saco de palavras dos dois idiomas não será comparável! Estamos passando para o modelo por razões de compatibilidade, mas você não pode obter a saída do modelo (ou seja, o arco previsto do idioma treinado) e compará -lo com o idioma de teste um.
Você precisa de um script rápido para executar o pipeline de pré -processamento? Temos você coberto! Carregue seus documentos e use nossa classe SimplePreprocessing. Ele filtrará automaticamente palavras frequentes e removerá documentos vazios após o treinamento. O método de pré -processamento retornará os documentos pré -processados e não processados. Geralmente, usamos o não procedido para Bert e o pré -processado para o saco de palavras.
from contextualized_topic_models . utils . preprocessing import WhiteSpacePreprocessing
documents = [ line . strip () for line in open ( "unpreprocessed_documents.txt" ). readlines ()]
sp = WhiteSpacePreprocessing ( documents , "english" )
preprocessed_documents , unpreprocessed_corpus , vocab , retained_indices = sp . preprocess ()Você tem incorporações personalizadas e deseja usá -las para obter resultados mais rápidos? Apenas dê -os a Kitty!
from contextualized_topic_models . models . kitty_classifier import Kitty
import numpy as np
# read the training data
training_data = list ( map ( lambda x : x . strip (), open ( "train_data" ). readlines ()))
custom_embeddings = np . load ( 'custom_embeddings.npy' )
kt = Kitty ()
kt . train ( training_data , custom_embeddings = custom_embeddings , stopwords_list = [ "stopwords" ])
print ( kt . pretty_print_word_classes ())Nota: As incorporações personalizadas devem ser Numpy.Arrays.
Este pacote foi criado com Cookiecutter e o modelo de projeto Audreyr/Cookiecutter-Pypackage. Para facilitar o uso da biblioteca, também incluímos o pacote RBO, todos os direitos reservados ao autor desse pacote.
Lembre -se de que esta é uma ferramenta de pesquisa :)
