Inicio>Relacionado con la programación>Otro código fuente
Descargar

tomotopía

Inglés , 한국어.

¿Qué es la tomotopia?

Tomotopy es una extensión de Python de Tomoto (herramienta de modelado de temas) que es una biblioteca de modelos de temas basada en el muestreo de Gibbs escrita en C ++. Utiliza una vectorización de las CPU modernas para maximizar la velocidad. La versión actual de Tomoto admite varios modelos de temas principales que incluyen

  • Asignación latente de Dirichlet (Tomotopy.Damodel)
  • LDA etiquetado (Tomotopy.lldamodel)
  • LDA parcialmente etiquetado (Tomotopy.ldamodel)
  • LDA supervisado (Tomotopy.Sldamodel)
  • Regresión multinomial de Dirichlet (tomotopy.dmrmodel)
  • Regresión multinomial generalizada de Dirichlet (tomotopy.gdmrmodel)
  • Proceso jerárquico de Dirichlet (Tomotopy.hdpModel)
  • LDA jerárquico (Tomotopy.hldamodel)
  • LDA de múltiples grano (tomotopy.mgldamodel)
  • Asignación de Pachinko (Tomotopy.Pamodel)
  • PA jerárquico (tomotopy.hpamodel)
  • Modelo de tema correlacionado (tomotopy.ctmodel)
  • Modelo de temas dinámicos (tomotopy.dtmodel)
  • Modelo de tema basado en pseudo-documento (Tomotopy.PtModel).

Visite https://bab2min.github.io/tomotopy para ver más información.

Empezando

Puede instalar tomotopia fácilmente usando PIP. (https://pypi.org/project/tomotopy/)

 $ PIP Install -Upgrade Pip
$ Pip Instalar Tomotopia

Las versiones compatibles con OS y Python son:

  • Linux (x86-64) con Python> = 3.6
  • macOS> = 10.13 con Python> = 3.6
  • Windows 7 o posterior (x86, x86-64) con Python> = 3.6
  • Otro sistema operativo con python> = 3.6: compilación del código fuente requerido (con C ++ 14 compilador compatible)

Después de instalar, puede iniciar tomotopia simplemente importando.

 Importar tomotopia como TP
print (tp.isa) # prints 'avx2', 'avx', 'sse2' o 'none'

Actualmente, la tomotopia puede explotar las instrucciones AVX2, AVX o SSE2 SIMD establecidas para maximizar el rendimiento. Cuando se importa el paquete, verificará los conjuntos de instrucciones disponibles y seleccionará la mejor opción. Si TP.ISA no dice nada, las iteraciones de entrenamiento pueden llevar mucho tiempo. Pero, dado que la mayoría de las CPU Modern Intel o AMD proporcionan un conjunto de instrucciones SIMD, la aceleración SIMD podría mostrar una gran mejora.

Aquí hay un código de muestra para el entrenamiento LDA simple de textos del archivo 'sample.txt'.

 Importar tomotopia como TP
mdl = tp.ldamodel (k = 20)
Para línea en Open ('sample.txt'):
    mdl.add_doc (line.strip (). Split ())

para i en el rango (0, 100, 10):
    mdl.train (10)
    print ('iteración: {}  tlog-likelihood: {}'. Format (i, mdl.ll_per_word)))

para k en el rango (mdl.k):
    Imprimir ('Las 10 palabras principales del tema #{}'. Format (k))
    print (mdl.get_topic_words (k, top_n = 10))

mdl.summary ()

Rendimiento de la tomotopia

Tomotopy utiliza muestreo colapsado de Gibbs (CGS) para inferir la distribución de temas y la distribución de palabras. En general, CGS converge más lentamente que los Bayes variacionales (VB) que usa el ldamodelo de Gensim, pero su iteración se puede calcular mucho más rápido. Además, la tomotopia puede aprovechar las CPU multinúcleo con un conjunto de instrucciones SIMD, que puede dar lugar a iteraciones más rápidas.

El siguiente cuadro muestra la comparación del tiempo de ejecución del modelo LDA entre Tomotopy y Gensim. Los datos de entrada constan de 1000 documentos aleatorios de Wikipedia en inglés con 1,506,966 palabras (aproximadamente 10.1 MB). Tomotopy entrena 200 iteraciones y gensim entrena 10 iteraciones.

Rendimiento en Intel i5-6600, x86-64 (4 núcleos)

Rendimiento en Intel Xeon E5-2620 V4, x86-64 (8 núcleos, 16 hilos)

Aunque la tomotopia iteró 20 veces más, el tiempo de ejecución general fue 5 ~ 10 veces más rápido que Gensim. Y produce un resultado estable.

Es difícil comparar CGS y VB directamente porque son técnicas totalmente diferentes. Pero desde un punto de vista práctico, podemos comparar la velocidad y el resultado entre ellos. El siguiente cuadro muestra la verificación log-Likelilio por palabra de los dos modelos.

El conjunto de instrucciones SIMD tiene un gran efecto en el rendimiento. La siguiente es una comparación entre conjuntos de instrucciones SIMD.

Afortunadamente, la mayoría de las CPU X86-64 recientes proporcionan un conjunto de instrucciones AVX2, por lo que podemos disfrutar del rendimiento de AVX2.

Guardar y carga del modelo

Tomotopy proporciona método de guardado y carga para cada clase de modelo de tema, por lo que puede guardar el modelo en el archivo cuando lo desee, y volver a cargarlo desde el archivo.

 Importar tomotopia como TP

mdl = tp.hdpmodel ()
Para línea en Open ('sample.txt'):
    mdl.add_doc (line.strip (). Split ())

para i en el rango (0, 100, 10):
    mdl.train (10)
    print ('iteración: {}  tlog-likelihood: {}'. Format (i, mdl.ll_per_word)))

# Guardar en el archivo
mdl.save ('sample_hdp_model.bin')

# Cargar desde el archivo
mdl = tp.hdpmodel.load ('sample_hdp_model.bin')
para k en el rango (mdl.k):
    Si no es mdl.is_live_topic (k): continuar
    Imprimir ('Las 10 palabras principales del tema #{}'. Format (k))
    print (mdl.get_topic_words (k, top_n = 10))

# El modelo guardado es el modelo HDP,
# Entonces, cuando lo cargue por modelo LDA, planteará una excepción
mdl = tp.ldamodel.load ('sample_hdp_model.bin')

Cuando carga el modelo desde un archivo, un tipo de modelo en el archivo debe coincidir con la clase de métodos.

Vea más en Tomotopy.ldamodel.Save y Tomotopy.ldamodel.Load Methods.

Visor de modelos interactivo

interactive_model_viewer_demo.mp4

Puede ver el resultado del modelado utilizando el visor interactivo desde V0.13.0.

 Importar tomotopia como TP
modelo = tp.ldamodel (...)
# ... algunos códigos de entrenamiento ...
tp.viewer.open_viewer (modelo, host = "localhost", puerto = 9999)
# Y abra http: // localhost: 9999 en su navegador web!

Si tiene un archivo de modelo guardado, también puede usar la siguiente línea de comando.

 Python -M Tomotopy.viewer A_Trained_Model.Bin --host localhost --port 9999

Ver más en el módulo Tomotopy.Viewer.

Documentos en el modelo y fuera del modelo

Podemos usar el modelo de tema para dos propósitos principales. El básico es descubrir temas de un conjunto de documentos como resultado del modelo capacitado, y el más avanzado es inferir distribuciones de temas para documentos invisibles mediante el uso del modelo capacitado.

Llamamos el documento en el propósito anterior (utilizado para la capacitación de modelos) como documento en el modelo , y el documento en el propósito posterior (documento invisible durante la capacitación) como documento fuera del modelo .

En la tomotopia, estos dos tipos diferentes de documentos se generan de manera diferente. Un documento en el modelo puede ser creado por el método Tomotopy.ldamodel.add_doc. ADD_DOC se puede llamar antes de Tomotopy.ldamodel.rain comienza. En otras palabras, después del tren llamado, ADD_DOC no puede agregar un documento al modelo porque el conjunto de documentos utilizados para la capacitación se ha solucionado.

Para adquirir la instancia del documento creado, debe usar tomotopy.ldamodel.docs como:

 mdl = tp.ldamodel (k = 20)
idx = mdl.add_doc (palabras)
Si IDX <0: Levante RunTimeError ("No se pudo agregar DOC")
doc_inst = mdl.docs [IDX]
# doc_inst es una instancia del documento agregado

Un documento fuera del modelo es generado por el método Tomotopy.ldamodel.make_doc. make_doc solo se puede llamar después de que comience el tren. Si usa make_doc antes de que se haya solucionado el conjunto de documentos utilizado para la capacitación, puede obtener resultados equivocados. Dado que Make_DOC devuelve la instancia directamente, puede usar su valor de retorno para otras manipulaciones.

 mdl = tp.ldamodel (k = 20)
# add_doc ...
mdl.train (100)
doc_inst = mdl.make_doc (unseen_doc) # doc_inst es una instancia del documento invisible

Inferencia por documentos invisibles

Si el modelo crea un nuevo documento.ldamodel.make_doc, el modelo puede inferir su distribución de temas. La inferencia para el documento invisible debe realizarse utilizando el método Tomotopy.ldamodel.Infer.

 mdl = tp.ldamodel (k = 20)
# add_doc ...
mdl.train (100)
doc_inst = mdl.make_doc (unseen_doc)
topic_dist, ll = mdl.infer (DOC_INST)
Imprimir ("Distribución de temas para documentos invisibles:", topic_dist)
Imprima ("Log-Likelilidad de inferencia:", LL)

El método inferir puede inferir solo una instancia de tomotopia. Documento o una lista de instancias de tomotopia. Ver más en Tomotopy.ldamodel.infer.

Corpus y transformar

Cada modelo de tema en Tomotopy tiene su propio tipo de documento interno. Se puede crear y agregar un documento adecuado para cada modelo a través del método ADD_DOC de cada modelo. Sin embargo, tratar de agregar la misma lista de documentos a diferentes modelos se vuelve bastante inconveniente, porque ADD_DOC debe llamarse a la misma lista de documentos a cada modelo diferente. Por lo tanto, la tomotopia proporciona la clase Tomotopy.utils.corpus que contiene una lista de documentos. tomotopy.utils.corpus se puede insertar en cualquier modelo pasando como cuerpo de argumentos al método __init__ o add_corpus de cada modelo. Por lo tanto, insertar tomotopy.utils.corpus solo tiene el mismo efecto para insertar documentos que posee el corpus.

Algunos modelos de temas requieren datos diferentes para sus documentos. Por ejemplo, Tomotopy.DMRModel requiere metadatos de argumento en el tipo STR, pero Tomotopy.ldamodel requiere etiquetas de argumentos en el tipo de lista [STR]. Dado que tomotopy.utils.corpus posee un conjunto independiente de documentos en lugar de estar vinculados a un modelo de tema específico, los tipos de datos requeridos por un modelo de tema pueden ser inconsistentes cuando se agrega un corpus a ese modelo de tema. En este caso, los datos misceláneos se pueden transformar para ser ajustados el modelo de tema objetivo utilizando la transformación de argumentos. Vea más detalles en el siguiente código:

 de Tomotopy Importación DMRModel
de Tomotopy.Utils Corpus de importación

Corpus = Corpus ()
corpus.add_doc ("abcde" .split (), a_data = 1)
corpus.add_doc ("efghi" .split (), a_data = 2)
corpus.add_doc ("ijklm" .split (), a_data = 3)

modelo = dmrmodel (k = 10)
Model.Add_Corpus (Corpus)
# Pierdes el campo 'a_data` en `corpus`,
# y `metadatos` que` dmrmodel` requiere está lleno del valor predeterminado, str.

afirmar model.docs [0] .metadata == ''
afirmar model.docs [1] .metadata == ''
afirmar model.docs [2] .metadata == ''

Def transform_a_data_to_metadata (misc: dict):
    return {'metadata': str (misc ['a_data'])}
# Esta función transforma `a_data` en` metadata`

modelo = dmrmodel (k = 10)
Model.Add_Corpus (Corpus, Transform = Transform_a_data_to_metadata)
# Ahora los documentos en `Model` tienen` metadata` no defactores, que se generan desde el campo 'a_data`.

afirmar model.docs [0] .metadata == '1'
afirmar model.docs [1] .metadata == '2'
afirmar model.docs [2] .metadata == '3'

Algoritmos de muestreo paralelo

Desde la versión 0.5.0, la tomotopía le permite elegir un algoritmo de paralelismo. El algoritmo proporcionado en versiones anteriores a 0.4.2 es copy_merge, que se proporciona para todos los modelos de temas. La nueva partición de algoritmo, disponible desde 0.5.0, hace que el entrenamiento sea generalmente más rápido y más eficiente en la memoria, pero está disponible en no todos los modelos de temas.

El siguiente cuadro muestra la diferencia de velocidad entre los dos algoritmos en función del número de temas y el número de trabajadores.

Rendimiento por versión

Los cambios de rendimiento por versión se muestran en el siguiente gráfico. Se midió el tiempo que lleva ejecutar el tren modelo LDA con 1000 iteración. (Documentos: 11314, Vocab: 60382, Palabras: 2364724, Intel Xeon Gold 5120 @2.2Ghz)

Temas de fijación de prioras de palabras

Desde la versión 0.6.0, se ha agregado un nuevo método tomotopy.ldamodel.set_word_prior. Le permite controlar la palabra anterior para cada tema. Por ejemplo, podemos establecer el peso de la palabra 'iglesia' en 1.0 en el tema 0, y el peso a 0.1 en el resto de los temas siguiendo los códigos. Esto significa que la probabilidad de que la palabra 'iglesia' se asigne al Tema 0 es 10 veces mayor que la probabilidad de ser asignada a otro tema. Por lo tanto, la mayor parte de la 'iglesia' se asigna al Tema 0, por lo que el Tema 0 contiene muchas palabras relacionadas con la 'Iglesia'. Esto permite manipular algunos temas para que se coloquen en un número de tema específico.

 Importar tomotopia como TP
mdl = tp.ldamodel (k = 20)

# Agregar documentos a `MDL`

# Palabra de configuración anterior
mdl.set_word_prior ('iglesia', [1.0 si k == 0 else 0.1 para k en el rango (20)])

Consulte Word_prior_example en Ejemplo.py para obtener más detalles.

Ejemplos

Puede encontrar un ejemplo de código de tomotopia Python en https://github.com/bab2min/tomotopy/blob/main/examples/.

También puede obtener el archivo de datos utilizado en el código de ejemplo en https://drive.google.com/file/d/18opnijd4iwpyyz2o7pqopyetakexa71j/view.

Licencia

Tomotopy tiene licencia bajo los términos de la licencia MIT, lo que significa que puede usarla para cualquier propósito razonable y permanecer en plena propiedad de toda la documentación que produzca.

Historia

  • 0.13.0 (2024-08-05)
    • Nuevas características
      • Las características principales del visor de modelos de temas Tomotopy.viewer.open_viewer () están listos ahora.
      • se agrega tomotopy.ldamodel.get_hash (). Puede obtener el valor hash de 128 bits del modelo.
      • Agregue un argumento ngram_list a tomotopy.utils.simpleTokenizer.
    • Correcciones de errores
      • Se corrigió un error de tramos inconsistente después de Corpus.concat_ngrams.
      • Optimizó el cuello de botella de Tomotopy.ldamodel.load () y Tomotopy.ldamodel.save () y mejoró su velocidad más de 10 veces.
  • 0.12.7 (2023-12-19)
    • Nuevas características
      • Visor de modelos de tema agregado Tomotopy.viewer.open_viewer ()
      • Optimizado el rendimiento de Tomotopy.utils.corpus.process ()
    • Correcciones de errores
      • Document.span ahora devuelve los rangos en la unidad de caracteres, no en la unidad de byte.
  • 0.12.6 (2023-12-11)
    • Nuevas características
      • Se agregó algunas características de conveniencia a Tomotopy.ldamodel.train y tomotopy.ldamodel.set_word_prior.
      • Ldamodel.train ahora tiene nuevos argumentos de devolución de llamada, devolución de llamada_interval y show_progres para monitorear el progreso de la capacitación.
      • Ldamodel.set_word_prior ahora puede aceptar el tipo de dict [int, float] como su argumento anterior.
  • 0.12.5 (2023-08-03)
    • Nuevas características
      • Soporte agregado para la arquitectura Linux ARM64.
  • 0.12.4 (2023-01-22)
    • Nuevas características
      • Soporte agregado para la arquitectura MACOS ARM64.
    • Correcciones de errores
      • Se solucionó un problema donde tomotopy.document.get_sub_topic_dist () plantea una mala excepción de argumentos.
      • Se solucionó un problema en el que el aumento de la excepción a veces causa accidentes.
  • 0.12.3 (2022-07-19)
    • Nuevas características
      • Ahora, insertar un documento vacío usando tomotopy.ldamodel.add_doc () simplemente lo ignora en lugar de plantear una excepción. Si el argumento recientemente agregado ignore_empty_words se establece en falso, se plantea una excepción como antes.
      • Tomotopy.hdpmodel.purge_dead_topics () se agrega para eliminar temas no vivos del modelo.
    • Correcciones de errores
      • Se solucionó un problema que evitaba establecer valores definidos por el usuario para NUSQ en Tomotopy.Sldamodel (por @JucEddrero).
      • Se solucionó un problema donde tomotopy.utils.coherence no funcionó para tomotopy.dtmodel.
      • Se solucionó un problema que a menudo se bloqueaba al llamar a Make_Dic () antes de llamar a Train ().
      • Resolvió el problema de que los resultados de Tomotopy.DMRModel y Tomotopy.gdmrModel son diferentes incluso cuando la semilla se fija.
      • Se ha mejorado el proceso de optimización de parámetros de Tomotopy.DMRModel y Tomotopy.gdMrModel.
      • Se solucionó un problema que a veces se bloqueaba al llamar a Tomotopy.ptModel.Copy ().
  • 0.12.2 (2021-09-06)
    • Un problema en el que llamar a Convert_To_Lda de Tomotopy.hdpModel con min_cf> 0, min_df> 0 o rm_top> 0 causa un bloqueo se ha solucionado.
    • Se agrega un nuevo argumento de_pseudo_doc a tomotopy.document.get_topics y tomotopy.document.get_topic_dist. Este argumento solo es válido para documentos de PTModel, permite controlar una fuente para calcular la distribución de temas.
    • Se ha cambiado un valor predeterminado para el argumento P de Tomotopy.PtModel. El nuevo valor predeterminado es K * 10.
    • El uso de documentos generados por make_doc sin llamar a Infer no causa un bloqueo ya, sino que simplemente imprima mensajes de advertencia.
    • Se ha solucionado un problema en el que el código C ++ interno no se compila en el entorno Clang C ++ 17.
  • 0.12.1 (2021-06-20)
    • Se ha solucionado un problema en el que Tomotopy.ldamodel.set_word_prior () causa un bloqueo.
    • Ahora tomotopy.ldamodel.perplexity y tomotopy.ldamodel.ll_per_word Devuelve el valor preciso cuando el peso de término no es uno.
    • se añadió tomoTopy.ldamodel.used_vocab_weuth_freq, que devuelve frecuencias de palabras ponderadas a términos.
    • Ahora Tomotopy.ldamodel.summary () muestra no solo la entropía de las palabras, sino también la entropía de las palabras ponderadas a términos.
  • 0.12.0 (2021-04-26)
    • Ahora tomoTopy.DMRModel y Tomotopy.gdmrmodel admite múltiples valores de metadatos (ver https://github.com/bab2min/tomotopy/blob/main/examples/dmr_multi_label.py)
    • Se mejoró el rendimiento de Tomotopy.gdmrmodel.
    • Se ha agregado un método Copy () para que todos los modelos temáticos hagan una copia profunda.
    • Se solucionó un problema cuando las palabras que están excluidas de la capacitación (por min_cf, min_df) tienen una identificación de tema incorrecta. Ahora todas las palabras excluidas tienen -1 como identificación del tema.
    • Ahora todas las excepciones y advertencias que generadas por la tomotopia siguen los tipos de pitón estándar.
    • Los requisitos del compilador se han elevado a C ++ 14.
  • 0.11.1 (2021-03-28)
    • Se solucionó un error crítico de alfas asimétricos. Debido a este error, la versión 0.11.0 se ha eliminado de los lanzamientos.
  • 0.11.0 (2021-03-26) (eliminado)
    • Se agregó un nuevo modelo de tema Tomotopy.PtModel para textos cortos al paquete.
    • Se solucionó un problema donde a veces tomotopia.hdpmodel.infer causa una falla de segmentación.
    • Se solucionó un desajuste de la versión de API numpy.
    • Ahora son compatibles con los antecedentes asimétricos de documento.
    • Se admite serialización de modelos de temas para bytes en la memoria.
    • Se agregó un argumento normalizado a get_topic_dist (), get_topic_word_dist () y get_sub_topic_dist () para controlar la normalización de los resultados.
    • Ahora tomotopy.dmrmodel.lambdas y tomotopy.dmrmodel.alpha da valores correctos.
    • Se agregaron soportes de metadatos categóricos para tomotopy.gdmrmodel (ver https://github.com/bab2min/tomotopy/blob/main/examples/gdmr_both_categorical_and_numerical.py).
    • El apoyo de Python3.5 fue eliminado.
  • 0.10.2 (2021-02-16)
    • Se solucionó un problema donde Tomotopy.CtModel.rain falla con K.
    • Se solucionó un problema donde Tomotopy.utils.corpus pierde sus valores de UID.
  • 0.10.1 (2021-02-14)
    • Se solucionó un problema donde tomotopy.utils.corpus.extract_ngrams abras con entrada vacía.
    • Se solucionó un problema donde Tomotopy.ldamodel.Infer aumenta la excepción con una entrada válida.
    • Se solucionó un problema donde Tomotopy.hldamodel.Infer genera Tomotopy Wrong.document.path.
    • Dado que se agregó un nuevo parámetro Freeze_Topics para Tomotopy.hldamodel.train, puede controlar si crear un nuevo tema o no cuando se capacita.
  • 0.10.0 (2020-12-19)
    • La interfaz de tomotopy.utils.corpus y de tomotopy.ldamodel.docs se unificó. Ahora puede acceder al documento en Corpus de la misma manera.
    • __getItem__ de tomotopy.utils.corpus se mejoró. No solo la indexación por INT, sino también por ITerable [int], se admiten cortes. También es compatible con la indexación por UID.
    • Nuevos métodos tomotopy.utils.corpus.extract_ngrams y tomotopy.utils.corpus.concat_ngrams. Extrae colocaciones N-Gram usando PMI y las concatena en una sola palabras.
    • Se agregó un nuevo método Tomotopy.ldamodel.add_corpus, y Tomotopy.ldamodel.Infer puede recibir el corpus como entrada.
    • Se agregó un nuevo módulo tomotopy.coherencia. Proporciona la forma de calcular la coherencia del modelo.
    • Se añadió una ventana de parámetro a Tomotopy.label.Forelevance.
    • Se solucionó un problema donde NAN a menudo ocurre al entrenar tomotopía.
    • Ahora Python3.9 es compatible.
    • Se eliminó una dependencia de Py-Cpuinfo y se mejoró la inicialización del módulo.
  • 0.9.1 (2020-08-08)
    • Se fijaron fugas de memoria de la versión 0.9.0.
    • Tomotopy.ctmodel.summary () fue fijo.
  • 0.9.0 (2020-08-04)
    • Se ha agregado el método Tomotopy.ldamodel.summary (), que imprime un resumen legible por humanos del modelo.
    • El generador de números aleatorios del paquete ha sido reemplazado por Eigenrand. Acelera la generación de números aleatorios y resuelve la diferencia de resultados entre las plataformas.
    • Debido a lo anterior, incluso si la semilla es la misma, el resultado del entrenamiento del modelo puede ser diferente de la versión antes de 0.9.0.
    • Se corrigió un error de entrenamiento en Tomotopy.hdpModel.
    • Tomotopy.dmrmodel.alpha ahora muestra Dirichlet Prior de la distribución de temas por documento por metadatos.
    • TOMOTOPY.DTMODEL.GET_COUNT_BY_TOPICS () se ha modificado para devolver un ndarray bidimensional.
    • Tomotopy.dtmodel.alpha se ha modificado para devolver el mismo valor que Tomotopy.dtmodel.get_alpha ().
    • Se solucionó un problema en el que no se podía obtener el valor de metadatos para el documento de tomotopía. GDMRMODEL.
    • Tomotopy.hldamodel.alpha ahora muestra Dirichlet Prior de la distribución de profundidad por documento.
    • se ha agregado tomotopy.ldamodel.global_step.
    • Tomotopy.mgldamodel.get_count_by_topics () ahora devuelve el recuento de palabras para temas globales y locales.
    • Tomotopy.pamodel.alpha, tomoTopy.pamodel.subalpha y tomotopy.pamodel.get_count_by_super_topic ().
  • 0.8.2 (2020-07-14)
    • Se han agregado nuevas propiedades Tomotopy.dtmodel.num_timePoints y tomotopy.dtmodel.num_docs_by_timePoint.
    • Un error que causa diferentes resultados con la plataforma diferente, incluso si las semillas fueran las mismas, se solucionó parcialmente. Como resultado de esta solución, ahora la tomotopia en 32 bits produce diferentes resultados de entrenamiento de la versión anterior.
  • 0.8.1 (2020-06-08)
    • Se solucionó un error donde Tomotopy.ldamodel.used_vocabs devolvió un valor incorrecto.
    • Ahora Tomotopy.ctmodel.prior_cov devuelve una matriz de covarianza con forma [k, k].
    • Ahora Tomotopy.ctmodel.get_correlations con argumentos vacíos devuelve una matriz de correlación con la forma [k, k].
  • 0.8.0 (2020-06-06)
    • Dado que Numpy se introdujo en la tomotopia, muchos métodos y propiedades de la tomoquía regresan no solo la lista, sino ahora numpy.ndarray ahora.
    • Tomotopy tiene una nueva dependencia numpy> = 1.10.0.
    • Se solucionó una estimación incorrecta de tomotopy.hdpmodel.infer.
    • Se agregó un nuevo método sobre la conversión de HDPModel a Ldamodel.
    • Nuevas propiedades que incluyen tomotopy.ldamodel.used_vocabs, tomotopy.ldamodel.used_vocab_freq y tomotopy.ldamodel.used_vocab_df se agregaron a los modelos temáticos.
    • Se agregó un nuevo modelo de tema G-DMR (Tomotopy.GDMRModel).
    • Se solucionó un error al inicializar Tomotopy.Label. Forelevance en macOS.
    • Se solucionó un error que ocurrió al usar tomotopy.utils.corpus creado sin parámetros sin procesar.
  • 0.7.1 (2020-05-08)
    • Tomotopy.document.path se agregó para Tomotopy.hldamodel.
    • Se solucionó un error de corrupción de memoria en Tomotopy.label.pmiextractor.
    • Se solucionó un error de compilación en GCC 7.
  • 0.7.0 (2020-04-18)
    • Tomotopy.dtmodel se agregó al paquete.
    • Se solucionó un error en tomotopy.utils.corpus.save.
    • Se agregó un nuevo método tomotopy.document.get_count_vector a la clase de documentos.
    • Ahora las distribuciones de Linux usan ManyLinux2010 y se aplica una optimización adicional.
  • 0.6.2 (2020-03-28)
    • Se solucionó un error crítico relacionado con el guardado y la carga. La versión 0.6.0 y 0.6.1 se han eliminado de las versiones.
  • 0.6.1 (2020-03-22) (eliminado)
    • Se solucionó un error relacionado con la carga del módulo.
  • 0.6.0 (2020-03-22) (eliminado)
    • Tomotopy.utils.corpus Clase que administra múltiples documentos fácilmente se agregó.
    • TOMOTOPY.LDAMODEL.SET_WORD_PRIRIR que controla los prioras de tope de palabras de los modelos de temas.
    • Se agregó un nuevo argumento min_df que filtra palabras basadas en la frecuencia del documento a la __init__ de cada modelo de tema.
    • Tomotopy.Label, se agregó el submódulo sobre el etiquetado del tema. Actualmente, solo se proporciona tomotopy.label.Forelevance.
  • 0.5.2 (2020-03-01)
    • Se solucionó un problema de falla de segmentación en Tomotopy.lldamodel.add_doc.
    • Se solucionó un error que se infiere de Tomotopy.hdpModel a veces bloquea el programa.
    • Se solucionó un problema de choque de tomotopy.ldamodel.infer con PS = Tomotopy.ParallelsCheme.Partition, Together = True.
  • 0.5.1 (2020-01-11)
    • Se solucionó un error que Tomotopy.sldamodel.make_doc no admite valores faltantes para y.
    • Ahora Tomotopy.Sldamodel es totalmente admite los valores faltantes para las variables de respuesta y. Los documentos con valores faltantes (NAN) se incluyen en el tema de modelado, pero se excluyen de la regresión de las variables de respuesta.
  • 0.5.0 (2019-12-30)
    • Ahora tomotopy.pamodel.infer Devuelve ambas distribuciones de temas y distribución sub-tópica.
    • Se agregaron nuevos métodos get_sub_topics y get_sub_topic_dist en tomoTopy.document. (para pamodelo)
    • Se añadió un nuevo paralelo paralelo para el método Tomotopy.ldamodel.train y tomotopy.ldamodel.infer. Puede seleccionar algoritmo de paralelismo cambiando este parámetro.
    • Tomotopy.ParallelsCheme.Partition, se agregó un nuevo algoritmo. Funciona de manera eficiente cuando el número de trabajadores es grande, el número de temas o el tamaño del vocabulario es grande.
    • Se solucionó un error donde RM_TOP no funcionó en Min_cf <2.
  • 0.4.2 (2019-11-30)
    • Se solucionaron las tareas de temas incorrectas de Tomotopy.lldamodel y Tomotopy.ldamodel.
    • Se implementó __reprePr__ de Tomotopy.Document y Tomotopy.Dictionary.
  • 0.4.1 (2019-11-27)
    • Se solucionó un error en la función init de Tomotopy.ldamodel.
  • 0.4.0 (2019-11-18)
    • Al paquete se agregaron nuevos modelos que incluyen tomotopy.ldamodel y tomotopy.hldamodel.
  • 0.3.1 (2019-11-05)
    • Un problema donde get_topic_dist () devuelve un valor incorrecto cuando se establece min_cf o rm_top.
    • El valor de retorno de get_topic_dist () del documento Tomotopy.mgldamodel se solucionó para incluir temas locales.
    • Se mejoró la velocidad de estimación con TW = uno.
  • 0.3.0 (2019-10-06)
    • Se agregó un nuevo modelo, Tomotopy.lldamodel al paquete.
    • Se solucionó un problema de falla de HDPModel.
    • Dado que se implementó la estimación de hiperparameter para HDPModel, el resultado de HDPModel puede diferir de las versiones anteriores.
      Si desea desactivar la estimación del hiperparámetro de HDPModel, configure Optim_Interval en cero.
  • 0.2.0 (2019-08-18)
    • Al paquete se agregaron nuevos modelos que incluyen tomotopy.ctmodel y tomotopy.sldamodel.
    • Se agregó una nueva opción de parámetro RM_TOP para todos los modelos de temas.
    • Se solucionaron los problemas en el método de guardado y carga para pamodel y hpamodel.
    • Se fijó un bloqueo ocasional en la carga de HDPModel.
    • El problema que ll_per_word se calculó incorrectamente cuando se solucionó min_cf> 0.
  • 0.1.6 (2019-08-09)
    • Se solucionaron los errores de compilación en el entorno MACOS con MACOS.
  • 0.1.4 (2019-08-05)
    • El problema cuando ADD_DOC recibe una lista vacía como la entrada se solucionó.
    • El problema de que Tomotopy.pamodel.get_topic_words no extrae la distribución de palabras de subtópico.
  • 0.1.3 (2019-05-19)
    • El parámetro MIN_CF y su función de removación de palabras de parada se agregaron para todos los modelos de temas.
  • 0.1.0 (2019-05-12)
    • Primera versión de Tomotopy

Bintings para otros idiomas

  • Ruby: https://github.com/ankane/tomoto

Bibliotecas agrupadas y su licencia

  • EIGEN: Esta aplicación utiliza las características de MPL2 de Eigen, una biblioteca de plantilla C ++ para álgebra lineal. Una copia de la licencia MPL2 está disponible en https://www.mozilla.org/en-us/mpl/2.0/. El código fuente de la biblioteca Eigen se puede obtener en http://eigen.tuxfamily.org/.
  • Eigenrand: licencia del MIT
  • Variante de mapbox: licencia BSD

Citación

 @Software {Minchul_lee_2022_6868418,
  autor = {Minchul Lee},
  title = {bab2min/tomotopy: 0.12.3},
  mes = jul,
  año = 2022,
  Publisher = {Zenodo},
  versión = {v0.12.3},
  doi = {10.5281/zenodo.6868418},
  url = {https://doi.org/10.5281/zenodo.6868418}
}
Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo