introduction

échantillon

`result`



"Obake" peut être chanté par "you"[Degré de similitude:0.24651645]

Sujet principal

API externe utilisée pour créer l'outil

Code source

https://github.com/kE-sakai/rhyming-app-v1

Ce que j'ai fait

――① Outil de recherche de mots qui peut marcher sur la rime --API utilisé

API COTOHA Similarity Judgment -② Outil de génération de pool de mots de recherche --API utilisé
API d'analyse de syntaxe COTOHA
API d'acquisition d'article Qiita Post

① Outil de recherche de mots qui peut marcher sur la rime

rôle

Un outil pour extraire des mots spécifiés et des mots rimés à partir de fichiers CSV
Jugement de similitude entre les mots en utilisant l'API COTOHA en option

Figure

Comment ça fonctionne

--Convertissez le mot spécifié et le mot dans le fichier CSV en Romaji en utilisant pykakashi

`converter`


    def convert_hiragana_to_roma(self, target_word_hiragana):
        #En cas d'incitation
        #Puisque "tsu" et "tsu" sont convertis en le même "tsu", utilisez "x" comme caractère spécial.
        if target_word_hiragana == "Tsu":
            return "x"
        else:
            kakasi_lib = kakasi()
            #Hira Kana en caractères romains
            kakasi_lib.setMode('H', 'a')
            conv = kakasi_lib.getConverter()

            target_word_roma = conv.do(target_word_hiragana)
            return target_word_roma

Extraire les modèles de voyelles de Romaji et comparer s'ils sont le même modèle

conditions	Mot original	Avant la conversion	Après la conversion
Seules les voyelles	Obake	obake	oae
Contient un rappel	plein	ippai	ixai
"N" est inclus	brochet	sanma	ana
"-" Est inclus	Tonnerre	sanda-	anaa

`converter`


    #Convertir le pseudonyme de lecture en modèle phonologique
    def convert_roma_to_phoneme_pattern(self, target_char_roma_list):
        pre_phoneme = None
        hit_list = []
        for target_char_roma in target_char_roma_list:
            #Étui de vase
            #N'importe lequel de "Ah, euh, eh, oh"
            vowel_char = self.__find_vowel_char(
                target_char_roma
            )
            specific_char = self.__find_specific_char(
                pre_phoneme,
                target_char_roma
            )

            if vowel_char:
                hit_list.append(vowel_char)
                pre_phoneme = vowel_char
            elif specific_char:
                #Pas une voyelle, mais un cas cible
                #""
                #"Hmm"
                #"-"
                hit_list.append(specific_char)
                pre_phoneme = specific_char
            else:
                continue

        phoneme_pattern = "".join(hit_list)
        return phoneme_pattern

    def __find_vowel_char(self, char_roma):
        #Pour les voyelles
        vowel_list = ["a", "i", "u", "e", "o"]
        for vowel in vowel_list:
            if char_roma.find(vowel) > -1:
                return vowel
            else:
                continue
        #Si ce n'est pas une voyelle
        return None

    def __find_specific_char(self, pre_phoneme, char_roma):
        #Dans le cas de "n"
        #Dans le cas de "tsu":
        if char_roma == "n" or char_roma == "x":
            return char_roma
        #Dans le cas de "-"
        #Considérez la même chose que la voyelle précédente
        #Exemple)Daa-> a
        elif pre_phoneme != None and char_roma == "-":
            return pre_phoneme
        else:
            return None

Exemple d'exécution

`execute`


$cd src
$python main.fantôme de py

`result`


«Obake» peut être rimé avec «réponse»
"Obake" peut s'attarder avec "vous"

Jugement de similarité

Après avoir extrait la combinaison de mots qui peuvent être rimés, définissez le mot spécifié sur «base_word» et le mot extrait de CSV sur «pool_word» pour analyse.

`cotoha_client.py`


    def check_score(self, base_word, pool_word, access_token):
        headers = {
            "Content-Type": COTOHA_CONTENT_TYPE,
            "charset": COTOHA_CHAR_SET,
            "Authorization": "Bearer {}".format(access_token)
        }
        data = {
            "s1": base_word,
            "s2": pool_word,
            "type": "default"
        }
        req = urllib.request.Request(
            f"{COTOHA_BASE_URL}/{COTOHA_SIMILARITY_API_NAME}",
            json.dumps(data).encode(),
            headers
        )
        time.sleep(COTOHA_REQUEST_SLEEP_TIME)
        with urllib.request.urlopen(req) as res:
            body = res.read()
            return json.loads(body.decode())["result"]["score"]

Exemple d'exécution

`execute`


$cd src
$python main.fantôme de py

`result`


«Obake» peut être chanté avec «réponse»[Degré de similitude:0.063530244]
"Obake" peut être chanté par "you"[Degré de similitude:0.24651645]

Tâche

Le fichier CSV d'origine est corrigé

À l'origine, pendant le développement, j'ai utilisé la liste de nomenclature attachée à mecab comme pool de mots. «Je pensais que ce serait plus intéressant si je pouvais créer un mécanisme pour augmenter le nombre et les types de vocabulaire, j'ai donc proposé un outil pour générer un pool de mots.

② Outil de génération de pool de mots

rôle

(1) Un outil qui génère un CSV pour la recherche de mots utilisé dans un outil de recherche de mots qui peut marcher sur la rime.

Diagramme

Comment ça fonctionne

Obtenez le titre de l'article publié obtenu par l'API d'acquisition d'articles publiés par Qiita

`qiita_client.py`


    def list_articles(self):
        req = urllib.request.Request(
            f"{QIITA_BASE_URL}/{QIITA_API_NAME}?page={QIITA_PAGE_NUMBERS}&per_page={QIITA_ITEMS_PAR_PAGE}"
        )
        with urllib.request.urlopen(req) as res:
            body = res.read()
            return json.loads(body.decode())

--Classez les titres acquis en parties en appliquant l'API d'analyse syntaxique de COTOHA

`cotoha_client.py`


    # target_Mettez le titre de l'article de Qiita en phrase
    def parse(self, target_sentence, access_token):
        headers = {
            "Content-Type": COTOHA_CONTENT_TYPE,
            "charset": COTOHA_CHAR_SET,
            "Authorization": "Bearer {}".format(access_token)
        }
        data = {
            "sentence": target_sentence,
        }
        req = urllib.request.Request(
            f"{COTOHA_BASE_URL}/{COTOHA_PARSE_API_NAME}",
            json.dumps(data).encode(),
            headers
        )
        time.sleep(COTOHA_REQUEST_SLEEP_TIME)
        with urllib.request.urlopen(req) as res:
            body = res.read()
            return json.loads(body.decode())["result"]

Extraire uniquement le nomen des mots de la pièce et la sortie dans un fichier CSV

`finder.py`


    #Extraire uniquement la nomenclature du résultat de l'analyse syntaxique et renvoyer la liste
    def find_noun(self, target_sentence_element):
        noun_list = []
        for element_num in range(len(target_sentence_element)):
            tokens = target_sentence_element[element_num]["tokens"]

            for tokens_num in range(len(tokens)):
                target_form = tokens[tokens_num]["form"]
                target_kana = tokens[tokens_num]["kana"]
                target_pos = tokens[tokens_num]["pos"]

                #S'il s'agit d'une nomenclature, enregistrez-la dans la liste
                if target_pos == TARGET_CLASS:
                    #Les mots anglais, les nombres et les symboles stockent des pseudonymes de lecture à la place
                    # TODO:Il y a place à l'amélioration dans le jugement.
                    if re.match(FINDER_REGEX, target_form):
                        noun_list.append(target_kana)
                    else:
                        noun_list.append(target_form)

        return noun_list

Exemple d'exécution

`execute`


$cd tool
$python word_pool_generator.py

`word_pool.csv`


sauvegarde
outil
abc
chaîne
visuel
studio
code
Remarque
la gestion
Expansion
Résumé
papier
Commentaire

Tâche

«Honnêtement, c'est lourd. Même 40 articles publiés prendront environ 5 minutes à traiter. ――Le nombre de nomenclatures pouvant être extraites dans un titre d'article est d'environ 2 à 5. «Cependant, comme je touchais à« pandas »pour la première fois lors de la sortie dans un fichier CSV, je pense que je peux encore améliorer la logique. «C'est un niveau que j'ai fait quelque chose qui fonctionne pour le moment.

Amélioration du jugement des mots anglais ――Dans la logique actuelle, «Raspberry Pi» n'est pas «Raspberry Pi» mais «RSPBRRWPI». Par exemple, si vous ne pouvez passer que "Raspberry" à l'API d'analyse syntaxique et le juger comme "Raspberry", il semble que vous puissiez vous sentir un peu mieux en inventant la manière de passer les mots. «Au fait," Google "était" Google ".

――Être capable d'augmenter la variation des mots ――Il semble que vous puissiez collecter des mots provenant d'autres domaines en grattant sur d'autres sites.

Articles que j'ai utilisés comme référence

https://note.com/junkawashima/n/n146874f827bc
https://qiita.com/komorin0521/items/8cd1eb0cdb4a9ede217e

Autre

Sur le motif qui a fait

«La raison pour laquelle j'ai fait ce genre de chose en premier lieu est que j'ai vu cet article il y a environ six mois et j'ai dit avec un ami:« Je peux utiliser le traitement du langage naturel pour rimer. J'ai eu une conversation, "Puis-je trouver un mot?" Cependant, je ne connaissais pas du tout le domaine du traitement du langage naturel à ce moment-là (même maintenant), et quand j'ai vu ce projet, j'ai pensé que je pouvais en faire quelque chose de proche, alors j'ai décidé de créer cet outil. Je l'ai fait.