Bert en sentiment 2

Zo, ik heb nu ook reakties uit onze end-user-satisfaction-survey om kunnen zetten om te testen of sentiment analyse training, gebaseerd op film recenties, kunnen gebruikt worden voor dit soort survey reakties.

Het rare is dat het lastig te beoordelen is. De survey vraagt o.a. over een 'overall waardering voor IT' in een cijfer 1 tot 9 en daarnaast om een overall commentaar / toelichting. Die twee lijken regelmatig niet met elkaar in overeenstemming te zijn. Hier zijn een paar resultaten inclusief de voorspelling van Bert:

100 negative 7.0 There have been many instances where a ticket is closed with no actual resolution, which        can be very frustrating.
102 positive 9.0 The sorts of things that I need done are not what is displayed on the IT website: in this      case, I needed a server to be replaced.  The existing item w ...
104 negative 10.0 none
106 positive 7.0 Our local IT is good, always has been helpful. More and more though, they are unable to        help because of some new imposed process that forces us to go ...
107 positive 5.0 Often I need a local IT support. Infact the process to receive support is too long.
    For example, when we receive a new PC, we have to install and man...
110 negative 8.0 Continued slowdown or, quite frankly, unusability of the drives: Pena_Tax1 ...
111 negative 8.0 No feedback needed. IT services are good and working for me. Communications on IT related      services are done reguraly.
120 positive 7.0 -sehr schlecht: an jedem PC muss das Profil neu eingerichtet werden (Verknüpfungen,            Festplatten usw.); dies behindert vorallem IT unerfahrene Person a ...   


Oke, er zijn dus vreemde combinaties te vinden. Dat deze Bert geen Duits kent is hem vergeven :-) 
Doordat de survey score ook geen echte relatie met het sentiment in de tekst lijkt te hebben is het helaas lastig om te valideren hoe goed het model werkt en het echte sentiment hieruit kan halen.  

Bert en sentiment

Sentiment analyse is een van de veel gebruikte NLP voorbeelden. Ik zie dat men hierbij vaak gebruik maakt van filmrecenties. Dus ook maar eens kijken of ik Bert dat kan laten doen. Ik wil uiteindelijk testen of dan ook het sentiment in onze 'end user satisfaction survey' daarmee gemeten kan worden.

De data haal ik hier vandaan:

http://ai.stanford.edu/~amaas/data/sentiment/

Na het uitpakken blijkt de structuur van de data ietsje ingewikkeld. Er is een train en test folder met in de train een 'pos' een 'neg' en een 'unsup' folder. Daarbinnen zitten de recenties in afzonderlijke files. Gelukkig zit er een goede readme bij:

In the labeled train/test sets, a negative review has a score <= 4 out of 10,
and a positive review has a score >= 7 out of 10. Thus reviews with
more neutral ratings are not included in the train/test sets. In the
unsupervised set, reviews of any rating are included and there are an
even number of reviews > 5 and <= 5.

Om een of andere reden werkt mijn eerste poging om de data 'hanteerbaar' te maken niet. Onduidelijke foutmelding. Gelukkig vindt ik hier een goede code om e.e.a. naar een mooie csv om te zetten.

Uiteraard lees ik de readme niet goed genoeg en ga ik er eerst vanuit dat de 'unsup' folder de 'neutralere' reviews bevat. (5 tot 6) Die wil ik er graag bij hebben om deze ook te kunnen herkennen.
Dat levert een uiterst teleurstellend resultaat op. Na de 2e epoch blijft alles ongeveer op dezelfde accuracy en loss uitkomen. (acc rond 50%)

Als ik de 'unsup' laat vervallen is Bert veel enthousiaster:

 Ik moet dus wel bij de 6e of 7e epoch stoppen:

Mooi! Een behoorlijke test accuracy en F1 score. Nu nog mijn end user satisfaction commentaren gaan aanbieden. Ik ben benieuwd!


 

Bert testen met incident beschrijvingen 2

In een eerdere proef heb ik getest of ik (Bert) op basis van incident beschrijvingen de bijbehorende prioriteit kon voorspellen. Dat lukte behoorlijk goed. Meer dan 82 % test accuracy! (F1=70,7%)

Ook interessant is of ik het aan de juiste business service kan koppelen. Er zijn 215 business services.
Hier is een 'redelijke' verdeling in de 15K records:

GCS Helpdesk                                                1934
PIL O2C ERP                                                 1612
HC One SAP R3                                                935
LOCAL APPS CLUSTER MED HAIFA                                 500
PIL B2B Service Cloud SMAX                                   493
HC I-IMAGING R3                                              491
PC Hardware                                                  437
Philips Volcano Manufacturing Apps Service                   427
Philips Store                                                338
...
...
Ticket Status Update                                           1
Gainesville Engineering Applications                           1
OneDrive                                                       1

71% test accuracy lijkt zeker niet slecht op basis van de beperkte omschrijvingen! De F1 is hier wat minder. Ik weet niet zeker welke conclusie ik hieruit moet trekken.

Eenzelfde uitdaging is het bijzoeken van de juiste assignmentgroup. Dat zijn er 394. Met hier wat voorbeelden:

'HP GERMANY OSS SUPPORT TEAM', 'PH PIC TSRD SUPPORT TEAM', 'PEAS Servicedesk', 'PH GCS OPIE Support Team', 'LOCAL APPS PCERV DIST SUPPORT', ...

Hoewel er in de 15K records ook assignmentgroepen zijn die maar 1 keer voorkomen is er verder een 'redelijke' verdeling. De grootste neemt zo'n 10% in, de tweede iets minder. Daarna gaat het redelijk snel omlaag: 

WT PIL O2C ERP                              1551
PH GCS ServiceMax IT Support Team           1293
WTT One IT One SAP R3                        809
HC Service Max SFDC Support                  493
WTT One IT I-IMAGING R3                      438
PH GCS LOCAL IT SUPPORT TEAM                 338
Philips Volcano Costa Rica Support Team      329
WT EAI & PI Support                          288
...
...
WTT GDS SUPPLY TEAM                            1
HP GLOBAL OSS SUPPORT TEAM                     1
HP FRANCE OSS SUPPORT TEAM                     1
TA HTC CAD  Service Desk                       1
WT PIL O2C AFTERCRE SLATAM                     1

Kijken we naar de validatie uitkomsten dan zien we redelijk wat variatie:

>>> predicts[:20]
array([265, 229, 265, 367, 390, 349, 155, 159, 196, 349, 339, 138, 155,
       303,   0, 328, 208, 353,  58,  58], dtype=int64)

Een redelijk resultaat een test accuracy van bijna 60%. De F1 ziet er hier wat minder goed uit.
De incidenten hebben ook, behalve de 'verkorte omschrijving' ook een uitgebreide omschrijving en andere metadata. Wellicht dat daarmee de accuracy nog flink omhoog te brengen is. Scheelt een hoop werk als er al een assignment en service (en prioriteits) advies gegeven kan worden. 

BERTje: Als meer tekst niet helpt misschien dan minder? ...

Het verhogen van de maximale tekstlengte van 128 naar 192 werkt dus wel maar geeft minder goede resultaten. Daarnaast neemt het 2x zo lang om te trainen. Wat zou er gebeuren als we de sequence length omlaag brengen, oftewel minder tekst te leren geven? Ik breng de max seq length terug naar 64. Het moet dan ook mogelijk zijn om met grotere batches te werken dus die zet ik op 50.

De trainingstijd gaat in ieder geval met ongeveer de helpft omlaag naar een kleine 400 seconden per epoch. Dat scheelt al een hoop! Nu kijken wat de effecten op de scores zijn. Uiteraard zal dat voornamelijk bepaald worden door het feit of de classificerende informatie vooral in het eerste deel van de tekst terug te vinden is. Meer, andere informatie erbij lijkt daarna voor 'ruis' te zorgen.

De F1 score is iets beter: van 77.6 naar 78.3. De test accuracy is iets omlaag gegaan: van 88.6 naar 87.6. Maar goed iig dus de snelheids winst.

Epoch 1/10
42850/42850 [==============================] - 408s 10ms/step - loss: 2.7999 - sparse_categorical_accuracy: 0.5262
Epoch 2/10
42850/42850 [==============================] - 392s 9ms/step - loss: 0.8889 - sparse_categorical_accuracy: 0.8131
Epoch 3/10
42850/42850 [==============================] - 392s 9ms/step - loss: 0.5507 - sparse_categorical_accuracy: 0.8692
Epoch 4/10
42850/42850 [==============================] - 392s 9ms/step - loss: 0.3966 - sparse_categorical_accuracy: 0.8987
Epoch 5/10
42850/42850 [==============================] - 392s 9ms/step - loss: 0.3028 - sparse_categorical_accuracy: 0.9182
Epoch 6/10
42850/42850 [==============================] - 392s 9ms/step - loss: 0.2456 - sparse_categorical_accuracy: 0.9322
Epoch 7/10
42850/42850 [==============================] - 393s 9ms/step - loss: 0.2123 - sparse_categorical_accuracy: 0.9394
Epoch 8/10
42850/42850 [==============================] - 394s 9ms/step - loss: 0.1922 - sparse_categorical_accuracy: 0.9449
Epoch 9/10
42850/42850 [==============================] - 395s 9ms/step - loss: 0.1691 - sparse_categorical_accuracy: 0.9505
Epoch 10/10
42850/42850 [==============================] - 392s 9ms/step - loss: 0.1548 - sparse_categorical_accuracy: 0.9551
 

BERTje met langere teksten

In de serie van ChrisMcCormickAI wordt aangegeven dat Bert met een tekstlengte kan werken van maximaal 256. Tot nu toe heb ik steeds 128 aangehouden, mede omdat ik meende dat dat maximum uit het model zou blijken:

Layer (type)                    Output Shape         Param #     Connected to
==================================================================================================
Input-Token (InputLayer)        (None, 128)          0
__________________________________________________________________________________________________
Input-Segment (InputLayer)      (None, 128)          0
__________________________________________________________________________________________________
Embedding-Token (TokenEmbedding [(None, 128, 768), ( 23040000    Input-Token[0][0]
__________________________________________________________________________________________________
Embedding-Segment (Embedding)   (None, 128, 768)     1536        Input-Segment[0][0]
__________________________________________________________________________________________________
Embedding-Token-Segment (Add)   (None, 128, 768)     0           Embedding-Token[0][0]
                                                                 Embedding-Segment[0][0]
__________________________________________________________________________________________________
Embedding-Position (PositionEmb (None, 128, 768)     98304       Embedding-Token-Segment[0][0]
__________________________________________________________________________________________________
Embedding-Dropout (Dropout)     (None, 128, 768)     0           Embedding-Position[0][0]
__________________________________________________________________________________________________
Embedding-Norm (LayerNormalizat (None, 128, 768)     1536        Embedding-Dropout[0][0]
__________________________________________________________________________________________________
Encoder-1-MultiHeadSelfAttentio (None, 128, 768)     2362368     Embedding-Norm[0][0]
...
...

Nou, blijkbaar dus niet. Een lengte van 256 lukt mij niet:

 Resource exhausted: OOM when allocating tensor with shape[300,256,256]

Maar als ik de lengte naar 192 aanpas (en voor de zekerheid de batchgrootte naar 10) begint die vrolijk te zoemen. Ofwel: hij gaat er lekker mee aan de slag. Wel duren de epochs langer: 1562 seconden. Nou ja, ik ben benieuwd of hij er wijzer van is geworden. 

Helaas, duurt 2x zo lang en maakt hem (haar?) niet slimmer.

Epoch 1/10
42890/42890 [==============================] - 1562s 36ms/step - loss: 1.7809 - sparse_categorical_accuracy: 0.6647
Epoch 2/10
42890/42890 [==============================] - 1555s 36ms/step - loss: 0.7816 - sparse_categorical_accuracy: 0.8110
Epoch 3/10
42890/42890 [==============================] - 1536s 36ms/step - loss: 0.6109 - sparse_categorical_accuracy: 0.8435
Epoch 4/10
42890/42890 [==============================] - 1544s 36ms/step - loss: 0.5158 - sparse_categorical_accuracy: 0.8633
Epoch 5/10
42890/42890 [==============================] - 1543s 36ms/step - loss: 0.4523 - sparse_categorical_accuracy: 0.8755
Epoch 6/10
42890/42890 [==============================] - 1549s 36ms/step - loss: 0.4019 - sparse_categorical_accuracy: 0.8885
Epoch 7/10
42890/42890 [==============================] - 1550s 36ms/step - loss: 0.3620 - sparse_categorical_accuracy: 0.8979
Epoch 8/10
42890/42890 [==============================] - 1548s 36ms/step - loss: 0.3278 - sparse_categorical_accuracy: 0.9080
Epoch 9/10
42890/42890 [==============================] - 1549s 36ms/step - loss: 0.2985 - sparse_categorical_accuracy: 0.9134
Epoch 10/10

42890/42890 [==============================] - 1551s 36ms/step - loss: 0.2720 - sparse_categorical_accuracy: 0.9223

BERTje met nieuwe vocab

Omdat niet alle kleine letters in de vocab file van BERTje - cased zitten (zie vorig bericht) en ik daardoor dus behoorlijk wat [UNK] (unknowns) krijg, doe ik een test om te kijken wat het effect is als ik de vocab file aanpas en op de plaats van de hoofletters kleine letters plaats en vice versa (om doublures te voorkomen).

Je zou zeggen dat dit moet mogen. Een hoofdletter en een kleine letter hebben meestal denk ik dezelfde betekenis in een woord. Maar ik ben benieuwd. Het aantal unknowns is in ieder geval drastisch afgenomen lijkt het uit een steekproef. Gevoelsmatig is er ook meer tekst in de 128 tokens gecodeerd maar dat kan ook suggestie zijn.

Hier zijn de resultaten:

Met spec (moet ze toch weer eens in de grafiek toevoegen):
Epoch 1/10
42875/42875 [==============================] - 821s 19ms/step - loss: 2.1561 - sparse_categorical_accuracy: 0.6187
Epoch 2/10
42875/42875 [==============================] - 805s 19ms/step - loss: 0.6760 - sparse_categorical_accuracy: 0.8408
Epoch 3/10
42875/42875 [==============================] - 805s 19ms/step - loss: 0.4641 - sparse_categorical_accuracy: 0.8788
Epoch 4/10
42875/42875 [==============================] - 805s 19ms/step - loss: 0.3492 - sparse_categorical_accuracy: 0.9045
Epoch 5/10
42875/42875 [==============================] - 805s 19ms/step - loss: 0.2887 - sparse_categorical_accuracy: 0.9182
Epoch 6/10
42875/42875 [==============================] - 805s 19ms/step - loss: 0.2391 - sparse_categorical_accuracy: 0.9309
Epoch 7/10
42875/42875 [==============================] - 805s 19ms/step - loss: 0.2141 - sparse_categorical_accuracy: 0.9369
Epoch 8/10
42875/42875 [==============================] - 805s 19ms/step - loss: 0.1820 - sparse_categorical_accuracy: 0.9449
Epoch 9/10
42875/42875 [==============================] - 804s 19ms/step - loss: 0.1666 - sparse_categorical_accuracy: 0.9498
Epoch 10/10
42875/42875 [==============================] - 804s 19ms/step - loss: 0.1700 - sparse_categorical_accuracy: 0.9487

Het is iets minder goed dan de oorspronkelijke:

Dat is wel bijzonder. Het lijkt erop dat er met de [UNK] geen relevante info is verloren gegaan of dat het 'gebruiken van hoofdletters' de info minder goed heeft gemaakt. Kan ook gewoon een afwijking zijn door een andere random initialisatie van het netwerk. 

BERT(je) verdieping

Vandaag een aardige serie Youtube filmpjes gevonden die helpen om Bert beter te begrijpen. In deze serie van ChrisMcCormickAI wordt het gebruik van Bert op een heel duidelijke en zorgvuldige wijze toegelicht. Een van de zaken is de uitleg over de input voor Bert. Hoewel hij ergens aangeeft dat je kan kiezen voor een zins lengte van 256 blijkt dat niet uit mijn eerder model overzicht. Ik denk dat het daar over "Bert large" gaat.

De zinnen moeten worden voorzien van de juiste begin en eindtokens [CLS] en [SEP]. Daarnaast moet er in de 2e 128 bytes input aangegeven worden welke input 'echte tokens' zijn en welke 'paddings' [PAD]. Natuurlijk wil ik kijken of dat bij mijn input goed is gegaan.
Ik kijk eerst naar de NL 'vocab file':

[UNK]
[CLS]
[SEP]
[PAD]
[MASK]
!
"
&
'
(
)
De [CLS] en de [SEP] lijken op de juiste plaatst te staan Hoewel ik mij afvraag of afzonderlijke zinnen allemaal van deze codering voorzien moeten zijn.  Dat zie ik niet zo snel terug. Wel zijn er diverse [UNK] (code 0) die slaan op unknown. Tevens is het [PAD] (3) token niet goed uitgevoerd. De nullen op het eind zouden m.i. een drie moeten zijn. De 2e reeks moet aangeven waar de 'echte' tokens (incl [CLS], [SEP] en [UNK] staan (hoewel ik de laatste niet helemaal zeker weet). Dat is, zoals hieronder te zien is, ook niet het geval. De hele 2e reeks is altijd alleen van nullen voorzien. 

>>> train_x[0][100]
array([    1, 22795, 26385, 20076,     0,   113,   134, 15607, 12486,
          13, 12828, 22796, 18100, 29220, 25138, 16934, 16779,  8378,
       13903, 10537, 15305, 20076,  7862, 15607, 12365,    13, 15612,
       17064, 16203, 16204, 26054, 19377, 21877, 10537, 14294,  7862,
        7932, 13604, 20722, 27373, 16804, 14293, 29438,  9092, 11281,
       20732, 22065,    13, 20047,   123,   131,    13,  8431, 17707,
       22286,    13, 15557, 22055, 12918,    11, 15061, 24298, 20722,
       22538, 25138, 26576, 14912, 23917,     0,   132, 10343, 17811,
       15333, 23879,     2,     0,     0,     0,     0,     0,     0,
           0,     0,     0,     0,     0,     0,     0,     0,     0,
           0,     0,     0,     0,     0,     0,     0,     0,     0,
           0,     0,     0,     0,     0,     0,     0,     0,     0,
           0,     0,     0,     0,     0,     0,     0,     0,     0,
           0,     0,     0,     0,     0,     0,     0,     0,     0,
           0,     0])
>>> train_x[1][100]
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

Ik zie overigens dat de vocab file zowel hoofd- en kleine letters bevat. Ik heb mij blijkbaar eerder vergist en ben ervan uitgegaan dat het een 'uncased versie' betrof. Ik meen zelfs dat het moedel pas goed ging rekenen nadat ik de zinnen naar uncased heb omgezet. Gek genoeg lijken er maar een paar kleine letters in de vocab voor te komen:

...
W
Y
Z
`
b
d
v
w
z
«
»
–
‘
’
“
”
...
Wel weer als vervolg teken : ##a etc Daar word wel het hele alfabet afgedekt.



Formeel zou de [UNK] code niet (vaak) voor mogen komen. Elk woord zou normaliter in zijn 'woorddelen' moeten kunnen worden uitgedrukt. Desnoods in de afzonderlijke letters. Zo zou een onbekend woord, bijvoorbeeld "dirk",  worden opgesplitst in d, ##i, ##r, ##k. (Met de ## indien het een vervolg letter is.) Maar als ze niet ik de vocab voorkomen kan het uiteraard een probleem worden. Ook zijn niet alle 'leestekens' er zo te zien. Ik mis bijvoorbeeld het apenstaartje.

Maar goed, dat vraagt verder onderzoek. Eerst maar eens testen of een betere codering ook een beter resultaat oplevert.

Ik ben ook benieuwd wat er zou gebeuren als ik de hoofdletters in de vocab door kleine letters vervang. Een mooi experiment.

Bert testen met incident beschrijvingen

Nu ik de methodiek van classificatie van teksten met Bert "onder de knie" lijk te hebben wil ik ook eens wat andere situaties testen die meer in mijn vakgebied liggen. Ik laad daartoe , als eerste, de korte omschrijvingen van 15000 incidenten (helaas is er tegenwoordig een export aantal ingericht in ServiceNow) en kijk of ik de bijbehorende prioriteit kan voorspellen.

De teksten zijn merendeels in Engels dus ik gebruik "Bert-base-uncased".
Voorbeelden zijn:

1 - Critical - customer master block - W & K MOVEIS LTDA
1 - Critical - Error message upon GATP simulation CRITICAL
1 - Critical - update Profit Centers as per attached file
1 - Critical - The Production system is completely down for BPDH , PDH and FORDH
3 - Moderate - Error while updating master data
3 - Moderate - CDP050909: Deliveries failed
3 - Moderate - CN137684
3 - Moderate - Error 500 - Internal Server Error
3 - Moderate - Subcontractor Work Order WO-00905176 not changing to fixed after service receipt is done.

3 - Moderate hk18 MM DOC#5255057187 blocked in SAP, but no reflect in RBAM

We hebben: ['1 - Critical', '2 - High', '3 - Moderate'] als labels.
De eerste keer lijkt nergens op. Al na de 2e epoch zakt de accuracy terug naar bij de .50. Dan bedenk ik mij dat ik natuurlijk wel de teksten 'uncased' moet maken. Dat gaat heel veel beter:

Het lijkt er dus op dat ik (eh ... Bert), aan de hand van de korte omschrijvingen, met 81% zekerheid kan voorspellen wat de juiste prioriteit is. Omdat Moderate het meeste voorkomt check ik een deel van de voorspelde waarden:

>>> df.priority.value_counts()
3 - Moderate    8578
2 - High        5718
1 - Critical     704

>>> predicts[:100]
array([2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 2, 1, 2, 1, 2,
       1, 1, 2, 2, 2, 1, 1, 2, 0, 1, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1,
       2, 2, 2, 0, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 2, 2, 1, 1, 2, 2, 1,
       2, 2, 2, 1, 2, 2, 0, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
       2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 1, 2], dtype=int64)

Hij gaat er dus zeker niet vanuit dat alles een moderate uitkomst moet hebben. (wat al een 58% correcte uitkomst zou kunnen opleveren)

Update 17/2/2020: Ik merk bij mijn DIRKje test dat het inkorten van de teksten tot op zekere hoogte verbetering van het resultaat geeft. Daarnaast worden de traintijden veel korter. Ik probeer dat ook met deze dataset. Ik maak de lengte maximaal 32 tokens. De batchsize kan ik dan 100 maken waardoor de traintijd teruggaat naar zo'n 55 seconden per epoch. Dat is leuk testen! (Ik weet niet zeker meer hoeveel hij er oorspronkelijk over deed. ) 
Ik kijk ook eens naar de vorm van de tokenopslag:

'[CLS] us : cleveland : net ##app na ##01 ##6 is down global hosting hosting database em ##ea at ##os supply team [SEP] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] '

of

'[CLS] [ ultrasound hyper ##care ] { cs j ##ms rc mb ##p 2 } aix _ on _ demand - nl ##yeh ##vb ##pa ##12 procedure : jd _ mb [SEP] '

De [PAD] blijkt bij Bert basis op nummer 0 te staan. De padding gaat hier dus iig goed.

Interessant! Ook hier geeft het wegnemen van informatie ongeveer een % verbetering in zowel de F1 als in de test accuracy.

   

BERTje als summarizer 2

Op de melding op github dat het mij niet lukte om het model uit transformers te laden heb ik vrijwel direct de tip gekregen dat ik de laatste versie van de transformer module hiervoor moest downloaden. En inderdaad, hoewel ik nog maar recentelijk de module met pip heb geinstalleerd heb ik de 2.2.0 versie gekregen. Met 'pip install transformers -U' krijg ik de 2.4.1 versie en werkt alles wel naar wens. Gelijk uitproberen of de samenvattingen nu op BERTje werken. Eerst moet ik het model weer toevoegen aan de 'beschikbare modellen in 'bert_parent.py'. Maar dan ook maar eens de samenvatting van Wiki beschrijving van aannemer testen:

'Een aannemer is een onderneming die de verantwoordelijkheid op zich neemt om bouwactiviteiten te realiseren en te coordineren de aannemer verzorgt , voor een in het contract bepaalde prijs en binnen een overeengekomen termijn , de levering van een volledig voltooid bouwwerk . Soms is een aannemer zijn eigen opdrachtgever , en dus ook die van de architect , bijvoorbeeld wanneer hij zelfstandig een bouwproject begint op een door hem verworven bouwperceel , deze vorm projectontwikkeling vindt het meest plaats bij de bouw van woningen en kantoren . De Europese aanbesteding is de meest uitgebreide vorm van aanbesteden en kent de onder andere de varianten Open zonder voorafgaande selectieronde en Niet open met voorafgaande selectieronde . Indien blijkt dat zij na aanmelden aan de criteria voldoen mogen zij alsnog inschrijven op het werk . Verder bestaat regelgeving op het gebied van arbeidsomstandigheden , milieu , voorschriften van nutsbedrijven enz . Tot zijn productiepersoneel behoren meestal timmerlieden , metselaars en opperlieden . Daarnaast zijn er nog talloze disciplines in de bouw werkzaam , zoals steigerbouwers , vloerenleggers , stukadoors , tegelzetters , loodgieters , installateurs , elektriciens , schilders , voegers enz .'

Even de vorige met multilanguage ernaast zetten:

'Een aannemer is een onderneming die de verantwoordelijkheid op zich neemt om bouwactiviteiten te realiseren en te coordineren de aannemer verzorgt , voor een in het contract bepaalde prijs en binnen een overeengekomen termijn , de levering van een volledig voltooid bouwwerk . De opdrachtgever of bouwheer kan op zijn beurt een architect of architectenbureau inschakelen , die het ontwerp en soms het toezicht op de bouwplaats voor zijn rekening neemt . Het ontwerp van de architect of anderszins resulteert vaak in een bestek en tekeningen waarin de beschrijving van het werk is opgenomen en hetgeen een onderlegger vormt voor en onderdeel is van de overeenkomst tussen opdrachtgever en aannemer . Van alle beschikbare vormen van aanbesteding wordt de traditionele openbare aanbesteding het meest gehanteerd . Regelgeving Tijdens het bouwproces heeft de aannemer te maken met allerhande wet en regelgeving zoals het Bouwbesluit , de Woningwet , het Bouwstoffenbesluit en de UAV in Nederland . Tot zijn productiepersoneel behoren meestal timmerlieden , metselaars en opperlieden . Daarnaast zijn er nog talloze disciplines in de bouw werkzaam , zoals steigerbouwers , vloerenleggers , stukadoors , tegelzetters , loodgieters , installateurs , elektriciens , schilders , voegers enz . Werkproces Wanneer de opdracht is verstrekt en de nodige vergunningen geregeld zijn kan de aannemer aan de slag .'

Ja, het is natuurlijk een minitest (geel zijn de overeenkomende teksten) maar ik vind de samenvatting van BERTje meer samenhang hebben. 

@misc{vries2019bertje,
    title={BERTje: A Dutch BERT Model},
    author={Wietse de Vries and Andreas van Cranenburgh and Arianna Bisazza and Tommaso Caselli and Gertjan van Noord and Malvina Nissim},
    year={2019},
    eprint={1912.09582},
    archivePrefix={arXiv},
    primaryClass={cs.CL}
}

BERTje als summarizer

Enthousiast wegens het succes wil ik nu ook BERTje as summarizer gaan proberen. Ik zie hier een mooie implementatie: https://github.com/dmmiller612/bert-extractive-summarizer
De software is eenvoudig met pip te installeren en er lijken opties te zijn om ook naar het NL model te kunnen verwijzen.

from summarizer import Summarizer

body = ''' hier tekst van bepaalde langere lengte '
model = Summarizer(model="bert-base-dutch-cased")
model(body)

Helaas loop ik (weer) tegen het probleem aan dat het model bij de transformers niet beschikbaar lijkt.Hoewel hier wel in de documentatie beschreven krijg ik een foutmelding als ik het model probeer te gebruiken.
Ik zie ook dat er uberhaupt maar een paar Bert modellen standaard beschikbaar zijn. Het toevoegen van BERTje lukt helaas niet. Wel lukt het om in 'bert_parent.py' de 'bert-base-multilingual-cased' toe te voegen.

    MODELS = {

        'bert-base-uncased': (BertModel, BertTokenizer),

        'bert-large-uncased': (BertModel, BertTokenizer),

        'bert-base-multilingual-cased':(BertModel, BertTokenizer),

        'xlnet-base-cased': (XLNetModel, XLNetTokenizer),

        'xlm-mlm-enfr-1024': (XLMModel, XLMTokenizer),

        'distilbert-base-uncased': (DistilBertModel, DistilBertTokenizer),

        'albert-base-v1': (AlbertModel, AlbertTokenizer),

        'albert-large-v1': (AlbertModel, AlbertTokenizer)

    }

Kijk, nu kunnen we dat iig testen. Ik gooi er wat wiki tekstjes doorheen:


Een aannemer is een onderneming die de verantwoordelijkheid op zich neemt om bouwactiviteiten te realiseren en te coordineren de aannemer verzorgt , voor een in het contract bepaalde prijs en binnen een overeengekomen termijn , de levering van een volledig voltooid bouwwerk . De opdrachtgever of bouwheer kan op zijn beurt een architect of architectenbureau inschakelen , die het ontwerp en soms het toezicht op de bouwplaats voor zijn rekening neemt . Het ontwerp van de architect of anderszins resulteert vaak in een bestek en tekeningen waarin de beschrijving van het werk is opgenomen en hetgeen een onderlegger vormt voor en onderdeel is van de overeenkomst tussen opdrachtgever en aannemer . Het bestek en de tekeningen beschrijven zo nauwkeurig mogelijk wat de kwaliteits en kwantiteitseisen zijn die de opdrachtgever aan het werk stelt . Begripsbepaling aannemer Bouw UAV de aannemer de natuurlijke of rechtspersoon , aan wie het werk is opgedragen . Overig Aannemer is een begrip dat ook buiten de bouw wordt gebruikt . Bijvoorbeeld het aannemen van onderzoekswerk , industrieel onderhoud reparatie of het aannemen van werk in het openbaar vervoer . Bestek De beoogde kwaliteit van het werk wordt door opdrachtgever of architect vastgelegd in gedetailleerde bestekken en bestektekeningen . Soms is een aannemer zijn eigen opdrachtgever , en dus ook die van de architect , bijvoorbeeld wanneer hij zelfstandig een bouwproject begint op een door hem verworven bouwperceel , deze vorm projectontwikkeling vindt het meest plaats bij de bouw van woningen en kantoren . Bij andere projecten , zoals bedrijfsgebouwen , scholen , bankgebouwen , winkels , maar ook weg en waterbouwkundige projecten , is er vrijwel altijd sprake van een opdrachtgever . Aanbestedingsvormen Er zijn verschillende soorten van aanbesteden Europese aanbesteding Openbare aanbesteding Aanbesteding met voorafgaande selectie Onderhands aanbesteding Aanbesteding in regie . De Europese aanbesteding is de meest uitgebreide vorm van aanbesteden en kent de onder andere de varianten Open zonder voorafgaande selectieronde en Niet open met voorafgaande selectieronde . Een Europese aanbesteding is bij sommige projecten verplicht . Van alle beschikbare vormen van aanbesteding wordt de traditionele openbare aanbesteding het meest gehanteerd . Verder kennen we de aanbesteding met voorafgaande selectie , waarbij een aantal aannemers worden uitgenodigd al dan niet op basis van objectief vastgestelde criteria zich aan te melden . Indien blijkt dat zij na aanmelden aan de criteria voldoen mogen zij alsnog inschrijven op het werk . De onderhandse aanbesteding is een ouderwetse benaming van het aanbesteden van een werk aan slechts een beperkt aantal willekeurig te selecteren partijen . Deze vorm van aanbesteden komt vooral in de particuliere aanbesteding van vooral woningen veel voor . Het aanbesteding in regie is een vorm waarbij de afgesproken prijs niet gerelateerd is aan het te realiseren project maar gebaseerd op vooraf overeengekomen uurlonen , materieel en materiaalprijzen , opslagpercentages voor algemene kosten , winst en risico . Deze vorm van aanbesteding is bijzonder geschikt als het gaat om onderhoudswerkzaamheden waarvan van tevoren niet bekend is in welke aantallen de verschillende onderhoudswerken zullen gaan voorkomen . De gunning De gunning is de toewijzing van het werk aan een van de aanbieders door de opdrachtgever . De gunning vond in het verleden vrijwel altijd plaats op basis van de laagste prijs . Met de invoering van de aanbestedingswet per april , is ook gunnen op basis van de economisch meest voordelige inschrijving EMVI uitgangspunt geworden bij in elk geval Europees aanbesteden en moet de aanbestedende dienst goed motiveren als deze toch besluit om op laagste prijs te gunnen . De laatste tijd worden naast deze traditionele manier van aanbesteden steeds vaker innovatieve manieren van aanbesteden gehanteerd . Het gaat dan vooral om contract en aanbestedingsvormen waarbij de aannemer verantwoordelijk is voor zowel het ontwerp als de uitvoering , eventueel in combinatie met exploitatie en financiering . Regelgeving Tijdens het bouwproces heeft de aannemer te maken met allerhande wet en regelgeving zoals het Bouwbesluit , de Woningwet , het Bouwstoffenbesluit en de UAV in Nederland . Verder bestaat regelgeving op het gebied van arbeidsomstandigheden , milieu , voorschriften van nutsbedrijven enz . Personeel Naast administratief personeel heeft een aannemer calculatoren werkvoorbereiders projectleiders en uitvoerders in dienst . Tot zijn productiepersoneel behoren meestal timmerlieden , metselaars en opperlieden . In de weg en waterbouw kraanmachinisten en grondwerkers . Daarnaast zijn er nog talloze disciplines in de bouw werkzaam , zoals steigerbouwers , vloerenleggers , stukadoors , tegelzetters , loodgieters , installateurs , elektriciens , schilders , voegers enz . Deze laatste vaklieden worden meestal ingezet door het inschakelen van zogenaamde onderaannemers . Onderaannemer Persoon of organisatie die in opdracht van een aannemer , zonder bij de aannemer in dienst te zijn , het aangenomen werk geheel of gedeeltelijk uitvoert , vaak tegen een vastgestelde prijs . Werkproces Wanneer de opdracht is verstrekt en de nodige vergunningen geregeld zijn kan de aannemer aan de slag . De bouwplaats moet worden ingericht , een werkplanning gemaakt , keten en bouwhekken geplaatst , personeel en materieel worden gepland , materialen en onderaannemersdiensten worden ingekocht . De aannemer is in de moderne bouw meer een coordinerend dan een uitvoerend bedrijf . Op de bouwplaats is een belangrijke taak weggelegd voor de uitvoerder , deze ziet toe op de dagelijkse gang van zaken op de bouwplaats . Beroep in de bouw Civiele techniek . 

Wordt nu:

'Een aannemer is een onderneming die de verantwoordelijkheid op zich neemt om bouwactiviteiten te realiseren en te coordineren de aannemer verzorgt , voor een in het contract bepaalde prijs en binnen een overeengekomen termijn , de levering van een volledig voltooid bouwwerk . De opdrachtgever of bouwheer kan op zijn beurt een architect of architectenbureau inschakelen , die het ontwerp en soms het toezicht op de bouwplaats voor zijn rekening neemt . Het ontwerp van de architect of anderszins resulteert vaak in een bestek en tekeningen waarin de beschrijving van het werk is opgenomen en hetgeen een onderlegger vormt voor en onderdeel is van de overeenkomst tussen opdrachtgever en aannemer . Van alle beschikbare vormen van aanbesteding wordt de traditionele openbare aanbesteding het meest gehanteerd . Regelgeving Tijdens het bouwproces heeft de aannemer te maken met allerhande wet en regelgeving zoals het Bouwbesluit , de Woningwet , het Bouwstoffenbesluit en de UAV in Nederland . Tot zijn productiepersoneel behoren meestal timmerlieden , metselaars en opperlieden . Daarnaast zijn er nog talloze disciplines in de bouw werkzaam , zoals steigerbouwers , vloerenleggers , stukadoors , tegelzetters , loodgieters , installateurs , elektriciens , schilders , voegers enz . Werkproces Wanneer de opdracht is verstrekt en de nodige vergunningen geregeld zijn kan de aannemer aan de slag .'

Tja ... ziet er wel goed uit denk ik. Lastig te beoordelen of dit nu de beste samenvatting is. 

Epoch 1/10
42875/42875 [==============================] - 822s 19ms/step - loss: 2.1951 - sparse_categorical_accuracy: 0.6136
Epoch 2/10
42875/42875 [==============================] - 804s 19ms/step - loss: 0.6784 - sparse_categorical_accuracy: 0.8422
Epoch 3/10
42875/42875 [==============================] - 804s 19ms/step - loss: 0.4639 - sparse_categorical_accuracy: 0.8804
Epoch 4/10
42875/42875 [==============================] - 805s 19ms/step - loss: 0.3498 - sparse_categorical_accuracy: 0.9040
Epoch 5/10
42875/42875 [==============================] - 803s 19ms/step - loss: 0.2857 - sparse_categorical_accuracy: 0.9173
Epoch 6/10
42875/42875 [==============================] - 805s 19ms/step - loss: 0.2349 - sparse_categorical_accuracy: 0.9322
Epoch 7/10
42875/42875 [==============================] - 804s 19ms/step - loss: 0.2088 - sparse_categorical_accuracy: 0.9384
Epoch 8/10
42875/42875 [==============================] - 804s 19ms/step - loss: 0.1866 - sparse_categorical_accuracy: 0.9452
Epoch 9/10
42875/42875 [==============================] - 805s 19ms/step - loss: 0.1799 - sparse_categorical_accuracy: 0.9469
Epoch 10/10
42875/42875 [==============================] - 805s 19ms/step - loss: 0.1563 - sparse_categorical_accuracy: 0.9536

>>> print(np.sum(test_y == predicts) / test_y.shape[0])
0.89

>>> print(F1 = f1_m(predicts,test_y))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in f1_m
  File "<stdin>", line 2, in precision_m
  File "C:\Python36\lib\site-packages\keras\backend\tensorflow_backend.py", line 1601, in clip
    min_value = _to_tensor(min_value, x.dtype.base_dtype)
AttributeError: 'numpy.dtype' object has no attribute 'base_dtype'
>>>
>>>

Ja! hij doet 't!

Ziet er goed uit: De .878 onderaan is de test accuracy!


Epoch 1/7
42875/42875 [==============================] - 827s 19ms/step - loss: 2.1634 - sparse_categorical_accuracy: 0.6159
Epoch 2/7
42875/42875 [==============================] - 806s 19ms/step - loss: 0.6872 - sparse_categorical_accuracy: 0.8400
Epoch 3/7
42875/42875 [==============================] - 814s 19ms/step - loss: 0.4701 - sparse_categorical_accuracy: 0.8801
Epoch 4/7
42875/42875 [==============================] - 801s 19ms/step - loss: 0.3559 - sparse_categorical_accuracy: 0.9027
Epoch 5/7
42875/42875 [==============================] - 802s 19ms/step - loss: 0.2887 - sparse_categorical_accuracy: 0.9187
Epoch 6/7
42875/42875 [==============================] - 802s 19ms/step - loss: 0.2449 - sparse_categorical_accuracy: 0.9300
Epoch 7/7
42875/42875 [==============================] - 801s 19ms/step - loss: 0.2104 - sparse_categorical_accuracy: 0.9384
10700/10700 [==============================] - 51s 5ms/step
0.8781308411214953

Model is af ! Maar ...

De data is eindelijk weer teruggezt naar leesbare tekst. Dat heeft even geduurd. Ik kan nu het model maken /testen.

Ik maak gebruik van een aangapste versie van deze site https://www.kaggle.com/sharmilaupadhyaya/20newsgroup-classification-using-keras-bert-in-gpu/

Daar worden de woorden weer in tokens omgezet maar nu volgens de BERTje vocab file.

uiteindelijk lijk ik een mooie train en testset te hebben.
Als ik het model start krijg ik echter al snel out of memory errors. Ik verlaag de batch size van 50 naar 25. Dat gaat al beter. Helaas komt die met een melding dat de dataset vorm niet goed is:

ValueError: Error when checking model input: the list of Numpy arrays that you are passing to your model is not the size the model expected. Expected to see 2 array(s), but instead got the following list of 1 arrays: [array([[[    1, 15015,   133, ..., 17556,   115,     2],
        [    1, 15061, 24298, ..., 25138, 26576,     2],
        [    1,  8740,   132, ..., 17300, 16039,     2],
        ...,
        [    1,... 

Dat is vreemd. Ik check de vorm van de dataset:

>>> np.asarray(train_x).shape
(2, 42875, 128) 

Ik kijk hoe de structuur eruit zou moeten zien uit de voorbeeld dataset:

>>> np.asarray(train_x).shape
(2, 15050, 128)

Dat lijkt toch aardig op elkaar. Kijk ik echter rechtsreeks naar de data zie ik idd een verschil:

Mijn dataset:

>>> train_x
array([[[    1, 15015,   133, ..., 17556,   115,     2],
        [    1, 15061, 24298, ..., 25138, 26576,     2],
        [    1,  8740,   132, ..., 17300, 16039,     2],
        ...,
        [    1,  8740,   132, ...,     0,     0,     0],
        [    1, 13177, 24804, ..., 14496,    13,     2],
        [    1, 13177, 24804, ..., 24570, 27106,     2]],

       [[    0,     0,     0, ...,     0,     0,     0],
        [    0,     0,     0, ...,     0,     0,     0],
        [    0,     0,     0, ...,     0,     0,     0],
        ...,
        [    0,     0,     0, ...,     0,     0,     0],
        [    0,     0,     0, ...,     0,     0,     0],
        [    0,     0,     0, ...,     0,     0,     0]]])

Voorbeeld dataset:

>>> train_x
[array([[    1, 11745,    25, ...,     0, 26189,     2],
       [    1, 11745,    25, ..., 20125, 10537,     2],
       [    1, 11745,    25, ...,     0,     0,     0],
       ...,
       [    1, 11745,    25, ..., 10046,   131,     2],
       [    1, 19748, 26361, ..., 17370, 25866,     2],
       [    1, 11745,    25, ...,    81,    11,     2]]), array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       ...,
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]])]

Net ff anders. Toch nog maar even sleutelen helaas.