Préparation

Bibliothèque à utiliser

import MeCab
import ngram
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties

Enregistrer le texte analysé morphologiquement sous forme de fichier

Le texte du roman de Soseki Natsume "Je suis un chat" ( neko.txt ) est analysé morphologiquement à l'aide de MeCab, et le résultat est enregistré dans un fichier appelé neko.txt.mecab. Utilisez ce fichier pour implémenter un programme qui répond aux questions suivantes. Pour les problèmes 37, 38, 39, utilisez matplotlib ou Gnuplot.

Créez une fonction appelée make_analyzed_file, effectuez une analyse morphologique et enregistrez-la dans un fichier. On suppose que neko.txt est téléchargé à l'avance et enregistré dans le même dossier que le fichier d'exécution.

def make_analyzed_file(input_file_name: str, output_file_name: str) -> None:
    """
Analyse morphologique de fichiers texte japonais simples et enregistrement dans un fichier.
    :param input_file_name Nom du fichier de phrases en japonais brut
    :param output_file_name Nom du fichier de phrases qui a été analysé morphologiquement
    """
    _m = MeCab.Tagger("-Ochasen")
    with open(input_file_name, encoding='utf-8') as input_file:
        with open(output_file_name, mode='w', encoding='utf-8') as output_file:
            output_file.write(_m.parse(input_file.read()))

make_analyzed_file('neko.txt', 'neko.txt.mecab')

30. Lecture des résultats de l'analyse morphologique

Implémentez un programme de lecture des résultats d'analyse morphologique (neko.txt.mecab) Cependant, chaque élément morphologique est stocké dans un type de mappage avec la clé de forme de surface (surface), de forme de base (base), une partie du mot (pos) et une partie du mot sous-classification 1 (pos1), et une phrase est exprimée sous la forme d'une liste d'éléments morphologiques (type de mappage). Faisons le. Pour le reste des problèmes du chapitre 4, utilisez le programme créé ici.

Convertissez simplement les résultats de l'analyse morphologique des chaînes de caractères délimitées par des tabulations en type dictionnaire et enregistrez-les dans «morphèmes», et enregistrez chaque phrase dans «phrases».

def tabbed_str_to_dict(tabbed_str: str) -> dict:
    """
Par exemple, "progressivement Shidaini complément graduellement-Convertit une chaîne de caractères qui représente un élément morphologique avec un délimiteur de tabulation tel que "général" en type Dict.
    :param tabbed_str Chaîne délimitée par des tabulations représentant la morphologie
    :Un élément morphologique représenté par le type de retour Dict
    """
    elements = tabbed_str.split()
    if 0 < len(elements) < 4:
        return {'surface': elements[0], 'base': '', 'pos': '', 'pos1': ''}
    else:
        return {'surface': elements[0], 'base': elements[1], 'pos': elements[2], 'pos1': elements[3]}


def morphemes_to_sentence(morphemes: list) -> list:
    """
Regrouper et lister la liste des éléments morphologiques représentés par type Dict par ponctuation.
    :param morphemes Liste des éléments morphologiques représentés par type Dict
    :retour Liste des phrases
    """
    sentences = []
    sentence = []

    for morpheme in morphemes:
        sentence.append(morpheme)
        if morpheme['pos1'] == 'symbole-Phrase':
            sentences.append(sentence)
            sentence = []

    return sentences


with open('neko.txt.mecab', encoding='utf-8') as file_wrapper:
    morphemes = [tabbed_str_to_dict(line) for line in file_wrapper]

sentences = morphemes_to_sentence(morphemes)

#Vérifiez le résultat
print(morphemes[::100])
print(sentences[::100])

31. verb / 32. Prototype du verbe / 33.

Extraire toutes les formes de surface du verbe. Extraire toutes les formes originales du verbe. Extraire toute la nomenclature de la connexion.

verbs_surface = [morpheme['surface'] for morpheme in morphemes if morpheme['pos1'].find('') == 0]
verbs_base = [morpheme['base'] for morpheme in morphemes if morpheme['pos1'].find('') == 0]
nouns_suru = [morpheme['surface'] for morpheme in morphemes if morpheme['pos1'] == '-']

#
print(verbs_surface[::100])
print(verbs_base[::100])
print(nouns_suru[::100])

Verbe Verbe Nom Sahen Connexion Confirmation du résultat 34. "B de A"

Extraire la nomenclature dans laquelle deux nomenclatures sont reliées par "non".

def ngramed_list(lst: list, n: int = 3) -> list:
    """
Convertir la liste en N-gramme.
    :param lst N Liste des cibles de programmation
    :param n N (La valeur par défaut est N= 3)
    :retourne la liste N Grammed
    """
    index = ngram.NGram(N=n)
    return [term for term in index.ngrams(lst)]


def is_noun_no_noun(words: list) -> bool:
    """
Une liste de trois mots est un «nom»-de-Déterminer s'il est composé de "nom".
    :mots param Une liste de 3 mots
    :return bool (True:"nom-de-Il est composé de "nom"/ False:"nom-de-Il n'est pas composé de "nom")
    """
    return (type(words) == list) and (len(words) == 3) and \
           (words[0]['pos1'].find('nom') == 0) and \
           (words[1]['surface'] == 'de') and \
           (words[2]['pos1'].find('nom') == 0)


#"nom-de-名詞」を含むNグラムdeみを抽出
noun_no_noun = [ngrams for ngrams in ngramed_list(morphemes) if is_noun_no_noun(ngrams)]

#Retirez la couche de surface et joignez
noun_no_noun = [''.join([word['surface'] for word in ngram]) for ngram in noun_no_noun]

#Vérifiez le résultat
print(noun_no_noun[::100])

35. Concaténation de nomenclature

Extraire la concaténation de la nomenclature (noms qui apparaissent consécutivement) avec la correspondance la plus longue.

def morphemes_to_noun_array(morphemes: list) -> list:
    """
Regroupez la liste des éléments morphologiques représentés par le type dictionnaire par des éléments morphologiques autres que la ponctuation ou la nomenclature, et faites une liste.
    :param morphemes Liste des éléments morphologiques représentés par type de dictionnaire
    :retour Liste des connexions de nomenclature
    """
    nouns_list = []
    nouns = []

    for morpheme in morphemes:
        if morpheme['pos1'].find('nom') >= 0:
            nouns.append(morpheme)
        elif (morpheme['pos1'] == 'symbole-Phrase') | (morpheme['pos1'].find('nom') < 0):
            nouns_list.append(nouns)
            nouns = []

    return [nouns for nouns in nouns_list if len(nouns) > 1]


noun_array = [''.join([noun['surface'] for noun in nouns]) for nouns in morphemes_to_noun_array(morphemes)]

#Vérifiez le résultat
print(noun_array[::100])

36. Fréquence d'occurrence des mots

Trouvez les mots qui apparaissent dans la phrase et leur fréquence d'apparition, et classez-les par ordre décroissant de fréquence d'apparition.

def get_frequency(words: list) -> dict:
    """
Reçoit une liste de mots et renvoie un dictionnaire avec des mots comme clés et une fréquence comme valeur.
    :mots param liste de mots
    :return dict Un dictionnaire avec le mot comme clé et la fréquence comme valeur
    """
    frequency = {}
    for word in words:
        if frequency.get(word):
            frequency[word] += 1
        else:
            frequency[word] = 1

    return frequency


frequency = get_frequency([morpheme['surface'] for morpheme in morphemes])

#Trier
frequency = [(k, v) for k, v in sorted(frequency.items(), key=lambda x: x[1], reverse=True)]

#Vérifiez le résultat
print(frequency[0:20])

37. Top 10 des mots fréquents / 38. Histogramme / 39. Loi de Zipf

Affichez les 10 mots les plus fréquents et leur fréquence d'apparition dans un graphique (par exemple, un graphique à barres). Tracez un histogramme de la fréquence d'occurrence des mots (l'axe horizontal représente la fréquence d'occurrence et l'axe vertical représente le nombre de types de mots qui prennent la fréquence d'occurrence sous forme de graphique à barres). Tracez les deux graphiques logarithmiques avec la fréquence d'occurrence des mots sur l'axe horizontal et la fréquence d'occurrence sur l'axe vertical.

Le système de graphes sera mis en place.

fig = plt.figure(figsize=(20, 6))

# 37.Affichez les 10 mots avec une fréquence d'apparition élevée et leur fréquence d'apparition dans un graphique (par exemple, un graphique à barres).
words = [f[0] for f in frequency[0:10]]
x_pos = np.arange(len(words))
fp = FontProperties(fname=r'/Library/Fonts/Hiragino Marugo ProN W4.ttc', size=14)

ax1 = fig.add_subplot(131)
ax1.bar(x_pos, [f[1] for f in frequency[0:10]], align='center', alpha=0.4)
ax1.set_xticks(x_pos)
ax1.set_xticklabels(words, fontproperties=fp)
ax1.set_ylabel('Frequency')
ax1.set_title('Top 10 frequent words')

# 38.Dessinez un histogramme de la fréquence d'occurrence des mots (l'axe horizontal représente la fréquence d'occurrence et l'axe vertical représente le nombre de types de mots qui prennent la fréquence d'occurrence sous forme de graphique à barres).
freq = list(dict(frequency).values())
freq.sort(reverse=True)

ax2 = fig.add_subplot(132)
ax2.hist(freq, bins=50, range=(0, 50))
ax2.set_title('Histogram of word count')
ax2.set_xlabel('Word count')
ax2.set_ylabel('Frequency')

# 39.Tracez les deux graphiques logarithmiques avec la fréquence d'occurrence des mots sur l'axe horizontal et la fréquence d'occurrence sur l'axe vertical.
rank = list(range(1, len(freq) + 1))

ax3 = fig.add_subplot(133)
ax3.plot(freq, rank)
ax3.set_xlabel('Rank')
ax3.set_ylabel('Frequency')
ax3.set_title('Zipf low')
ax3.set_xscale('log')
ax3.set_yscale('log')

fig.savefig('morphological_analysis.png')

[PYTHON] 100 Language Processing Knock 2015 Chapitre 4 Analyse morphologique (30-39)

environnement