├── aozora_scraping.py
├── config.ini
├── cotoha_function.py
├── json_to_obj.py
├── main.py
├── respobj
│   ├── __init__.py
│   └── coreference.py
└── result

# -*- coding:utf-8 -*-
import requests
from bs4 import BeautifulSoup

def get_aocora_sentence(aozora_url):
    res = requests.get(aozora_url)
    #Schöne Suppeninitialisierung
    soup = BeautifulSoup(res.content, 'lxml')
    #Holen Sie sich den Haupttext von Aozora Bunko
    main_text = soup.find("div", class_="main_text")
    #Beseitigung von Rubin
    for script in main_text(["rp","rt","h4"]):
        script.decompose()
    sentences = [line.strip() for line in main_text.text.splitlines()]
    #Beseitigung leerer Teile
    sentences = [line for line in sentences if line != '']
    return sentences

Wenn Sie die URL von Aozora Bunko an die Methode "get_aocora_sentence" übergeben, wird der Text dieser Seite als Liste für jeden Zeilenumbruch zurückgegeben, wobei Rubin und Ränder weggelassen werden.

    main_text = soup.find("div", class_="main_text")

Irgendwie ist es ein Prozess, nachdem man weiß, dass der Textkörper von Aozora Bunko von "

# -*- coding:utf-8 -*-
import os
import urllib.request
import json
import configparser
import codecs

#COTOHA API-Operationsklasse
class CotohaApi:
    #Initialisieren
    def __init__(self, client_id, client_secret, developer_api_base_url, access_token_publish_url):
        self.client_id = client_id
        self.client_secret = client_secret
        self.developer_api_base_url = developer_api_base_url
        self.access_token_publish_url = access_token_publish_url
        self.getAccessToken()

    #Zugriffstoken erhalten
    def getAccessToken(self):
        #Zugriff auf die URL-Angabe für die Token-Erfassung
        url = self.access_token_publish_url

        #Header-Spezifikation
        headers={
            "Content-Type": "application/json;charset=UTF-8"
        }

        #Körperspezifikation anfordern
        data = {
            "grantType": "client_credentials",
            "clientId": self.client_id,
            "clientSecret": self.client_secret
        }
        #Codieren Sie die Anforderungshauptteilspezifikation in JSON
        data = json.dumps(data).encode()

        #Anforderungsgenerierung
        req = urllib.request.Request(url, data, headers)

        #Senden Sie eine Anfrage und erhalten Sie eine Antwort
        res = urllib.request.urlopen(req)

        #Antwortkörper erhalten
        res_body = res.read()

        #Dekodieren Sie den Antworttext von JSON
        res_body = json.loads(res_body)

        #Holen Sie sich das Zugriffstoken vom Antworttext
        self.access_token = res_body["access_token"]

    #Korrespondenzanalyse-API
    def coreference(self, document):
        #URL-Angabe der API für die Korrespondenzanalyse-Erfassung
        url = self.developer_api_base_url + "v1/coreference"
        #Header-Spezifikation
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Körperspezifikation anfordern
        data = {
            "document": document
        }
        #Codieren Sie die Anforderungshauptteilspezifikation in JSON
        data = json.dumps(data).encode()
        #Anforderungsgenerierung
        req = urllib.request.Request(url, data, headers)
        #Senden Sie eine Anfrage und erhalten Sie eine Antwort
        try:
            res = urllib.request.urlopen(req)
        #Was tun, wenn in der Anforderung ein Fehler auftritt?
        except urllib.request.HTTPError as e:
            #Wenn der Statuscode 401 Unauthorized lautet, fordern Sie das Zugriffstoken erneut an und fordern Sie es erneut an
            if e.code == 401:
                print ("get access token")
                self.access_token = getAccessToken(self.client_id, self.client_secret)
                headers["Authorization"] = "Bearer " + self.access_token
                req = urllib.request.Request(url, data, headers)
                res = urllib.request.urlopen(req)
            #Wenn der Fehler nicht 401 ist, wird die Ursache angezeigt.
            else:
                print ("<Error> " + e.reason)

        #Antwortkörper erhalten
        res_body = res.read()
        #Dekodieren Sie den Antworttext von JSON
        res_body = json.loads(res_body)
        #Holen Sie sich das Analyseergebnis vom Antworttext
        return res_body

Informationen zu den Funktionen, die die COTOHA-API verwenden, finden Sie unter Ich habe versucht, die COTOHA-API in Python zu verwenden, die angeblich einfach in der Verarbeitung natürlicher Sprache zu handhaben ist. Ich hab es geschafft. Beachten Sie jedoch, dass sich die URL für die Kollatierungsanalyse von "Beta / Coreference" in "V1 / Coreference" geändert hat. (Jetzt wird sich die Beta-Version vielleicht eines Tages ändern)

Die erste Hälfte der Übergabe des Textes an die Korrespondenzanalyse in "main.py" ist wie folgt. Ich habe es geschrieben (ich habe es so geschrieben, wie es ist, weil es einen Teil zu erklären gibt)

main.py

# -*- coding:utf-8 -*-
import os
import json
import configparser
import datetime
import codecs
import cotoha_function as cotoha
from aozora_scraping import get_aocora_sentence
from respobj.coreference import Coreference
from json_to_obj import json_to_coreference

if __name__ == '__main__':
    #Rufen Sie den Speicherort der Quelldatei ab
    APP_ROOT = os.path.dirname(os.path.abspath( __file__)) + "/"

    #Stellen Sie den eingestellten Wert ein
    config = configparser.ConfigParser()
    config.read(APP_ROOT + "config.ini")
    CLIENT_ID = config.get("COTOHA API", "Developer Client id")
    CLIENT_SECRET = config.get("COTOHA API", "Developer Client secret")
    DEVELOPER_API_BASE_URL = config.get("COTOHA API", "Developer API Base URL")
    ACCESS_TOKEN_PUBLISH_URL = config.get("COTOHA API", "Access Token Publish URL")

    #Konstante
    max_word = 1800
    max_call_api_count = 150
    max_elements_count = 20
    #URL von Aozora Bunko
    aozora_html = 'Irgendein'
    #Aktuelle Uhrzeit
    now_date = datetime.datetime.today().strftime("%Y%m%d%H%M%S")
    #Pfad der Datei zum Speichern des Originaltextes
    origin_txt_path = './result/origin_' + now_date + '.txt'
    #Pfad der Datei zum Speichern der Ergebnisse
    result_txt_path = './result/converted_' + now_date + '.txt'

    #COTOHA API-Instanziierung
    cotoha_api = cotoha.CotohaApi(CLIENT_ID, CLIENT_SECRET, DEVELOPER_API_BASE_URL, ACCESS_TOKEN_PUBLISH_URL)

    #Holen Sie sich den Text von Aozora Bunko
    sentences = get_aocora_sentence(aozora_html)
    #Speichern Sie den Originaltext zum Vergleich
    with open(origin_txt_path, mode='a') as f:
        for sentence in sentences:
            f.write(sentence + '\n')

    #Ursprünglicher Wert
    start_index = 0
    end_index = 0
    call_api_count = 1
    temp_sentences = sentences[start_index:end_index]
    elements_count = end_index - start_index
    limit_index = len(sentences)
    result = []
    print("Gesamtzahl der Listen" + str(limit_index))
    while(end_index <= limit_index and call_api_count <= max_call_api_count):
        length_sentences = len(''.join(temp_sentences))
        if(length_sentences < max_word and elements_count < max_elements_count and end_index < limit_index):
            end_index += 1
        else:
            if end_index == limit_index:
                input_sentences = sentences[start_index:end_index]
                print('Index: ' + str(start_index) + 'Von' + str(end_index) + 'Bis')
                #Ausgangsbedingungen
                end_index += 1
            else:
                input_sentences = sentences[start_index:end_index - 1]
                print('Index: ' + str(start_index) + 'Von' + str(end_index-1) + 'Bis')
            print(str(call_api_count) + 'Zweite Mitteilung')
            response = cotoha_api.coreference(input_sentences)
            result.append(json_to_coreference(response))
            call_api_count += 1
            start_index = end_index - 1
        temp_sentences = sentences[start_index:end_index]
        elements_count = end_index - start_index

Erstens ist es nicht möglich, alle Sätze auf einmal zu senden (obwohl dies natürlich sein kann).

Verhalten im Prozess gefunden

Ich konnte keine Erwähnung in der Referenz finden,

• Die maximale Textlänge beträgt ca. 1800 Zeichen (Ich habe versucht, die Phase der Geschichte mit COTOHA zu extrahieren und zu veranschaulichen)
• Die Anzahl der Elemente in der Liste darf nicht 20 oder mehr betragen.

(Es wurde nicht verifiziert, aber ich denke, dass die Verarbeitung anderer COTOHA-APIs ähnlich oder eng sein kann.) Nach der while-Anweisung in der if-Anweisung "Wirf die in die Liste gepackten Textdaten für jeden Zeilenumbruch so weit wie möglich in die Korrespondenzanalyse" wird implementiert.

Mir ging es eher um die Liste als nur um die einfache Satzlänge, da ich dachte, dass die Genauigkeit beeinträchtigt werden könnte, wenn die Korrespondenzanalyse nicht an den Satzpausen durchgeführt würde. (Erwartet und nicht überprüft)

call_api_count <= max_call_api_count Mit dem kostenlosen Plan beträgt jede API 1000 Aufrufe pro Tag, daher habe ich eine schlechte Aussage gemacht, dass ich die Anzahl der API-Aufrufe bis zu einem gewissen Grad kontrollieren wollte.

Weisen Sie der Klasse die Antwort aus dem JSON-Format zu.

Ich denke, das ist Geschmackssache, Ist es nicht einfacher, die API-Antwort einer Klasse zuzuweisen, als sie wie im Wörterbuchtyp zu verwenden? Es ist eine Angebotsabteilung.

Mit der COTOHA-API scheint der Wörterbuchtyp die Mehrheit im Qiita-Artikel zu sein, daher werde ich eine Referenz zur Korrespondenzanalyse veröffentlichen.

Schauen wir uns zunächst ein offizielles Beispiel an, in welchem JSON-Format die Antwort der Korrespondenzanalyse eingeht. (Wie üblich, wenn Sie werfen "Taro ist ein Freund. Er hat gegrilltes Fleisch gegessen.")

coreference.json

{
  "result" : {
    "coreference" : [ {
      "representative_id" : 0,
      "referents" : [ {
        "referent_id" : 0,
        "sentence_id" : 0,
        "token_id_from" : 0,
        "token_id_to" : 0,
        "form" : "Taro"
      }, {
        "referent_id" : 1,
        "sentence_id" : 1,
        "token_id_from" : 0,
        "token_id_to" : 0,
        "form" : "er"
      } ]
    } ],
    "tokens" : [ [ "Taro", "Ist", "Freund", "ist" ], [ "er", "Ist", "Gebratenes Fleisch", "Zu", "Essen", "Ta" ] ]
  },
  "status" : 0,
  "message" : "OK"
}

Die Definition der Klasse, der dies zugeordnet werden kann, lautet wie folgt. Wenn Sie einen Blick auf die [offizielle Referenz] werfen (https://api.ce-cotoha.com/contents/reference/apireference.html#correspond), sollten Sie sie verstehen können. Definieren wir die JSON-Hierarchie aus dem tiefsten Teil.

resobj/coreference.py

# -*- coding: utf-8; -*-
from dataclasses import dataclass, field
from typing import List

#Entitätsobjekt
@dataclass
class Referent:
    #Entitäts-ID
    referent_id: int
    #Die Nummer der Anweisung, die die Entität enthält
    sentence_id: int
    #Entitätsstartformular Elementnummer
    token_id_from: int
    #Endform der Entität Elementnummer
    token_id_to: int
    #Zielkorrespondenz
    form: str

#Informationsobjekt zur Korrespondenzanalyse
@dataclass
class Representative:
    #ID der Korrespondenzanalyse
    representative_id: int
    #Array von Entitätsobjekten
    referents: List[Referent] = field(default_factory=list)

#Ergebnisobjekt der Korrespondenzanalyse
@dataclass
class Result:
    #Array von Informationsobjekten zur Korrespondenzanalyse
    coreference: List[Representative] = field(default_factory=list)
    #Anordnung der Notation, erhalten durch morphologische Analyse jedes Satzes des Analysezielsatzes
    tokens: List[List[str]] = field(default_factory=list)

#Antwort
@dataclass
class Coreference:
    #Ergebnisobjekt der Korrespondenzanalyse
    result: Result
    #Statuscode 0:OK, >0:Error
    status: int
    #Fehlermeldung
    message: str

Wo ich erwischt wurde Aus irgendeinem Grund wurde das Formularfeld der Klasse "Referent" in Official Reference nicht erläutert. Es dauerte einige Zeit, bis ich bemerkte, dass die "Token" der "Result" -Klasse "List [List [str]]" waren.

Methode zum Zuweisen von json zur Klasse (json_to_coreference wird auch in main.py beschrieben)

json_to_obj.py

# -*- coding:utf-8 -*-
import json
import codecs
import marshmallow_dataclass
from respobj.coreference import Coreference

def json_to_coreference(jsonstr):
    json_formated = codecs.decode(json.dumps(jsonstr),'unicode-escape')
    result = marshmallow_dataclass.class_schema( Coreference )().loads(json_formated)
    return result

Es ist als "Datenklassen", "Marshmallow_Dataclass" implementiert. Die marshmallow_dataclass wird oft nicht installiert. (PyPI-Seite)

Dies ist der Hauptgrund, warum dieses Mal Python 3.7 verwendet werden sollte. Ich empfehle diese Methode, da selbst bei einer Änderung der Spezifikationen die entsprechenden Teile leicht zu verstehen sind und ich denke, dass die Korrespondenz schnell sein wird. (Ich denke, es ist nur so, dass ich nicht an Pythons Wörterbuchtyp gewöhnt bin, also benutze ihn bitte nur als Referenz.)

Referenzseite JSON die Python-Klasse

Speichern Sie es in einer Datei, nachdem Sie es in eine Korrespondenz eingeschlossen haben.

Die Frage hier ist "welche Korrespondenz zum Runden verwendet wird". Dieses Mal werden wir es basierend auf der Vorhersage, dass das, was zuerst im Text erscheint, der Hauptteil ~~ easy ~~ ist, mit den entsprechenden Wörtern implementieren, die zuvor erschienen sind.

• In der ersten Hälfte wird jedes Element (Anzahl der Kommunikationen) der Klasse "Coreference" in der Ergebnisliste gespeichert.

main.py

    #Zweite Hälfte
    for obj in result:
        coreferences = obj.result.coreference
        tokens = obj.result.tokens
        for coreference in coreferences:
            anaphor = []
            #Basierend auf der ersten Entsprechung in der Koreferenz.
            anaphor.append(coreference.referents[0].form)
            for referent in coreference.referents:
                sentence_id = referent.sentence_id
                token_id_from = referent.token_id_from
                token_id_to = referent.token_id_to
                #Schreiben Sie neu, damit die Anzahl der Elemente in der Liste für die nachfolgende Verarbeitung nicht geändert wird.
                anaphor_and_empty = anaphor + ['']*(token_id_to - token_id_from)
                tokens[sentence_id][token_id_from: (token_id_to + 1)] = anaphor_and_empty
        #Speichern Sie den geänderten Text in einer Datei
        with open(result_txt_path, mode='a') as f:
            for token in tokens:
                line = ''.join(token)
                f.write(line + '\n')

Welches Zahlenelement (Satz) des Satzes in "Token" ist "Satz_ID" token_id_from und token_id_to bedeuten, dass die token_id_toth totoken_id_toth des im Satz id_idth analysierten Elements der Entsprechung entspricht.

Finden Sie die Korrespondenz zum Umschreiben mit coreference.referents [0] .form, Beim Umschreiben

                #Schreiben Sie neu, damit die Anzahl der Elemente in der Liste für die nachfolgende Verarbeitung nicht geändert wird.
                anaphor_and_empty = anaphor + ['']*(token_id_to - token_id_from)
                tokens[sentence_id][token_id_from: (token_id_to + 1)] = anaphor_and_empty

Ich werde so ein bisschen arbeiten. (Die Anzahl der neu zu schreibenden Elemente und die Anzahl der neu zu schreibenden Elemente stimmen zwangsweise überein.) Wenn Sie dies nicht tun, sind die Nummern von "token_id_from" und "token_id_to" falsch. (Bitte sag mir, ob es einen besseren Weg gibt)

# -*- coding:utf-8 -*-
import os
import json
import configparser
import datetime
import codecs
import cotoha_function as cotoha
from aozora_scraping import get_aocora_sentence
from respobj.coreference import Coreference
from json_to_obj import json_to_coreference

if __name__ == '__main__':
    #Rufen Sie den Speicherort der Quelldatei ab
    APP_ROOT = os.path.dirname(os.path.abspath( __file__)) + "/"

    #Stellen Sie den eingestellten Wert ein
    config = configparser.ConfigParser()
    config.read(APP_ROOT + "config.ini")
    CLIENT_ID = config.get("COTOHA API", "Developer Client id")
    CLIENT_SECRET = config.get("COTOHA API", "Developer Client secret")
    DEVELOPER_API_BASE_URL = config.get("COTOHA API", "Developer API Base URL")
    ACCESS_TOKEN_PUBLISH_URL = config.get("COTOHA API", "Access Token Publish URL")

    #Konstante
    max_word = 1800
    max_call_api_count = 150
    max_elements_count = 20
    #URL von Aozora Bunko
    aozora_html = 'https://www.aozora.gr.jp/cards/000155/files/832_16016.html'
    #Aktuelle Uhrzeit
    now_date = datetime.datetime.today().strftime("%Y%m%d%H%M%S")
    #Pfad der Datei zum Speichern des Originaltextes
    origin_txt_path = './result/origin_' + now_date + '.txt'
    #Pfad der Datei zum Speichern der Ergebnisse
    result_txt_path = './result/converted_' + now_date + '.txt'

    #COTOHA API-Instanziierung
    cotoha_api = cotoha.CotohaApi(CLIENT_ID, CLIENT_SECRET, DEVELOPER_API_BASE_URL, ACCESS_TOKEN_PUBLISH_URL)

    #Holen Sie sich den Text von Aozora Bunko
    sentences = get_aocora_sentence(aozora_html)
    #Speichern Sie den Originaltext zum Vergleich
    with open(origin_txt_path, mode='a') as f:
        for sentence in sentences:
            f.write(sentence + '\n')

    #Ursprünglicher Wert
    start_index = 0
    end_index = 0
    call_api_count = 1
    temp_sentences = sentences[start_index:end_index]
    elements_count = end_index - start_index
    limit_index = len(sentences)
    result = []
    print("Gesamtzahl der Listen" + str(limit_index))
    while(end_index <= limit_index and call_api_count <= max_call_api_count):
        length_sentences = len(''.join(temp_sentences))
        if(length_sentences < max_word and elements_count < max_elements_count and end_index < limit_index):
            end_index += 1
        else:
            if end_index == limit_index:
                input_sentences = sentences[start_index:end_index]
                print('Index: ' + str(start_index) + 'Von' + str(end_index) + 'Bis')
                #Ausgangsbedingungen
                end_index += 1
            else:
                input_sentences = sentences[start_index:end_index - 1]
                print('Index: ' + str(start_index) + 'Von' + str(end_index-1) + 'Bis')
            print(str(call_api_count) + 'Zweite Mitteilung')
            response = cotoha_api.coreference(input_sentences)
            result.append(json_to_coreference(response))
            call_api_count += 1
            start_index = end_index - 1
        temp_sentences = sentences[start_index:end_index]
        elements_count = end_index - start_index
    
    for obj in result:
        coreferences = obj.result.coreference
        tokens = obj.result.tokens
        for coreference in coreferences:
            anaphor = []
            #Basierend auf der ersten Entsprechung in der Koreferenz.
            anaphor.append(coreference.referents[0].form)
            for referent in coreference.referents:
                sentence_id = referent.sentence_id
                token_id_from = referent.token_id_from
                token_id_to = referent.token_id_to
                #Schreiben Sie neu, damit die Anzahl der Elemente in der Liste für die nachfolgende Verarbeitung nicht geändert wird.
                anaphor_and_empty = anaphor + ['']*(token_id_to - token_id_from)
                tokens[sentence_id][token_id_from: (token_id_to + 1)] = anaphor_and_empty
        #Speichern Sie den geänderten Text in einer Datei
        with open(result_txt_path, mode='a') as f:
            for token in tokens:
                line = ''.join(token)
                f.write(line + '\n')