Cet article est lié à la partie ❷ de Collecte et classification des informations liées à l'apprentissage automatique (concept).
Cela fait plusieurs mois depuis l'enquête proprement dite, donc elle peut être légèrement différente de la situation actuelle. Veuillez également noter à l'avance que les résultats ne sont pas satisfaisants.
Je suis nouveau sur Qiita et Python, il peut donc y avoir beaucoup de descriptions étranges, mais j'apprécierais que vous puissiez commenter celles-ci.
Le processus expliqué dans cet article est le suivant.
❶ Exploration du site Placez l'article analysé sous le répertoire bookmarks.crawled. ↓ ❷ Transformer l'article en objet Python Créez un objet Python pour chaque article. ↓ ❸ Corpus en objet Python Convertissez l'ensemble de documents en un objet Python en tant que corpus. ↓ ❹ Classification par modèle thématique Utilisez ce corpus pour essayer de classer par modèle de sujet.
Les détails du thésaurus sont mélangés, mais à part ça, je vais l'expliquer étape par étape autant que possible.
Dans ❷ de Collecte et classification des informations liées à l'apprentissage automatique (concept), le scénario consistait à saisir directement les résultats collectés par FESS, mais cette fois [ Répertoire de raccourcis et conversion de texte brut](http://qiita.com/suchowan/items/6556756d2e816c7255b7#5-%E3%83%97%E3%83%AC%E3%82%A4%E3%83%B3 % E3% 83% 86% E3% 82% AD% E3% 82% B9% E3% 83% 88% E3% 82% AF% E3% 83% AD% E3% 83% BC% E3% 83% AB% E3 % 83% 89% E3% 82% B3% E3% 83% B3% E3% 83% 86% E3% 83% B3% E3% 83% 84% E3% 83% 87% E3% 82% A3% E3% 83 % AC% E3% 82% AF% E3% 83% 88% E3% 83% AA) Le contenu téléchargé par crawl.rb est placé sous le répertoire bookmarks.crawled et saisi.
Si vous saisissez directement les résultats collectés par FESS,
・ Les anciens documents expirent ・ Les articles en double et les articles moins importants exclus lors de la classification manuelle des articles seront restaurés.
Parce que.
Lisez le fichier HTML sous le répertoire bookmarks.crawled et stockez-le dans un objet de classe Article Python.
Classe d'article
attribut
chemin chemin du fichier HTML
contenu Un fichier HTML dont les balises HTML ont été supprimées
Liste de nomenclature dans le contenu des jetons(list of string)
Les résultats de l'enquête sur la bibliothèque de Extraire le texte du HTML du blog avec Python 2015 seront utiles.
Si vous voulez vraiment l'implémenter, vous devez utiliser Webstemmer, mais il est nécessaire de générer un modèle pour chaque site de blog à l'avance, ce qui est compliqué. Je ne l'ai pas utilisé cette fois.
La classe Article implémentée est basée sur l'expression régulière de extractcontent.
(1) janome
J'ai essayé d'utiliser la bibliothèque d'analyse morphologique japonaise de Pure Python janome. Puisque le dictionnaire a presque la même structure que MeCab et que les mots alphabétiques sont définis en pleine largeur, nous avons utilisé la bibliothèque de conversion demi-largeur pleine largeur mojimoji pour le prétraitement. ..
article_janome.py
import codecs
import re
import mojimoji
from janome.tokenizer import Tokenizer
class Article:
encodings = [
"utf-8",
"cp932",
"euc-jp",
"iso-2022-jp",
"latin_1"
]
tokenizer = Tokenizer("user_dic.csv", udic_type="simpledic", udic_enc="utf8")
def __init__(self,path):
print(path)
self.path = path
self.contents = self.preprocess(self.get_contents(path))
self.tokens = [token.surface for token in self.tokenizer.tokenize(self.contents) if re.match("Nomenclature personnalisée|nom,(Unique|Général|Sa étrange)", token.part_of_speech)]
def get_contents(self,path):
exceptions = []
for encoding in self.encodings:
try:
all = codecs.open(path, 'r', encoding).read()
parts = re.split("(?i)<(body|frame)[^>]*>", all, 1)
if len(parts) == 3:
head, void, body = parts
else:
print('Cannot split ' + path)
body = all
return re.sub("<[^>]+?>", "", re.sub(r"(?is)<(script|style|select|noscript)[^>]*>.*?</\1\s*>","", body))
except UnicodeDecodeError:
continue
print('Cannot detect encoding of ' + path)
print(exceptions)
return None
def get_title(self,path):
return re.split('\/', path)[-1]
def preprocess(self, text):
text = re.sub("&[^;]+;", " ", text)
text = mojimoji.han_to_zen(text, digit=False)
text = re.sub('(\s| |＃)+', " ", text)
return text
Dans le dictionnaire IPA par défaut, «intelligence artificielle» est décomposée en deux mots tels que «artificiel» et «intelligence». Par conséquent, j'ai enregistré le terme que je veux utiliser comme un mot dans user_dic.csv et j'ai essayé de l'utiliser à partir de janome.
ensuite,
mecab-ipadic-NEologd : Neologism dictionary for MeCab Ajout de mots Wikipedia et Hatena au dictionnaire de mecab dans Ubuntu 14.04 Générer et utiliser un dictionnaire utilisateur à partir de mots clés Wikipedia et Hatena pour l'analyse morphologique
J'ai également trouvé, mais je ne l'ai pas encore essayé car c'était après le passage à la politique d'utilisation de thesaurus.csv.
(3) thesaurus
Comme cela sera décrit plus tard, lors de l'extraction de jetons à l'aide de la bibliothèque d'analyse morphologique japonaise, perplexité ne tombait pas dans la plage autorisée et l'extraction de sujets ne fonctionnait pas. Par conséquent, thesaurus.csv contient environ 350 mots qui apparaissent fréquemment à la main dans l'intelligence artificielle.
thesaurus.csv(Exemple)
Traitement du langage naturel,NLP,Natural Language Processing,natural language processing
Question Réponse
reconnaissance vocale
AlphaGo,Alpha Go
…
Le processus d'enregistrement et de suppression des mots clés en tant que jetons,
thesaurus.py
import re
import mojimoji
class Thesaurus:
def __init__(self,path):
map = dict()
with open(path, 'r') as thesaurus:
for line in thesaurus.readlines():
words = [mojimoji.han_to_zen(word, digit=False) for word in re.split(',', line.strip())]
for word in words:
if word in map:
print('Word duplicated: ' + word)
raise
map[word] = words[0]
self.words = map
self.re = re.compile("|".join(sorted(map.keys(), key=lambda x: -len(x))))
def tokenize(self,sentence):
for token in re.finditer(self.re, sentence):
yield(Token(self.words[token.group()]))
class Token:
def __init__(self, surface):
self.surface = surface
self.part_of_speech = "Nomenclature personnalisée"
Je l'ai décrit dans et remplacé la bibliothèque d'analyse morphologique japonaise [^ 1].
article.py
import codecs
import re
import mojimoji
from thesaurus import Thesaurus
class Article:
encodings = [
"utf-8",
"cp932",
"euc-jp",
"iso-2022-jp",
"latin_1"
]
tokenizer = Thesaurus('thesaurus.csv')
def __init__(self,path):
print(path)
self.path = path
self.contents = self.preprocess(self.get_contents(path))
self.tokens = [token.surface for token in self.tokenizer.tokenize(self.contents) if re.match("Nomenclature personnalisée|nom,(Unique|Général|Sa étrange)", token.part_of_speech)]
def get_contents(self,path):
exceptions = []
for encoding in self.encodings:
try:
all = codecs.open(path, 'r', encoding).read()
parts = re.split("(?i)<(body|frame)[^>]*>", all, 1)
if len(parts) == 3:
head, void, body = parts
else:
print('Cannot split ' + path)
body = all
return re.sub("<[^>]+?>", "", re.sub(r"(?is)<(script|style|select|noscript)[^>]*>.*?</\1\s*>","", body))
except UnicodeDecodeError:
continue
print('Cannot detect encoding of ' + path)
print(exceptions)
return None
def get_title(self,path):
return re.split('\/', path)[-1]
def preprocess(self, text):
text = re.sub("&[^;]+;", " ", text)
text = mojimoji.han_to_zen(text, digit=False)
return text
Dans le modèle de rubrique, les phrases sont traitées comme BOW (Sac de mots, liste de (identifiant de mot, nombre d'occurrences)). Par conséquent, nous avons défini les classes suivantes.
attribut
articles (Chemin du fichier HTML:Objet de l'article)OrderedDictionary composé de
liste des clés des chemins de fichiers HTML(list of string)
taille Article Nombre d'objets
textes Jetons qui composent le corpus(list of (list of string))
Textes de corpus convertis en liste de BOW
Sauvegarde de la méthode de classe/Il a une charge et vous permet d'enregistrer des objets dans un fichier.
attribut
Objet Corpus de formation pour la formation
Objet Corpus pour test de test
dictionary training,test Gensim couramment utilisés.corpora.Objet dictionnaire
(ID de mot(integer)Exprimé comme(string)Conservez la correspondance de)
corpus.py
import pickle
from collections import defaultdict
from gensim import corpora
class Corpora:
def __init__(self, training, test, dictionary):
self.training = training
self.test = test
self.dictionary = dictionary
def save(self, title):
self.training.save(title+'_training')
self.test.save(title+'_test')
self.dictionary.save(title+".dict")
@classmethod
def load(cls, title):
training = Corpus.load(title+'_training')
test = Corpus.load(title+'_test')
dictionary = corpora.Dictionary.load(title+".dict")
return cls(training, test, dictionary)
@classmethod
def generate(cls, training, test):
training_corpus = Corpus.generate(training)
test_corpus = Corpus.generate(test)
all_texts = training_corpus.texts + test_corpus.texts
frequency = defaultdict(int)
for text in all_texts:
for token in text:
frequency[token] += 1
all_texts = [[token for token in text if frequency[token] > 1] for text in all_texts]
dictionary = corpora.Dictionary(all_texts)
training_corpus.mm(dictionary)
test_corpus.mm(dictionary)
return cls(training_corpus, test_corpus, dictionary)
class Corpus:
def __init__(self, articles):
self.articles = articles
self.keys = list(articles.keys())
self.size = len(articles.keys())
def article(self, index):
return self.articles[self.keys[index]]
def mm(self, dictionary):
values_set = set(dictionary.values())
self.texts = [[token for token in text if token in values_set] for text in self.texts]
# print(self.texts[0])
self.corpus = [dictionary.doc2bow(text) for text in self.texts]
def save(self, title):
with open(title+".pickle", 'wb') as f:
pickle.dump(self.articles, f)
corpora.MmCorpus.serialize(title+".mm", self.corpus)
@classmethod
def load(cls, title):
with open(title+".pickle", 'rb') as f:
articles = pickle.load(f)
corpus = cls(articles)
corpus.corpus = corpora.MmCorpus(title+".mm")
return corpus
@classmethod
def generate(cls, articles):
corpus = cls(articles)
corpus.texts = [articles[key].tokens for key in articles.keys()]
return corpus
Jusqu'à présent, il s'agit d'une technologie couramment requise, indépendamment de ce qui est utilisé pour les outils sur site.
Préparez le support à outils ci-dessus,
Création d'une application à l'aide du modèle de rubrique… (* 1)
Nous avons classé par modèle thématique en référence à.
test_view_LDA.py
import pprint
import logging
import glob
import numpy as np
import matplotlib.pylab as plt
from collections import OrderedDict
from gensim import corpora, models, similarities
from pprint import pprint # pretty-printer
from corpus import Corpus, Corpora
from article import Article
#logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
topic_range = range(10, 11)
training_percent = 90
test_percent = 10
path_pattern = '/home/samba/suchowan/links/bookmarks.crawled/**/*.html'
def corpus_pair(path, training_range, test_range):
all_paths = glob.glob(path, recursive=True)
training_paths = [v for i, v in enumerate(all_paths) if ((i * 2017) % 100) in training_range]
test_paths = [v for i, v in enumerate(all_paths) if ((i * 2017) % 100) in test_range ]
training_articles = OrderedDict([(path,Article(path)) for path in training_paths])
test_articles = OrderedDict([(path,Article(path)) for path in test_paths])
return Corpora.generate(training_articles, test_articles)
def calc_perplexity(m, c):
return np.exp(-m.log_perplexity(c))
def search_model(pair):
most = [1.0e15, None]
print("dataset: training/test = {0}/{1}".format(pair.training.size, pair.test.size))
for t in topic_range:
m = models.LdaModel(corpus=pair.training.corpus, id2word=pair.dictionary, num_topics=t, iterations=500, passes=10)
p1 = calc_perplexity(m, pair.training.corpus)
p2 = calc_perplexity(m, pair.test.corpus)
print("{0}: perplexity is {1}/{2}".format(t, p1, p2))
if p2 < most[0]:
most[0] = p2
most[1] = m
return most[0], most[1]
pair = corpus_pair(path_pattern, range(0, training_percent+1), range(training_percent, training_percent+test_percent+1))
pair.save('article_contents')
perplexity, model = search_model(pair)
print("Best model: topics={0}, perplexity={1}".format(model.num_topics, perplexity))
def show_document_topics(c, m, r):
# make document/topics matrix
t_documents = OrderedDict()
for s in r:
# ts = m.__getitem__(c[s], -1)
ts = m[c[s]]
max_topic = max(ts, key=lambda x: x[1])
if max_topic[0] not in t_documents:
t_documents[max_topic[0]] = []
t_documents[max_topic[0]] += [(s, max_topic[1])]
return t_documents
topic_documents = show_document_topics(pair.test.corpus, model, range(0,pair.test.size))
for topic in topic_documents.keys():
print("Topic #{0}".format(topic))
for article in topic_documents[topic]:
print(article[0], pair.test.article(article[0]).path)
pprint(model.show_topics())
La bibliothèque utilisée était gensim et Calcul de similarité pour les utilisateurs de Twitter utilisant tfidf, lsi, lda. / 88) et [Essayez le traitement du langage naturel avec le modèle Python_topic](http://esu-ko.hatenablog.com/entry/2016/03/24/Python%E3%81%A7%E8%87 % AA% E7% 84% B6% E8% A8% 80% E8% AA% 9E% E5% 87% A6% E7% 90% 86% E3% 82% 92% E3% 81% 97% E3% 81% A6 % E3% 81% BF% E3% 82% 8B_% E3% 83% 88% E3% 83% 94% E3% 83% 83% E3% 82% AF% E3% 83% A2% E3% 83% 87% E3 J'ai également fait référence à% 83% AB). ★training
contribution:corpus de formation- list of (list of (ID de mot,Nombre d'apparitions))Et le nombre de sujets
list of (ID de mot,Nombre d'apparitions) - 個々の article での単語のNombre d'apparitions (L'ordre d'apparition n'est pas pris en compte)
production:Modèle LDA- gensim.models.ldamodel
list of ((list of (ID de mot,Nombre d'apparitions))Formule pour calculer la probabilité d'ajustement du sujet à partir de)
★test
contribution:corpus de test- list of (list of (ID de mot,Nombre d'apparitions))
list of (ID de mot,Nombre d'apparitions) - 個々の article での単語のNombre d'apparitions (L'ordre d'apparition n'est pas pris en compte)
production: list of (liste des probabilités d'ajustement)
J'ai essayé de faire un corpus et de classer par modèle de sujet simplement en extrayant des mots avec janome et en les rétrécissant par parties seulement de la parole, mais la perplexité est devenue une valeur astronomique et cela n'avait aucun sens.
Nous avons peut-être omis une partie du prétraitement requis, mais la raison sous-jacente est claire.
Nombre de types de mots >> Nombre de documents
Cette.
Le modèle de sujet a des variables qui peuvent être ajustées par le nombre de types de mots + α. Une convergence forcée sous la condition "nombre de types de mots >> nombre de documents" entraînera inévitablement un surapprentissage.
Nombre de types de mots << Nombre de documents
Vous devez affiner les mots pour que
Ce qui suit est le résultat de l'enregistrement manuel d'environ 350 mots qui apparaissent fréquemment dans l'intelligence artificielle dans thesaurus.csv et de la création d'un corpus en les utilisant uniquement.
Le nombre de sujets est une entrée de formation, mais vous pouvez automatiser la décision en recherchant le nombre de sujets qui minimise la persistance. Dans l'exemple d'opération, il a été confirmé à l'avance que le nombre de sujets est de 10 et la perplexité est minimisée.
Selon (* 1)
L'inverse de la perplexité indique le degré auquel les mots d'un document peuvent être prédits, le plus élevé est donc 1. Plus la précision du modèle est mauvaise, plus la valeur est élevée (2 chiffres, c'est bien, la première moitié de 3 chiffres est OK, et après ça c'est mauvais, Dans le cas de 1 chiffre, il vaut mieux revoir le modèle et la méthode de calcul de la perplexité pour d'éventuelles erreurs. Bon).
Dans l'exemple d'exécution, 1920 article (90%) est utilisé pour l'entraînement, 210 article (10%) est utilisé pour le test [^ 2] et la perplexité du corpus de test est 68,4.
La liste des formules pour calculer la probabilité d'ajustement du sujet est la suivante
[(0,
'0.268*image+ 0.124*Ｄｅｌｌ + 0.049*ＣＮＮ + 0.043*L'apprentissage en profondeur+ 0.038*réseau neuronal+ '
'0.026*Apprentissage automatique+ 0.025*Ｃｈａｉｎｅｒ + 0.024*ＧＰＵ + 0.023*article+ 0.022*Reconnaissance d'image'),
(1,
'0.135*Apprentissage automatique+ 0.121*Ｐｙｔｈｏｎ + 0.102*article+ 0.055*Ｃｈａｉｎｅｒ + 0.052*Ｄｅｌｌ + '
'0.037*L'apprentissage en profondeur+ 0.033*ｎｕｍｐｙ + 0.023*Cadre+ 0.019*réseau neuronal+ 0.019*Ｓｐａｒｋ'),
(2,
'0.111*article+ 0.097*Prévoir+ 0.090*Classement+ 0.071*Université+ 0.055*Chercher+ 0.033*Intelligence artificielle+ '
'0.032*Ｙａｈｏｏ + 0.032*Ｄｅｌｌ + 0.029*Base de données+ 0.026*Brevet'),
(3,
'0.121*Ｒｕｂｙ + 0.100*Jeu+ 0.090*ＡｌｐｈａＧｏ + 0.085*Aller+ 0.077*article+ 0.076*Intelligence artificielle+ '
'0.053*Ｇｏｏｇｌｅ + 0.052*Ｍｉｃｒｏｓｏｆｔ + 0.047*Ｔａｙ + 0.034*Ｔｗｉｔｔｅｒ'),
(4,
'0.113*ＴｅｎｓｏｒＦｌｏｗ + 0.103*ＬＳＴＭ + 0.070*Ｄｅｌｌ + 0.068*ＣＮＮ + 0.063*ｌｉｎｅ + '
'0.058*Ｔｈｅａｎｏ + 0.043*ＳＰＡＲＱＬ + 0.038*Ｋｅｒａｓ + 0.037*Ｐｙｔｈｏｎ + 0.035*ＭＮＩＳＴ'),
(5,
'0.130*Nuage+ 0.096*Sécurité+ 0.079*ＡＷＳ + 0.079*Ａｍａｚｏｎ + 0.075*article+ 0.057*ＩｏＴ '
'+ 0.042*Big Data+ 0.031*Livres+ 0.023*attaque+ 0.022*ＩＢＭ'),
(6,
'0.177*Ｇｏｏｇｌｅ + 0.137*ＡＰＩ + 0.100*Chercher+ 0.071*article+ 0.055*Ｆａｃｅｂｏｏｋ + '
'0.031*Ｗａｔｓｏｎ + 0.030*ＩＢＭ + 0.026*Ｂｌｕｅｍｉｘ + 0.026*Apprentissage automatique+ 0.025*Ｔｗｉｔｔｅｒ'),
(7,
'0.351*Intelligence artificielle+ 0.093*robot+ 0.064*L'apprentissage en profondeur+ 0.049*article+ 0.032*Université+ 0.029*Apprentissage automatique+ '
'0.020*Université de Tokyo+ 0.019*Ｆａｃｅｂｏｏｋ + 0.019*films+ 0.019*Ｇｏｏｇｌｅ'),
(8,
'0.188*ｂｏｔ + 0.180*Ｍｉｃｒｏｓｏｆｔ + 0.057*Ａｚｕｒｅ + 0.056*Ｅｌａｓｔｉｃｓｅａｒｃｈ + '
'0.042*ｗｏｒｄ2ｖｅｃ + 0.038*Apprentissage automatique+ 0.033*ｌｉｎｅ + 0.030*Chercher+ 0.027*Ｋｉｂａｎａ + '
'0.022*Traitement du langage naturel'),
(9,
'0.102*article+ 0.094*Ｔｗｉｔｔｅｒ + 0.079*robot+ 0.060*ＩｏＴ + 0.058*Sony+ 0.041*Renforcer l'apprentissage'
'+ 0.038*ＴｅｎｓｏｒＦｌｏｗ + 0.029*Ｊａｖａ + 0.028*Ｄｅｅｐ\u3000Ｑ−Ｎｅｔｗｏｒｋ + 0.027*Classement')]
Une perplexité de 68,4 ne semble pas être si grave, mais en regardant cette formule, il semble assez difficile pour l'œil humain de lire le sens du sujet.
Pour revenir en arrière, dans l'exemple de (* 1), sous forme de token extrait de l'article d'origine,
Grand salon de 15 places ou plus / Parking disponible / La réception est OK après 19h00 / Ouvert toute l'année / À moins de 3 minutes à pied de la gare la plus proche / Coiffure / Ongles / Réception avant 10h / Service boissons disponible / Paiement par carte OK / Beaucoup de personnel féminin / Chambre privée disponible / Non-fumeur / Chambre semi-privée disponible
L'explication comme l'exemple dans est divisée par «/». Il s'agit plus d'une caractéristique directe que d'un jeton extrait du langage naturel. Avec ce jeton lucratif, la perplexité sur les deux sujets est 17.1, donc je ne pense pas que cet exemple était trop maladroit. Inversement, avec un ensemble de données d'échelle et de contenu comme cet exemple, il peut être difficile de faire une classification non supervisée frappante avec un modèle thématique.
Si des améliorations sont possibles, les points suivants peuvent être pris en compte.
-Extraire le vrai texte en utilisant Webstemmer. ・ Mise au point de thesaurus.csv
Cependant, pour ce dernier, je ne sais pas à quoi sert l'automatisation en maintenant manuellement les synonymes. De plus, à mesure que de nouvelles entreprises entrent dans le secteur de l'apprentissage automatique, elles doivent décider et les ajouter à thesaurus.csv.
Le JUMAN ++ récemment annoncé
D'après ce que j'ai lu, cela peut être efficace pour résoudre le problème, mais c'est une tâche future.
[^ 1]: les itérateurs, etc. sont implémentés de manière à avoir la même API.
[^ 2]: Au moment de cette enquête, il y avait environ 2000 articles, mais maintenant il est passé à environ 5000 articles.
Recommended Posts