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.

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)

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é

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

É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

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

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