OCTIS
1.0.0
O Octis (otimizar e comparar modelos de tópicos é simples) visa treinar, analisar e comparar modelos de tópicos, cujos hiperparâmetros ideais são estimados por meio de uma abordagem de otimização bayesiana. Este trabalho foi aceito na faixa de demonstração do EACL2021. Clique para ler o artigo!
Índice
Você pode instalar o Octis com o seguinte comando:
pip install Octis
Você pode encontrar os requisitos no arquivo requisitos.txt.
Para entender facilmente como usar o Octis, convidamos você a experimentar nossos tutoriais :)
| Nome | Link |
|---|---|
| Como construir um modelo de tópico e avaliar os resultados (LDA no 20NewsGroups) | |
| Como otimizar os hiperparâmetros de um modelo de tópico neural (CTM no M10) |
Dois guias sobre como usar o Octis com exemplos práticos:
Um tutorial sobre modelagem de tópicos nas letras de músicas:
Para carregar um dos conjuntos de dados já pré -processados da seguinte forma:
from octis . dataset . dataset import Dataset
dataset = Dataset ()
dataset . fetch_dataset ( "20NewsGroup" )Basta usar um dos nomes do conjunto de dados listados abaixo. NOTA: É sensível ao minúsculo!
| Nome em Octis | Fonte | # Docs | # Palavras | # Rótulos | Linguagem |
|---|---|---|---|---|---|
| 20NewsGroup | 20NewsGroup | 16309 | 1612 | 20 | Inglês |
| Bbc_news | BBC-News | 2225 | 2949 | 5 | Inglês |
| Dblp | Dblp | 54595 | 1513 | 4 | Inglês |
| M10 | M10 | 8355 | 1696 | 10 | Inglês |
| Dbpedia_it | Dbpedia_it | 4251 | 2047 | 5 | italiano |
| Europarl_it | Europarl_it | 3613 | 2000 | N / D | italiano |
Caso contrário, você pode carregar um conjunto de dados pré -processado personalizado da seguinte maneira:
from octis . dataset . dataset import Dataset
dataset = Dataset ()
dataset . load_custom_dataset_from_folder ( "../path/to/the/dataset/folder" )A partição pode ser "trem" para a partição de treinamento, "teste" para testar a partição, ou "val" para a partição de validação. Um exemplo de conjunto de dados pode ser encontrado aqui: sample_dataset.
Da mesma forma que os conjuntos de dados do TensorFlow e a biblioteca NLP da HuggingFace, acabamos de baixar e preparamos conjuntos de dados públicos. Não hospedamos ou distribuímos esses conjuntos de dados, atestamos sua qualidade ou justiça ou afirmamos que você tem licença para usar o conjunto de dados. É de sua responsabilidade determinar se você tem permissão para usar o conjunto de dados na licença do conjunto de dados e citar o proprietário certo do conjunto de dados.
Se você é proprietário do conjunto de dados e deseja atualizar qualquer parte dele ou não deseja que seu conjunto de dados seja incluído nesta biblioteca, entre em contato com um problema do GitHub.
Se você é proprietário do conjunto de dados e deseja incluir seu conjunto de dados nesta biblioteca, entre em contato com um problema do Github.
Para pré -processar um conjunto de dados, importe a classe de pré -processamento e use o método preprocess_dataset.
import os
import string
from octis . preprocessing . preprocessing import Preprocessing
os . chdir ( os . path . pardir )
# Initialize preprocessing
preprocessor = Preprocessing ( vocabulary = None , max_features = None ,
remove_punctuation = True , punctuation = string . punctuation ,
lemmatize = True , stopword_list = 'english' ,
min_chars = 1 , min_words_docs = 0 )
# preprocess
dataset = preprocessor . preprocess_dataset ( documents_path = r'..corpus.txt' , labels_path = r'..labels.txt' )
# save the preprocessed dataset
dataset . save ( 'hello_dataset' )Para obter mais detalhes sobre o pré -processamento, consulte o exemplo de demonstração de pré -processamento na pasta Exemplos.
Para construir um modelo, carregue um conjunto de dados pré -processado, defina o modelo Hyperparameters e use train_model() para treinar o modelo.
from octis . dataset . dataset import Dataset
from octis . models . LDA import LDA
# Load a dataset
dataset = Dataset ()
dataset . load_custom_dataset_from_folder ( "dataset_folder" )
model = LDA ( num_topics = 25 ) # Create model
model_output = model . train_model ( dataset ) # Train the modelSe o conjunto de dados for particionado, você pode:
| Nome | Implementação |
|---|---|
| CTM (Bianchi et al. 2021) | https://github.com/milanlproc/contextualized-topic-models |
| ETM (Dieng et al. 2020) | https://github.com/adjidieng/etm |
| HDP (Blei et al. 2004) | https://radiMreturek.com/gensim/ |
| LDA (Blei et al. 2003) | https://radiMreturek.com/gensim/ |
| LSI (Landauer et al. 1998) | https://radiMreturek.com/gensim/ |
| NMF (Lee e Seung 2000) | https://radiMreturek.com/gensim/ |
| Neurallda (Srivastava e Sutton 2017) | https://github.com/estebandito22/pytorchavitm |
| Prodlda (Srivastava e Sutton 2017) | https://github.com/estebandito22/pytorchavitm |
Se você usar uma dessas implementações, cite o papel certo.
Se você implementou um modelo e deseja atualizar qualquer parte dele, ou não deseja que seu modelo seja incluído nesta biblioteca, entre em contato com um problema do GitHub.
Se você implementou um modelo e deseja incluir seu modelo nesta biblioteca, entre em contato através de um problema do GitHub. Caso contrário, se você deseja incluir o modelo sozinho, consulte a seção a seguir.
Para avaliar um modelo, escolha uma métrica e use o método score() da classe métrica.
from octis . evaluation_metrics . diversity_metrics import TopicDiversity
metric = TopicDiversity ( topk = 10 ) # Initialize metric
topic_diversity_score = metric . score ( model_output ) # Compute score of the metricMétricas de classificação :
- F1-Score:
F1Score(dataset)- Precisão:
PrecisionScore(dataset)- Lembre -se:
RecallScore(dataset)- Precisão:
AccuracyScore(dataset)
Métricas de coerência :
- Coerência UMass:
Coherence(measure='u_mass')- Coerência c_v:
Coherence(measure='c_v')- Coerência UCI:
Coherence(measure='c_uci')- Coerência NPMI:
Coherence(measure='c_npmi')- Coerência de incorporação de palavras pareadas:
WECoherencePairwise()- Centroid de coerência baseada em palavras:
WECoherenceCentroid()
Métricas de diversidade :
- Diversidade de tópicos:
TopicDiversity()- Invertedrbo:
InvertedRBO()- Invertedrbo, baseado em incorporação de palavras:
WordEmbeddingsInvertedRBO()- Word incorporando Invertedrbo Centroid:
WordEmbeddingsInvertedRBOCentroid()- Odds ratio:
LogOddsRatio()- Divergência Kullback-Liebler:
KLDivergence()
Métricas de similaridade :
- Sobreposição com tendenciosas classificadas:
RBO()- Matches RBO baseados em incorporação de palavras:
WordEmbeddingsRBOMatch()- RBO Centroid baseado em palavras:
WordEmbeddingsRBOCentroid()- Similaridade pareada baseada em incorporação de palavras:
WordEmbeddingsPairwiseSimilarity()- A similaridade centróide baseada em incorporação de palavras:
WordEmbeddingsCentroidSimilarity()- Similaridade da soma ponderada baseada em incorporação de palavras:
WordEmbeddingsWeightedSumSimilarity()- Similaridade Jaccard em pares:
PairwiseJaccardSimilarity()
Métricas de significância do tópico :
- Uniforme KL:
KL_uniform()- KL VACOUSE:
KL_vacuous()- KL Background:
KL_background()
Os modelos herdados da classe AbstractModel definidos em octis/modelos/model.py. Para construir seu próprio modelo, sua classe deve substituir o método Train_model (self, conjunto de dados, hiperparâmetros), que sempre requer pelo menos um objeto de conjunto de dados e um dicionário de hiperparâmetros como entrada e deve retornar um dicionário com a saída do modelo como saída.
Para entender melhor como um modelo funciona, vamos dar uma olhada na implementação do LDA. A primeira etapa no desenvolvimento de um modelo personalizado é definir o dicionário de valores de hiperparâmetros padrão:
hyperparameters = { 'corpus' : None , 'num_topics' : 100 , 'id2word' : None , 'alpha' : 'symmetric' ,
'eta' : None , # ...
'callbacks' : None }Definir os valores de hiperparâmetros padrão permite que os usuários trabalhem em um subconjunto deles sem precisar atribuir um valor a cada parâmetro.
A etapa a seguir é a substituição de trens_model ():
def train_model ( self , dataset , hyperparameters = {}, top_words = 10 ):O método LDA requer um conjunto de dados, o dicionário de hiperparâmetros e um argumento extra (opcional) usado para selecionar quantas das palavras mais significativas rastreiam para cada tópico.
Com os padrões de hyperparameters, os de entrada e o conjunto de dados, você poderá escrever seu próprio código e retornar como saída de um dicionário com pelo menos 3 entradas:
Se o seu modelo suportar a partição de treinamento/teste, ele também deve retornar:
Para otimizar um modelo, você precisa selecionar um conjunto de dados, uma métrica e o espaço de pesquisa dos hiperparâmetros para otimizar. Para os tipos de hyperparameters, usamos tipos scikit-optimize (https://scikit-optimize.github.io/stable/modules/space.html)
from octis . optimization . optimizer import Optimizer
from skopt . space . space import Real
# Define the search space. To see which hyperparameters to optimize, see the topic model's initialization signature
search_space = { "alpha" : Real ( low = 0.001 , high = 5.0 ), "eta" : Real ( low = 0.001 , high = 5.0 )}
# Initialize an optimizer object and start the optimization.
optimizer = Optimizer ()
optResult = optimizer . optimize ( model , dataset , eval_metric , search_space , save_path = "../results" # path to store the results
number_of_call = 30 , # number of optimization iterations
model_runs = 5 ) # number of runs of the topic model
#save the results of th optimization in a csv file
optResult . save_to_csv ( "results.csv" )O resultado fornecerá o valor mais bem-visto da métrica com a configuração correspondente de hiperparâmetro e os hiperparâmetros e o valor métrico para cada iteração da otimização. Para visualizar essas informações, você deve definir o atributo 'plot' da Bayesian_Otimization como TRUE.
Você pode encontrar mais aqui: Otimizer ReadMe
O Octis inclui uma interface gráfica amigável para criar, monitorar e visualizar experimentos. Seguindo os padrões de implementação dos conjuntos de dados, modelos e métricas, o painel atualizará e permitirá que você use suas próprias implementações personalizadas.
Para executar o painel, você precisa clonar o repositório. Enquanto estiver no diretório do projeto, execute o seguinte comando:
python OCTIS/dashboard/server.pyO navegador será aberto e você será redirecionado para o painel. No painel que você pode:
Este trabalho foi aceito na faixa de demonstração do EACL 2021! Clique para ler o artigo! Se você decidir usar este recurso, cite:
@InProedingings {TerraGni2020octis,
Title = {{Octis}: Comparar e otimizar modelos de tópicos é simples!},
Autor = {Terragni, Silvia e Fersini, Elisabetta e Galuzzi, Bruno Giovanni e Tropeno, Pietro e Candelieri, Antonio},
ano = {2021},
booktitle = {Anais da 16ª Conferência do Capítulo Europeu da Associação de Linguística Computacional: Demonstrações do Sistema},
mês = abril,
ano = "2021",
publisher = "Association for Computational Linguistics",
url = "https://www.aclweb.org/anthology/2021.eacl-dmos.31",
páginas = "263--270",
}
@InProedings {dblp: conf/clic-it/TerraGnif21,
autor = {Silvia Terragni e Elisabetta Fersini},
Editor = {Elisabetta Fersini e Marco Passarotti e Viviana Patti},
title = {{Octis 2.0: otimizar e comparar modelos de tópicos em italiano é uniforme
Mais simples!}},
booktitle = {Anais da Oitava Conferência Italiana sobre Linguística Computacional,
Clic-it 2021, Milão, Itália, 26 a 28 de janeiro de 2022},
Série = {{CEUR} Workshop Proceedings},
volume = {3033},
editor = {ceur-ws.org},
ano = {2021},
url = {http://ceur-ws.org/vol-3033/paper55.pdf},
}
Este pacote foi criado com Cookiecutter e o modelo de projeto Audreyr/Cookiecutter-Pypackage. Graças a todos os desenvolvedores que lançaram as implementações de seus modelos de tópicos. Um agradecimento especial a Tenggaard, que nos ajudou a encontrar muitos bugs nos lançamentos de Octis e Emil Rijcken, que gentilmente escreveu dois guias sobre como usar o Octis :)
