Ik moest verschillende dingen proberen met een zinnig grote formule dataset, om te spelen met wat feestschikkende gedachten. Het probleem was dat ik geen dataset had.

Vergeet het maar, ik dacht, er zijn bergen plannen Online-Ik zal een deel van die plannen gebruiken!

Door de geïmplanteerde informatie organisaties zoals het h-formule microformaat, en de formule schets van Schema.org, worden grote aantallen van de online verspreide plannen semantisch verhoogd. Veel beter, er is een Ruby pearl genaamd hangry om deze configuraties te ontleden. In een kwestie van seconden, was ik plannen aan het omzetten in georganiseerde informatie.

Het ding waar ik het meest op gebrand was, was fixeren, en hier raakte ik mijn volgende nummer: Ik had begrijpelijke regelingen van de bevestigingen, maar niets was voldoende georganiseerd om naar bedragen te kijken, similitudes te ontdekken, of eenheden om te zetten.

Ingrediënten zijn hard

De eerste paar voorbeelden waar ik naar keek, leken vrij eenvoudig:

 “2 eetlepels boter”,

 “2 eetlepels meel”,

 “1/2 kopje witte wijn”,

 “1 kopje kippenbouillon”,

Het leek erop dat er een duidelijk patroon ontstond, en misschien zou één regel Ruby code voldoende zijn:

hoeveelheid, eenheid, naam = beschrijving.split(” “, 3)

Helaas was de waarheid veel verwarrender. Ik ontdekte een steeds groter aantal modellen die niet pasten bij dit eenvoudige voorbeeld. Een paar fixaties hadden talrijke hoeveelheden die samengevoegd hadden moeten worden (“3 kopjes en 2 eetlepels”, of “2 bundels van 10 ons”); andere hadden electieve hoeveelheden in metrisch en magnifiek, of in kopjes ounces; weer andere streefden de fixeernaam na met planningsrichtlijnen, of registreerden verschillende fixaties samen in een gelijkaardig ding.

De ongewone gevallen werden steeds hoger, en mijn eenvoudige Ruby code raakte steeds meer in de war. Ik stopte met het houden van de code, op dat moment, ik stopte met het gevoel dat het goed zou zijn na de refactoring, en uiteindelijk heb ik het weggegooid.

Ik had een heel andere regeling nodig.

Naamsvermelding

Het leek erop dat het ideale probleem voor beheerde AI-ik had hopen informatie die ik moest classificeren; fysiek het regelen van een eenzaam model was echt eenvoudig; toch was het fysiek onderscheiden van een algemeen voorbeeld, best case scenario moeilijk, en zelfs vanuit een pessimistisch standpunt ondenkbaar.

Na te hebben nagedacht over mijn keuzes, leek een genoemde stofherkenner op het juiste apparaat om te gebruiken. Genoemde stofherkenners onderscheiden vooraf gekarakteriseerde classificaties in de inhoud; voor mijn situatie had ik er een nodig om naam, hoeveelheden en eenheden van fixaties waar te nemen.

Ik heb me gevestigd op de Stanford NER, die gebruik maakt van een voorwaardelijk willekeurig veldgroeperingsmodel. Om direct ter zake te komen, begrijp ik de wiskunde achter dit specifieke model niet, maar je kunt het papier1 wel doornemen in het geval je alle verdomde subtiliteiten nodig hebt. Het belangrijkste voor mij was dat ik dit NER-model kon voorbereiden zonder iemand anders dataset.

De procedure die ik heb gevolgd om mijn model voor te bereiden was afhankelijk van het model Jane Austen van Stanford NER FAQ.

Voorbereiding van het model

Het belangrijkste wat ik deed was mijn modelinformatie verzamelen. Binnen een eenzame formule is de manier waarop de bevestigingen zijn samengesteld zeer uniform. Ik moest ervoor zorgen dat ik een fatsoenlijke omvang van de configuraties had, dus ik sloot me aan bij de bevestigingen van ongeveer 30.000 online plannen in een eenzame opsomming, regelde ze willekeurig, en koos de eerste 1.500 om mijn voorbereidingsset te zijn.

Het leek er wel op:

banketbakkerssuiker voor het afstoffen van de taart

1 1/2 kopje gerookte zalm in blokjes gesneden

1/2 kopje hele amandelen (3 oz), geroosterd

Vervolgens heb ik een stuk van Stanford’s suite van NLP-apparaten gebruikt om deze te verdelen in penningen.

De bijhorende richting zal de inhoud doornemen van de standaard info, en de opbrengst van de munten tot aan de standaard opbrengst:

java – cp stanford-ner.jar edu.stanford.nlp.process.PTBTokenizer

Voor deze situatie moest ik een model samenstellen dat een eenzame fixatie-uitbeelding begrijpt, niet een hele opstelling van fixatie-uitbeeldingen. In de NLP toespraak impliceert dit dat elke fixeerafbeelding als een ander verslag moet worden gezien. Om dat tegen de Stanford NER-instrumenten te zeggen, moeten we elke opstelling van de penningen met een duidelijke lijn isoleren.

Ik heb ze opgesplitst met behulp van een beetje schelpinhoud:

terwijl leesregel; doe

 echo $line | java -cp stanford-ner.jar edu.stanford.nlp.process.PTBTokenizer >> train.tok

 echo >> trein.tok

gedaan < trein.txt

De uitgang zag er zo uit:

banketbakkers

suiker

voor

afstoffen

de

taart

1 1/2

bekers

in blokjes gesneden

gerookt

zalm

1/2

beker

heel

amandelen

-LRB-

3

oz

-RRB-

,

geroosterd

Het laatste handmatige voorschot was om de penningen te etiketteren, om aan te tonen wat een stuk van de naam van een vaststelling was, wat een stuk van het bedrag was, en wat een stuk van de eenheid was. 1.500 modellen waren rond de 10.000 lopers, die elk met de hand werden genoemd.

Elk speelfiguur heeft een merkteken nodig, zelfs speelfiguren die niet intrigerend zijn, die met O. Stanford NER worden genoemd, verwacht dat de speelfiguren en het merkteken worden geïsoleerd door een tabbladkarakter. Om te beginnen heb ik elke penning gemarkeerd met O:

perl -ne ‘chomp; $_ =~ /^$/ ? print ‘\n’ : print ‘$_tOn”.

 train.tok > train.tsv

Enkele uren later zagen de resultaten er zo uit:

banketbakkers NAAM

N              AAM

suiker           NAAM

voor             O

Afstoffen         O

de             O

taart            O

1 1/2           KWANTITEIT

bekers            UNIT

blokjes           O

gerookte          NAAM

Z         ALMNAAM

1/2             KWANTITEIT

beker             UNIT

gehele           O

amandelen         NAAM

-LRB-           O

3               KWANTITEIT

oz              UNIT

-RRB-           O

,               O

geroosterd         O

Nu de trainingsset klaar was, kon ik het model bouwen:

java -cp stanford-ner.jar edu.stanford.nlp.ie.crf.CRFClassifier.

 -trainFile trein.tsv.

 -serialiserenNaar ner-model.ser.gz.

 -prop trein.prop

Het train.prop bestand dat ik gebruikte was zeer vergelijkbaar met het Stanford NER FAQ’s voorbeeldbestand, austen.prop.

En daar had ik het! Een model dat nieuwe voorbeelden kan classificeren.