Ich habe versucht, TOPIC MODEL in Python zu implementieren

Die folgenden Materialien wurden als Referenz verwendet.

NLP-Programmier-Tutorial 7-Themen-Modell http://www.phontron.com/slides/nlp-programming-ja-07-topic.pdf, (Siehe 25.06.2015)

Im Folgenden finden Sie eine grobe Erläuterung des THEMENmodells.

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

Beschreiben der Gesamtkonfiguration bei der Implementierung in Python.

TOPIC MODEL.jpg

Die Konfiguration ist nicht schwierig, daher denke ich, dass es einfach zu implementieren ist.

Im Gegensatz zum allgemeinen maschinellen Lernen erhält das TOPIC-Modell nicht das Thema des Dokuments, das dem Etikett entspricht.

Es ist eine Methode, um zu üben, wie ein Thema in dieser Situation geschätzt wird.

Im Allgemeinen wird die Methode des unbeaufsichtigten Lernens verwendet.

Probenahme

Page 11 Zitat NLP-Programmier-Tutorial 7-Themen-Modell http://www.phontron.com/slides/nlp-programming-ja-07-topic.pdf, (Siehe 25.06.2015)

Unten ist der implementierte Code.

 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

Übergeben Sie der Funktion die Wörterbuchdaten, die die Themen- und Wahrscheinlichkeitswerte für die aus der Verteilung erhaltene Stichprobe enthalten.
Berechnen Sie die Summe der Wahrscheinlichkeitswerte. Erhalten Sie Zufallswerte mit einer gleichmäßigen Verteilung im Bereich der Wahrscheinlichkeitssummen von 3,0. (Ändern Sie diese Verteilung je nach Problem)
Subtrahieren Sie den Wert jeder Wahrscheinlichkeit vom Zufallswert, und das Thema, das erhalten wird, wenn es kleiner als 0 wird, wird zum Thema des Wortes.

Ein spezifisches Beispiel ist wie folgt.

String A B C D Themenspalte 1 2 2 3

Angenommen, die Ausgabewahrscheinlichkeit des Themas ergibt sich aus der Wahrscheinlichkeitsverteilung wie folgt

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

Die Summe beträgt 1/2 + 1/3 + 1/3 + 1/4

Der vorläufige Ausgabewert im Bereich von 0 bis zur Summe

1/2 + 1/3

Im Falle von

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

Sie können sehen, dass das Thema "2", das durch Subtrahieren der Wahrscheinlichkeitsausgabe in den Zeichenfolgen bis zu B oben erhalten wird, das in diesem Beispiel erhaltene Thema ist.

Gibbs Sampling

Die diesmal verwendete Methode ist die Gibbs-Abtastung.

Diese Methode ist eine Methode zum Generieren einer Stichprobe gemäß einer bestimmten Verteilung.

Wenn eine Verteilung wichtig ist, hängt die Auswahl dieser Verteilung von dem Problem ab, das Sie lösen möchten.

Die gleichzeitige Wahrscheinlichkeitsverteilung $ P (X, Y) $ ist diesmal angegeben, eine Abtastung ist jedoch unmöglich, da aus der gleichzeitigen Wahrscheinlichkeit zwei Variablen angegeben werden.

Daher wird die Abtastung unter Verwendung einer bedingten Wahrscheinlichkeitsverteilung durchgeführt. Zusammenfassend

Zeichenfolge korrigiert und abgetastet Problem behoben und abgetastet

Mach einfach das oben.

Stichprobe eines bestimmten Themenmodells.

Zitiert auf den Seiten 16-19 NLP-Programmier-Tutorial 7-Themen-Modell http://www.phontron.com/slides/nlp-programming-ja-07-topic.pdf, (Siehe 25.06.2015)

Löschen Sie das Zeichenfolgen- / Themenpaar und berechnen Sie die Wahrscheinlichkeit neu

Multiplizieren Sie die Themenwahrscheinlichkeit mit der Wortwahrscheinlichkeit, um die gleichzeitige Wahrscheinlichkeit zu berechnen

Probieren Sie eine aus der aktualisierten simultanen Wahrscheinlichkeitsverteilung aus und aktualisieren Sie sie basierend auf den Ausgabewörtern und -themen

Da viele Zählungen auf 0 fallen, wird eine Glättung durchgeführt.

Initialisieren

Initialisieren und definieren Sie die erforderlichen Werte Definition des Init-Teils Definieren Sie Wörter und Themen im Dokumentenkorpus self.xcorpus = numpy.array([]) self.ycorpus = numpy.array([]) Zählen und halten Sie die Anzahl der Wörter und Themen self.xcounts = {} self.ycounts = {} Themenvektor self.topics_vector = numpy.array([]) Anzahl der Themen self.TOPICS = 7 Dokument Identifikation self.docid = 1 Unterschiedliche Anzahl von Wörtern self.different_word = 0 Im Initilisierungsteil wird das Thema des Anfangsworts zufällig angegeben. Dieser zufällig gegebene Teil ist ein Teil, der entwickelt werden kann, beispielsweise unter Verwendung einer konjugierten vorherigen Verteilung.

#-*- 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))

Zähler

__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

Zählen Sie die Anzahl der Themen und Wörter Berechnet auch die Anzahl der Wörter, wenn ein Thema angegeben wird, und das Thema, wenn eine Dokument-ID angegeben wird

Probenahme

__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

Wörter und Themen aufnehmen und subtrahieren
Berechnen Sie die bedingte Wahrscheinlichkeit eines Wortes für ein Thema und die bedingte Wahrscheinlichkeit eines Dokuments für ein Thema für jedes Thema anhand der Anzahl der Spitzen.
Aktualisieren Sie die gleichzeitige Wahrscheinlichkeit für jedes Thema
Generieren Sie Themen mit gleichzeitiger Wahrscheinlichkeit
Berechnen Sie die logarithmische Wahrscheinlichkeit anhand des generierten Themas
Fügen Sie Wörtern Themen hinzu
Fügen Sie dem Themenkorpus Themen hinzu

Ich werde den Code unten setzen.

https://github.com/SnowMasaya/TOPIC_MODEL