[PYTHON] Erstellen einer API, die mit BERT im Django REST-Framework negativ-positive Inferenzergebnisse zurückgibt

Dieser Beitrag ist der Artikel zum 20. Tag von "Django Adventskalender 2019 - Qiita".

Es ist siny.

In diesem Artikel habe ich die Herausforderungen beim Erstellen einer Rest-API zusammengefasst, die unter Verwendung des ** Django REST-Frameworks ** und des ** BERT-Modells ** negativ-positive Inferenzergebnisse zurückgibt.

• Da DRF und BERT dieses Mal zum ersten Mal implementiert wurden, würde ich es begrüßen, wenn Sie auf Fehler oder Punkte wie "Es ist besser, dies zu tun!" Hinweisen könnten.

Einführung

Dieser Artikel behandelt nicht die Teile, die sich auf die Implementierung des BERT-Modells beziehen, da Django der Hauptzweck ist. Informationen zur Implementierung und zum Erlernen des BERT-Modells unter Verwendung des in diesem Artikel verwendeten japanischen Datensatzes finden Sie unter ** Adventskalender zur Verarbeitung natürlicher Sprache 2019, Tag 25 (Erstellung einer Negativ-Positiv-Klassifizierungsmaschine mit BERT) ** ".

Zunächst ist es ein schematisches Diagramm der Gesamtverarbeitung der DRF-Umgebung, die dieses Mal angenommen wird.

Was Sie tun, ist einfach: Es handelt sich um eine REST-API, die (binäre Klassifizierung) ableitet, ob der als Eingabedaten angegebene Satz bei einem BERT-Modell negativ oder positiv ist, und das Ergebnis an die Clientseite zurückgibt.

• In der schematischen Darstellung wird die Azure Data Science-Umgebung (DSVM) verwendet. Dieses Mal wird sie jedoch mithilfe eines lokalen Entwicklungsservers erstellt.

[API-Demo-Video]

Die in diesem Artikel implementierten Module befinden sich in diesem Git-Repository. Laden Sie sie daher herunter und verwenden Sie sie entsprechend.

In Bezug auf BERT [Buch "Lernen während des Machens! Entwicklung tiefes Lernen von PyTorch"](https://www.amazon.co.jp/%E3%81%A4%E3%81%8F%E3%82%8A % E3% 81% AA% E3% 81% 8C% E3% 82% 89% E5% AD% A6% E3% 81% B6-PyTorch% E3% 81% AB% E3% 82% 88% E3% 82% 8B % E7% 99% BA% E5% B1% 95% E3% 83% 87% E3% 82% A3% E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83% BC% E3 % 83% 8B% E3% 83% B3% E3% 82% B0-% E5% B0% 8F% E5% B7% 9D% E9% 9B% 84% E5% A4% AA% E9% 83% 8E / dp / Es wurde unter Bezugnahme auf 4839970254) erstellt. Im obigen Buch basierte die negative / positive Klassifizierung des BERT-Modells auf englischen Daten, daher haben wir es verbessert, damit es im japanischen Datensatz basierend auf dem Buch als negativ / positiv klassifiziert werden kann.

Inhaltsverzeichnis

1. Prämisse
2. Umweltbau
3. Erstellen eines Django REST-Frameworks
4. Inferenz mit der REST-API
5. Einfaches Werkzeug
6. Zusammenfassung
7. Nachschlagewerke

1. Prämisse

Es wurde bestätigt, dass der Inhalt dieses Artikels in den folgenden Umgebungen funktioniert.

Unmittelbare Umwelt

2. Umweltbau

Dieses Mal werden wir eine DRF erstellen, die in der Ubuntu-Umgebung von Windows 10 funktioniert. Erstellen Sie zunächst eine virtuelle Umgebung und installieren Sie die erforderlichen Module mit conda.

Installation verschiedener Module

conda create -n drf python=3.6
conda activate drf
conda install pytorch=0.4 torchvision -c pytorch
conda install pytorch=0.4 torchvision cudatoolkit -c pytorch
conda install pandas scikit-learn django

Wenn conda nicht funktioniert, installieren Sie es mit pip.

pip install mojimoji
pip install attrdict
pip install torchtext
pip install pyknp
pip install djangorestframework

Juman ++ Installation

Das diesmal verwendete BERT Japanese Pretrained-Modell verwendet Human ++ (v2.0.0-rc2) für die morphologische Analyse des Eingabetextes. Daher entspricht dieser Artikel auch dem morphologischen Analysewerkzeug ** Human ++ **. Die Vorgehensweise zur Installation von Juman ++ ist in einem separaten Artikel zusammengefasst. Weitere Informationen finden Sie im Folgenden.

[** Zusammenfassung der JUMAN ++ - Installationsprozedur **] https://sinyblog.com/deaplearning/juman/

Nach der Installation von Juman ++ ist es in Ordnung, wenn die morphologische Analyse in der lokalen Umgebung wie folgt verfügbar ist.

#JUMAN Funktionsprüfung
from pyknp import Juman					
text = "Ich lerne etwas über die Verarbeitung natürlicher Sprache."					
juman = Juman()					
result =juman.analysis(text)					
result = [mrph.midasi for mrph in result.mrph_list()]					
print(text)
Ich lerne etwas über die Verarbeitung natürlicher Sprache.
print(result)
['Natur', 'Sprache', 'wird bearbeitet', 'Zu', 'Über', 'Lernen', 'Während ~', 'ist', '。']			

3. Erstellen eines Django REST-Frameworks

Projekterstellung

Erstellen Sie zunächst ein Django-Projekt. (Projektname: drf)

django-admin startproject drf

Anwendungserstellung

Erstellen Sie als Nächstes eine Anwendung (Anwendungsname: appv1).

cd drf
python manage.py startapp appv1

Anpassung von settings.py

Fügen Sie INSTALLED_APPS in settings.py rest_framework und application (appv1) hinzu.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',                #add
    'appv1.apps.Appv1Config',        #add

]

Platzierung von BERT-bezogenen Modulen

Erstellen Sie die folgenden Ordner direkt unter dem Anwendungsordner (appv1) und platzieren Sie die Module wie angegeben.

• Wenn Sie die trainierte Modelldatei (bert_fine_tuning_chABSA.pth) vorerst verwenden möchten, laden Sie die trainierte Modelldatei von [hier] herunter (https://drive.google.com/drive/folders/1EKTcda0ktz9xxLsXshvEbgszBMOe7bAv?usp=sharing). Bitte platzieren Sie es.
• Vocab.txt, bert_config.json und pytorch_model.bin sind [HP, veröffentlicht von der Kyoto University](http://nlp.ist.i.kyoto-u.ac.jp/index.php?BERT%E6%97%A5 Sie können es von% E6% 9C% AC% E8% AA% 9EPretrained% E3% 83% A2% E3% 83% 87% E3% 83% AB) herunterladen.

Platzieren Sie die folgenden Dateien direkt unter der Anwendung (appv1).

Starten Sie den Shell-Modus von Django und generieren Sie eine Wörterbuch-Datendatei, die für die Inferenz verwendet werden soll.

python manage.py shell
from appv1.config import *
from appv1.predict import create_vocab_text
TEXT = create_vocab_text()

Wenn Sie das oben genannte ausführen, wird appv1 / data / text.pkl generiert.

Die gesamte Verzeichnisstruktur ist wie folgt.

├─drf
│  │  db.sqlite3
│  │  manage.py
│  │
│  ├─appv1
│  │  │  admin.py
│  │  │  apps.py
│  │  │  bert.py           #BERT-Modelldefinition
│  │  │  config.py         #Verschiedene Einstellungsdateien
│  │  │  dataloader.py     #Generierungsdatei für den Torchtext-Datenlader
│  │  │  models.py
│  │  │  predict.py        #Zum Nachdenken
│  │  │  serializers.py    #Serializer
│  │  │  tests.py
│  │  │  tokenizer.py      #BERT Word Split verwandte Shell
│  │  │  views.py
│  │  ├─data

│  │  │      test_dumy.tsv  #Dummy-Daten
│  │  │      train_dumy.tsv #Dummy-Daten
│  │  │      text.pkl    #Für Inferenz verwendete Wordbook-Daten
│  │  │
│  │  ├─vocab
│  │  │      vocab.txt   #Bert Lexikon Daten
│  │  │
│  │  ├─weights
│  │  │      bert_config.json
│  │  │      bert_fine_tuning_chABSA.pth  #Fein abgestimmtes Bert-Modell
│  │  │      pytorch_model.bin
│  │  │
│  ├─drf
│  │  │  settings.py
│  │  │  urls.py
│  │  │  wsgi.py

Bestätigung der Inferenzoperation

Stellen Sie sicher, dass der Inferenzprozess mit dem von BERT trainierten Modell in der Django-Umgebung ordnungsgemäß funktioniert.

Führen Sie nach dem Starten des Django-Shell-Modus den folgenden Befehl aus, um Beispieltextdaten anzugeben und zu bestätigen, dass eine negative oder positive Beurteilung vorgenommen werden kann.

• Siehe Kommentare zur Verarbeitung der einzelnen Befehle.

python manage.py shell
-----------------------------------------------------------------------------
#Shell-Modus von hier
In [1]: from appv1.config import *
In [2]: from appv1.predict import predict2, create_vocab_text, build_bert_model
In [3]: from appv1.bert import get_config, BertModel,BertForchABSA, set_learned_params
In [4]: import torch
In [5]: config = get_config(file_path=BERT_CONFIG)  #Laden der BERT-Konfigurationseinstellungen
In [6]: net_bert = BertModel(config)   #BERT-Modellgenerierung
In [7]: net_trained = BertForchABSA(net_bert)   #Kombinieren Sie den negativen / positiven Klassifikator mit dem BERT-Modell
In [8]: net_trained.load_state_dict(torch.load(MODEL_FILE, map_location='cpu'))  #Geringes Lerngewicht
   ...:Machen
Out[8]: IncompatibleKeys(missing_keys=[], unexpected_keys=[])
In [9]: net_trained.eval()   #In den Inferenzmodus versetzen
Out[9]:
BertForchABSA(
  (bert): BertModel(
    (embeddings): BertEmbeddings(
      (word_embeddings): Embedding(32006, 768, padding_idx=0)
      (position_embeddings): Embedding(512, 768)
      (token_type_embeddings): Embedding(2, 768)
      (LayerNorm): BertLayerNorm()
      (dropout): Dropout(p=0.1)
    )
    (encoder): BertEncoder(
      (layer): ModuleList(
        (0): BertLayer(
          (attention): BertAttention(
            (selfattn): BertSelfAttention(
              (query): Linear(in_features=768, out_features=768, bias=True)
              (key): Linear(in_features=768, out_features=768, bias=True)
              (value): Linear(in_features=768, out_features=768, bias=True)
              (dropout): Dropout(p=0.1)
            )

 ~~Da es viele Ausgabeergebnisse gibt, werden einige weggelassen.

    (pooler): BertPooler(
      (dense): Linear(in_features=768, out_features=768, bias=True)
      (activation): Tanh()
    )
  )
  (cls): Linear(in_features=768, out_features=2, bias=True)
)

In [10]: input_text = "In Bezug auf das Ergebnis war das ordentliche Ergebnis auf einen Rückgang der Zinsen für Kredite und Gewinne aus dem Verkauf von Wertpapieren zurückzuführen.
    ...:Es ging um 7.273 Millionen Yen auf 67.413 Millionen Yen zurück."
In [11]: result = predict2(input_text, net_trained).numpy()[0]  #Inferenz ausführen(Der Rückgabewert ist negativ oder positiv
    ...:Tib)
['[UNK]', 'Oberfläche', 'Zu', 'Oki', 'ganz zu schweigen von', 'Ist', '、', '[UNK]', 'Einnahmen', 'Ist', '、', 'Ausleihe', 'Geld', 'Interesse', 'Oder', 'Wertvoll', 'Wertpapiere', 'Verkauf', 'Profitieren', 'von', 'Verringern', 'Zu', 'Als', '、', 'Erste Amtszeit', 'Verhältnis', '[UNK]', 'Kreis', 'Verringern', 'von', '[UNK]', 'Kreis', 'Wann', 'Nari', 'War']
[2, 1, 534, 8, 7779, 26207, 9, 6, 1, 7919, 9, 6, 15123, 306, 28611, 34, 27042, 4190, 3305, 8995, 5, 1586, 8, 52, 6, 4523, 2460, 1, 387, 1586, 5, 1, 387, 12, 105, 4561, 3]
In [12]: print(result)
0

Wie oben erwähnt, ist die Operation in Ordnung, wenn ein negativer (0) oder positiver (1) Wert als Rückgabewert in der Ergebnisvariablen ohne Fehler zurückgegeben wird.

Erstellen eines Serializers

Erstellen Sie als Nächstes einen DRF-Serializer. Darüber hinaus sind Serialisierung und Deserialisierung in DRF die folgenden Prozesse.

In diesem Fall wird das Modell von Django nicht behandelt, sodass keine Konvertierung in ein Modellobjekt durchgeführt wird. Erstellen Sie stattdessen einen Serializer mit der Aufschrift "** Empfangen Sie den Eingabetext, den Sie negativ / positiv beurteilen möchten, geben Sie ihn in das von BERT trainierte Modell ein und geben Sie das Inferenzergebnis aus **".

Es gibt drei Haupttypen von DRF-Serialisierern, aber dieses Mal möchten wir eine angepasste Verarbeitung implementieren, die nicht vom Modell abhängt. Daher verwenden wir die ** Serializer-Klasse ** von rest_framework.

|Serializer-Verarbeitung|Bedeutung| |:--|:--|:--|　 | ModelSerializer　　　　　　　|Verwenden Sie ein einzelnes Modellobjekt| |Serializer|Behandeln Sie eine einzelne Ressource oder implementieren Sie eine modellunabhängige angepasste Verarbeitung| |ListSerializer|Behandeln Sie mehrere Ressourcen|

Erstellen Sie eine Datei mit dem Namen serializers.py direkt unter appv1 und fügen Sie den folgenden Code hinzu.

appv1\serializers.py

from rest_framework import serializers
from appv1.config import *	
from appv1.predict import predict2
from appv1.bert import get_config, BertModel,BertForchABSA	
import torch		


class BertPredictSerializer(serializers.Serializer):
    """Serializer, um negative / positive BERT-Klassifizierungsergebnisse zu erhalten"""

    input_text = serializers.CharField()
    neg_pos = serializers.SerializerMethodField()

    def get_neg_pos(self, obj):
        config = get_config(file_path=BERT_CONFIG)  #Laden der Bert-Konfigurationsdatei
        net_bert = BertModel(config)  #BERT-Modellgenerierung
        net_trained = BertForchABSA(net_bert) # #Kombinieren Sie den negativen / positiven Klassifikator mit dem BERT-Modell
        net_trained.load_state_dict(torch.load(MODEL_FILE, map_location='cpu'))  #Gelernte Gewichte laden
        net_trained.eval()  #In den Inferenzmodus versetzen
        label = predict2(obj['input_text'], net_trained).numpy()[0]  #Inferenzergebnis abrufen
        return label

Erstellen Sie zunächst einen Serializer mit dem Namen ** BertPredictSerializer **, indem Sie ** serializers.Serializer ** von rest_framework erben.

class BertPredictSerializer(serializers.Serializer):
    """Serializer, um negative / positive BERT-Klassifizierungsergebnisse zu erhalten"""

    input_text = serializers.CharField()
    neg_pos = serializers.SerializerMethodField()

Ein Zeichenfolgentyp CharField ist als Eingabe definiert (** input_text **). Da die Ausgabe ein dynamischer Wert ist (Inferenzergebnis), kann der Wert des Feldes durch das Ergebnis der Methode ** serializers bestimmt werden. SerializerMethodField () ** wird verwendet, um das Feld ** neg_pos ** zu definieren ..

Definieren Sie bei Verwendung von SerializerMethodField () den angewendeten Methodennamen als ** get_ + Feldname **. In diesem Fall definieren wir die Methode ** get_neg_pos **.

Wenn Sie einen solchen Serializer definieren, wird die Methode get_neg_pos ausgeführt, wenn Sie den Eingabetext mit BertPredictSerializer in die API-Ansicht POSTEN, und das Verarbeitungsergebnis wird als JSON-Zeichenfolge zurückgegeben.

Dieses Mal möchten wir die Eingabesatzdaten an das BERT-Lernmodell übergeben und das negative / positive Beurteilungsergebnis erhalten. Daher wird die folgende Verarbeitung in der Methode get_neg_pos beschrieben.

    def get_neg_pos(self, obj):
        config = get_config(file_path=BERT_CONFIG)  #Laden der Bert-Konfigurationsdatei
        net_bert = BertModel(config)  #BERT-Modellgenerierung
        net_trained = BertForchABSA(net_bert) # #Kombinieren Sie den negativen / positiven Klassifikator mit dem BERT-Modell
        net_trained.load_state_dict(torch.load(MODEL_FILE, map_location='cpu'))  #Gelernte Gewichte laden
        net_trained.eval()  #In den Inferenzmodus versetzen
        label = predict2(obj['input_text'], net_trained).numpy()[0]  #Inferenzergebnis abrufen
        return label

Sie können sehen, was wir tun, indem Sie sich die Kommentare ansehen, aber ich werde es unten hinzufügen.

• ** get_config ** -Methode: Lesen Sie aus bert_config.json und konvertieren Sie JSON-Wörterbuchvariablen in Objektvariablen
• ** BertModel ** -Klasse: Klasse, die das BERT-Modell generiert
• ** BertForchABSA ** Klasse: Ein Modell, bei dem der Teil, der das Negativ / Positiv von chABSA bestimmt, mit dem BERT-Modell (BertModel) verbunden ist.
• ** Predict2 ** -Methode: Eine Methode, die ableitet, ob der Eingabesatz negativ oder positiv ist und 0 oder 1 zurückgibt.

Die obigen vier Methodenklassen sind in ** bert.py ** definiert. ** Laden Sie die trainierten Modellparameter mit net_trained.load_state_dict **. Die ** Predict2 ** -Methode ist in ** Predict.py ** definiert. Wenn Sie den Eingabesatz ** im ersten Argument und die trainierte Modellinstanz ** im zweiten Argument übergeben, ** schließen Sie daraus Es ist eine Methode **, die das Ergebnis zurückgibt (0 oder 1).

Damit ist die Erstellung des Serializers abgeschlossen.

Ansicht erstellen

Die DRF-Ansicht kann entweder als klassenbasierte Ansicht oder als funktionsbasierte Ansicht implementiert werden.

Dieses Mal habe ich versucht, eine klassenbasierte Ansicht namens GenericAPIView zu verwenden.

from django.shortcuts import render
from rest_framework import generics, status
from rest_framework.response import Response
from appv1.serializers import BertPredictSerializer


class BertPredictAPIView(generics.GenericAPIView):
    """BERT negative / positive Klassifizierungsvorhersageklasse"""
    serializer_class = BertPredictSerializer

    def post(self, request, *args, **kwargs):     

        serializer = self.get_serializer(request.data)
        return Response(serializer.data, status=status.HTTP_200_OK)

Es erbt ** GenericAPIView ** und definiert ** BertPredictAPIView **. Geben Sie die in serializer.py definierte Serialisierungsklasse (BertPredictSerialzer) im Attribut ** serializer_class ** an. Definieren Sie dann die ** post ** -Methode in BertPredictAPIView und verwenden Sie die ** get_serializer ** -Methode von GenericAPIView intern, um die für die Validierung verwendete Serializer-Instanz abzurufen. Geben Sie ** request.data ** als Argument an.

serializer = self.get_serializer(request.data)

** request.data ** arbeitet mit den Methoden "POST", "PUT" und "PATCH", um beliebige Daten zu verarbeiten. (Funktion ähnlich wie request.POST) Geben Sie abschließend ** serializer.data ** als Argument von ** Response ** an, um die Ansicht zu vervollständigen, die das Inferenzergebnis zurückgibt.

Definition von urls.py

Fügen Sie abschließend die URL-Definition in drf \ urlspy hinzu.

from django.contrib import admin
from django.urls import path
from appv1 import views  #add


urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/v1/predict/', views.BertPredictAPIView.as_view()),   #add
]

Das in views.py definierte BertPredictAPIView ist als URL-Muster mit dem Namen api / v1 / Predict definiert. Sie haben jetzt ** http://127.0.0.1/api/v1/predict ** als Rest-API-Endpunkt definiert.

Führen Sie zu diesem Zeitpunkt die Djagno-Migration einmal aus und führen Sie den Runserver aus.

python manage.py migrate
python manage.py runserver

Wenn Sie danach auf ** http://127.0.0.1:8000/api/v1/predict/** zugreifen, wird der folgende Bildschirm angezeigt.

Geben Sie den Text, den Sie als negativ / positiv beurteilen möchten, in "** Eingabetext **" am unteren Bildschirmrand ein und drücken Sie die Taste ** POST **, um mit dem fein abgestimmten trainierten Modell von BERT eine Schlussfolgerung zu ziehen und das Ergebnis zurückzugeben. ..

Der folgende Bildschirm zeigt das Ergebnis der Eingabe des Satzes "In Tokyu Community Co., Ltd. hat sich der Verwaltungsbestand sowohl für Wohnungen als auch für Gebäude erweitert, was zu höheren Umsätzen und Gewinnen führt" und Drücken der POST-Taste.

Als Rückgabewert werden ** input_text ** und ** neg_pos (0 oder 1) ** zurückgegeben, die negativ / positiv darstellen.

Im obigen Beispiel wird positiv (= 1) als Inferenzergebnis zurückgegeben.

4. Inferenz mit der REST-API

Versuchen Sie als Nächstes, die erstellte REST-API vom lokalen Client aufzurufen und das Inferenzergebnis zu erhalten. Diesmal werden Client und Server einfach auf demselben PC ausgeführt.

Öffnen Sie nach dem Starten des Entwicklungsservers mit dem Runserver python manage.py den DOS-Bildschirm usw. in einem separaten Fenster und führen Sie den Befehl python aus, damit der Python-Code ausgeführt und der folgende Code ausgeführt werden kann.

import urllib.request
import urllib.parse
import json
def predict(input_text):
    URL = "http://127.0.0.1:8000/api/v1/predict/"
    values = {
        "format": "json",
        "input_text": input_text,
        }
    data = urllib.parse.urlencode({'input_text': input_text}).encode('utf-8')
    request = urllib.request.Request(URL, data)
    response = urllib.request.urlopen(request)
    result= json.loads(response.read())
    return result

input_text = "In Bezug auf das Ergebnis verringerte sich das ordentliche Ergebnis gegenüber dem Vorjahr um 7.273 Millionen Yen auf 67.413 Millionen Yen, was auf einen Rückgang der Zinsen für Kredite und des Gewinns aus dem Verkauf von Wertpapieren zurückzuführen ist."
result = predict(input_text)
print(result)
{'input_text': 'In Bezug auf das Ergebnis verringerte sich das ordentliche Ergebnis gegenüber dem Vorjahr um 7.273 Millionen Yen auf 67.413 Millionen Yen, was auf einen Rückgang der Zinsen für Kredite und des Gewinns aus dem Verkauf von Wertpapieren zurückzuführen ist.', 'neg_pos': 0}
print(result['input_text'])
In Bezug auf das Ergebnis verringerte sich das ordentliche Ergebnis gegenüber dem Vorjahr um 7.273 Millionen Yen auf 67.413 Millionen Yen, was auf einen Rückgang der Zinsen für Kredite und des Gewinns aus dem Verkauf von Wertpapieren zurückzuführen ist.
print(result['neg_pos'])
0

Geben Sie ** "http://127.0.0.1:8000/api/v1/predict/"** als Endpunkt an. Geben Sie json als Format und input_text als Eingabedaten für die Variablenwerte des Wörterbuchtyps an.

Wenn Sie es anschließend mit der POST-Methode zusammen mit den für den Endpunkt mit urllib.request.Request codierten Satzdaten auslösen, wird die in views.py definierte BertPredictAPIView-Klasse aufgerufen und der Prozess wird im Ablauf der Serialisierung → Inferenzausführung verschoben Gehen. Ich werde das Verarbeitungsergebnis mit json.loads konvertieren, damit es auf der Python-Seite als Wörterbuchtyp behandelt werden kann.

Anschließend werden die Daten wie unten gezeigt in Wörterbuchtypen konvertiert, sodass Sie über den Schlüsselnamen (input_text, neg_pos) auf die gewünschten Informationen zugreifen können.

{'input_text': 'In Bezug auf das Ergebnis verringerte sich das ordentliche Ergebnis gegenüber dem Vorjahr um 7.273 Millionen Yen auf 67.413 Millionen Yen, was auf einen Rückgang der Zinsen für Kredite und des Gewinns aus dem Verkauf von Wertpapieren zurückzuführen ist.', 'neg_pos': 0}

5. Einfaches Werkzeug

Erstellen Sie schließlich einen einfachen Befehl, der automatisch eine große Menge von Eingabedaten an die REST-API sendet und das Inferenzergebnis ausgibt. Die unten verwendeten CSV-Dateien und -Programme befinden sich unter django-drf-dl / drf / tools / in Git-Repository.

Bereiten Sie die folgende test.csv-Datei vor, die Sie vorhersagen möchten. (Spaltenname ist INPUT)

Platzieren Sie Predict.py mit dem folgenden Code im selben Ordner wie test.csv.

import pandas as pd
import numpy as np
import urllib.request
import urllib.parse
import json

def predict(input_text):
    URL = "http://127.0.0.1:8000/api/v1/predict/"
    values = {
        "format": "json",
        "input_text": input_text,
            }
    data = urllib.parse.urlencode({'input_text': input_text}).encode('utf-8')
    request = urllib.request.Request(URL, data)
    response = urllib.request.urlopen(request)
    result= json.loads(response.read())
    return result['neg_pos'][1]	

if __name__ == '__main__':
    print("Start if __name__ == '__main__'")
    print('load csv file ....')
    df = pd.read_csv("test.csv", engine="python", encoding="utf-8-sig")
    df["PREDICT"] = np.nan   #Vorhersage-Spalte hinzufügen
    print('Getting prediction results ....')
    for index, row in df.iterrows():
        df.at[index, "PREDICT"] = predict(row['INPUT'])
    print('save results to csv file')
    df.to_csv("predicted_test .csv", encoding="utf-8-sig", index=False)
    print('Processing terminated normally.')

Wenn Sie den DOS-Bildschirm starten und den folgenden Befehl ausführen, wird test.csv zeilenweise gelesen und an die REST-API gesendet, um das Inferenzergebnis zu erhalten.

python predict.py
----------------------------------
Start if __name__ == '__main__'
load csv file ....
Getting prediction results ....
save results to csv file
Processing terminated normally.

Wenn die letzten Daten fertig sind, wird "Predicted_test.csv" mit dem Inferenzergebnis im selben Ordner generiert.

6. Zusammenfassung

Dieses Mal habe ich eine REST-API erstellt, die einfache Negative und Positive mithilfe eines binären Klassifizierungsmodells von DRF und BERT in der lokalen Umgebung beurteilt. In Zukunft möchte ich eine REST-API auf der Azure-Plattform erstellen und auf Aufgaben wie Mehrfachklassifizierung und FAQ anstelle der Binärklassifizierung anwenden.

7. Nachschlagewerke

Das in diesem Artikel erstellte DRF wurde erstellt, indem ein wenig basierend auf dem Inhalt in Django REST Framework-Lehrbuch, das vor Ort verwendet werden kann angewendet wurde. Ich habe dieses Mal zum ersten Mal DRF mit diesem Buch gelernt, aber es ist ein sehr hilfreiches Buch, daher wird es für diejenigen empfohlen, die von nun an DRF lernen möchten.

Morgen ist der 21. Tagesartikel von "Django Adventskalender 2019 - Qiita" von ssh22. Vielen Dank!