Utilisez MeCab pour traduire des phrases bâclées de manière "lente".

Quand je surfe sur le net, je flotte de railleries qui sortent des mots Masakari et Ahat Ahat. Si une telle balle perdue vole ici, comment devrions-nous la dépenser pour la santé mentale?

Une solution consiste à parer ces mauvaises phrases de santé mentale en les convertissant «lentement».

yukkurihonyaku.png

** Traduction lente ** http://needtec.sakura.ne.jp/yukkuri_translator/

Disons qu'on vous a dit: "Ne faites pas que des vidéos d'excréments, c'est de l'incompétence." Cependant, s'il est converti en "Ouais, ne le faites pas, ne le faites pas.", Vous ne vous fâcherez pas.

Ici, nous allons utiliser MeCab pour effectuer une analyse morphologique, et convertir lentement les phrases qui sont mauvaises pour la santé mentale pour éliminer l'inconfort, mais plutôt pour qu'elles se sentent chez elles.

Code source

yukkuri_translator.py


#!/usr/bin/env python
# -*- coding: utf-8 -*-
import MeCab
import jctconv
import sys
import codecs
reload(sys)
sys.setdefaultencoding('utf-8')
sys.stdout = codecs.getwriter('utf-8') (sys.stdout)


converter = {
    'manger' : 'Mush Mush',
    'manger' : 'Musha Musha',
    'dormir' : 'Suyasu',
    'dormir' : 'Suyasu',
    'Dormir' : 'Suyasuyashi',
    'Dormir' : 'Suyasuyashi',
    'merde' : 'Oui oui',
    'Tabouret' : 'Oui oui',
    'Vol' : 'Oui oui',
    'urine' : 'Shishi',
    'Pisse' : 'Shishi',
    'Soleil' : 'Soleil',
    'Les sanctions' : 'Du tout',
    'Confiserie' : 'Juste',
    'bonbons' : 'Juste',
    'sucre' : 'Juste',
    'jus' : 'Juste',
    'Coordination' : 'Coordination',
    'grossesse' : 'Ninshin'
}



class MarisaTranslator:
    def __init__(self, user_dic):
        self.mecab = MeCab.Tagger("-u " + user_dic)

    def _check_san(self, n):
        """
Juger s'il faut ajouter "san"
        """
        f = n.feature.split(',')
        if f[0] == 'nom':
            if f[1] == 'Nomenclature propriétaire' or f[1] == 'Général':
                if n.next:
                    #Vérifiez le mot suivant
                    nf = n.next.feature.split(',')
                    if nf[0] in ['nom', 'Verbe auxiliaire']:
                        #Si la nomenclature suit, n'ajoutez pas "san" ici
                        return False
                    else:
                        if n.surface.endswith('M.'):  # M.でおわる場合は付与しない
                            return False
                        if n.surface == 'm' or n.surface == 'Sama':  # mでおわる場合は付与しない
                            return False
                        return True
                else:
                    return True
        return False


    def _check_separator(self, n):
        """
Juger s'il faut ajouter ","
        """
        f = n.feature.split(',')
        if f[0] == 'Particule':
            if n.next:
                #Vérifiez le mot suivant
                nf = n.next.feature.split(',')
                if nf[0] in ['symbole', 'Particule']:
                    return False
                return True
        return False


    def _get_gobi(self, n):
        if n.next:
            f_next = n.next.feature.split(',')
            if n.next.surface == '、':
                return None
            if f_next[0] == 'BOS/EOS' or f_next[0] == 'symbole':
                f = n.feature.split(',')
                if f[0] in ['Particule', 'nom', 'symbole', 'Des mots impressionnants']:
                    return None
                if f[5] in ['Commande e', 'Type continu']:
                    return None
                if n.surface in ['Est']:
                    return 'Quoi'
                else:
                    return n.surface + 'Noze'
        return None

    def translate(self, src):
        n = self.mecab.parseToNode(src)
        text = ''
        pre_node = None
        while n:
            f = n.feature.split(',')
            if n.surface in converter:
                text += converter[n.surface]
            elif len(f) > 8:
                gobi = self._get_gobi(n)
                if gobi is not None:
                    text += gobi
                elif f[8] != '*':
                    text += f[8]
                else:
                    text += n.surface
            else:
                text += n.surface
            if self._check_san(n):
                text += 'M.'
            elif self._check_separator(n):
                text += '、'
            n = n.next
            pre_node = n
        return jctconv.kata2hira(text.decode('utf-8')).encode('utf-8')

Exemple d'utilisation de la classe ci-dessus:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from yukkuri_translator import MarisaTranslator


if __name__ == "__main__":
    t = MarisaTranslator('yukkuri.dic')
    print t.translate('Ne faites pas que des vidéos d'excréments, cette faible capacité.')

La description

Conversion en hiragana

En rendant tous les caractères kana simples, cela devient une ligne comme un cerveau de 餡子.

Pour ce faire, effectuez d'abord une analyse morphologique avec MeCab. Cela vous donnera la lecture de chaque mot. Cela s'applique à 8 fonctionnalités (en commençant par 0). Puisque cette lecture est en katakana, utilisez jctconv pour tout convertir en pseudonyme simple.

Il peut être mal lu, mais il s'agit de ** spécification ** car ce n'est qu'un sushi.

Puisqu'il ne s'agit que d'un pseudonyme plat, ajoutez "," de manière appropriée.

En raison de la lenteur des spécifications, les pseudonymes plats seront beaucoup utilisés. Par conséquent, afin d'améliorer la lisibilité, ajoutez autant que possible "," après le mot auxiliaire. Voir "_check_separator" pour plus d'informations sur cette condition.

Ajouter "san" à la fin de "nom"

En ajoutant "san" à la fin de la nomenclature, vous pouvez exprimer la lenteur. Si la nomenclature continue, il existe des conditions telles que l'exclusion, veuillez donc vérifier "_check_san" pour plus de détails.

Ajouter "noze" à la fin du mot

La fin de Slow Marisa a une caractéristique, et dans de nombreux cas, la fin de la phrase se termine par "Noze" ou "Nanoze", donc je l'ai reproduite.

Un exemple est le suivant.

La gestion des paiements et des dépenses est la norme

S'il y a

Il est naturel de gérer les dépenses

Ce sera.

Veuillez vous référer à "_get_gobi" pour la condition de la fin.

Remplacer le mot

Essayez de remplacer quelques mots. Par exemple, le mot sale «feces» est remplacé par «yes» pour stabiliser l'esprit de l'utilisateur. Ce remplacement est effectué en fonction du contenu enregistré dans la variable du convertisseur.

Résumé

En utilisant l'analyse morphologique de MeCab, il a été confirmé que les phrases mauvaises pour la santé mentale peuvent être déguisées comme si elles parlaient lentement et gentiment.

En appliquant cela, on pense qu'il est possible de traduire en phrases comme "Slowly Reimu", "Slowly Youmu" et "Yaruo".

Voici une application qui s'exécute sur le Web et son code.

** Traduction lente ** http://needtec.sakura.ne.jp/yukkuri_translator/ https://github.com/mima3/yukkuri_translator

c'est tout.

Recommended Posts

Utilisez MeCab pour traduire des phrases bâclées de manière "lente".
Un moyen simple d'utiliser Wikipedia avec Python
Un mémorandum parce que j'ai trébuché en essayant d'utiliser MeCab avec Python
Une manière intelligente de chronométrer le traitement avec Python
Détecter les anomalies dans les phrases en utilisant ELMo, BERT, USE
Un mémorandum sur l'utilisation de keras.preprocessing.image de Keras
Pratique pour utiliser les sous-graphiques matplotlib dans l'instruction for
Correction d'un moyen pour l'UEFI de forcer Windows à démarrer
Ajouter un dictionnaire à MeCab
Comment utiliser pyenv et pyenv-virtualenv à votre manière
Un moyen simple d'éviter plusieurs boucles for en Python
Un moyen standard de développer et de distribuer des packages en Python
Introduction d'une bonne méthode de gestion des connexions DB en Python
Un moyen simple de réexécuter une commande précédemment exécutée dans ipython
[Introduction à Python] Comment utiliser l'opérateur in dans l'instruction for?
La meilleure façon d'utiliser MeCab et CaboCha avec Google Colab
Comment utiliser les classes dans Theano
Comment utiliser SQLite en Python
Comment utiliser Mysql avec python
Comment utiliser ChemSpider en Python
Comment utiliser PubChem avec Python
Connectez-vous à postgreSQL depuis Python et utilisez des procédures stockées dans une boucle.
Utilisez un raccourci pour activer ou désactiver le pavé tactile dans Linux Mint
Je pensais qu'il serait lent d'utiliser l'instruction for dans NumPy, mais ce n'était pas le cas.
Comment utiliser les colonnes calculées dans CASTable
[Introduction à Python] Comment utiliser la classe en Python?
Utiliser l'impression dans l'expression lambda Python2
Je veux imprimer dans la notation d'inclusion
Comment utiliser mecab, neologd-ipadic sur colab
Comment utiliser Google Test en langage C
Comment obtenir stacktrace en python
Connaissances minimales pour utiliser Form avec Flask
Comment utiliser l'interpréteur d'Anaconda avec PyCharm
Comment utiliser __slots__ dans la classe Python
[V11 ~] Un mémorandum à mettre dans Misskey
Utilisez Python 3 Subprocess.run () dans le script CGI
Comment utiliser les expressions régulières en Python
Comment utiliser Map dans ViewPager d'Android
Comment utiliser is et == en Python
Utiliser WebDAV dans un environnement Docker portable
Flutter dans Docker - Comment créer et utiliser un environnement de développement Flutter dans un conteneur Docker
Utilisez libsixel pour générer Sixel en Python et générer le graphe Matplotlib vers le terminal.
Utilisez dHash pour localiser sur le parcours à partir d'une scène dans un jeu de course
Recherche d'un moyen efficace d'écrire un Dockerfile avec Python avec de la poésie
Le programme Python est lent! Je veux accélérer! Dans ce cas ...
Comment utiliser loc / iloc / ix pour obtenir en spécifiant une colonne dans CASTable