Página Inicial>Relacionado com a programação>Outro código-fonte
Baixar

Tomotopy

Inglês , 한국어.

O que é o Tomotopy?

Tomotopy é uma extensão Python da Tomoto (Tops Modelaing Tool), que é uma biblioteca de modelos de tópicos baseada em amostragem de Gibbs escrita em C ++. Ele utiliza uma vetorização das CPUs modernas para maximizar a velocidade. A versão atual do tomoto suporta vários modelos de tópicos principais, incluindo

  • Alocação de Dirichlet latente (Tomotopy.ldamodel)
  • LDA rotulado (tomotopy.lldamodel)
  • LDA parcialmente rotulado (TOMOTOPY.PLDAMODEL)
  • LDA supervisionada (Tomotopy.Sldamodel)
  • Regressão multinomial Dirichlet (TOMOTOPY.DMRMODEL)
  • Regressão multinomial generalizada de Dirichlet (TOMOTOPY.GDMRMODEL)
  • Processo hierárquico Dirichlet (TOMOTOPY.HDPMODEL)
  • LDA hierárquica (Tomotopy.hldamodel)
  • LDA multi -grão (TOMOTOPY.MGLDAMODEL)
  • Alocação de Pachinko (Tomotopy.pamodel)
  • PA hierárquica (TOMOTOPY.HPAMODEL)
  • Modelo de tópico correlacionado (Tomotopy.ctmodel)
  • Modelo de tópico dinâmico (Tomotopy.dtmodel)
  • Modelo de tópico baseado em pseudo-documentos (Tomotopy.ptModel).

Visite https://bab2min.github.io/tomotopy para ver mais informações.

Começando

Você pode instalar o Tomotopy facilmente usando PIP. (https://pypi.org/project/tomotopy/)

 $ pip install -upgrade pip
$ pip install tomotopy

As versões SO suportadas e Python são:

  • Linux (x86-64) com python> = 3.6
  • macOS> = 10.13 com python> = 3.6
  • Windows 7 ou posterior (x86, x86-64) com python> = 3.6
  • Outro sistema operacional com python> = 3.6: Compilação do código -fonte necessário (com C ++ 14 compilador compatível)

Após a instalação, você pode iniciar o Tomotopy apenas importando.

 importar tomotopy como tp
Imprima (tp.isa) # impressões 'Avx2', 'Avx', 'SSE2' ou 'Nenhum'

Atualmente, o Tomotopy pode explorar o conjunto de instruções AVX2, AVX ou SSE2 SIMD para maximizar o desempenho. Quando o pacote for importado, ele verificará os conjuntos de instruções disponíveis e selecionam a melhor opção. Se o TP.isa não informar, as iterações de treinamento podem levar muito tempo. Mas, como a maioria das Intel ou AMD CPUs modernas fornece um conjunto de instruções SIMD, a aceleração do SIMD pode mostrar uma grande melhoria.

Aqui está um código de amostra para treinamento simples de LDA de textos do arquivo 'sample.txt'.

 importar tomotopy como tp
mdl = tp.ldamodel (k = 20)
para linha em aberto ('sample.txt'):
    mdl.add_doc (line.strip (). split ())

para i no intervalo (0, 100, 10):
    mdl.Train (10)
    Print ('iteração: {}  tlog-Likelihood: {}'. formato (i, mdl.ll_per_word))

para k em range (mdl.k):
    print ('10 principais palavras do tópico #{}'. formato (k))
    print (mdl.get_topic_words (k, top_n = 10))

mdl.summary ()

Desempenho de tomotopia

O Tomotopy usa amostragem de Gibbs colapsada (CGS) para inferir a distribuição de tópicos e a distribuição de palavras. Geralmente, o CGS converge mais lentamente do que o Bayes Variational (VB) que o Ldamodel da Gensim usa, mas sua iteração pode ser calculada muito mais rápida. Além disso, o Tomotopy pode aproveitar as CPUs multicore com um conjunto de instruções SIMD, que pode resultar em iterações mais rápidas.

A seguir, o gráfico mostra a comparação do tempo de execução do modelo LDA entre o Tomotopy e o Gensim. Os dados de entrada consistem em 1000 documentos aleatórios da Wikipedia em inglês com 1.506.966 palavras (cerca de 10,1 MB). Tomotopy treina 200 iterações e Gensim treina 10 iterações.

Desempenho na Intel I5-6600, x86-64 (4 núcleos)

Desempenho em Intel Xeon E5-2620 V4, x86-64 (8 núcleos, 16 threads)

Embora o Tomotopy tenha atendido 20 vezes mais, o tempo geral de execução foi 5 ~ 10 vezes mais rápido que o Gensim. E produz um resultado estável.

É difícil comparar CGs e VB diretamente porque são técnicas totalmente diferentes. Mas, do ponto de vista prático, podemos comparar a velocidade e o resultado entre eles. O gráfico a seguir mostra a probabilidade de log por palavra do resultado de dois modelos.

O conjunto de instruções SIMD tem um grande efeito no desempenho. A seguir, é apresentada uma comparação entre os conjuntos de instruções SIMD.

Felizmente, a maioria das CPUs X86-64 recentes fornecem um conjunto de instruções AVX2, para que possamos aproveitar o desempenho do AVX2.

Modelo Salvar e Carregar

O TOMOTOPY fornece um método de salvar e carregar para cada classe de modelo de tópico, para que você possa salvar o modelo no arquivo sempre que desejar e recarregá-lo do arquivo.

 importar tomotopy como tp

mdl = tp.hdpmodel ()
para linha em aberto ('sample.txt'):
    mdl.add_doc (line.strip (). split ())

para i no intervalo (0, 100, 10):
    mdl.Train (10)
    Print ('iteração: {}  tlog-Likelihood: {}'. formato (i, mdl.ll_per_word))

# salvar no arquivo
mdl.save ('sample_hdp_model.bin')

# Carregar do arquivo
mdl = tp.hdpmodel.load ('sample_hdp_model.bin')
para k em range (mdl.k):
    se não mdl.is_live_topic (k): continue
    print ('10 principais palavras do tópico #{}'. formato (k))
    print (mdl.get_topic_words (k, top_n = 10))

# O modelo salvo é o modelo HDP,
# Então, quando você o carrega pelo modelo LDA, ele levantará uma exceção
mdl = tp.ldamodel.load ('sample_hdp_model.bin')

Quando você carrega o modelo de um arquivo, um tipo de modelo no arquivo deve corresponder à classe de métodos.

Veja mais no tomotopy.ldamodel.

Visualizador de modelo interativo

interactive_model_viewer_demo.mp4

Você pode ver o resultado da modelagem usando o visualizador interativo desde a v0.13.0.

 importar tomotopy como tp
modelo = tp.ldamodel (...)
# ... alguns códigos de treinamento ...
tp.viewer.open_viewer (modelo, host = "localhost", porta = 9999)
# E aberto http: // localhost: 9999 no seu navegador da web!

Se você tiver um arquivo de modelo salvo, também pode usar a seguinte linha de comando.

 python -m tomotopy.viewer a_trared_model.bin -host localhost --port 9999

Veja mais no Módulo Tomotopy.Viewer.

Documentos no modelo e fora do modelo

Podemos usar o modelo de tópico para dois propósitos principais. O básico é descobrir tópicos de um conjunto de documentos como resultado de modelo treinado, e o mais avançado é inferir distribuições de tópicos para documentos invisíveis usando o modelo treinado.

Nomeamos o documento no primeiro objetivo (usado para treinamento de modelos) como documento no modelo e o documento no objetivo posterior (documento invisível durante o treinamento) como documento fora do modelo .

Na tomotopia, esses dois tipos diferentes de documentos são gerados de maneira diferente. Um documento no modelo pode ser criado por tomotopy.ldamodel.add_doc método. add_doc pode ser chamado antes do totopy.ldamodel.Train inicia. Em outras palavras, depois que o trem chamado, Add_Doc não pode adicionar um documento ao modelo porque o conjunto de documentos usados ​​para o treinamento foi corrigido.

Para adquirir a instância do documento criado, você deve usar o tomotopy.ldamodel.docs como:

 mdl = tp.ldamodel (k = 20)
idx = mdl.add_doc (palavras)
Se IDX <0: Levante o RuntimeError ("Falha ao adicionar Doc")
doc_inst = mdl.docs [idx]
# doc_inst é uma instância do documento adicionado

Um documento fora do modelo é gerado por tomotopy.ldamodel.make_doc Método. make_doc pode ser chamado somente após o início do trem. Se você usar make_doc antes que o conjunto de documentos usados ​​para o treinamento seja corrigido, poderá obter resultados errados. Como Make_doc retorna a instância diretamente, você pode usar seu valor de retorno para outras manipulações.

 mdl = tp.ldamodel (k = 20)
# add_doc ...
mdl.Train (100)
doc_inst = mdl.make_doc (unseen_doc) # doc_inst é uma instância do documento invisível

Inferência por documentos invisíveis

Se um novo documento for criado por tomotopy.ldamodel.make_doc, sua distribuição de tópicos poderá ser inferida pelo modelo. A inferência por documento invisível deve ser executada usando o método TOMOTOPY.LDAMODEL.Infer.

 mdl = tp.ldamodel (k = 20)
# add_doc ...
mdl.Train (100)
doc_inst = mdl.make_doc (Unseen_doc)
tópico_dist, ll = mdl.infer (doc_inst)
Print ("Distribuição de tópicos para documentos invisíveis:", tópico_dist)
Print ("Log-Likelincohity of Inference:", LL)

O método inferno pode inferir apenas uma instância de tomotopia.Document ou uma lista de instâncias de tomotopia.Document. Veja mais em tomotopy.ldamodel.infer.

Corpus e transformar

Todo modelo de tópico em Tomotopy tem seu próprio tipo de documento interno. Um documento pode ser criado e adicionado ao Adequado para cada modelo através do método add_doc de cada modelo. No entanto, tentar adicionar a mesma lista de documentos a diferentes modelos se torna bastante inconveniente, porque o add_doc deve ser chamado para a mesma lista de documentos para cada modelo diferente. Assim, a Tomotopy fornece a classe Tomotopy.utils.Corpus que possui uma lista de documentos. tomotopy.utils.corpus pode ser inserido em qualquer modelo passando como argumento corpus para __init__ ou add_corpus método de cada modelo. Portanto, inserir tomotopia.utils.corpus tem o mesmo efeito para inserir documentos que o corpus mantém.

Alguns modelos de tópicos requerem dados diferentes para seus documentos. Por exemplo, tomotopy.dmrmodel requer metadados de argumento no tipo STR, mas tomotopy.pldamodel requer rótulos de argumento no tipo de lista [str]. Como Tomotopy.utils.corpus mantém um conjunto independente de documentos, em vez de estar vinculado a um modelo de tópico específico, os tipos de dados exigidos por um modelo de tópico podem ser inconsistentes quando um corpus é adicionado a esse modelo de tópico. Nesse caso, dados diversos podem ser transformados para serem ajustados modelo de tópico de destino usando a transformação do argumento. Veja mais detalhes no seguinte código:

 De Tomotopy Import dmrmodel
de tomotopy.utils importar 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)

Model = dmrmodel (k = 10)
Model.add_corpus (corpus)
# Você perde `a_data` campo em` corpus`,
# e `metadados 'que` dmrmodel` requer é preenchido com o valor padrão, vazio str.

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

def transform_a_data_to_metadata (misc: dict):
    Retornar {'Metadata': str (Misc ['a_data'])}
# Esta função transforma `a_data` para` metadata '

Model = dmrmodel (k = 10)
model.add_corpus (corpus, transform = transform_a_data_to_metadata)
# Agora, os documentos em `modelo` possuem metadados não-defensores ', que geraram a partir do campo` a_data`.

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

Algoritmos de amostragem paralela

Desde a versão 0.5.0, o Tomotopy permite escolher um algoritmo de paralelismo. O algoritmo fornecido nas versões antes de 0.4.2 é copy_merge, que é fornecido para todos os modelos de tópicos. A nova partição do algoritmo, disponível desde 0,5.0, torna o treinamento geralmente mais rápido e mais econômico, mas está disponível em todos os modelos de tópicos.

O gráfico a seguir mostra a diferença de velocidade entre os dois algoritmos com base no número de tópicos e no número de trabalhadores.

Desempenho por versão

As alterações de desempenho por versão são mostradas no gráfico a seguir. O tempo que leva para executar o trem do modelo LDA com 1000 iteração foi medido. (Docs: 11314, Vocab: 60382, palavras: 2364724, Intel Xeon Gold 5120 @2.2GHz)

Prestando tópicos usando PRIORES WORD

Desde a versão 0.6.0, um novo método tomotopy.ldamodel.set_word_prior foi adicionado. Ele permite controlar a palavra antes de cada tópico. Por exemplo, podemos definir o peso da palavra 'igreja' para 1,0 no tópico 0 e o peso para 0,1 no restante dos tópicos seguindo os códigos. Isso significa que a probabilidade de a palavra 'igreja' ser atribuída ao tópico 0 é 10 vezes maior que a probabilidade de ser atribuído a outro tópico. Portanto, a maior parte da 'igreja' é designada para o tópico 0; portanto, o tópico 0 contém muitas palavras relacionadas à 'igreja'. Isso permite manipular alguns tópicos a serem colocados em um número de tópico específico.

 importar tomotopy como tp
mdl = tp.ldamodel (k = 20)

# Adicione documentos em `mdl`

# Configuração da palavra anterior
mdl.set_word_prior ('igreja', [1,0 se k == 0 else 0,1 para k no intervalo (20)]))

Consulte o word_prior_example no exemplo.py para obter mais detalhes.

Exemplos

Você pode encontrar um exemplo de código python de tomotopia em https://github.com/bab2min/tomotopy/blob/main/examples/.

Você também pode usar o arquivo de dados usado no código de exemplo em https://drive.google.com/file/d/18opnijd4iwpyyz2o7pqopyetakexa71j/view.

Licença

O TOMOTOPY é licenciado sob os termos da licença do MIT, o que significa que você pode usá -la para qualquer finalidade razoável e permanecer em propriedade completa de toda a documentação que você produz.

História

  • 0,13,0 (2024-08-05)
    • Novos recursos
      • Os principais recursos do visualizador de modelos de tópicos tomotopy.Viewer.open_viewer () estão prontos agora.
      • tomotopy.ldamodel.get_hash () é adicionado. Você pode obter valor de hash de 128 bits do modelo.
      • Adicione um argumento ngram_list ao tomotopy.utils.simpletekenizer.
    • Correções de bug
      • Corrigido o bug inconsistente de vãos após o corpus.concat_ngrams é chamado.
      • Otimizou o gargalo de tomotopy.ldamodel.load () e tomotopy.ldamodel.save () e melhorou sua velocidade mais de 10 vezes.
  • 0,12,7 (2023-12-19)
    • Novos recursos
      • Adicionado Modelo de Tópico Visualizador Tomotopy.Viewer.open_viewer ()
      • Otimizou o desempenho de tomotopy.utils.corpus.process ()
    • Correções de bug
      • Document.span agora retorna os intervalos na unidade de caracteres, não na unidade de bytes.
  • 0,12,6 (2023-12-11)
    • Novos recursos
      • Adicionado alguns recursos de conveniência ao tomotopy.ldamodel.Train e Tomotopy.ldamodel.set_word_prior.
      • Ldamodel.Train agora possui novos argumentos, retorno de chamada, callback_interval e SHOW_PROGRES para monitorar o progresso do treinamento.
      • Ldamodel.set_word_prior agora pode aceitar o tipo ditado [int, float] como seu argumento anterior.
  • 0,12,5 (2023-08-03)
    • Novos recursos
      • Adicionado suporte à arquitetura Linux ARM64.
  • 0,12,4 (2023-01-22)
    • Novos recursos
      • Adicionado suporte à arquitetura MacOS Arm64.
    • Correções de bug
      • Corrigido um problema em que tomotopy.document.get_sub_topic_dist () levanta uma exceção de argumento ruim.
      • Corrigido um problema em que o aumento de exceção às vezes causa acidentes.
  • 0,12,3 (2022-07-19)
    • Novos recursos
      • Agora, inserir um documento vazio usando TOMOTOPY.ldamodel.add_doc () apenas o ignora em vez de aumentar uma exceção. Se o argumento recém -adicionado ignore_empty_words estiver definido como false, uma exceção será levantada como antes.
      • Tomotopy.hdpmodel.purge_dead_topics () é adicionado para remover tópicos não-de-vida do modelo.
    • Correções de bug
      • Corrigido um problema que impede a definição de valores definidos pelo usuário para NUSQ em tomotopy.sldamodel (por @jucendrero).
      • Corrigido um problema em que tomotopia.
      • Corrigido um problema que costumava travar ao chamar make_dic () antes de ligar para o trem ().
      • Resolveu o problema de que os resultados da tomotopia.dmrmodel e tomotopy.gdmrmodel são diferentes, mesmo quando a semente é fixa.
      • O processo de otimização de parâmetros de tomotopia.dmrmodel e tomotopy.gdmrmodel foi aprimorado.
      • Corrigido um problema que às vezes travava ao chamar Tomotopy.ptModel.copy ().
  • 0,12,2 (2021-09-06)
    • Um problema em que a chamada convert_to_lda de tomotopy.hdpmodel com min_cf> 0, min_df> 0 ou rm_top> 0 causa uma falha foi corrigida.
    • Um novo argumento de_pseudo_doc é adicionado ao tomotopy.document.get_topics e tomotopy.document.get_topic_dist. Esse argumento é válido apenas para documentos do PTModel, ele permite controlar uma fonte para a distribuição de tópicos da computação.
    • Um valor padrão para o argumento p de tomotopia.PtModel foi alterado. O novo valor padrão é K * 10.
    • O uso de documentos gerados por Make_Doc sem chamar inferir não causa mais um acidente, mas apenas imprima as mensagens de aviso.
    • Um problema em que o código C ++ interno não é compilado no ambiente Clang C ++ 17 foi corrigido.
  • 0,12,1 (2021-06-20)
    • Um problema em que o tomotopy.ldamodel.set_word_prior () causa um acidente foi corrigido.
    • Agora tomotopy.ldamodel.perplexity and tomotopy.ldamodel.ll_per_word retorna o valor preciso quando o peso do termo não for um.
    • Tomotopy.ldamodel.used_vocab_weighted_freq foi adicionado, que retorna frequências de palavras ponderadas por termo.
    • Agora tomotopy.ldamodel.summary () mostra não apenas a entropia das palavras, mas também a entropia de palavras ponderadas a termo.
  • 0,12,0 (2021-04-26)
    • Agora tomotopy.dmrmodel e tomotopy.gdmrmodel suportam vários valores de metadados (consulte https://github.com/bab2min/tomotopy/blob/main/examples/dmr_multi_label.py)
    • O desempenho do tomotopy.GDMRModel foi aprimorado.
    • Um método copy () foi adicionado para todos os modelos de tópicos fazer uma cópia profunda.
    • Um problema foi corrigido onde as palavras excluídas do treinamento (por min_cf, min_df) têm ID de tópico incorreto. Agora todas as palavras excluídas têm -1 como ID do tópico.
    • Agora, todas as exceções e avisos que gerados pela Tomotopy seguem os tipos padrão de Python.
    • Os requisitos do compilador foram elevados para C ++ 14.
  • 0.11.1 (2021-03-28)
    • Um bug crítico de alfas assimétricos foi corrigido. Devido a esse bug, a versão 0.11.0 foi removida das liberações.
  • 0.11.0 (2021-03-26) (removido)
    • Um novo modelo de tópico tomotopy.PtModel para textos curtos foi adicionado ao pacote.
    • Um problema foi corrigido onde o tomotopia.hdpmodel.infer causa uma falha de segmentação às vezes.
    • Uma incompatibilidade da versão da API Numpy foi corrigida.
    • Agora, os anteriores de documentos assimétricos são suportados.
    • Os modelos de tópicos serializados para bytes na memória são suportados.
    • Um argumento normalizado foi adicionado para get_topic_dist (), get_topic_word_dist () e get_sub_topic_dist () para controlar a normalização dos resultados.
    • Agora tomotopy.dmrmodel.lambdas e tomotopy.dmrmodel.alpha fornece valores corretos.
    • Foram adicionados os suportes de metadados categóricos para tomotopy.gdmrmodel (consulte https://github.com/bab2min/tomotopy/blob/main/exames/gdmr_both_categorical_and_numerical.py).
    • O suporte do Python3.5 foi descartado.
  • 0,10,2 (2021-02-16)
    • Um problema foi corrigido onde o tomotopy.ctmodel.Train falha com K.
    • Um problema foi corrigido onde o tomotopia.utils.Corpus perde seus valores de UID.
  • 0,10.1 (2021-02-14)
    • Um problema foi corrigido onde tomotopia.utils.corpus.extract_ngrams Craches com entrada vazia.
    • Um problema foi corrigido onde o tomotopy.ldamodel.infer levanta exceção com entrada válida.
    • Um problema foi corrigido onde o tomotopy.hldamodel.infer gera tomotopia errada.document.path.
    • Como um novo parâmetro Freeze_topics para tomotopy.hldamodel.Train foi adicionado, você pode controlar se deve criar um novo tópico ou não ao treinar.
  • 0,10,0 (2020-12-19)
    • A interface do tomotopia.utils.corpus e do tomotopia.ldamodel.docs foram unificadas. Agora você pode acessar o documento em corpus da mesma maneira.
    • __getItem__ de tomotopia.utils.corpus foi melhorado. Não apenas a indexação por int, mas também por Iterable [int], o fatiamento é suportado. Também a indexação por UID é suportada.
    • Novos métodos tomotopy.utils.corpus.extract_ngrams e tomotopy.utils.corpus.concat_ngrams foram adicionados. Eles extraem colocações de n-gramas usando PMI e as concatenas em uma única palavra.
    • Um novo método tomotopy.ldamodel.add_corpus foi adicionado e tomotopy.ldamodel.infer pode receber corpus como entrada.
    • Um novo módulo Tomotopy.Coerência foi adicionada. Ele fornece a maneira de calcular a coerência do modelo.
    • Um paramter window_size foi adicionado ao tomotopy.label.forelevance.
    • Um problema foi corrigido onde a NAN ocorre frequentemente ao treinar tomotopia.hdpmodel.
    • Agora Python3.9 é suportado.
    • Uma dependência do PY-CPUINFO foi removida e a inicialização do módulo foi aprimorada.
  • 0.9.1 (2020-08-08)
    • Os vazamentos de memória da versão 0.9.0 foram corrigidos.
    • tomotopy.ctmodel.summary () foi corrigido.
  • 0.9.0 (2020-08-04)
    • O método tomotopy.ldamodel.summary (), que imprime o resumo legível pelo homem do modelo, foi adicionado.
    • O gerador de números aleatórios do pacote foi substituído por Eigenrand. Ele acelera a geração de números aleatórios e resolve a diferença de resultado entre as plataformas.
    • Devido a acima, mesmo que a semente seja a mesma, o resultado do treinamento do modelo pode ser diferente da versão antes de 0.9.0.
    • Corrigido um erro de treinamento em tomotopia.hdpmodel.
    • tomotopy.dmrmodel.alpha agora mostra Dirichlet anterior da distribuição de tópicos por documento por metadados.
    • tomotopy.dtmodel.get_count_by_topics () foi modificado para retornar um ndarray bidimensional.
    • tomotopy.dtmodel.alpha foi modificado para retornar o mesmo valor que tomotopy.dtmodel.get_alpha ().
    • Corrigido um problema em que o valor de metadados não pôde ser obtido para o documento de tomotopy.gdmrmodel.
    • tomotopy.hldamodel.alpha agora mostra Dirichlet antes da distribuição de profundidade por documento.
    • tomotopy.ldamodel.global_step foi adicionado.
    • tomotopy.mgldamodel.get_count_by_topics () agora retorna a contagem de palavras para tópicos globais e locais.
    • foram adicionados tomotopy.pamodel.alpha, tomotopy.pamodel.subalpha e tomotopy.pamodel.get_count_by_super_topic () foram adicionados.
  • 0,8,2 (2020-07-14)
    • Novas propriedades tomotopy.dtmodel.num_timepoints e tomotopy.dtmodel.num_docs_by_timepoint foram adicionadas.
    • Um bug que causa resultados diferentes com a plataforma diferente, mesmo que as sementes fossem as mesmas foram parcialmente fixadas. Como resultado dessa correção, agora o Tomotopy em 32 bits produz diferentes resultados de treinamento da versão anterior.
  • 0,8.1 (2020-06-08)
    • Um bug em que o tomotopy.ldamodel.used_vocabs retornou um valor incorreto foi corrigido.
    • Agora tomotopy.ctmodel.prior_cov retorna uma matriz de covariância com forma [k, k].
    • Agora tomotopy.ctmodel.get_correlações com argumentos vazios retorna uma matriz de correlação com forma [k, k].
  • 0,8,0 (2020-06-06)
    • Desde que Numpy foi introduzido em Tomotopy, muitos métodos e propriedades de retorno de tomotopia não apenas listam, mas agora Numpy.ndarray.
    • Tomotopy possui uma nova dependência numpy> = 1.10.0.
    • Uma estimativa errada de tomotopia.hdpmodel.infer foi fixada.
    • Foi adicionado um novo método sobre a conversão de HDPModel em LDamodel.
    • Novas propriedades, incluindo tomotopy.ldamodel.used_vocabs, tomotopy.ldamodel.used_vocab_freq e tomotopy.ldamodel.used_vocab_df foram adicionados aos modelos de tópicos.
    • Foi adicionado um novo modelo de tópico de G-DMR (TOMOTOPY.GDMRMODEL).
    • Foi corrigido um erro na inicialização do tomotopy.label.forelevância no macOS.
    • Um erro que ocorreu ao usar tomotopia.utils.corpus criado sem parâmetros brutos foi corrigido.
  • 0.7.1 (2020-05-08)
    • tomotopy.document.path foi adicionado para tomotopia.hldamodel.
    • Um bug de corrupção de memória no tomotopy.label.pmiextractor foi corrigido.
    • Um erro de compilação no GCC 7 foi corrigido.
  • 0,7,0 (2020-04-18)
    • tomotopy.dtmodel foi adicionado ao pacote.
    • Um bug no tomotopy.utils.corpus.save foi corrigido.
    • Um novo método tomotopy.document.get_count_vector foi adicionado à classe de documentos.
    • Agora, as distribuições do Linux usam o ManyLinux2010 e uma otimização adicional é aplicada.
  • 0.6.2 (2020-03-28)
    • Um bug crítico relacionado a salvar e carregar foi corrigido. A versão 0.6.0 e 0.6.1 foram removidos das liberações.
  • 0.6.1 (2020-03-22) (removido)
    • Um bug relacionado ao carregamento do módulo foi corrigido.
  • 0.6.0 (2020-03-22) (removido)
    • Tomotopy.utils.Corpus Classe que gerencia vários documentos foi facilmente adicionada.
    • Tomotopy.ldamodel.set_word_prior O método que controla os anteriores dos modelos de tópicos de tópicos de palavras foi adicionado.
    • Um novo argumento min_df que filtra as palavras com base na frequência do documento foi adicionado ao __init__ de todos os modelos de tópicos.
    • TOMOTOPY.LABEL, o submódulo sobre rotulagem de tópicos foi adicionado. Atualmente, apenas tomotopy.label.forelevance é fornecido.
  • 0.5.2 (2020-03-01)
    • Um problema de falha de segmentação foi corrigido no tomotopy.lldamodel.add_doc.
    • Um bug foi corrigido que inferno de tomotopia. HDPModel às vezes trava o programa.
    • Um problema de acidente foi corrigido de tomotopy.ldamodel.infer com ps = tomotopy.paralelscheme.partição, juntos = true.
  • 0.5.1 (2020-01-11)
    • Um bug foi corrigido que tomotopy.sldamodel.make_doc não suporta valores ausentes para y.
    • Agora tomotopy.sldamodel suporta totalmente valores ausentes para variáveis ​​de resposta y. Os documentos com valores ausentes (NAN) estão incluídos no tópico de modelagem, mas excluídos da regressão das variáveis ​​de resposta.
  • 0.5.0 (2019-12-30)
    • Agora tomotopy.pamodel.infer retorna a distribuição de distribuição de tópicos e a distribuição subtópica.
    • Novos métodos get_sub_topics e get_sub_topic_dist foram adicionados ao tomotopy.document. (para Pamodel)
    • O novo parâmetro paralelo foi adicionado para tomotopia.ldamodel.Train e Tomotopy.ldamodel.infer Método. Você pode selecionar o algoritmo do paralelismo alterando este parâmetro.
    • TOMOTOPY.PARALLELSCHEME.Partição, um novo algoritmo, foi adicionado. Funciona com eficiência quando o número de trabalhadores é grande, o número de tópicos ou o tamanho do vocabulário é grande.
    • Um bug em que RM_top não funcionou em min_cf <2 foi corrigido.
  • 0.4.2 (2019-11-30)
    • As atribuições de tópicos erradas de tomotopia.lldamodel e tomotopy.pldamodel foram corrigidos.
    • __REPR__ legível de tomotopia.Document e Tomotopy.Dicionário foi implementado.
  • 0.4.1 (2019-11-27)
    • Um bug na função init de tomotopy.pldamodel foi corrigido.
  • 0.4.0 (2019-11-18)
    • Novos modelos, incluindo tomotopy.pldamodel e tomotopy.hldamodel foram adicionados ao pacote.
  • 0.3.1 (2019-11-05)
    • Um problema em que get_topic_dist () retorna valor incorreto quando o min_cf ou rm_top está definido.
    • O valor de retorno de get_topic_dist () de tomotopy.mgldamodel O documento foi corrigido para incluir tópicos locais.
    • A velocidade de estimativa com TW = um foi melhorada.
  • 0.3.0 (2019-10-06)
    • Um novo modelo, Tomotopy.lldamodel foi adicionado ao pacote.
    • Uma questão de travamento do HDPModel foi corrigida.
    • Como a estimativa do hiperparâmetro para o HDPModel foi implementada, o resultado do HDPModel pode diferir das versões anteriores.
      Se você deseja desativar a estimativa do hyperparâmetro do HDPModel, defina otim_interval como zero.
  • 0.2.0 (2019-08-18)
    • Novos modelos, incluindo tomotopy.ctmodel e tomotopy.sldamodel foram adicionados ao pacote.
    • Uma nova opção de parâmetro rm_top foi adicionada para todos os modelos de tópicos.
    • Os problemas no método de salvar e carregar para pamodel e hpamodel foram fixados.
    • Uma falha ocasional no carregamento do HDPModel foi fixada.
    • O problema que ll_per_word foi calculado incorretamente quando o min_cf> 0 foi corrigido.
  • 0.1.6 (2019-08-09)
    • Os erros de compilação em CLANG com o ambiente MacOS foram corrigidos.
  • 0.1.4 (2019-08-05)
    • O problema quando o add_doc recebe uma lista vazia como entrada foi corrigida.
    • O problema que o tomotopy.pamodel.get_topic_words não extrai a distribuição de palavras do subtópico foi corrigido.
  • 0.1.3 (2019-05-19)
    • O parâmetro min_cf e sua função de remoção de palavras de parada foram adicionadas para todos os modelos de tópicos.
  • 0.1.0 (2019-05-12)
    • Primeira versão do Tomotopy

Ligações para outros idiomas

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

Bibliotecas agrupadas e sua licença

  • Eigen: Este aplicativo usa os recursos licenciados por MPL2 do Eigen, uma biblioteca de modelos C ++ para álgebra linear. Uma cópia da licença MPL2 está disponível em https://www.mozilla.org/en-us/mpl/2.0/. O código -fonte da biblioteca Eigen pode ser obtido em http://eigen.tuxfamily.org/.
  • Eigenrand: MIT Licença
  • Variante MapBox: Licença BSD

Citação

 @software {Minchul_Lee_2022_6868418,
  autor = {Minchul Lee},
  title = {Bab2min/Tomotopy: 0.12.3},
  mês = Jul,
  ano = 2022,
  editor = {zenodo},
  versão = {v0.12.3},
  doi = {10.5281/zenodo.6868418},
  url = {https://doi.org/10.5281/zenodo.6868418}
}
Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos