By Walid Amamo, oprichter van UBIAI

Foto door JJ Ying on Unsplash

Introductie

 
Een van de nuttigste toepassingen van NLP-technologie is het extraheren van informatie uit ongestructureerde teksten - contracten, financiële documenten, medische dossiers, enz. - waarmee automatisch gegevens kunnen worden opgevraagd om nieuwe inzichten te verkrijgen. Traditioneel wordt benoemde entiteitsherkenning veel gebruikt om entiteiten in een tekst te identificeren en de gegevens op te slaan voor geavanceerd opvragen en filteren. Als we echter de ongestructureerde tekst semantisch willen begrijpen, NER alleen is niet genoeg, omdat we niet weten hoe de entiteiten aan elkaar gerelateerd zijn. Door gezamenlijke NER- en relatie-extractie uit te voeren, wordt een geheel nieuwe manier geopend voor het ophalen van informatie door middel van kennisgrafieken, waar u door verschillende knooppunten kunt navigeren om verborgen relaties te ontdekken. Daarom zal het gezamenlijk uitvoeren van deze taken voordelig zijn.

Voortbouwend op mijn vorige artikel waar we een BERT-model voor NER hebben verfijnd met behulp van spaCy3, zullen we nu relatie-extractie aan de pijplijn toevoegen met behulp van de nieuwe Thinc-bibliotheek van spaCy. We trainen het relatie-extractiemodel volgens de stappen beschreven in documentatie van spaCy. We zullen de prestaties van de relatieclassificator vergelijken met behulp van transformatoren en tok2vec-algoritmen. Ten slotte testen we het model op een online gevonden functiebeschrijving.

Relatieclassificatie:

 
In de kern is het relatie-extractiemodel een classificator die een relatie voorspelt r voor een bepaald entiteitspaar {e1, e2}. In het geval van transformatoren wordt deze classificatie toegevoegd bovenop de verborgen uitvoerstatussen. Lees dit uitstekend voor meer informatie over het extraheren van relaties dit artikel schetsen van de theorie van fijnafstemming van het transformatormodel voor relatieclassificatie.

Het vooraf getrainde model dat we gaan verfijnen is het roberta-base model, maar je kunt elk vooraf getraind model gebruiken dat beschikbaar is in de Huggingface-bibliotheek door simpelweg de naam in het configuratiebestand in te voeren (zie hieronder).

In deze zelfstudie gaan we de relatie tussen de twee entiteiten {Ervaring, Vaardigheden} extraheren Ervaring in en tussen {Diploma, Diploma_major} as Diploma voor. Het doel is om de vereiste jaren ervaring in een specifieke vaardigheid en het diploma major dat aan het vereiste diploma is gekoppeld, te extraheren. U kunt natuurlijk uw eigen relatieclassificatie trainen voor uw eigen use-case, zoals het vinden van de oorzaak/gevolg van symptomen in medische dossiers of bedrijfsovernames in financiële documenten. De mogelijkheden zijn grenzeloos…

In deze zelfstudie behandelen we alleen het extractiegedeelte van de entiteitsrelatie. Raadpleeg mijn vorige artikel.

Gegevensannotatie:

 
Zoals in mijn vorige artikel, we gebruiken UBIAI tool voor tekstannotatie om de gezamenlijke entiteit- en relatie-annotatie uit te voeren vanwege de veelzijdige interface waarmee we gemakkelijk kunnen schakelen tussen entiteit- en relatie-annotatie (zie hieronder):

UBIAI's gezamenlijke entiteit en annotatie-interface voor relaties

Voor deze zelfstudie heb ik slechts ongeveer 100 documenten met entiteiten en relaties geannoteerd. Voor de productie hebben we zeker meer geannoteerde gegevens nodig.

Data voorbereiding:

 
Voordat we het model trainen, moeten we onze geannoteerde gegevens converteren naar een binair spacy-bestand. We splitsen eerst de vanuit UBIAI gegenereerde annotatie op in training/dev/test en slaan deze afzonderlijk op. Wij wijzigen de code dat wordt geleverd in de tutorial repo van spaCy om het binaire bestand te maken voor onze eigen annotatie (conversiecode).

We herhalen deze stap voor de trainings-, ontwikkel- en testdataset om drie binaire spacy-bestanden te genereren (bestanden beschikbaar in github).

Relatie Extractie Model Training:

 
Voor training leveren we de entiteiten uit ons gouden corpus en trainen we de classifier op deze entiteiten.

• Open een nieuw Google Colab-project en zorg ervoor dat u GPU selecteert als hardwareversneller in de notebookinstellingen. Zorg ervoor dat GPU is ingeschakeld door het volgende uit te voeren: !nvidia-smi
• Spacy-nightly installeren:

!pip install -U spacy-nightly --pre

• Installeer het wielpakket en kloon de relatie-extractierepo van Spacy:

!pip install -U pip setuptools wheel
!python -m spacy project clone tutorials/rel_component

• Installeer de transformatorpijplijn en de bibliotheek met ruimtelijke transformatoren:

!python -m spacy download en_core_web_trf
!pip install -U spacy transformers

• Wijzig de map in de map rel_component: cd rel_component
• Maak een map met de naam "data" in rel_component en upload de binaire bestanden voor training, ontwikkeling en testen erin:

Trainingsmap

• Open het project.yml-bestand en werk het trainings-, ontwikkelings- en testpad bij:

train_file: "data/relations_training.spacy"dev_file: "data/relations_dev.spacy"test_file: "data/relations_test.spacy"

• U kunt het vooraf getrainde transformatormodel wijzigen (als u bijvoorbeeld een andere taal wilt gebruiken), door naar configs/rel_trf.cfg te gaan en de naam van het model in te voeren:

[components.transformer.model]@architectures = "spacy-transformers.TransformerModel.v1"name = "roberta-base" # Transformer model from huggingfacetokenizer_config = {"use_fast": true}

• Voordat we met de training beginnen, verminderen we de max_length in configs/rel_trf.cfg van de standaard 100 token naar 20 om de efficiëntie van ons model te vergroten. De max_length komt overeen met de maximale afstand tussen twee entiteiten waarboven ze niet in aanmerking komen voor relatieclassificatie. Hierdoor worden twee entiteiten uit hetzelfde document geclassificeerd, zolang ze zich binnen een maximale afstand (in aantal tokens) van elkaar bevinden.

[components.relation_extractor.model.create_instance_tensor.get_instances]@misc = "rel_instance_generator.v1"max_length = 20

• We zijn eindelijk klaar om het relatie-extractiemodel te trainen en te evalueren; voer gewoon de onderstaande opdrachten uit:

!spacy project run train_gpu # command to train train transformers
!spacy project run evaluate # command to evaluate on test dataset

Je zou moeten zien dat de P-, R- en F-score wordt bijgewerkt:

Modeltraining is bezig

Nadat het model klaar is met trainen, begint de evaluatie van de testdataset onmiddellijk en worden de voorspelde versus gouden labels weergegeven. Het model wordt samen met de scores van ons model opgeslagen in een map met de naam "training".

Voer in plaats daarvan de volgende opdracht uit om het niet-transformatormodel tok2vec te trainen:

!spacy project run train_cpu # command to train train tok2vec
!spacy project run evaluate

We kunnen de prestaties van de twee modellen vergelijken:

# Transformer model "performance":{"rel_micro_p":0.8476190476,"rel_micro_r":0.9468085106,"rel_micro_f":0.8944723618,}
# Tok2vec model "performance":{"rel_micro_p":0.8604651163,"rel_micro_r":0.7872340426,"rel_micro_f":0.8222222222,}

De precisie en recall-scores van het op een transformator gebaseerde model zijn aanzienlijk beter dan tok2vec en tonen het nut van transformatoren aan bij het omgaan met een kleine hoeveelheid geannoteerde gegevens.

Pijpleiding voor gezamenlijke entiteit en relatie-extractie:

 
Ervan uitgaande dat we al een NER-transformatormodel hebben getraind zoals in mijn vorige post, halen we entiteiten uit een online gevonden functiebeschrijving (die geen deel uitmaakte van de training of de ontwikkelset) en voeren ze door naar het relatie-extractiemodel om de relatie te classificeren.

• Installeer spacy-transformatoren en transformatorpijplijn
• Laad het NER-model en extraheer entiteiten:

import spacynlp = spacy.load("NER Model Repo/model-best")Text=['''2+ years of non-internship professional software development experience
Programming experience with at least one modern language such as Java, C++, or C# including object-oriented design.1+ years of experience contributing to the architecture and design (architecture, design patterns, reliability and scaling) of new and current systems.Bachelor / MS Degree in Computer Science. Preferably a PhD in data science.8+ years of professional experience in software development. 2+ years of experience in project management.Experience in mentoring junior software engineers to improve their skills, and make them more effective, product software engineers.Experience in data structures, algorithm design, complexity analysis, object-oriented design.3+ years experience in at least one modern programming language such as Java, Scala, Python, C++, C#Experience in professional software engineering practices & best practices for the full software development life cycle, including coding standards, code reviews, source control management, build processes, testing, and operationsExperience in communicating with users, other technical teams, and management to collect requirements, describe software product features, and technical designs.Experience with building complex software systems that have been successfully delivered to customersProven ability to take a project from scoping requirements through actual launch of the project, with experience in the subsequent operation of the system in production''']for doc in nlp.pipe(text, disable=["tagger"]): print(f"spans: {[(e.start, e.text, e.label_) for e in doc.ents]}")

• We drukken de geëxtraheerde entiteiten af:

spans: [(0, '2+ years', 'EXPERIENCE'), (7, 'professional software development', 'SKILLS'), (12, 'Programming', 'SKILLS'), (22, 'Java', 'SKILLS'), (24, 'C++', 'SKILLS'), (27, 'C#', 'SKILLS'), (30, 'object-oriented design', 'SKILLS'), (36, '1+ years', 'EXPERIENCE'), (41, 'contributing to the', 'SKILLS'), (46, 'design', 'SKILLS'), (48, 'architecture', 'SKILLS'), (50, 'design patterns', 'SKILLS'), (55, 'scaling', 'SKILLS'), (60, 'current systems', 'SKILLS'), (64, 'Bachelor', 'DIPLOMA'), (68, 'Computer Science', 'DIPLOMA_MAJOR'), (75, '8+ years', 'EXPERIENCE'), (82, 'software development', 'SKILLS'), (88, 'mentoring junior software engineers', 'SKILLS'), (103, 'product software engineers', 'SKILLS'), (110, 'data structures', 'SKILLS'), (113, 'algorithm design', 'SKILLS'), (116, 'complexity analysis', 'SKILLS'), (119, 'object-oriented design', 'SKILLS'), (135, 'Java', 'SKILLS'), (137, 'Scala', 'SKILLS'), (139, 'Python', 'SKILLS'), (141, 'C++', 'SKILLS'), (143, 'C#', 'SKILLS'), (148, 'professional software engineering', 'SKILLS'), (151, 'practices', 'SKILLS'), (153, 'best practices', 'SKILLS'), (158, 'software development', 'SKILLS'), (164, 'coding', 'SKILLS'), (167, 'code reviews', 'SKILLS'), (170, 'source control management', 'SKILLS'), (174, 'build processes', 'SKILLS'), (177, 'testing', 'SKILLS'), (180, 'operations', 'SKILLS'), (184, 'communicating', 'SKILLS'), (193, 'management', 'SKILLS'), (199, 'software product', 'SKILLS'), (204, 'technical designs', 'SKILLS'), (210, 'building complex software systems', 'SKILLS'), (229, 'scoping requirements', 'SKILLS')]

We hebben met succes alle vaardigheden, aantal jaren ervaring, diploma en diploma major uit de tekst gehaald! Vervolgens laden we het relatie-extractiemodel en classificeren we de relatie tussen de entiteiten.

Opmerking: zorg ervoor dat u rel_pipe en rel_model kopieert van de map scripts naar uw hoofdmap:

map Scripts

import randomimport typerfrom pathlib import Pathimport spacyfrom spacy.tokens import DocBin, Docfrom spacy.training.example import Examplefrom rel_pipe import make_relation_extractor, score_relationsfrom rel_model import create_relation_model, create_classification_layer, create_instances, create_tensors# We load the relation extraction (REL) modelnlp2 = spacy.load("training/model-best")# We take the entities generated from the NER pipeline and input them to the REL pipelinefor name, proc in nlp2.pipeline: doc = proc(doc)# Here, we split the paragraph into sentences and apply the relation extraction for each pair of entities found in each sentence.for value, rel_dict in doc._.rel.items(): for sent in doc.sents: for e in sent.ents: for b in sent.ents: if e.start == value[0] and b.start == value[1]: if rel_dict['EXPERIENCE_IN'] >=0.9 : print(f" entities: {e.text, b.text} --> predicted relation: {rel_dict}")

Hier tonen we alle entiteiten die een relatie hebben Ervaring in met betrouwbaarheidsscore hoger dan 90%:

"entities":("2+ years", "professional software development"") --> predicted relation":
{"DEGREE_IN":1.2778723e-07,"EXPERIENCE_IN":0.9694631}"entities":"(""1+ years", "contributing to the"") -->
predicted relation":
{"DEGREE_IN":1.4581254e-07,"EXPERIENCE_IN":0.9205434}"entities":"(""1+ years","design"") --> predicted relation":
{"DEGREE_IN":1.8895419e-07,"EXPERIENCE_IN":0.94121873}"entities":"(""1+ years","architecture"") --> predicted relation":
{"DEGREE_IN":1.9635708e-07,"EXPERIENCE_IN":0.9399484}"entities":"(""1+ years","design patterns"") --> predicted relation":
{"DEGREE_IN":1.9823732e-07,"EXPERIENCE_IN":0.9423302}"entities":"(""1+ years", "scaling"") --> predicted relation":
{"DEGREE_IN":1.892173e-07,"EXPERIENCE_IN":0.96628445}entities: ('2+ years', 'project management') --> predicted relation:
{'DEGREE_IN': 5.175297e-07, 'EXPERIENCE_IN': 0.9911635}"entities":"(""8+ years","software development"") -->
predicted relation":
{"DEGREE_IN":4.914319e-08,"EXPERIENCE_IN":0.994812}"entities":"(""3+ years","Java"") -->
predicted relation":
{"DEGREE_IN":9.288566e-08,"EXPERIENCE_IN":0.99975795}"entities":"(""3+ years","Scala"") --> predicted relation":
{"DEGREE_IN":2.8477e-07,"EXPERIENCE_IN":0.99982494}"entities":"(""3+ years","Python"") -->
predicted relation":
{"DEGREE_IN":3.3149718e-07,"EXPERIENCE_IN":0.9998517}"entities":"(""3+ years","C++"") -->
predicted relation":
{"DEGREE_IN":2.2569053e-07,"EXPERIENCE_IN":0.99986637}

Opmerkelijk genoeg waren we in staat om bijna alle jaren van ervaring samen met hun respectieve vaardigheden correct te extraheren zonder valse positieven of negatieven!

Laten we eens kijken naar de entiteiten die een relatie hebben Diploma voor:

entities: ('Bachelor / MS', 'Computer Science') -->
predicted relation: {'DEGREE_IN': 0.9943974, 'EXPERIENCE_IN':1.8361954e-09} entities: ('PhD', 'data science') --> predicted relation: {'DEGREE_IN': 0.98883855, 'EXPERIENCE_IN': 5.2092592e-09}

Nogmaals, we hebben met succes alle relaties tussen diploma en diploma major geëxtraheerd!

Dit laat opnieuw zien hoe gemakkelijk het is om transformatormodellen nauwkeurig af te stemmen op uw eigen domeinspecifieke casus met een kleine hoeveelheid geannoteerde gegevens, of het nu gaat om NER- of relatie-extractie.

Met slechts honderd geannoteerde documenten konden we een relatieclassificator met goede prestaties trainen. Bovendien kunnen we dit initiële model gebruiken om honderden niet-gelabelde gegevens automatisch te annoteren met minimale correctie. Dit kan het annotatieproces aanzienlijk versnellen en de modelprestaties verbeteren.

Conclusie:

 
Transformers hebben het domein van NLP echt getransformeerd en ik ben vooral enthousiast over hun toepassing bij het extraheren van informatie. Ik wil graag een pluim geven aan explosie-AI (spaCy-ontwikkelaars) en knuffelgezicht voor het bieden van open source-oplossingen die de acceptatie van transformatoren vergemakkelijken.

Als u gegevensannotatie nodig heeft voor uw project, aarzel dan niet om het uit te proberen UBIAI annotatie hulpmiddel. We bieden tal van programmeerbare labeloplossingen (zoals automatische ML-annotatie, reguliere uitdrukkingen, woordenboeken, enz.) om handannotatie te minimaliseren.

Tot slot, afrekenen dit artikel om te leren hoe u de NER- en relatie-extractiemodellen kunt gebruiken om kennisgrafieken te maken en nieuwe inzichten te extraheren.

Als je een opmerking hebt, laat dan hieronder een bericht achter of stuur een e-mail naar admin@ubiai.tools!

 
Bio: Walid Amamo is de oprichter van UBIAI, een annotatietool voor NLP-toepassingen, en is gepromoveerd in natuurkunde.

ORIGINELE. Met toestemming opnieuw gepost.

Zie ook:

• Hoe de BERT-transformator nauwkeurig af te stemmen met spaCy 3
• Een kenniskaart maken voor het zoeken naar werk met BERT
• Verfijning van transformatormodel voor factuurherkenning