J'ai essayé de démarrer avec Jubatus.

Hypothèses et objectifs

CentOS-6.6
Un grand nombre d'articles de blog catégorisés (corps), etc. sont inclus dans MySQL
Je veux faire de l'apprentissage automatique la correspondance entre les mots caractéristiques inclus dans l'article de blog et la catégorie, et estimer quelle catégorie est susceptible de correspondre lors de l'alimentation d'un texte approprié.

Installation de Jubatus

Installez à partir du package selon les instructions sur le site officiel.

$ sudo rpm -Uvh http://download.jubat.us/yum/rhel/6/stable/x86_64/jubatus-release-6-1.el6.x86_64.rpm
$ sudo yum install jubatus jubatus-client

Obtenez un échantillon

Il existe un exemple de référentiel appelé jubatus-example, alors récupérez-le.

$ git clone https://github.com/jubatus/jubatus-example.git

Il y a pas mal d'explications telles que README en japonais, donc je pense qu'il est facile d'entrer à partir d'ici.

Modifier l'exemple

Pour cela, vous pouvez utiliser un exemple appelé `` twitter_streaming_location ''. Le mouvement de cet échantillon est le suivant.

Apprentissage
Obtenez celui avec la géolocalisation de Tokyo / Hokkaido / Kyushu sur le flux public de Twitter
Laissez le corps du tweet apprendre à quelle région appartient le tweet.
Classification
Si vous donnez une phrase, elle estimera dans quelle zone le tweet a été tweeté.

twitter_streaming_locationÀ un nom approprié pour chaque répertoire et modifiez-le.

Dans le processus d'apprentissage, apprenez la correspondance entre la catégorie de blog et le texte, Donnez du texte au classificateur et essayez de deviner la catégorie.

Préparation au processus d'apprentissage

Préparation des données des enseignants

Préparez un SQL approprié et exportez la liste des catégories de blog et le corps du texte en texte. Avec CLI, vous pouvez obtenir des données délimitées par des tabulations en procédant comme suit.

$ mysql -uuser -p -N db < blog.sql > blog.txt

Train.py modifié

Le train.py original analyse les géolocalisations des tweets et fait beaucoup de choses, donc c'est un gâchis. Un peu réécrit pour apprendre des données délimitées par des tabulations alimentées à partir d'une entrée standard au lieu de tweets acquis à partir du réseau.

`train.py`


#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys
import json
import re

from jubatus.classifier import client
from jubatus.common import Datum

# Jubatus Configuration
host = "127.0.0.1"
port = 9199
instance_name = "" # required only when using distributed mode

def print_color(color, msg, end):
    sys.stdout.write('\033[' + str(color) + 'm' + str(msg) + '\033[0m' + str(end))

def print_red(msg, end="\n"):
    print_color(31, msg, end)

def print_green(msg, end="\n"):
    print_color(32, msg, end)

def train():
    classifier = client.Classifier(host, port, instance_name)
    for line in sys.stdin:
        category_name, body = line.split("\t")
        d = Datum({'text': body})
        classifier.train([(category_name, d)])

        # Print trained entry
        print_green(category_name, ' ')
        print body

    #Si vous souhaitez sauvegarder les données d'apprentissage après l'apprentissage, activez les éléments suivants
    # classifier.save("foo")

if __name__ == '__main__':
    try:
        train()
    except KeyboardInterrupt:
        print "Stopped."

Préparation au processus de classification

Modifié classify.py

Il n'est presque pas nécessaire de changer cela, mais j'ai changé l'affichage uniquement pour les trois premières catégories estimées.

`classify.py`


#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

from jubatus.classifier import client
from jubatus.common import Datum

# Jubatus configuration
host = "127.0.0.1"
port = 9199
instance_name = "" # required only when using distributed mode

def estimate_blog_category_for(text):
    classifier = client.Classifier(host, port, instance_name)

    # Create datum for Jubatus
    d = Datum({'text': text})

    # Send estimation query to Jubatus
    result = classifier.classify([d])

    if len(result[0]) > 0:
        # Sort results by score
        est = sorted(result[0], key=lambda e: e.score, reverse=True)

        # Print the result
        print "Estimated Category for %s:" % text
        i = 0
        for e in est:
            print "  " + e.label + " (" + str(e.score) + ")"
            i += 1
            if i >= 3:
                break
    else:
        # No estimation results; maybe we haven't trained enough
        print "No estimation results available."
        print "Train more data or try using another text."

if __name__ == '__main__':
    if len(sys.argv) == 2:
        estimate_blog_category_for(sys.argv[1])
    else:
        print "Usage: %s data" % sys.argv[0]

Démarrer le serveur jubatus

Je voulais que le texte soit séparé en mecab au lieu de bigramme, j'ai donc réécrit un peu les paramètres.

`blog_category.json`


{
  "method": "NHERD",
  "parameter": {
    "regularization_weight": 0.001
  },
  "converter": {
    "num_filter_types": {
    },
    "num_filter_rules": [
    ],
    "string_filter_types": {
    },
    "string_filter_rules": [
    ],
    "num_types": {
    },
    "num_rules": [
    ],
    "string_types": {
        "bigram":  { "method": "ngram", "char_num": "2" },
        "mecab": {
          "method": "dynamic",
          "path": "libmecab_splitter.so",
          "function": "create"
        }
    },
    "string_rules": [
        { "key": "*", "type": "mecab", "sample_weight": "bin", "global_weight": "idf" }
    ]
  }
}

Spécifiez ce json pour démarrer le serveur.

$ jubaclassifier -f blog_category.json -t 0

Test de fonctionnement

Apprentissage

Envoyez les données préparées sur les enseignants à train.py

$ cat blog.txt | ./train.py

Classification

Devinons la catégorie en alimentant un texte adapté.

$ ./classify.py "Ravi de vous rencontrer. Mon nom est Tanaka."
Catégorie estimée pour Nice pour vous rencontrer. Mon nom est Tanaka.:
Auto-introduction(0.231856495142)
journal intime(0.0823381990194)
Remarquer(0.0661180838943)

Apprenez les tendances des mots clés dans les textes avec Jubatus et classez vos textes d'entrée