J'ai essayé d'implémenter TOPIC MODEL en Python

J'ai essayé d'implémenter TOPIC MODEL en Python

Les matériaux suivants ont été utilisés comme référence.

Modèle à 7 sujets du didacticiel de programmation PNL http://www.phontron.com/slides/nlp-programming-ja-07-topic.pdf, (Voir 2015-06-25)

Veuillez vous référer à ce qui suit pour une explication approximative du modèle TOPIC.

http://qiita.com/GushiSnow/items/8156d440540b0a11dfe6

Décrivez la configuration globale lors de l'implémentation en Python.

TOPIC MODEL.jpg

La configuration n'est pas difficile, donc je pense que c'est facile à mettre en œuvre.

Contrairement à l'apprentissage automatique général, le modèle TOPIC ne reçoit pas le sujet du document qui correspond à l'étiquette.

C'est une méthode pour s'entraîner à estimer un sujet dans cette situation.

Généralement, la méthode d'apprentissage non supervisé est utilisée.

échantillonnage

Citation de la page 11 Modèle à 7 sujets du didacticiel de programmation PNL http://www.phontron.com/slides/nlp-programming-ja-07-topic.pdf, (Voir 2015-06-25)

TOPIC_MODEL_example.png

Voici le code implémenté.

 def sampleOne(probs):
     z = 0
     for k, v in probs.items():
         z = z + v
     remaining = random.uniform(0, z)
     for k,v in probs.items():
         remaining = remaining - v
         if  remaining <= 0:
             return k
  1. Transmettez à la fonction les données du dictionnaire qui contiennent le sujet et les valeurs de probabilité pour l'échantillon obtenu à partir de la distribution.
  2. Calculez la somme des valeurs de probabilité. Obtenez des valeurs aléatoires avec une distribution uniforme dans la plage des sommes des valeurs de probabilité de 3,0. (Modifiez cette distribution en fonction du problème)
  3. Soustrayez la valeur de chaque probabilité de la valeur aléatoire, et le sujet obtenu lorsqu'il devient inférieur à 0 devient le sujet du mot.

Un exemple spécifique est le suivant.

Chaîne A B C D Colonne de sujet 1 2 2 3

En supposant que la probabilité de sortie du sujet est la suivante à partir de la distribution de probabilité

1:1/2 2:1/3 3:1/4

Le total est 1/2 + 1/3 + 1/3 + 1/4

La valeur de sortie provisoire dans la plage de 0 à la somme

1/2 + 1/3

dans le cas de

A B C D 1 2 2 4 1/2 1/3 1/3 1/4

Vous pouvez voir que le sujet «2» obtenu en soustrayant la probabilité de sortie par les chaînes de caractères jusqu'à B ci-dessus est le sujet obtenu dans cet exemple.

Échantillonnage Gibbs

La méthode utilisée cette fois est l'échantillonnage de Gibbs.

Cette méthode est une méthode pour générer un échantillon selon une certaine distribution.

Lorsqu'une distribution est importante, le choix de cette distribution dépend du problème que vous souhaitez résoudre.

La distribution de probabilité simultanée $ P (X, Y) $ est donnée cette fois, mais l'échantillonnage est impossible car deux variables sont données à partir de la probabilité simultanée.

Par conséquent, l'échantillonnage est effectué à l'aide d'une distribution de probabilité conditionnelle. En résumé

Chaîne de caractères fixe et échantillonnée Sujet fixe et échantillonné

Faites simplement ce qui précède.

Échantillonnage d'un modèle thématique spécifique.

Cité aux pages 16-19 Modèle à 7 sujets du didacticiel de programmation PNL http://www.phontron.com/slides/nlp-programming-ja-07-topic.pdf, (Voir 2015-06-25)

Supprimer la paire chaîne / sujet et recalculer la probabilité

TOPIC_MODEL_example1.png

Multipliez la probabilité du sujet par la probabilité du mot pour calculer la probabilité simultanée

TOPIC_MODEL_example2.png

Échantillonnez-en un de la distribution de probabilité simultanée mise à jour et mettez-le à jour en fonction des mots et des sujets de sortie

TOPIC_MODEL_example3.png

Étant donné que de nombreux nombres tombent à 0, un lissage est effectué.

TOPIC_MODEL_example4.png

Initialisation

Initialisez et définissez les valeurs requises Définition de la partie init Définir des mots et des sujets dans le corpus de documents self.xcorpus = numpy.array([]) self.ycorpus = numpy.array([]) Comptez et maintenez le nombre de mots et de sujets self.xcounts = {} self.ycounts = {} Vecteur de sujet self.topics_vector = numpy.array([]) Nombre de sujets self.TOPICS = 7 Identifiant du document self.docid = 1 Nombre de mots différent self.different_word = 0 Dans la partie d'initialisation, le sujet du mot initial est donné au hasard. Cette partie donnée au hasard est une partie qui peut être conçue comme l'utilisation d'une distribution a priori conjuguée.

#-*- coding:utf-8 -*-
__author__ = 'ohgushimasaya'
from numpy import *
from numpy.random import *
import numpy
from Add_Count import add_count
import os.path
class initilaze_topic_model:
      def __init__(self):
          self.xcorpus = numpy.array([])
          self.ycorpus = numpy.array([])
          self.xcounts = {}
          self.ycounts = {}
          self.topics_vector = numpy.array([])
          self.TOPICS = 7
          self.docid = 1
          self.different_word = 0
      def initilize(self):
          first_time = 1
          adder = add_count(self.xcounts, self.ycounts)
          self.docid = os.path.getsize("07-train.txt")
          for line in open("07-train.txt", "r"):
              rline = line.rstrip("¥n")
              words = numpy.array(rline.split(" "))
              topics_vector = []
              self.different_word = set(words)
          for word in words:
              topic = randint(self.TOPICS) + 1
              topics_vector.append(topic)
              adder.add_counter(word, topic, self.docid, 1)
              array_topics_vector = numpy.array(topics_vector)
              if first_time == 1:
                 self.xcorpus = numpy.hstack((self.xcorpus, words))
                 self.ycorpus = numpy.hstack((self.ycorpus, array_topics_vector))
                 first_time = first_time + 1
              else:
                 self.xcorpus=numpy.vstack((self.xcorpus, words))
                 self.ycorpus = numpy.vstack((self.ycorpus, array_topics_vector))

compteur

__author__ = 'ohgushimasaya'
class add_count:
      def __init__(self, xcounts, ycoutns):
          self.xcounts = xcounts
          self.ycounts = ycoutns
      def add_counter(self, word, topic, docid, amount):
      #Word
          self.xcounts = add_count.check_dict(topic, self.xcounts, amount)
          self.xcounts = add_count.check_dict((word, topic), self.xcounts, amount)
          #TOPIC
          self.ycounts = add_count.check_dict(docid, self.ycounts, amount)
          self.ycounts = add_count.check_dict((topic, docid), self.ycounts, amount)
      @staticmethod
      def check_dict(key, w_t_count, amount):
          if w_t_count.has_key(key):
             w_t_count.update({key:w_t_count[key] + amount})
             return w_t_count
          else:
             w_t_count[key] = 1
             return w_t_count

Comptez le nombre de sujets et de mots Calcule également le nombre de mots lorsqu'un sujet est donné et le sujet lorsqu'un identifiant de document est donné

échantillonnage

__author__ = 'ohgushimasaya'
from numpy import *
from numpy.random import *
import numpy
import random
from Add_Count import add_count
import os.path
class Sampling:
      def __init__(self, xcorpus, ycorpus):
          self.iteration = 1000
          self.xcorpus = xcorpus
          self.ycorpus = ycorpus
          self.alpha = 0.01
          self.beta = 0.03
      def sampling(self, TOPICS, xcounts, ycounts, docId, different_word):
          for i in range(0, self.iteration):
              Sampling.sampler(self, i, TOPICS, xcounts, ycounts, docId, different_word)
      @staticmethod
      def sampler(self, i, TOPICS, xcounts, ycounts, docId, different_word):
          ll = 0
          adder = add_count(xcounts, ycounts)
          probs = {}
          for i in range(0, len(self.xcorpus)):
              for j in range(0, len(self.xcorpus[i])):
                  x = self.xcorpus[i][j]
                  y = self.ycorpus[i][j]
                  adder.add_counter(x, y, i, -1)
                  for k in range(TOPICS):
                      if xcounts.has_key(k) and (x, k) in xcounts and ycounts.has_key(docId) \
                      and (y, docId) in ycounts:
                         if xcounts[k] != 0 and ycounts[docId] != 0:
                            p_x_y = 1.0 * xcounts[(x, k)] + self.alpha / xcounts[k] + self.alpha * len(different_word)
                            p_y_Y = 1.0 * ycounts[(y, docId)] + self.beta / ycounts[docId] + self.beta * TOPICS
                            probs.update({k : p_x_y * p_y_Y})
              new_y = Sampling.sampleOne(probs)
              ll = ll + log(probs[new_y])
              adder.add_counter(x, new_y, i ,1)
              self.ycorpus[i][j] = new_y
          print ll
      @staticmethod
      def sampleOne(probs):
          z = 0
          for k, v in probs.items():
              z = z + v
          remaining = random.uniform(0, z)
          for k,v in probs.items():
              remaining = remaining - v
              if remaining <= 0:
                 return k
  1. Prenez des mots et des sujets et soustrayez
  2. Calculez la probabilité conditionnelle d'un mot pour un sujet et la probabilité conditionnelle d'un document pour un sujet pour chaque sujet par le nombre de sommets.
  3. Mettre à jour la probabilité simultanée pour chaque sujet
  4. Générer des sujets en utilisant la probabilité simultanée
  5. Calculer la probabilité logarithmique à l'aide du sujet généré
  6. Ajouter des sujets aux mots
  7. Ajouter des sujets au corpus de sujets

Je vais mettre le code ci-dessous.

https://github.com/SnowMasaya/TOPIC_MODEL

Recommended Posts

J'ai essayé d'implémenter TOPIC MODEL en Python
J'ai essayé d'implémenter PLSA en Python
J'ai essayé d'implémenter la permutation en Python
J'ai essayé d'implémenter PLSA dans Python 2
J'ai essayé d'implémenter ADALINE en Python
J'ai essayé d'implémenter PPO en Python
J'ai essayé d'implémenter le tri sélectif en python
J'ai essayé d'implémenter un pseudo pachislot en Python
J'ai essayé d'implémenter le poker de Drakue en Python
J'ai essayé d'implémenter GA (algorithme génétique) en Python
J'ai essayé d'implémenter la fonction d'envoi de courrier en Python
J'ai essayé d'implémenter le blackjack du jeu Trump en Python
J'ai essayé de mettre en œuvre un jeu de dilemme de prisonnier mal compris en Python
J'ai essayé d'implémenter PCANet
J'ai essayé d'implémenter StarGAN (1)
J'ai essayé d'implémenter la régression linéaire bayésienne par échantillonnage de Gibbs en python
J'ai essayé d'implémenter le jeu de cartes de Trump en Python
J'ai essayé de représenter graphiquement les packages installés en Python
J'ai essayé d'implémenter Mine Sweeper sur un terminal avec python
J'ai essayé d'implémenter le perceptron artificiel avec python
J'ai essayé de résumer comment utiliser les pandas de python
J'ai essayé d'implémenter le tri par fusion en Python avec le moins de lignes possible
J'ai essayé d'implémenter Deep VQE
J'ai essayé de toucher Python (installation)
J'ai essayé de mettre en place une validation contradictoire
J'ai essayé d'implémenter Realness GAN
J'ai essayé d'implémenter ce qui semble être un outil de snipper Windows avec Python
J'ai essayé la notification de ligne en Python
J'ai essayé de mettre en œuvre le modèle de base du réseau neuronal récurrent
J'ai essayé de créer une API list.csv avec Python à partir de swagger.yaml
J'ai essayé "Comment obtenir une méthode décorée en Python"
J'ai fait un chronomètre en utilisant tkinter avec python
J'ai essayé d'implémenter SSD avec PyTorch maintenant (édition du modèle)
J'ai essayé de résumer la gestion des exceptions Python
J'ai essayé d'implémenter Autoencoder avec TensorFlow
Entrée standard Python3 que j'ai essayé de résumer
J'ai essayé d'utiliser l'optimisation bayésienne de Python
Je voulais résoudre ABC159 avec Python
J'ai essayé d'implémenter CVAE avec PyTorch
[Python] J'ai essayé de calculer TF-IDF régulièrement
J'ai essayé de toucher Python (syntaxe de base)
[Python] J'ai essayé d'implémenter un tri stable, alors notez
J'ai essayé d'implémenter la lecture de Dataset avec PyTorch
Je veux faire le test de Dunnett en Python
Essayez d'implémenter Oni Mai Tsuji Miserable avec python
Python: j'ai pu récurer en lambda
Je veux créer une fenêtre avec Python
Comment implémenter la mémoire partagée en Python (mmap.mmap)
J'ai essayé Python> autopep8
J'ai essayé d'intégrer Keras dans TFv1.1
J'ai essayé de simuler "Birthday Paradox" avec Python
J'ai essayé la méthode des moindres carrés en Python
Mettre en œuvre des recommandations en Python
J'ai écrit "Introduction à la vérification des effets" en Python
Implémenter XENO avec python
J'ai essayé d'obtenir des données CloudWatch avec Python