OCTIS
1.0.0
OCTIS (Octis (optimizar y comparar modelos de tema es simple) tiene como objetivo capacitar, analizar y comparar modelos de temas, cuyos hiperparámetros óptimos se estiman mediante un enfoque de optimización bayesiana. Este trabajo ha sido aceptado en la pista de demostración de EACL2021. ¡Haga clic para leer el documento!
Tabla de contenido
Puede instalar Octis con el siguiente comando:
PIP install Octis
Puede encontrar los requisitos en el archivo requisitos.txt.
Para comprender fácilmente cómo usar Octis, lo invitamos a probar nuestros tutoriales :)
| Nombre | Enlace |
|---|---|
| Cómo construir un modelo de tema y evaluar los resultados (LDA en 20NewsGroups) | |
| Cómo optimizar los hiperparámetros de un modelo de tema neuronal (CTM en M10) |
Dos guías sobre cómo usar Octis con ejemplos prácticos:
Un tutorial sobre el tema modelado sobre las letras de las canciones:
Para cargar uno de los conjuntos de datos ya preprocesados de la siguiente manera:
from octis . dataset . dataset import Dataset
dataset = Dataset ()
dataset . fetch_dataset ( "20NewsGroup" )Simplemente use uno de los nombres del conjunto de datos enumerados a continuación. NOTA: ¡Es sensible a los casos!
| Nombre en Octis | Fuente | # Documentos | # Palabras | # Etiquetas | Idioma |
|---|---|---|---|---|---|
| 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 / A | italiano |
De lo contrario, puede cargar un conjunto de datos preprocesado personalizado de la siguiente manera:
from octis . dataset . dataset import Dataset
dataset = Dataset ()
dataset . load_custom_dataset_from_folder ( "../path/to/the/dataset/folder" )La partición puede ser "entrenar" para la partición de entrenamiento, "prueba" para probar la partición o "val" para la partición de validación. Aquí se puede encontrar un ejemplo de conjunto de datos: sample_dataset.
De manera similar a los conjuntos de datos TensorFlow y la biblioteca NLP de Huggingface, acabamos de descargar y preparar conjuntos de datos públicos. No alojamos ni distribuimos estos conjuntos de datos, respondemos por su calidad o equidad, ni afirmamos que tiene licencia para usar el conjunto de datos. Es su responsabilidad determinar si tiene permiso para usar el conjunto de datos bajo la licencia del conjunto de datos y citar al propietario correcto del conjunto de datos.
Si es propietario de un conjunto de datos y desea actualizar cualquier parte de él, o no desea que su conjunto de datos se incluya en esta biblioteca, póngase en contacto con un problema de GitHub.
Si es propietario de un conjunto de datos y desea incluir su conjunto de datos en esta biblioteca, póngase en contacto con un problema de GitHub.
Para preprocesar un conjunto de datos, importe la clase de preprocesamiento y use el 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 obtener más detalles sobre el preprocesamiento, consulte el ejemplo de demostración de preprocesamiento en la carpeta de ejemplos.
Para construir un modelo, cargue un conjunto de datos preprocesado, establezca los hiperparámetros del modelo y use train_model() para entrenar el 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 modelSi el conjunto de datos está dividido, puede:
| Nombre | Implementación |
|---|---|
| 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://radimrehurek.com/gensim/ |
| LDA (Blei et al. 2003) | https://radimrehurek.com/gensim/ |
| LSI (Landauer et al. 1998) | https://radimrehurek.com/gensim/ |
| NMF (Lee y Seung 2000) | https://radimrehurek.com/gensim/ |
| Neurallda (Srivastava y Sutton 2017) | https://github.com/estebandito22/pytorchavitm |
| Prodlda (Srivastava y Sutton 2017) | https://github.com/estebandito22/pytorchavitm |
Si usa una de estas implementaciones, asegúrese de citar el documento correcto.
Si implementó un modelo y desea actualizar cualquier parte de él, o no desea que su modelo se incluya en esta biblioteca, póngase en contacto con un problema de GitHub.
Si implementó un modelo y desea incluir su modelo en esta biblioteca, póngase en contacto con un problema de GitHub. De lo contrario, si desea incluir el modelo usted mismo, consulte la siguiente sección.
Para evaluar un modelo, elija una métrica y use el método score() de la clase 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 clasificación :
- F1-Puntore:
F1Score(dataset)- Precisión:
PrecisionScore(dataset)- Recuerdo:
RecallScore(dataset)- Precisión:
AccuracyScore(dataset)
Métricas de coherencia :
- Coherencia de UMass:
Coherence(measure='u_mass')- C_V Coherence:
Coherence(measure='c_v')- UCI Coherence:
Coherence(measure='c_uci')- Coherencia NPMI:
Coherence(measure='c_npmi')- Coherencia basada en la incrustación de palabras por pares:
WECoherencePairwise()- Centroide de coherencia basado en Word Baseding:
WECoherenceCentroid()
Métricas de diversidad :
- Diversidad de temas:
TopicDiversity()- Invertedrbo:
InvertedRBO()- Partidos invertidos basados en la incrustación de palabras:
WordEmbeddingsInvertedRBO()- Centroid invertedrbo basado en Word Inverting:
WordEmbeddingsInvertedRBOCentroid()- Log Wodds Ratio:
LogOddsRatio()- Divergencia de Kullback-Liebler:
KLDivergence()
Métricas de similitud :
- Superposición de sesgo de clasificación:
RBO()- Partidos de RBO basados en la incrustación de Word:
WordEmbeddingsRBOMatch()- Centroid RBO basado en la incrustación de Word:
WordEmbeddingsRBOCentroid()- Similitud por pares basadas en incrustaciones de palabras:
WordEmbeddingsPairwiseSimilarity()- Similitud centralide basada en incrustaciones de palabras:
WordEmbeddingsCentroidSimilarity()- Similitud de suma ponderada basada en incrustaciones de palabras:
WordEmbeddingsWeightedSumSimilarity()- Similitud de Jaccard por pares:
PairwiseJaccardSimilarity()
Métricas de importancia del tema :
- Uniforme KL:
KL_uniform()- KL vacío:
KL_vacuous()- Antecedentes de KL:
KL_background()
Los modelos heredan de la clase AbstractModel definida en Octis/Models/Model.py. Para construir su propio modelo, su clase debe anular el método Train_Model (Self, DataSet, Hyperparameters) que siempre requiere al menos un objeto de conjunto de datos y un diccionario de hiperparámetros como entrada y debe devolver un diccionario con la salida del modelo como salida.
Para comprender mejor cómo funciona un modelo, echemos un vistazo a la implementación de LDA. El primer paso para desarrollar un modelo personalizado es definir el diccionario de los valores de hiperparámetros predeterminados:
hyperparameters = { 'corpus' : None , 'num_topics' : 100 , 'id2word' : None , 'alpha' : 'symmetric' ,
'eta' : None , # ...
'callbacks' : None }La definición de los valores de hiperparámetros predeterminados permite a los usuarios trabajar en un subconjunto de ellos sin tener que asignar un valor a cada parámetro.
El siguiente paso es la anulación de Train_Model ():
def train_model ( self , dataset , hyperparameters = {}, top_words = 10 ):El método LDA requiere un conjunto de datos, el diccionario HyperParameters y un argumento adicional (opcional) utilizado para seleccionar cuántas de las palabras más significativas rastrean para cada tema.
Con los valores predeterminados de HyperParameters, los que están en entrada y el conjunto de datos, debe poder escribir su propio código y devolver como salida de un diccionario con al menos 3 entradas:
Si su modelo admite la partición de capacitación/prueba, también debe regresar:
Para optimizar un modelo, debe seleccionar un conjunto de datos, una métrica y el espacio de búsqueda de los hiperparámetros para optimizar. Para los tipos de hiperparámetros, utilizamos 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" )El resultado proporcionará el mejor valor de la métrica con la configuración del hiperparameter correspondiente y los hiperparámetros y el valor métrico para cada iteración de la optimización. Para visualizar esta información, debe establecer el atributo 'trazar' de Bayesian_optimization en verdadero.
Puede encontrar más aquí: Optimizer ReadMe
OCTIS incluye una interfaz gráfica fácil de usar para crear, monitorear y ver experimentos. Siguiendo los estándares de implementación de conjuntos de datos, modelos y métricas, el tablero actualizará automáticamente y le permitirá usar sus propias implementaciones personalizadas.
Para ejecutar el tablero necesitas clonar el repositorio. Mientras que en el directorio del proyecto ejecuta el siguiente comando:
python OCTIS/dashboard/server.pyEl navegador se abrirá y será redirigido al tablero. En el tablero puedes:
¡Este trabajo ha sido aceptado en la pista de demostración de EACL 2021! ¡Haga clic para leer el documento! Si decide usar este recurso, cite:
@InProcedings {Terragni2020Octis,
title = {{octis}: Comparar y optimizar los modelos de temas es simple!},
Autor = {Terragni, Silvia y Fersini, Elisabetta y Galuzzi, Bruno Giovanni y Tropeo, Pietro y Candelieri, Antonio},
año = {2021},
booktitle = {Actas de la 16ª Conferencia del Capítulo Europeo de la Asociación de Lingüística Computacional: Demostraciones del sistema},
mes = APR,
año = "2021",
Publisher = "Asociación de Lingüística Computacional",
url = "https://www.aclweb.org/anthology/2021.eacl-demos.31",
páginas = "263--270",
}
@InProcedings {dblp: conf/clic-it/terragnif21,
Autor = {Silvia Terragni y Elisabetta Fersini},
editor = {Elisabetta Fersini y Marco Passarotti y Viviana Patti},
title = {{Octis 2.0: Optimizar y comparar modelos de temas en italiano es incluso
Más simple!}},
booktitle = {Actas de la octava conferencia italiana sobre lingüística computacional,
CLIC-IT 2021, Milán, Italia, 26-28 de enero de 2022},
serie = {{ceur} Actas del taller},
volumen = {3033},
editor = {ceur-ws.org},
año = {2021},
url = {http://ceur-w.org/vol-3033/paper55.pdf},
}
Este paquete fue creado con Cookiecutter y la plantilla del proyecto Audreyr/Cookiecutter-Pypackage. Gracias a todos los desarrolladores que publicaron las implementaciones de sus modelos de tema. Un agradecimiento especial a Tenggaard, quien nos ayudó a encontrar muchos errores a principios de octis y a Emil Rijcken, quien amablemente escribió dos guías sobre cómo usar Octis :)
