Python: représentation vectorielle en langage naturel
Représentation vectorielle du document
Dans le traitement du langage naturel, j'ai principalement expliqué comment gérer les documents et les phrases. Nous analyserons les relations entre les phrases et les mots.
Représentation vectorielle du document
La représentation vectorielle d'un document est une représentation vectorielle de la façon dont les mots sont distribués dans un document.
Par exemple, la phrase "J'aime les tomates et les concombres comme les tomates" peut être convertie en l'expression vectorielle suivante.
(Mais le concombre, j'aime ça, et la tomate)= (1, 1, 1, 1, 1, 2)
Le nombre d'occurrences de chaque mot est exprimé, mais les informations sur l'endroit où il est apparu sont perdues. Autrement dit, la structure et les informations d'ordre des mots sont perdues. Une telle méthode d'expression vectorielle
Bag of Words(BOW)Est appelé.
Il existe trois méthodes typiques de conversion en représentation vectorielle.
(1) Count expression: comme dans l'exemple précédent, comment se concentrer sur le nombre d'occurrences de chaque mot dans le document
(2) Expression binaire: une méthode qui se concentre uniquement sur le fait que chaque mot apparaît ou non dans une phrase sans se soucier de la fréquence d'apparition.
③tf-expression idf: tf-Comment gérer les informations de poids de chaque mot dans une phrase calculée par une méthode appelée idf
Généralement, tf-idf est utilisé, mais le calcul prend du temps lorsqu'il y a beaucoup de phrases. Utilisez des représentations binaires ou comptées.
Expression du nombre d'arcs
Dans l'expression count, le document est converti en vecteur en comptant le nombre d'occurrences de chaque mot dans le document.
1.John likes to watch movies. Mary likes movies too.
2.John also likes to watch football games.
Quand il y avait les deux phrases ci-dessus, le sac de mots de ces deux phrases C'est un vecteur qui utilise le nombre d'occurrences de mots dans le document comme élément.
["John","likes","to","watch","movies","Mary","too","also","football", "games"]
Le nombre de fois où les mots ci-dessus apparaissent
1. [1, 2, 1, 1, 2, 1, 1, 0, 0, 0]
2. [1, 1, 1, 1, 0, 0, 0, 1, 1, 1]
Il est devenu. Cela représente les caractéristiques du texte.
En Python, en utilisant gensim, une bibliothèque d'apprentissage automatique principalement pour l'analyse de texte Il est possible de calculer automatiquement.
Premier,
dictionary = gensim.corpora.Dictionary
# (Texte divisé)
Crée un dictionnaire de mots qui apparaissent à l'avance dans le document.
dictionary.doc2bow
# (Chaque mot de la phrase divisée)
Vous pouvez créer un sac de mots avec, et le résultat sera une liste de (id, nombre d'occurrences). Vous pouvez obtenir le numéro d'identification de chaque mot avec dictionary.token2id.
from gensim import corpora
#Liste de mots pour chaque document(documents)Créez un dictionnaire de mots correspondant et le nombre d'occurrences de
dictionary = corpora.Dictionary(documents)
#Créer un sac de mots
bow_corpus = [dictionary.doc2bow(d) for d in documents]
Cliquez ici pour un code plus détaillé
from gensim import corpora
from janome.tokenizer import Tokenizer
text1 = "Des cuisses et des cuisses"
text2 = "Bonne nourriture et paysages"
text3 = "Mon hobby est la photographie"
t = Tokenizer()
tokens1 = t.tokenize(text1, wakati=True)
tokens2 = t.tokenize(text2, wakati=True)
tokens3 = t.tokenize(text3, wakati=True)
documents = [tokens1, tokens2, tokens3]
#Créez un dictionnaire de mots à l'aide de corpus.
dictionary =corpora.Dictionary(documents)
#Afficher l'id de chaque mot
print(dictionary.token2id)
#Créer un sac de mots
bow_corpus =[dictionary.doc2bow(d) for d in documents]
# (id,Nombre d'apparitions)La liste des est sortie.
print(bow_corpus)
print()
# bow_Produire le contenu du corpus d'une manière facile à comprendre
texts = [text1, text2, text3]
for i in range(len(bow_corpus)):
print(texts[i])
for j in range(len(bow_corpus[i])):
index = bow_corpus[i][j][0]
num = bow_corpus[i][j][1]
print("\"", dictionary[index], "\"Mais" ,num, "Fois", end=", ")
print()
Résultat de sortie
{'Sumomo': 0, 'Aussi': 1, 'AussiAussi': 2, 'de': 3, 'domicile': 4, 'cuisine': 5, 'vue': 6, 'génial': 7, 'je': 8, 'loisir': 9, 'Est': 10, 'Photo': 11, 'Tournage': 12, 'est': 13}
[[(0, 1), (1, 2), (2, 2), (3, 1), (4, 1)], [(1, 2), (5, 1), (6, 1), (7, 1)], [(3, 1), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1), (13, 1)]]
Des cuisses et des cuisses
"Sumomo"Une fois que, "Aussi"Deux fois, "Les pêches"Deux fois, "de"Une fois que, "domicile"Une fois que,
Bonne nourriture et paysages
"Aussi"Deux fois, "cuisine"Une fois que, "vue"Une fois que, "génial"Une fois que,
Mon hobby est la photographie
"de"Une fois que, "je"Une fois que, "loisir"Une fois que, "Est"Une fois que, "Photo"Une fois que, "Tournage"Une fois que, "est"Une fois que,
Pondération par BOW tf-idf (théorie)
Dans l'expression de comptage exécutée dans "BOW_count expression", le nombre d'occurrences des mots qui caractérisent la phrase a été traité comme la quantité de caractéristiques.
tf-idf est
tf(Term frequency):Fréquence des mots et
idf(Inverse Document Frequency):Inverser la fréquence du document qui montre à quel point le mot est rare (rareté)
Il est représenté par le produit de.
tf et idf sont définis par la formule suivante.
Diminuer l'importance des mots (mots généraux) qui apparaissent dans de nombreux documents La formule montre qu'elle joue un rôle dans l'augmentation de l'importance des mots qui n'apparaissent que dans un document particulier.
En conséquence, les valeurs telles que "est" et "masu" sont réduites et l'importance peut être réglée correctement.
En d'autres termes, dans tf-idf, les mots avec une répartition biaisée des apparences sont plus importants, qui n'apparaissent plus souvent que dans un document spécifique et moins souvent dans d'autres documents.
Pondération par BOW tf-idf (implémentation)
Je voudrais réellement implémenter tf-idf. Paquet fourni par scikit-learn
Implémentez en utilisant TfidfVectorizer.
TfidfVectorizer utilise la formule expliquée dans "BOW tf-idf weighting (théorie)". Il est implémenté de manière légèrement améliorée, mais l'essentiel est le même.
La mise en œuvre de la représentation vectorielle d'un document à l'aide de TfidfVectorizer est la suivante.
#Lors de l'affichage, afficher avec 2 chiffres valides
np.set_printoptions(precision=2)
#Documents séparés
docs = np.array([
"Blanc noir rouge",
"Blanc blanc noir",
"Rouge noir"
])
vectorizer = TfidfVectorizer(use_idf=True, token_pattern="(?u)\\b\\w+\\b")
vecs = vectorizer.fit_transform(docs)
#Obtenir un élément de colonne
print(vectorizer.get_feature_names())
# tf-Obtient la matrice qui stocke la valeur idf
print(vecs.toarray())
#Résultat de sortie
['blanc', 'rouge', 'noir']
[[ 0.62 0.62 0.48]
[ 0.93 0. 0.36]
[ 0. 0.79 0.61]]
La nième ligne de vecs.toarray () correspond à la nième représentation vectorielle des documents originaux du document. Et la nième colonne de vecs.toarray () correspond à la représentation vectorielle de tous les mots.
Je vais compléter le code.
vectorizer = TfidfVectorizer()
#Cela générera un convertisseur pour la représentation vectorielle.
use_idf=False
#Si vous faites cela, seul tf sera pondéré.
TfidfVectorizer
#En effet, par défaut, un caractère ou une chaîne de caractères n'est pas traité comme un jeton.
#Token comme argument_pattern="(?u)\\b\\w+\\b"Ne devrait pas être exclu en ajoutant.
"(?u)\\b\\w+\\b"
#Il s'agit d'une expression régulière qui signifie «toute chaîne d'un ou plusieurs caractères», mais vous n'avez pas besoin de la comprendre en profondeur.
#(Pour être exact, il s'agit d'une expression régulière avec une séquence d'échappement ajoutée.)
vectorizer.fit_transform()
#Convertissez le document en vecteur.
#L'argument est un tableau de documents séparés (divisés) par un espace blanc.
#Vous pouvez convertir la sortie en un tableau Numpy ndarray avec toarray.
np.set_printoptions()
#C'est une fonction qui définit le format d'affichage du tableau numpy et vous pouvez spécifier des nombres valides avec précision.
#Dans cet exemple, il est affiché avec deux nombres valides.
Voici un exemple basé sur ceci
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
np.set_printoptions(precision=2)
docs = np.array([
"Pomme pomme", "Gorille de la pomme", "Trompette de gorille"
])
#Conversion en représentation vectorielle.
vectorizer = TfidfVectorizer(use_idf=True, token_pattern=u"(?u)\\b\\w+\\b")
vecs = vectorizer.fit_transform(docs)
print(vectorizer.get_feature_names())
print(vecs.toarray())
Résultat de sortie
['gorille', 'rap', 'Pomme']
[[ 0. 0. 1. ]
[ 0.71 0. 0.71]
[ 0.61 0.8 0. ]]
car similitude
Jusqu'à présent, nous avons vectorisé des documents afin de les juger quantitativement. En comparant les vecteurs, vous pouvez analyser la similitude entre les documents. Pour montrer à quel point un vecteur est proche d'un vecteur
Il y a une similitude cos.
La similitude cos est exprimée par la formule suivante et représente le cosinus (0 à 1) de l'angle formé par le vecteur. Par conséquent, la valeur de similarité cos est élevée lorsque les directions des deux vecteurs sont proches. Il prend une petite valeur lorsqu'il est tourné dans la direction opposée.
Gardez à l'esprit que "quand il est proche de 1, c'est similaire, et quand il est proche de 0, ce n'est pas le cas".
Une fois mis en œuvre, ce sera comme suit. np.dot () représente le produit interne et np.linalg.norm représente la norme du vecteur (longueur du vecteur).
import numpy as np
def cosine_similarity(v1, v2):
cos_sim = np.dot(v1, v2) / (np.linalg.norm(v1)*np.linalg.norm(v2))
return cos_sim
Voici un exemple d'utilisation.
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
docs = np.array([
"Pomme pomme", "Gorille de la pomme", "Trompette de gorille"
])
vectorizer = TfidfVectorizer(use_idf=True, token_pattern=u"(?u)\\b\\w+\\b")
vecs = vectorizer.fit_transform(docs)
vecs = vecs.toarray()
#Définir une fonction pour trouver la similarité cos
def cosine_similarity(v1, v2):
cos_sim = np.dot(v1, v2) / (np.linalg.norm(v1)*np.linalg.norm(v2))
return cos_sim
#Comparons la similitude
print("%1.3F" % cosine_similarity(vecs[0], vecs[1]))
print("%1.3F" % cosine_similarity(vecs[0], vecs[2]))
print("%1.3F" % cosine_similarity(vecs[1], vecs[2]))
Représentation vectorielle des mots
Word2Vec
Dans la section précédente, le document était représenté sous forme de représentation vectorielle, mais cette fois nous allons vectoriser les mots. En exprimant un mot sous forme de vecteur, vous pouvez quantifier la proximité de la signification du mot et rechercher des synonymes.
Des recherches récentes en ont fait un outil de vectorisation des mots nouvellement nés
Il existe quelque chose qui s'appelle Word2Vec.
En bref, pour saisir le sens et la grammaire des mots Un outil qui compresse les dimensions en vectorisant les mots.
On dit que le nombre de vocabulaire que les Japonais utilisent quotidiennement est de dizaines de milliers à des centaines de milliers. Word2Vec peut exprimer chaque mot comme un vecteur d'environ 200 dimensions.
Word2Vec facilite l'expression de relations mot à mot
"Roi"-"Homme"+"femme"="Reine"
"Paris"-"France"+"Japon"="Tokyo"
Il est également possible d'effectuer des opérations entre des mots tels que.
Ici, nous donnons à Word2Vec les données documentaires de l'article d'actualité "liveoor news corpus". Nous apprendrons les relations entre les mots.
À partir de maintenant, nous utiliserons Word2Vec pour rechercher des chaînes qui sont très pertinentes pour le mot «homme». Le flux est le suivant. Le nom de session correspondant est également répertorié en même temps.
1,Extrayez les articles d'actualité sous forme de corpus de texte et divisez-les en phrases et catégories.:"Module Glob", "avec instruction", "call corpus"
2,Divisez les documents extraits par partie et faites une liste.: 「janome(3)」
3,Générez un modèle avec Word2Vec.:"Word2Vec (implémentation)"
4,Recherchez des mots qui sont très pertinents pour un homme.:"Word2Vec (implémentation)"
module glob
Le module glob est un module pratique pour manipuler des fichiers et des répertoires, et vous pouvez spécifier le chemin à l'aide d'expressions régulières.
Fichier: la plus petite unité d'informations exploitée et gérée par l'utilisateur, comme des documents, des photos et de la musique.
Répertoire: un conteneur qui contient des fichiers ensemble.
Chemin: l'emplacement d'un fichier ou d'un répertoire sur votre ordinateur.
module glob
Ce qui est différent du module os (essentiellement le module utilisé lors de la manipulation de fichiers et de répertoires)
Le fait est que vous pouvez rechercher des fichiers judicieusement en utilisant des caractères spéciaux et des chaînes. Par exemple, si vous écrivez comme dans l'exemple suivant en utilisant un astérisque * Vous pouvez afficher tous les fichiers txt dans le répertoire de test.
import glob
lis = glob.glob("test/*.txt")
print(lis)
#Résultat de sortie
["test/sample.txt", "test/sample1.txt", "test/sample2.txt"]
Vous pouvez également utiliser une chaîne spéciale comme dans l'exemple ci-dessous. Dans cet exemple, tous les fichiers d'exemple (nombre) .txt du répertoire de test peuvent être affichés.
import glob
lis = glob.glob("test/sample[0-9].txt")
print(lis)
#Résultat de sortie
["test/sample1.txt", "test/sample2.txt"]
avec déclaration
Lors de la lecture d'un fichier normal
open()Ouvrez le fichier avec
read()Lisez le fichier avec etc.
close()Fermez le fichier avec.
Le deuxième argument "r" de open () dans l'exemple ci-dessous spécifie le mode lors de l'ouverture d'un fichier. Dans ce cas, cela signifie lecture, ce qui signifie qu'il est en lecture seule. De plus, par exemple, s'il est en écriture seule, spécifiez "w" pour signifier l'écriture.
f = open("a.text", "r", encoding="utf-8")
data = f.read()
f.close()
Mais avec cette notation J'ai oublié d'écrire fermer () Une erreur s'est produite en cours de route et le fichier n'a pas pu être fermé La mémoire peut être gaspillée.
Donc au lieu
Utilisez l'instruction with.
Utilisez l'instruction with Et le fichier est automatiquement fermé () Même si une erreur se produit lors de l'ouverture du fichier, une gestion correcte des exceptions sera effectuée automatiquement. très pratique.
Si vous utilisez l'instruction with, ouvrez le fichier comme suit. Le plus populaire dans cet exemple
Code de caractère UTF-Le fichier est sorti à 8.
Un code de caractère est un numéro attribué à chaque caractère pour gérer le caractère sur l'ordinateur.
with open("a.text", "r", encoding="utf-8") as f:
Dans la phrase with, par exemple
data = f.read()
Lisez le fichier avec etc. Si vous utilisez read () Lit toutes les données du fichier sous forme de chaîne de caractères.
Sortir le corpus
Un corpus était des données qui donnaient des informations à un document ou des données audio.
Selon la source de téléchargement, le corpus d'actualités de livingoor contient les données suivantes.
Parmi les "actualités vivantes" exploitées par NHN Japan Co., Ltd.
Recueillir des articles de presse couverts par la licence Creative Commons
Il est créé en supprimant autant que possible les balises HTML.
Il ne nécessite pas le travail de formatage des données normalement requis.
Prenons le répertoire que j'utilise comme exemple Vous pouvez vérifier le contenu du répertoire texte et du répertoire pour chaque catégorie avec le code suivant.
glob.glob("./5050_nlp_data/*")
glob.glob("./text/sports-watch/*")
Cette fois, sortez le corpus d'actualités de Liveoor sous forme de corpus de texte Il est divisé en phrases et catégories. Vous pouvez sortir le corpus et le classer en écrivant comme suit. À première vue, c'est compliqué, mais le contenu est très simple.
splitlines()Est
Une fonction intégrée qui décompose une chaîne aux pauses et renvoie une liste de chaque ligne.
import glob
def load_livedoor_news_corpus():
category = {
"dokujo-tsushin": 1,
"it-life-hack":2,
"kaden-channel": 3,
"livedoor-homme": 4,
"movie-enter": 5,
"peachy": 6,
"smax": 7,
"sports-watch": 8,
"topic-news":9
}
docs = [] #Le texte de tous les articles est stocké ici.
labels = [] #Traitez les catégories 1 à 9 d'articles stockés dans les documents comme des étiquettes.
#Exécuter pour les répertoires de toutes les catégories.
for c_name, c_id in category.items():
# {c_name}Dans la catégorie.items()Nom de la catégorie c obtenu de_Incorporez le nom à l'aide de la méthode de format.
files = glob.glob("./5050_nlp_data/{c_name}/{c_name}*.txt".format(c_name=c_name))
#Affiche le nombre de fichiers (nombre d'articles) appartenant à la catégorie.
print("category: ", c_name, ", ", len(files))
#Pour chaque article, obtenez l'URL, la date, le titre et le corps des informations comme suit.
for file in files:
#Étant donné que l'instruction with est utilisée, fermez()Est inutile.
with open(file, "r", encoding="utf-8") as f:
#Fractionner par caractère de saut de ligne
lines = f.read().splitlines()
#0e URL lors de la séparation,La date est répertoriée en premier, le titre est répertorié en deuxième et le texte de l'article est répertorié après le troisième.
url = lines[0]
datetime = lines[1]
subject = lines[2]
#Le texte de l'article sera rassemblé sur une seule ligne.
body = "".join(lines[3:])
#Je vais rassembler le titre et le texte.
text = subject + body
docs.append(text)
labels.append(c_id)
return docs, labels
#Obtenez les données textuelles de tous les articles et leurs étiquettes (catégories).
docs, labels = load_livedoor_news_corpus()
Cliquez ici pour des exemples d'utilisation réels
import glob
def load_livedoor_news_corpus():
category = {
"dokujo-tsushin": 1,
"it-life-hack":2,
"kaden-channel": 3,
"livedoor-homme": 4,
"movie-enter": 5,
"peachy": 6,
"smax": 7,
"sports-watch": 8,
"topic-news":9
}
docs = []
labels = []
#Copiez le code ci-dessus.
for c_name, c_id in category.items():
files = glob.glob("./5050_nlp_data/{c_name}/{c_name}*.txt".format(c_name=c_name))
text = ""
for file in files:
with open(file, "r", encoding="utf-8") as f:
lines = f.read().splitlines()
url = lines[0]
datetime = lines[1]
subject = lines[2]
body = "".join(lines[3:])
text = subject + body
docs.append(text)
labels.append(c_id)
return docs, labels
docs, labels = load_livedoor_news_corpus()
print("\nlabel: ", labels[0], "\ndocs:\n", docs[0])
print("\nlabel: ", labels[1000], "\ndocs:\n", docs[1000])
Word2Vec (implémentation)
Maintenant que nous avons introduit l'étape précédente, expliquons le sujet principal de Word2Vec.
Lors de l'utilisation de Word2Vec, importez depuis le module gensim.
from gensim.models import word2vec
Listes (documents divisés) utilisées pour l'apprentissage Générez un modèle en l'utilisant comme argument de la fonction Word2Vec.
Utilisez le janome.tokenizer géré dans "BOW count" etc. pour écrire à l'avance. Lors de l'écriture, recherchez la partie de chaque mot.
En japonais, seuls les «noms, verbes, adjectifs, verbes adjectifs» peuvent être utilisés pour analyser la pertinence des mots. Créez une liste séparée de seulement «noms, verbes, adjectifs, verbes adjectifs».
Word2Vec est utilisé comme suit.
model = word2vec.Word2Vec(liste, size=a, min_count=b, window=c)
#Cependant, un, b,c est un nombre
Les principaux arguments utilisés par Word2Vec sont les suivants.
taille: le nombre de dimensions du vecteur.
fenêtre: les mots avant et après ce nombre sont considérés comme des mots apparentés pour l'apprentissage.
min_count: ignorez les mots qui apparaissent moins de n fois.
Après un bon apprentissage, pour le modèle
.most_similar(positive=["mot"])
Si vous utilisez la méthode most_similar () comme Celui qui présente une forte similitude avec le mot est sorti.
Par exemple Utilisez word2vec pour afficher des mots étroitement liés au mot «homme». Pour l'argument de word2vec.Word2Vec, spécifiez [phrases] dans la liste. Définissez size = 100, min_count = 20, window = 15.
import glob
from janome.tokenizer import Tokenizer
from gensim.models import word2vec
#Chargement et classement des actualités Liveoor
def load_livedoor_news_corpus():
category = {
"dokujo-tsushin": 1,
"it-life-hack":2,
"kaden-channel": 3,
"livedoor-homme": 4,
"movie-enter": 5,
"peachy": 6,
"smax": 7,
"sports-watch": 8,
"topic-news":9
}
docs = []
labels = []
for c_name, c_id in category.items():
files = glob.glob("./5050_nlp_data/{c_name}/{c_name}*.txt".format(c_name=c_name))
text = ""
for file in files:
with open(file, "r", encoding="utf-8") as f:
lines = f.read().splitlines()
#1,L'heure n'est pas liée à l'URL écrite sur la deuxième ligne, supprimez-la donc.
url = lines[0]
datetime = lines[1]
subject = lines[2]
body = "".join(lines[3:])
text = subject + body
docs.append(text)
labels.append(c_id)
return docs, labels
#Extraire les mots des parties et créer une liste de "noms, verbes, adjectifs, verbes adjectifs"
def tokenize(text):
tokens = t.tokenize(",".join(text))
word = []
for token in tokens:
part_of_speech = token.part_of_speech.split(",")[0]
if part_of_speech in ["nom", "verbe", "adjectif", "形容verbe"]:
word.append(token.surface)
return word
#Classer en étiquettes et en phrases
docs, labels = load_livedoor_news_corpus()
t = Tokenizer() #Créez d'abord une instance de Tokenizer
sentences = tokenize(docs[0:100]) #Limité en raison de la grande quantité de données
#Veuillez créer une réponse ci-dessous
#word2vec.Concernant l'argument de Word2Vec, la taille=100, min_count=20, window=Veuillez régler à 15
model = word2vec.Word2Vec([sentences], size=100, min_count=20, window=15)
print(model.most_similar(positive=["Homme"]))
Doc2Vec
Doc2Vec（1）
Doc2Vec est une technologie de vectorisation de phrases qui applique Word2Vec.
J'ai étudié la vectorisation de phrases avec BOW dans "Document Vector Representation" La grande différence avec BOW est que l'ordre des mots des phrases peut également être pris en compte comme une caractéristique.
Ce qui suit est un examen des lacunes de BOW tirées de la représentation vectorielle des documents.
① Il n'y a pas d'informations sur l'ordre des mots pour les mots
② Je ne suis pas doué pour exprimer le sens des mots
Doc2Vec compense ces deux défauts.
Doc2Vec（2）
Nous allons implémenter Doc2Vec. Créé dans "Retrieving Corpus"
liveoor news corpus docs[0],docs[1],docs[2],docs[3]Comparez la similitude de.
Le flux ressemble à ceci
1,Partage
Utilisez le Tokenizer de janome pour écrire le texte séparément.
2,Créer une instance de la classe TaggedDocument
Mots dans l'argument de TaggedDocument="Chaque élément divisé", tags=["marque"]Quand vous donnez
Vous pouvez créer une instance de la classe TaggedDocument.
Les balises sont comme l'identifiant d'un document.
Stockez le TaggedDocument dans une liste et transmettez-le à Doc2Vec.
3,Génération de modèle avec Doc2Vec
La formation du modèle est décrite comme suit.
model = Doc2Vec(documents=liste, min_count=1)
# min_count:N'utilisez que des mots qui apparaissent au moins ce nombre de fois pour l'apprentissage
4,Sortie de similarité
Le résultat de la similitude est décrit comme suit.
for i in range(4):
print(model.docvecs.most_similar("d"+str(i)))
Cliquez ici pour un exemple d'utilisation récapitulatif
import glob
from gensim.models.doc2vec import Doc2Vec
from gensim.models.doc2vec import TaggedDocument
from janome.tokenizer import Tokenizer
#Chargement et classement des actualités Liveoor
def load_livedoor_news_corpus():
category = {
"dokujo-tsushin": 1,
"it-life-hack":2,
"kaden-channel": 3,
"livedoor-homme": 4,
"movie-enter": 5,
"peachy": 6,
"smax": 7,
"sports-watch": 8,
"topic-news":9
}
docs = []
labels = []
for c_name, c_id in category.items():
files = glob.glob("./5050_nlp_data/{c_name}/{c_name}*.txt".format(c_name=c_name))
text = ""
for file in files:
with open(file, "r", encoding="utf-8") as f:
lines = f.read().splitlines()
#1,L'heure n'est pas liée à l'URL écrite sur la deuxième ligne, supprimez-la donc.
url = lines[0]
datetime = lines[1]
subject = lines[2]
body = "".join(lines[3:])
text = subject + body
docs.append(text)
labels.append(c_id)
return docs, labels
docs, labels = load_livedoor_news_corpus()
#Traitement Doc2Vec
token = [] #Une liste qui stocke les résultats de chaque document
training_docs = [] #Liste à stocker TaggedDocument
t = Tokenizer() #Créez d'abord une instance de Tokenizer
for i in range(4):
# docs[i]Et stockez-le dans un jeton
token.append(t.tokenize(docs[i], wakati=True))
#Créez une instance de la classe TaggedDocument et entraînez les résultats_Stocker dans les documents
#La balise est"numéro d"ça ira
training_docs.append(TaggedDocument(words=token[i], tags=["d" + str(i)]))
#Veuillez créer une réponse ci-dessous
model = Doc2Vec(documents=training_docs, min_count=1)
for i in range(4):
print(model.docvecs.most_similar("d"+str(i)))
Classification du texte japonais
Classification du texte japonais
Catégorisez les catégories de texte japonais dans une forêt aléatoire. Encore une fois, nous utilisons des news de Liveoor. Les données fournies à la forêt aléatoire sont une représentation vectorielle de l'article de presse Il est divisé en 9 catégories. En exprimant les articles sous forme de vecteurs, vous pouvez classer les articles en appliquant les méthodes apprises dans l'apprentissage supervisé telles quelles.
Le flux d'apprentissage de ce chapitre est le suivant.
1,Chargement et classification des actualités de Liveoor: "Récupération du Corpus"
2,Diviser les données en données d'entraînement et en données de test: "Théorie et pratique de la méthode Holdout" dans Introduction à l'apprentissage automatique
3,tf-Vectoriser les données d'entraînement et de test avec idf: "BOW tf-Pondération par idf (implémentation) "," fonction d'ajustement "
4.Apprendre en forêt aléatoire: Classification supervisée "Forêt aléatoire"
5.Implémentation: "Implémentation d'une catégorie de corpus dans une forêt aléatoire"
6.Augmenter la précision: "Augmenter la précision"
fonction d'ajustement
scikit-learn Pour les classes de conversion (StandardScaler, Normalizer, TfidfVectorizer, etc.) Il existe des fonctions telles que fit (), fit_transform (), transform ().
fit()Fonction: Obtenez des statistiques (valeur maximale, valeur minimale, moyenne, etc.) des données transmises et enregistrez-les en mémoire.
transform()Fonction: fit()Réécrivez les données en utilisant les informations acquises dans.
fit_transform()Fonction: fit()Après transformation()Réaliser.
La fonction fit () est utilisée pour apprendre les paramètres de l'ensemble de données d'entraînement La fonction tranform () remodèle les données en fonction des paramètres appris. En d'autres termes (1) Pour les données d'entraînement, utilisez la fonction fit_transform (2) Dans le cas des données de test, il est basé sur le résultat de fit () des données d'entraînement. Vous devez exécuter la fonction transform ().
Catégoriser les catégories de corpus par forêt aléatoire
Utilisez ce que vous avez appris pour classer le corpus de livesoornews en forêts aléatoires.
Comme je l'ai écrit dans "Classification du texte japonais", le flux est le suivant.
1,Chargement et classification des actualités de Liveoor: "Récupération du Corpus"
2,Diviser les données en données d'entraînement et données de test: "Théorie et pratique de la méthode Holdout" dans Introduction à l'apprentissage automatique
3,tf-Vectoriser les données d'entraînement et de test avec idf: "BOW tf-Pondération par idf (implémentation) "," fonction d'ajustement "
4.Apprendre en forêt aléatoire: Classification supervisée «Forêt aléatoire»
5.Implémentation: "Implémentation d'une catégorie de corpus dans une forêt aléatoire"
6.Augmenter la précision: "Augmenter la précision"
mise à niveau de la précision
Nous travaillerons à améliorer la précision de la prédiction des catégories implémentée dans "Classifier les catégories de corpus par forêt aléatoire".
TfidfVectorizer()Aux paramètres de
tokenizer=Vous pouvez définir une fonction pour diviser le texte par la fonction spécifiée.
Par exemple, la fonction suivante Si tokenizer = est utilisé comme argument, il sera vectorisé avec du texte contenant "nom, verbe, adjectif, adjectif verbe". Cette fois, j'ai essayé d'améliorer la précision de prédiction de la catégorie en omettant les mots auxiliaires, etc. Selon le modèle, il peut être préférable d'inclure des mots auxiliaires.
from janome.tokenizer import Tokenizer
t=Tokenizer()
def tokenize(text):
tokens = t.tokenize(",".join(text))
noun = []
for token in tokens:
#Sortez la pièce
partOfSpeech = token.part_of_speech.split(",")[0]
if partOfSpeech == "nom":
noun.append(token.surface)
if partOfSpeech == "verbe":
noun.append(token.surface)
if partOfSpeech == "adjectif":
noun.append(token.surface)
if partOfSpeech == "Verbe adjectif":
noun.append(token.surface)
return noun