Page d'accueil>Lié à la programmation>Autre code source
Télécharger

tomotopie

Anglais , 한국어.

Qu'est-ce que la tomotopie?

Tomotopy est une extension Python de Tomoto (outil de modélisation de sujets) qui est une bibliothèque de modèles de sujet basée sur l'échantillonnage Gibbs écrit en C ++. Il utilise une vectorisation des processeurs modernes pour maximiser la vitesse. La version actuelle de Tomoto prend en charge plusieurs modèles de sujet majeurs, notamment

  • Allocation de Dirichlet latente (tomotopy.ldamodel)
  • Étiqueté LDA (tomotopy.lldamodel)
  • LDA partiellement étiqueté (tomotopy.plamodel)
  • LDA supervisé (tomotopy.sldamodel)
  • Régression multinomiale Dirichlet (tomotopy.dmrmodel)
  • Régression multinomiale généralisée de Dirichlet (tomotopy.gdmrmodel)
  • Processus hiérarchique Dirichlet (tomotopy.hdpmodel)
  • LDA hiérarchique (tomotopy.hldamodel)
  • LDA multi-grains (tomotopy.mgldamodel)
  • Attribution de Pachinko (tomotopy.pamodel)
  • PA hiérarchique (tomotopy.hpamodel)
  • Modèle de sujet corrélé (tomotopy.ctmodel)
  • Modèle de sujet dynamique (tomotopy.dtmodel)
  • Modèle de sujet basé sur un pseudo-document (Tomotopy.ptmodel).

Veuillez visiter https://bab2min.github.io/tomotopy pour voir plus d'informations.

Commencer

Vous pouvez installer facilement la tomotopie à l'aide de PIP. (https://pypi.org/project/tomotopy/)

 $ PIP INSTALLANT - PIP DE COLAGE
$ pip install tomotopy

Les versions du système d'exploitation et de Python pris en charge sont:

  • Linux (x86-64) avec Python> = 3,6
  • macOS> = 10.13 avec python> = 3,6
  • Windows 7 ou version ultérieure (x86, x86-64) avec Python> = 3,6
  • Autre système d'exploitation avec Python> = 3,6: Compilation à partir du code source requis (avec compilateur compatible C ++ 14)

Après l'installation, vous pouvez démarrer la tomotopie en importation.

 importer la tomotopie comme TP
print (tp.isa) # imprime 'avx2', 'avx', 'sse2' ou 'nul'

Actuellement, Tomotopy peut exploiter le jeu d'instructions SIMD AVX2, AVX ou SSE2 pour maximiser les performances. Lorsque le package est importé, il vérifiera les ensembles d'instructions disponibles et sélectionnera la meilleure option. Si TP.isa n'en dit pas, les itérations de la formation peuvent prendre beaucoup de temps. Mais, comme la plupart des processeurs Intel ou AMD modernes fournissent un ensemble d'instructions SIMD, l'accélération SIMD pourrait montrer une grande amélioration.

Voici un exemple de code pour une formation LDA simple des textes du fichier «samptample.txt».

 importer la tomotopie comme TP
mdl = tp.ldamodel (k = 20)
pour la ligne dans Open ('Sample.txt'):
    mdl.add_doc (line.strip (). Split ())

pour i à portée (0, 100, 10):
    mdl.train (10)
    print ('itération: {}  tlog-likelihood: {}'. Format (i, mdl.ll_per_word))

pour K dans la gamme (MDL.K):
    print ('Top 10 des mots du sujet # {}'. Format (k))
    print (mdl.get_topic_words (k, top_n = 10))

mdl.summary ()

Performance de la tomotopie

La tomotopie utilise l'échantillonnage GIBBS effondré (CGS) pour déduire la distribution des sujets et la distribution des mots. Généralement, CGS converge plus lentement que les Bayes variationnels (VB) que le LDAMODEL de Gensim utilise, mais son itération peut être calculée beaucoup plus rapidement. De plus, la tomotopie peut profiter des processeurs multicore avec un ensemble d'instructions SIMD, ce qui peut entraîner des itérations plus rapides.

Le graphique suivant montre la comparaison du temps d'exécution du modèle LDA entre la tomotopie et la gensim. Les données d'entrée se compose de 1000 documents aléatoires de Wikipedia anglais avec 1 506 966 mots (environ 10,1 Mo). Tomotopy entraîne 200 itérations et gensim trains 10 itérations.

Performance dans Intel i5-6600, x86-64 (4 cœurs)

Performance dans Intel Xeon E5-2620 V4, x86-64 (8 cœurs, 16 threads)

Bien que la tomotopie ait itéré 20 fois plus, le temps d'exécution global était de 5 à 10 fois plus rapide que la gensim. Et il donne un résultat stable.

Il est difficile de comparer directement CGS et VB car ce sont des techniques totales différentes. Mais d'un point de vue pratique, nous pouvons comparer la vitesse et le résultat entre eux. Le graphique suivant montre le journal logarithmique par mot du résultat de deux modèles.

L'ensemble d'instructions SIMD a un grand effet sur les performances. Voici une comparaison entre les ensembles d'instructions SIMD.

Heureusement, la plupart des processeurs x86-64 récents fournissent un ensemble d'instructions AVX2, afin que nous puissions profiter des performances d'AVX2.

Modèle de sauvegarde et de chargement

Tomotopy fournit une méthode de sauvegarde et de chargement pour chaque classe de modèle de sujet, vous pouvez donc enregistrer le modèle dans le fichier quand vous le souhaitez et le recharger à partir du fichier.

 importer la tomotopie comme TP

mdl = tp.hdpmodel ()
pour la ligne dans Open ('Sample.txt'):
    mdl.add_doc (line.strip (). Split ())

pour i à portée (0, 100, 10):
    mdl.train (10)
    print ('itération: {}  tlog-likelihood: {}'. Format (i, mdl.ll_per_word))

# Enregistrer dans le fichier
MDL.SAVE ('Sample_HDP_MODEL.BIN')

# Chargement du fichier
mdl = tp.hdpmodel.load ('samptample_hdp_model.bin')
pour K dans la gamme (MDL.K):
    Si pas mdl.is_live_topic (k): continue
    print ('Top 10 des mots du sujet # {}'. Format (k))
    print (mdl.get_topic_words (k, top_n = 10))

# Le modèle enregistré est le modèle HDP,
# Donc, lorsque vous le chargez par modèle LDA, il augmentera une exception
mdl = tp.ldamodel.load ('samptample_hdp_model.bin')

Lorsque vous chargez le modèle à partir d'un fichier, un type de modèle dans le fichier doit correspondre à la classe des méthodes.

Voir plus sur tomotopy.ldamodel.save et tomotopy.ldamodel.load méthodes.

Visionneuse de modèle interactif

interactif_model_viewer_demo.mp4

Vous pouvez voir le résultat de la modélisation à l'aide de la visionneuse interactive depuis V0.13.0.

 importer la tomotopie comme TP
modèle = tp.ldamodel (...)
# ... quelques codes de formation ...
tp.viewer.open_viewer (modèle, host = "localhost", port = 9999)
# Et ouvrez http: // localhost: 9999 dans votre navigateur Web!

Si vous avez un fichier de modèle enregistré, vous pouvez également utiliser la ligne de commande suivante.

 Python -M Tomotopy.Viewer a_trained_model.bin - host localhost --port 9999

Voir plus sur Tomotopy.Viewer Module.

Documents dans le modèle et hors du modèle

Nous pouvons utiliser le modèle de sujet à deux fins majeures. La base est de découvrir des sujets d'un ensemble de documents à la suite d'un modèle formé, et le plus avancé est de déduire les distributions de sujet pour les documents invisibles en utilisant un modèle formé.

Nous avons nommé le document dans l'ancien objectif (utilisé pour la formation du modèle) comme document dans le modèle , et le document dans le ultime objectif (document invisible pendant la formation) en tant que document hors du modèle .

Dans la tomotopie, ces deux types de documents différents sont générés différemment. Un document dans le modèle peut être créé par la méthode tomotopy.ldamodel.add_doc. add_doc peut être appelé avant que tomotopy.ldamodel.train commence. En d'autres termes, après l'appel, ADD_DOC ne peut pas ajouter de document dans le modèle car l'ensemble du document utilisé pour la formation est devenu fixé.

Pour acquérir l'instance du document créé, vous devez utiliser tomotopy.ldamodel.docs comme:

 mdl = tp.ldamodel (k = 20)
idx = mdl.add_doc (mots)
Si idx <0: augmenter RunTimeError ("Échec de l'ajout de doc")
doc_inst = mdl.docs [idx]
# doc_inst est une instance du document ajouté

Un document hors du modèle est généré par Tomotopy.ldamodel.Make_doc. Make_doc ne peut être appelé qu'après le début du train. Si vous utilisez Make_doc avant que l'ensemble de document utilisé pour la formation ne soit réparé, vous pouvez obtenir de mauvais résultats. Étant donné que Make_Doc renvoie directement l'instance, vous pouvez utiliser sa valeur de retour pour d'autres manipulations.

 mdl = tp.ldamodel (k = 20)
# add_doc ...
mdl.train (100)
doc_inst = mdl.make_doc (unseen_doc) # doc_inst est une instance du document invisible

Inférence pour les documents invisibles

Si un nouveau document est créé par tomotopy.ldamodel.make_doc, sa distribution de sujet peut être déduite par le modèle. L'inférence pour un document invisible doit être effectuée à l'aide de la méthode 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)
Imprimer ("Distribution de la rubrique pour les documents invisibles:", topic_dist)
Imprimer ("Log-Likelihood of Inference:", LL)

La méthode inférée ne peut déduire qu'une seule instance de tomotopy.Document ou une liste d'instances de tomotopy.Document. Voir plus sur tomotopy.ldamodel.infer.

Corpus et transformée

Chaque modèle de sujet de Tomotopy a son propre type de document interne. Un document peut être créé et ajouté à chaque modèle via la méthode ADD_DOC de chaque modèle. Cependant, essayer d'ajouter la même liste de documents à différents modèles devient assez gênant, car add_doc doit être appelé pour la même liste de documents à chaque modèle différent. Ainsi, Tomotopy fournit une classe tomotopy.utils.corpus qui détient une liste de documents. tomotopy.utils.corpus peut être inséré dans n'importe quel modèle en passant comme argument corpus à __init__ ou méthode add_corpus de chaque modèle. Ainsi, l'insertion de tomotopy.utils.corpus a juste le même effet pour insérer des documents que le corpus détient.

Certains modèles de sujets nécessitent différentes données pour ses documents. Par exemple, tomotopy.dmrmodel nécessite des métadonnées d'argument dans le type STR, mais Tomotopy.plamodel nécessite des étiquettes d'argument dans le type de liste [STR]. Étant donné que Tomotopy.utils.corpus détient un ensemble indépendant de documents plutôt que d'être lié à un modèle de sujet spécifique, les types de données requis par un modèle de sujet peuvent être incompatibles lorsqu'un corpus est ajouté à ce modèle de sujet. Dans ce cas, les données diverses peuvent être transformées pour être ajusté le modèle de sujet cible à l'aide de la transformation d'argument. Voir plus de détails dans le code suivant:

 à partir de Tomotopy Import DMRMODEL
de tomotopy.utils import corpus

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)

modèle = dmrmodel (k = 10)
modèle.add_corpus (corpus)
# Vous perdez le champ `A_DATA` dans` Corpus`,
# et «Metadata» dont «dmrmodel» nécessite est rempli de la valeur par défaut, vide Str.

Assert Model.Docs [0] .Metadata == ''
Assert Model.Docs [1] .Metadata == ''
Assert Model.Docs [2] .Metadata == ''

def Transform_A_DATA_TO_METADATA (Misc: Dict):
    return {'métadata': str (misc ['a_data'])}
# Cette fonction transforme `a_data` en« métadonnées »

modèle = dmrmodel (k = 10)
modèle.add_corpus (corpus, transform = transform_a_data_to_metadata)
# Docute Docs dans `Model` a des métadonnées non défautes, générées à partir du champ` A_DATA`.

Assert Model.Docs [0] .Metadata == '1'
Assert Model.Docs [1] .Metadata == '2'
Assert Model.Docs [2] .Metadata == '3'

Algorithmes d'échantillonnage parallèle

Depuis la version 0.5.0, Tomotopy vous permet de choisir un algorithme de parallélisme. L'algorithme fourni dans les versions avant 0.4.2 est Copy_merge, qui est fourni pour tous les modèles de sujet. La nouvelle partition d'algorithme, disponible depuis 0.5.0, rend la formation généralement plus rapide et plus économe en mémoire, mais elle n'est pas disponible dans tous les modèles de sujet.

Le graphique suivant montre la différence de vitesse entre les deux algorithmes en fonction du nombre de sujets et du nombre de travailleurs.

Performance par version

Les modifications de performances par version sont affichées dans le graphique suivant. Le temps nécessaire pour exécuter le train du modèle LDA avec 1000 itération a été mesuré. (Docs: 11314, Vocab: 60382, mots: 2364724, Intel Xeon Gold 5120 @ 2,2 GHz)

Épisser des sujets utilisant des prieurs de mots

Depuis la version 0.6.0, une nouvelle méthode tomotopy.ldamodel.set_word_prior a été ajoutée. Il vous permet de contrôler le mot avant pour chaque sujet. Par exemple, nous pouvons régler le poids du mot «Église» à 1,0 dans le sujet 0, et le poids à 0,1 dans le reste des sujets par les codes suivants. Cela signifie que la probabilité que le mot «église» soit affecté au sujet 0 est 10 fois supérieur à la probabilité d'être affecté à un autre sujet. Par conséquent, la majeure partie de «l'église» est affectée au sujet 0, donc le sujet 0 contient de nombreux mots liés à «l'église». Cela permet de manipuler certains sujets à placer à un numéro de sujet spécifique.

 importer la tomotopie comme TP
mdl = tp.ldamodel (k = 20)

# ajouter des documents dans `mdl`

# définir le mot avant
mdl.set_word_prior ('église', [1.0 si k == 0 else 0.1 pour k dans la plage (20)])

Voir word_prior_example dans example.py pour plus de détails.

Exemples

Vous pouvez trouver un exemple de code python de tomotopie à https://github.com/bab2min/tomotopy/blob/main/examples/.

Vous pouvez également utiliser le fichier de données dans l'exemple de code sur https://drive.google.com/file/d/18opnijd4iwpyyz2o7pqopyetakexa71j/view.

Licence

Tomotopy est sous licence de licence MIT, ce qui signifie que vous pouvez l'utiliser à des fins raisonnables et rester en propriété totale de toute la documentation que vous produisez.

Histoire

  • 0,13,0 (2024-08-05)
    • Nouvelles fonctionnalités
      • Les principales fonctionnalités de la visionneuse du modèle de sujet tomotopy.viewer.open_viewer () sont prêtes maintenant.
      • tomotopy.ldamodel.get_hash () est ajouté. Vous pouvez obtenir une valeur de hachage 128 bits du modèle.
      • Ajoutez un argument ngram_list à tomotopy.utils.simpletokizer.
    • Correctifs de bugs
      • Correction du bug de Spans incohérent après que Corpus.Concat_Ngrams est appelé.
      • Optimisé le goulot d'étranglement de tomotopy.ldamodel.load () et tomotopy.ldamodel.save () et a amélioré sa vitesse plus de 10 fois.
  • 0.12,7 (2023-12-19)
    • Nouvelles fonctionnalités
      • Ajout de la visionneuse du modèle de sujet tomotopy.viewer.open_viewer ()
      • Optimisé les performances de tomotopy.utils.corpus.process ()
    • Correctifs de bugs
      • Document.span renvoie désormais les plages de l'unité de caractères, pas dans l'unité d'octets.
  • 0,12,6 (2023-12-11)
    • Nouvelles fonctionnalités
      • Ajout de quelques fonctionnalités de commodité à tomotopy.ldamodel.train et tomotopy.ldamodel.set_word_prior.
      • LDAMODEL.TRAIN a désormais de nouveaux arguments Rappel, Callback_Interval et Show_Proresh pour suivre les progrès de la formation.
      • LDAMODEL.SET_WORD_PRIOR peut désormais accepter le type de dict [int, float] comme son argument avant.
  • 0,12,5 (2023-08-03)
    • Nouvelles fonctionnalités
      • Ajout de la prise en charge de l'architecture Linux ARM64.
  • 0,12,4 (2023-01-22)
    • Nouvelles fonctionnalités
      • Ajout de la prise en charge de l'architecture MacOS ARM64.
    • Correctifs de bugs
      • Correction d'un problème où tomotopy.document.get_sub_topic_dist () soulève une mauvaise exception d'argument.
      • Correction d'un problème où l'élévation des exceptions provoque parfois des accidents.
  • 0.12.3 (2022-07-19)
    • Nouvelles fonctionnalités
      • Maintenant, l'insertion d'un document vide à l'aide de tomotopy.ldamodel.add_doc () l'ignore simplement au lieu de lever une exception. Si l'argument nouvellement ajouté ignore_empty_words est défini sur false, une exception est soulevée comme auparavant.
      • Tomotopy.hdpmodel.purge_dead_topics () est ajouté pour supprimer des sujets non-vie du modèle.
    • Correctifs de bugs
      • Correction d'un problème qui empêche la définition des valeurs définies par l'utilisateur pour NUSQ dans tomotopy.sldamodel (par @JuceNDeRero).
      • Correction d'un problème où tomotopy.utils.coherence n'a pas fonctionné pour tomotopy.dtmodel.
      • Correction d'un problème qui s'est souvent écrasé lors de l'appel Make_dic () avant d'appeler Train ().
      • A résolu le problème que les résultats de tomotopy.dmrmodel et tomotopy.gdmrmodel sont différents même lorsque la graine est fixe.
      • Le processus d'optimisation des paramètres de tomotopy.dmrmodel et tomotopy.gdmrmodel a été amélioré.
      • Correction d'un problème qui s'est parfois écrasé lors de l'appel tomotopy.ptmodel.copy ().
  • 0.12.2 (2021-09-06)
    • Un problème où l'appel convert_to_lda de tomotopy.hdpmodel avec min_cf> 0, min_df> 0 ou rm_top> 0 provoque un crash a été corrigé.
    • Un nouvel argument de_pseudo_doc est ajouté à tomotopy.document.get_topics et tomotopy.document.get_topic_dist. Cet argument n'est valable que pour les documents de PTModel, il permet de contrôler une source de distribution de sujets de calcul.
    • Une valeur par défaut pour l'argument P de tomotopy.ptmodel a été modifiée. La nouvelle valeur par défaut est k * 10.
    • L'utilisation de documents générés par Make_Doc sans appeler ne provoque plus de crash, mais il suffit d'imprimer des messages d'avertissement.
    • Un problème où le code C ++ interne n'est pas compilé dans l'environnement CLang C ++ 17 a été corrigé.
  • 0.12.1 (2021-06-20)
    • Un problème où tomotopy.ldamodel.set_word_prior () provoque un crash a été corrigé.
    • Maintenant, tomotopy.ldamodel.perplexity et tomotopy.ldamodel.ll_per_word renvoie la valeur précise lorsque le term-pair n'est pas un.
    • tomotopy.ldamodel.used_vocab_weeep_freq a été ajouté, ce qui renvoie les fréquences pondérées à terme.
    • Maintenant, tomotopy.ldamodel.summary () montre non seulement l'entropie des mots, mais aussi l'entropie des mots pondérés à terme.
  • 0,12,0 (2021-04-26)
    • Maintenant, Tomotopy.dmrmodel et Tomotopy.gdmrmodel prennent en charge plusieurs valeurs de métadonnées (voir https://github.com/bab2min/tomotopy/blob/main/examples/dmr_multi_label.py)
    • Les performances de tomotopy.gdmrmodel ont été améliorées.
    • Une méthode Copy () a été ajoutée pour tous les modèles de sujet pour faire une copie profonde.
    • Un problème a été résolu lorsque les mots qui sont exclus de la formation (par min_cf, min_df) ont un identifiant de sujet incorrect. Maintenant, tous les mots exclus ont -1 comme identifiant de sujet.
    • Maintenant, toutes les exceptions et avertissements générés par la tomotopie suivent les types de python standard.
    • Les exigences du compilateur ont été augmentées en C ++ 14.
  • 0.11.1 (2021-03-28)
    • Un bug critique d'alphas asymétriques a été corrigé. En raison de ce bogue, la version 0.11.0 a été supprimée des versions.
  • 0.11.0 (2021-03-26) (supprimé)
    • Un nouveau modèle de sujet tomotopy.ptmodel pour des textes courts a été ajouté dans le package.
    • Un problème a été résolu lorsque tomotopy.hdpmodel.infer provoque parfois un défaut de segmentation.
    • Une inadéquation de la version API Numpy a été fixée.
    • Désormais, les prieurs de documents asymétriques sont pris en charge.
    • Les modèles de sujets de sérialisation des octets en mémoire sont pris en charge.
    • Une normalisation d'argument a été ajoutée à get_topic_dist (), get_topic_word_dist () et get_sub_topic_dist () pour contrôler la normalisation des résultats.
    • Maintenant, tomotopy.dmrmodel.lambdas et tomotopy.dmrmodel.alpha donnent des valeurs correctes.
    • Des supports de métadonnées catégoriques pour tomotopy.gdmrmodel ont été ajoutés (voir https://github.com/bab2min/tomotopy/blob/main/examples/gdmr_both_categorical_and_numerical.py).
    • Le support Python3.5 a été abandonné.
  • 0.10.2 (2021-02-16)
    • Un problème a été résolu lorsque tomotopy.ctmodel.train échoue avec le grand K.
    • Un problème a été résolu lorsque tomotopy.utils.corpus perd leurs valeurs UID.
  • 0.10.1 (2021-02-14)
    • Un problème a été résolu lorsque tomotopy.utils.corpus.extract_ngrams crache avec une entrée vide.
    • Un problème a été résolu lorsque tomotopy.ldamodel.infer soulève une exception avec une entrée valide.
    • Un problème a été résolu lorsque tomotopy.hldamodel.infer génère une mauvaise tomotopie.Document.path.
    • Étant donné qu'un nouveau paramètre Freeze_Topics pour tomotopy.hldamodel.train a été ajouté, vous pouvez contrôler s'il faut créer un nouveau sujet ou non lors de la formation.
  • 0.10.0 (2020-12-19)
    • L'interface de tomotopy.utils.corpus et de tomotopy.ldamodel.docs étaient unifiées. Vous pouvez maintenant accéder au document dans Corpus de la même manière.
    • __getItem__ de tomotopy.utils.corpus a été amélioré. Non seulement l'indexation par INT, mais aussi par itérable [int], les tranches sont prises en charge. L'indexation par UID est également prise en charge.
    • De nouvelles méthodes tomotopy.utils.corpus.extract_ngrams et tomotopy.utils.corpus.concat_ngrams ont été ajoutées. Ils extraient les collocations de N-grammes en utilisant PMI et les concaténe en un seul mots.
    • Une nouvelle méthode tomotopy.ldamodel.add_corpus a été ajoutée, et tomotopy.ldamodel.infer peut recevoir du corpus comme entrée.
    • Un nouveau module tomotopy. cohérence a été ajouté. Il fournit le moyen de calculer la cohérence du modèle.
    • Un paramètre Window_Size a été ajouté à tomotopy.label.forelevance.
    • Un problème a été résolu lorsque NAN se produit souvent lors de la formation de tomotopie.hdpmodel.
    • Maintenant, Python3.9 est pris en charge.
    • Une dépendance à Py-Cpuinfo a été supprimée et l'initialisation du module a été améliorée.
  • 0.9.1 (2020-08-08)
    • Les fuites de mémoire de la version 0.9.0 ont été fixées.
    • tomotopy.ctmodel.summary () a été fixe.
  • 0.9.0 (2020-08-04)
    • La méthode tomotopy.ldamodel.summary (), qui imprime un résumé lisible par l'homme du modèle, a été ajoutée.
    • Le générateur de nombres aléatoires de package a été remplacé par eigenrand. Il accélère la génération de nombres aléatoires et résout la différence de résultats entre les plates-formes.
    • En raison de ci-dessus, même si les graines sont les mêmes, le résultat de la formation du modèle peut être différent de la version avant 0.9.0.
    • Correction d'une erreur de formation dans tomotopy.hdpmodel.
    • tomotopy.dmrmodel.alpha montre désormais Dirichlet antérieur de la distribution du sujet par document par les métadonnées.
    • tomotopy.dtmodel.get_count_by_topics () a été modifié pour retourner un NDArray à 2 dimensions.
    • tomotopy.dtmodel.alpha a été modifié pour renvoyer la même valeur que tomotopy.dtmodel.get_alpha ().
    • Correction d'un problème où la valeur des métadonnées n'a pas pu être obtenue pour le document de tomotopy.gdmrmodel.
    • tomotopy.hldamodel.alpha montre désormais Dirichlet préalable de la distribution de profondeur par document.
    • tomotopy.ldamodel.global_step a été ajouté.
    • tomotopy.mgldamodel.get_count_by_topics () renvoie désormais le nombre de mots pour les sujets globaux et locaux.
    • tomotopy.pamodel.alpha, tomotopy.pamodel.subalpha et tomotopy.pamodel.get_count_by_super_topic () ont été ajoutés.
  • 0.8.2 (2020-07-14)
    • Nouvelles propriétés tomotopy.dtmodel.num_timepoints et tomotopy.dtmodel.num_docs_by_timepoint ont été ajoutées.
    • Un bug qui provoque des résultats différents avec la plate-forme différente, même si les graines étaient les mêmes ont été partiellement corrigées. À la suite de ce correctif, Tomotopy en 32 bits donne des résultats de formation différents de la version antérieure.
  • 0.8.1 (2020-06-08)
    • Un bogue où tomotopy.ldamodel.used_vocabs a renvoyé une valeur incorrecte a été corrigée.
    • Maintenant, Tomotopy.ctmodel.prior_cov renvoie une matrice de covariance avec une forme [k, k].
    • Maintenant, tomotopy.ctmodel.get_correlations avec des arguments vides renvoie une matrice de corrélation avec la forme [k, k].
  • 0.8.0 (2020-06-06)
    • Depuis que Numpy a été introduit dans la tomotopie, de nombreuses méthodes et propriétés de la tomotopie renvoient non seulement la liste, mais Numpy.NDARRAY maintenant.
    • Tomotopy a une nouvelle dépendance Numpy> = 1,10.0.
    • Une mauvaise estimation de la tomotopie.hdpmodel.infer a été fixe.
    • Une nouvelle méthode sur la conversion de HDPModel en LDAMODEL a été ajoutée.
    • De nouvelles propriétés, notamment tomotopy.ldamodel.used_vocabs, tomotopy.ldamodel.used_vocab_freq et tomotopy.ldamodel.used_vocab_df, ont été ajoutées dans des modèles de sujets.
    • Un nouveau modèle de sujet G-DMR (tomotopy.gdmrmodel) a été ajouté.
    • Une erreur dans l'initialisation de tomotopy.label.ForElevance dans MacOS a été fixée.
    • Une erreur qui s'est produite lors de l'utilisation de tomotopy.utils.corpus créée sans paramètres brutes a été fixée.
  • 0.7.1 (2020-05-08)
    • tomotopy.document.path a été ajouté pour tomotopy.hldamodel.
    • Un bug de corruption de mémoire dans tomotopy.label.pmiextractor a été corrigé.
    • Une erreur de compilation dans GCC 7 a été fixée.
  • 0.7.0 (2020-04-18)
    • tomotopy.dtmodel a été ajouté dans le package.
    • Un bug dans tomotopy.utils.corpus.save a été corrigé.
    • Une nouvelle méthode tomotopy.document.get_count_vector a été ajoutée dans la classe de documents.
    • Désormais, les distributions Linux utilisent ManyLinux2010 et une optimisation supplémentaire est appliquée.
  • 0.6.2 (2020-03-28)
    • Un bogue critique lié à l'enregistrement et à la charge a été corrigé. La version 0.6.0 et 0,6.1 ont été supprimées des versions.
  • 0.6.1 (2020-03-22) (supprimé)
    • Un bogue lié au chargement du module a été corrigé.
  • 0,6,0 (2020-03-22) (supprimé)
    • tomotopy.utils.corpus classe qui gère facilement plusieurs documents a été ajouté.
    • Tomotopy.ldamodel.set_word_prior qui contrôle les prieurs de modèles de sujets par mot des modèles de sujets.
    • Un nouvel argument MIN_DF qui filtre les mots en fonction de la fréquence des documents a été ajouté à __init__ de chaque modèle.
    • Tomotopy.label, le sous-module sur l'étiquetage des sujets a été ajouté. Actuellement, seul tomotopy.label.Forelevance est fourni.
  • 0.5.2 (2020-03-01)
    • Un problème de défaut de segmentation a été résolu dans tomotopy.lldamodel.add_doc.
    • Un bogue a été corrigé que l'infération de tomotopy.hdpmodel plante parfois le programme.
    • Un problème de crash a été résolu de tomotopy.ldamodel.infer avec ps = tomotopy.Parallelscheme.Partition, ensemble = true.
  • 0.5.1 (2020-01-11)
    • Un bug a été corrigé que Tomotopy.sldamodel.make_doc ne prend pas en charge les valeurs manquantes pour y.
    • Maintenant, Tomotopy.Sldamodel prend en charge entièrement les valeurs manquantes pour les variables de réponse y. Les documents avec des valeurs manquants (NAN) sont inclus dans le sujet de modélisation, mais exclus de la régression des variables de réponse.
  • 0.5.0 (2019-12-30)
    • Maintenant, tomotopy.pamodel.infer renvoie à la fois la distribution de sujets et la distribution sous-dépendante.
    • De nouvelles méthodes get_sub_topics et get_sub_topic_dist ont été ajoutées dans tomotopy.Document. (pour Pamodel)
    • Un nouveau paramètre parallèle a été ajouté pour tomotopy.ldamodel.train et tomotopy.ldamodel.infer Méthode. Vous pouvez sélectionner l'algorithme de parallélisme en modifiant ce paramètre.
    • Tomotopy.Parallelscheme.Partition, un nouvel algorithme, a été ajouté. Il fonctionne efficacement lorsque le nombre de travailleurs est grand, le nombre de sujets ou la taille du vocabulaire est important.
    • Un bug où RM_TOP n'a pas fonctionné sur min_cf <2 a été corrigé.
  • 0.4.2 (2019-11-30)
    • Mauvaise affectation de sujet de tomotopy.lldamodel et tomotopy.plamodel ont été fixes.
    • Lisible __repr__ de tomotopy.Document et tomotopy.Dictionary a été mis en œuvre.
  • 0.4.1 (2019-11-27)
    • Un bogue à la fonction d'init de tomotopy.plamodel a été corrigé.
  • 0.4.0 (2019-11-18)
    • De nouveaux modèles comprenant tomotopy.plamodel et tomotopy.hldamodel ont été ajoutés dans l'emballage.
  • 0.3.1 (2019-11-05)
    • Un problème où get_topic_dist () renvoie une valeur incorrecte lorsque MIN_CF ou RM_TOP est fixé a été corrigé.
    • La valeur de retour de get_topic_dist () du document tomotopy.mgldamodel a été fixée pour inclure des sujets locaux.
    • La vitesse d'estimation avec TW = un a été améliorée.
  • 0.3.0 (2019-10-06)
    • Un nouveau modèle, Tomotopy.lldamodel a été ajouté dans le package.
    • Un problème de crash de HDPModel a été résolu.
    • Étant donné que l'estimation de l'hyperparamètre pour HDPModel a été mise en œuvre, le résultat de HDPModel peut différer des versions précédentes.
      Si vous souhaitez désactiver l'estimation de l'hyperparamètre de HDPModel, définissez Optim_interval sur zéro.
  • 0.2.0 (2019-08-18)
    • De nouveaux modèles comprenant Tomotopy.CtModel et Tomotopy.Sldamodel ont été ajoutés dans le package.
    • Une nouvelle option de paramètre RM_TOP a été ajoutée pour tous les modèles de sujets.
    • Les problèmes de méthode de sauvegarde et de charge pour Pamodel et HPAMODEL ont été résolus.
    • Un accident occasionnel dans le chargement du HDPModel a été fixé.
    • Le problème que LL_PER_WORD a été calculé de manière incorrecte lorsque MIN_CF> 0 a été corrigé.
  • 0.1.6 (2019-08-09)
    • Les erreurs de compilation à Clang avec un environnement macOS ont été fixées.
  • 0.1.4 (2019-08-05)
    • Le problème lorsque ADD_DOC reçoit une liste vide en tant qu'entrée a été résolu.
    • Le problème selon lequel Tomotopy.pamodel.get_topic_words n'extrait pas la distribution de mots de Subtopic a été fixé.
  • 0.1.3 (2019-05-19)
    • Le paramètre MIN_CF et sa fonction d'étoile de mot de mots ont été ajoutés pour tous les modèles de sujets.
  • 0.1.0 (2019-05-12)
    • Première version de Tomotopy

Reliures pour d'autres langues

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

Bibliothèques groupées et leur licence

  • Eigen: Cette application utilise les fonctionnalités liées à MPL2 de Eigen, une bibliothèque de modèles C ++ pour l'algèbre linéaire. Une copie de la licence MPL2 est disponible sur https://www.mozilla.org/en-us/mp/2.0/. Le code source de la bibliothèque Eigen peut être obtenu sur http://eigen.tuxfamily.org/.
  • Eigenrand: licence MIT
  • Variante Mapbox: Licence BSD

Citation

 @software {minchul_lee_2022_6868418,
  auteur = {Minchul Lee},
  Titre = {Bab2min / Tomotopy: 0.12.3},
  mois = juil,
  année = 2022,
  éditeur = {zenodo},
  version = {v0.12.3},
  doi = {10.5281 / zenodo.6868418},
  url = {https://doi.org/10.5281/zenodo.6868418}
}
Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout