[PYTHON] Vérification des performances du prétraitement des données dans le traitement du langage naturel

introduction

Lors de la systématisation de l'apprentissage automatique, un savoir-faire est nécessaire pour prendre en compte le temps et les ressources nécessaires au prétraitement des données et les utiliser dans la conception. Dans cet article, nous présenterons un aperçu du prétraitement des données pour les langages naturels et des résultats de vérification des performances basés sur le prétraitement des données dans chABSA-dataset, qui est un exemple de mise en œuvre de l'analyse de la polarité des émotions.

Liste des messages

1. Présentation du traitement du langage naturel et de son prétraitement
2. Vérification des performances du prétraitement des données dans le traitement du langage naturel ... This post

La table des matières de cet article est la suivante.

• [3. Exemple de ressources et de temps de traitement requis pour le prétraitement du traitement du langage naturel](# 3-Exemple de ressources et du temps de traitement requis pour le prétraitement du traitement du langage naturel)
• [3.1 Environnement de vérification](# 31-Environnement de vérification)
• [3.2 Contenu de l'expérience](# 32-Contenu expérimental)
• [3.2.1 Flux expérimental](# 321-Flux expérimental)
• [3.2.2 Comparaison des bibliothèques divisionnaires](# 322-Comparaison des bibliothèques d'écriture divisionnaires)
• [(1) Bibliothèque dépendante](Bibliothèque dépendante n ° 1)
• [(2) Comment appeler le traitement (fonction) dans le code](# 2-Comment appeler le traitement (fonction) dans le code)
• [(3) format de données E / S dans le code](# 3-io-format de données dans le code)
• [3.3 Résultats expérimentaux](# 33-Résultats expérimentaux)
• [3.4 Examen des résultats expérimentaux](# 34-Discussion des résultats expérimentaux)
• Résumé

3. Exemple de ressources et de temps de traitement nécessaires pour le prétraitement du traitement du langage naturel

Ici, le prétraitement des données (tableau 2 de la première partie) dans le jeu de données chABSA est exécuté, et la quantité de ressources et le temps de traitement requis sont vérifiés. En particulier, modifiez la bibliothèque utilisée pour le processus de division de Janome à MeCab et comparez la quantité de ressources et le temps de traitement dans les deux modèles.

3.1 Environnement de vérification

Le tableau 4 montre les performances de la machine virtuelle (VM) utilisée dans cette expérience.

Tableau 4 Spécifications de VM utilisées pour la vérification

Bien que les ressources GPU soient souvent utilisées dans le traitement d'images, elles ne sont pas nécessaires dans le traitement des données textuelles. Par conséquent, nous n'utiliserons pas de ressources GPU dans cette expérience.

Le tableau 5 montre les versions de logiciel utilisées dans la vérification.

Tableau 5 Version du logiciel utilisé pour la vérification

3.2 Contenu de l'expérience

3.2.1 Flux expérimental

[Dernier message](https://qiita.com/mkakida/items/eba36f519b08dbda1d82#22-%E5%8F%96%E3%82%8A%E6%89%B1%E3%81%86%E5%89 % 8D% E5% 87% A6% E7% 90% 86% E3% 81% AE% E6% A6% 82% E8% A6% 81) Normaliser le prétraitement des données dans l'ensemble de données chABSA indiqué dans le tableau 2) La quantité de ressources informatiques utilisées dans chaque processus et le temps de traitement sont mesurés. En ce qui concerne le traitement de vectorisation, la vectorisation n'est pas la cible de la mesure dans cette expérience car le contenu du traitement dépend largement de la mise en œuvre du modèle et il est peu probable que les résultats de mesure soient utiles pour d'autres projets.

Le tableau 6 redéfinit le traitement de la cible de mesure dans cette expérience. Chacun de ces processus est exécuté indépendamment et séquentiellement. De plus, bien que 2 260 types de données d'entreprises indépendantes soient traitées dans chaque processus, les données de chaque entreprise sont traitées séquentiellement et non en parallèle en raison de la mise en œuvre de l'ensemble de données chABSA.

Tableau 6 Processus à tester

3.2.2 Comparaison de bibliothèques d'écriture séparées

Dans le jeu de données chABSA, la partie traitement de division du traitement d'extraction des données d'analyse est implémentée à l'aide de Janome. Dans cette expérience, le traitement de division implémenté dans Janome est réécrit sur le traitement dans MeCab, et le temps de traitement requis est comparé.

Les trois points suivants seront modifiés lors de la réécriture du processus d'écriture de la division.

(1) Bibliothèque dépendante

Janome est fourni sous forme de package Python encapsulé dans un dictionnaire et ne peut être utilisé qu'en installant le package avec pip. En plus d'installer le package Python à l'aide de pip, MeCab nécessite l'installation du middleware MeCab (par exemple, le package rpm) pour chaque système d'exploitation.

(2) Comment appeler le traitement (fonction) dans le code

Bien que la cible d'importation et le nom de la fonction de division soient différents, la méthode d'appel elle-même est presque la même entre les bibliothèques.

(3) Format des données d'E / S dans le code

Pour Janome et MeCab, l'entrée est des données de type chaîne de caractères qui stockent des phrases, mais le type de données de sortie est différent. La sortie de la fonction de division de Janome est des données de type tableau qui ont chaque mot comme élément, tandis que la sortie de la fonction de division de MeCab est des données de type chaîne de caractères dans lesquelles chaque mot est séparé par un espace demi-largeur.

Par exemple, lorsque vous entrez la phrase de données de chaîne de texte et réécrivez le code qui renvoie le résultat de la division en jetons, réécrivez-le en tant que code 1 en code 2.

Code 1 Exemple de code fractionné utilisant Janome

##Exemple d'utilisation de Janome
from janome.tokenizer import Tokenizer
...(réduction)...

#Création d'instance
tokenizer = Tokenizer(wakati=True)

#Phrase de données de chaîne de caractères Saisissez la phrase et affichez le résultat de la division en jetons
tokens = tokenizer.tokenize(sentence)

#Les jetons définis sont un tableau avec chaque mot comme élément
...(réduction)...

Code 2 Exemple de code utilisant MeCab

##Exemple d'utilisation de Mecab
import MeCab
...(réduction)...

#Instance MeCab pour la sortie de fractions
mecab = MeCab.Tagger("-Owakati")

#Phrase de données de chaîne de caractères Saisissez la phrase et affichez le résultat de la division en jetons
tokens = mecab.parse(sentence)

#Les jetons définis sont une chaîne de caractères unique dans laquelle les mots sont séparés par un espace d'un octet.
# tokens.split(" ")Ensuite, la même sortie que dans le cas de Janome
...(réduction)...

3.3 Résultats expérimentaux

Les figures 1 à 3 montrent les résultats de l'exécution du prétraitement des données de l'ensemble de données chABSA présenté dans le tableau 2 de la première partie. La figure 1 montre le temps nécessaire pour exécuter chaque processus, et vous pouvez voir le temps total d'exécution et la répartition des processus # 1 à # 3. La figure 2 montre le taux d'utilisation moyen du processeur pendant chaque exécution de processus, et la figure 3 montre l'utilisation moyenne de la mémoire pendant chaque exécution de processus séparément pour chaque processus. Dans chaque figure, le traitement n ° 3 est présenté séparément pour l'implémentation Janome et l'implémentation MeCab.

Figure 1 Temps d'exécution du traitement

D'après la figure 1, indépendamment du fait que le traitement n ° 3 soit mis en œuvre dans Janome ou MeCab, le traitement n ° 1 prend environ 26 minutes, tandis que les autres traitements n ° 2 et n ° 3 sont combinés pendant environ 2 minutes au plus. On constate qu'il existe une grande différence de temps d'exécution pour chaque processus. Dans le processus chronophage n ° 1, un fichier de données au format xbrl de quelques Mo est lu et analysé pour chaque entreprise, et le HTML et les métadonnées des données de performance sont extraits. Étant donné que les données extraites par le traitement n ° 1 ont une quantité de données d'au plus plusieurs dizaines de Ko pour chaque entreprise, on considère qu'il existe une différence de sorte que l'ordre du temps de traitement change entre le traitement n ° 1 et les autres.

En outre, à partir de la figure 1, on peut voir que le processus n ° 3 pour effectuer la division et la normalisation est environ huit fois plus rapide lors de la mise en œuvre de la division avec Janome que lors de sa mise en œuvre avec MeCab. Cela est dû au fait que la bibliothèque Janome elle-même est un script Python, tandis que MeCab est implémenté en C ++.

Figure 2 Utilisation moyenne du processeur

Sur la figure 2, on peut voir que le taux d'utilisation du processeur pour les traitements n ° 1, n ° 2 et n ° 3-Janome est d'environ 90%, tandis que celui du n ° 3-MeCab est d'environ 70%. Cette différence est affectée par le rapport entre le temps nécessaire pour lire les données dans chaque processus.

Par exemple, la comparaison de # 3-Janome et # 3-MeCab, comme le montre la figure 1, # 3-MeCab prend environ 5 secondes pour l'ensemble du processus, tandis que # 3-Janome prend environ 40 secondes. .. Dans chaque processus, en plus de lire les mêmes données d'entrée à partir du fichier, le fichier corpus japonais pour l'écriture de division est lu en interne. Étant donné que le processeur attend pendant la lecture de ce fichier, il est possible que l'utilisation du processeur diminue. De même, l'utilisation du processeur du processus n ° 2 est inférieure à celle du processus n ° 1 en raison du rapport entre le temps de lecture des données et le temps de traitement.

Figure 3 Utilisation moyenne de la mémoire

À partir de la figure 3, nous pouvons d'abord voir qu'il existe une grande variation dans l'utilisation de la mémoire entre les processus. On pense que cela est dû au type et à la quantité de données traitées, ainsi qu'au type et à la quantité de bibliothèques chargées au moment de l'exécution du traitement. Le processus n ° 1 qui extrait les informations de performance des données brutes au format XBRL, qui est un type de XML, et le processus n ° 2 qui supprime les balises des données de données de performance (XML + HTML) utilisent des bibliothèques similaires. Cependant, la taille des données traitées est différente. Les données brutes qui représentent le rapport sur les titres de chaque société saisie dans le traitement n ° 1 ont une taille d'environ plusieurs Mo, tandis que les données d'entrée dans le traitement n ° 2 ne sont que la partie des informations sur les performances, elles ont donc plusieurs à plusieurs dizaines de Ko. Ce sera. En raison de cette différence dans la taille des données d'entrée devenant importante en raison du format d'expression de données à l'intérieur du programme, de la façon de conserver les données intermédiaires et de la différence dans le contenu détaillé du traitement, la différence dans l'utilisation de la mémoire entre le traitement n ° 1 et le traitement n ° 2 est de plusieurs dizaines. On pense qu'il est devenu MB. Concernant le traitement # 3-Janome et le traitement # 3-MeCab, l'implémentation de la librairie utilisée est très différente. En termes de langage, Janome est écrit uniquement en langage Python, tandis que MeCab est écrit en C ++. On pense que la différence dans le langage d'implémentation interne se reflète dans la différence d'utilisation de la mémoire.

3.4 Prise en compte des résultats expérimentaux

Dans cet article, à titre d'exemple de prétraitement de données dans le traitement du langage naturel, nous avons mené une expérience en utilisant le prétraitement des données de l'ensemble de données chABSA comme sujet. On ne peut pas dire que c'est une règle générale pour tout traitement du langage naturel, mais comme résultat expérimental d'un cas, on peut voir que la façon de penser suivante peut être faite.

--Prémisse

• La quantité totale de données brutes existe dans l'ordre de Go, mais les données sont divisées en fichiers de commande de Mo.
• Ne pas exécuter de traitement parallèle

--En pensant

• La ressource de goulot d'étranglement est le processeur, et le traitement de goulot d'étranglement est l'analyse des données brutes.
• Si l'utilisation de la mémoire pendant le prétraitement est susceptible de correspondre à l'ordre des Mo et que les restrictions de temps de traitement sont lâches, vous n'avez pas besoin d'un serveur coûteux avec une mémoire de grande capacité.
• Si les contraintes de temps sont fortes, une accélération peut être attendue en effectuant une parallélisation dans la plage où la mémoire du serveur ne devient pas un nouveau goulot d'étranglement.
• Si le processus d'écriture fractionnée est implémenté dans Janome, il peut être facilement réécrit dans MeCab, ce qui devrait accélérer et réduire l'utilisation de la mémoire. En effet, Janome est une implémentation Python, tandis que MeCab est une implémentation C ++. Cependant, comme nous l'avons expérimenté dans cet article, il convient de noter qu'il existe des cas où le rapport entre le temps d'exécution de l'écriture de division et l'ensemble du prétraitement est petit et l'effet de l'accélération est important dans le traitement parallèle. Dans l'expérience de cet article, la quantité de données extraites à diviser (chapitre des réalisations) était aussi petite que 3,5 Mo pour la quantité totale de données brutes (rapport sur les titres) de 7,9 Go, donc le temps de traitement L'analyse des données brutes a représenté la plupart des. En revanche, dans le cas où la différence entre les données brutes et les données à diviser est faible, on considère que le temps d'exécution du traitement de division devient plus long et que l'effet d'accélération du traitement de division devient plus grand.

Résumé

Dans cet article, nous avons présenté les résultats de la vérification des performances et leur prise en compte au sujet du prétraitement des données dans chABSA-dataset, qui est un exemple d'implémentation de l'analyse de polarité des émotions.

• En conséquence, la majeure partie du temps d'exécution du traitement a été consacrée à l'analyse des données brutes. On pense que cela est dû au fait que la taille des données à traiter diminue de l'ordre des Mo à l'ordre des Ko avant et après l'analyse des données brutes. De plus, lorsque l'on compare le cas où le processus d'écriture de division est implémenté avec Janome et le cas où il est implémenté avec MeCab, MeCab a un temps d'exécution et une consommation de mémoire plus petits. ――Lorsque la taille des données change de manière significative avant et après l'analyse des données brutes, comme dans ce cas, il existe une forte possibilité que la partie où la quantité de données à traiter est importante devienne un goulot d'étranglement. On peut s'attendre à une accélération en parallélisant le traitement tant que la mémoire ne devient pas un nouveau goulot d'étranglement.