Zelf optimaliserende modellen - 4

Ok, het wordt aannemelijk dat mijn gekozen algoritme wel aardig lijkt te werken voor de mnist dataset maar het dramatisch doet voor de Data Science Bowl. (Het opzoeken van celkernen). Het lijkt maar weinig variatie te vinden.  Na het verrijken (roteren / zoomen etc) van de onderliggende dataset (Ik meende dat die wellicht niet goed genoeg was) , het echt opsplitsen van train en validatie data, het uitbreiden van het aantal epochs per test naar 10 en nog wat 'mogelijke verbeteringen' komt die met onderstaand model.  Het lijkt nauwelijks te verschillen. In eerste instantie neemt de loss beter af maar na 5 epochs doet het oorspronkelijke model het toch weer beter. De grafiek van de accuracy is helemaal bizar. Snap ik (nog?) weinig van.

32.0 3.0 3.0 32.0 3.0 3.0 2.0 2.0 0.25 32.0 3.0 3.0 32.0 3.0 3.0 2.0 2.0 0.25 64.0 0.25

32.0 3.0 3.0 33.0 3.0 3.0 2.0 2.0 0.19 25.0 3.0 3.0 32.0 3.0 3.0 2.0 2.0 0.25 75.0 0.13

Loss

Accuracy

Misschien moet ik het anders aan gaan pakken. Ik selecteer nu zowel op loss en accuracy. Hier vindt ik echter een ander uitgangspunt:

Loss is often used in the training process to find the "best" parameter values for your model (e.g. weights in neural network). It is what you try to optimize in the training by updating weights.

Accuracy is more from an applied perspective. Once you find the optimized parameters above, you use this metrics to evaluate how accurate your model's prediction is compared to the true data.  

Bij een aanpassing van de optimizer naar standaard Gradient descent krijg ik het volgende verloop

32.0 3.0 3.0 32.0 3.0 3.0 2.0 2.0 0.25 32.0 3.0 3.0 32.0 3.0 3.0 2.0 2.0 0.25 64.0 0.25

32.0 3.0 4.0 32.0 4.0 3.0 2.0 2.0 0.25 35.0 3.0 2.0 22.0 3.0 3.0 2.0 2.0 0.25 48.0 0.25

Het lijkt er niet beter op te worden. De accuracy is helemaal 'gone with the wind'. Maar weer eens een nachtje over slapen ...

Zelf optimaliserende modellen - 3

Het opschalen naar grotere modellen van het optimalisatie algoritme lukt nog niet zo erg. In eerste instantie heb ik het getest met het U-shape model dat ik gebruikt heb bij de Kaggle competitie. Daar zitten wel heel veel parameters in. Het probleem is echter dat de verschillende layers sterk aan elkaar gekoppeld zijn. Een verandering van een parameter resulteert al snel in een ongeldig model.

Het lukt mij niet om de 'eisen' van het model in de code vast te leggen. Ik besluit eerst maar iets eenvoudiger te gaan: Een "convolutional autoencoder". Klinkt goed, niet waar? Zo'n encoder is er normaliter op gerecht om een afbeelding op basis van zo weinig mogelijke informatie, weer opnieuw op te bouwen. In de kaggle competitie 2018 Data science bowl gaat het echter om celkernen herkennen. Lijkt mij ook een goede optie.
Ik ga uit van een eenvoudiger model dat hier wordt uitgelegd.   

input_img = Input(shape=(28, 28, 1))  # adapt this if using `channels_first` image data format

x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling2D((2, 2), padding='same')(x)

# at this point the representation is (7, 7, 32)

x = Conv2D(32, (3, 3), activation='relu', padding='same')(encoded)
x = UpSampling2D((2, 2))(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)

autoencoder = Model(input_img, decoded)
autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')

Ook deze blijkt echter erg gevoelig voor aanpassing van de parameters. Op zich logisch omdat elke stap (modellaag) meebepalend is voor de output grootte die, voor deze doelstelling, uiteraard gelijk moet zijn aan de input-grootte. (Ik vergelijk afbeeldingen met een even groot masker).

Ik besluit door het toevoegen van 2 dense layers (en een flatten layer) het tussenformaat en het eindformaat te fixeren. De dense layer is een 1 dimensionale 'full connected' layer die zorgt voor een definieerbaar tussenformaat of eindformaat. Dat lijkt wel aardig te werken alleen krijg ik al snel een memory error. De flatten layer naar de 160x160 (formaat van de afbeeldingen) resulteert in teveel parameters. De oplossing is om er een extra, kleinere 'dense-layer' aan toe te voegen.

Nu blijft het programma in ieder geval lopen. Er worden echter maar een viertal verbeterde modellen gevonden. Daarna blijft het 'stil'.

Ivm de 'dense' layer bij de output van het model heb ik de maskers 'plat moeten slaan'. In plaats van 160 x 160 is het nu een groot array van 25600. Dat zou denk ik niet erg moeten zijn omdat er in de eindlaag toch iets meer met de afbeeldingsstructuur wordt gedaan. Wellicht dat ik de autoencoder moet loslaten en gewoon naar een uitgebreider convolutional model moet gaan met ook op het einde een dense layer.

Ik pak er een van de Keras site zelf. Het zogenaamde VGG-like convnet .  Met 2x2 convolutional layers opgevolgd per laag door een pooling layer en een dropout layer. Uiteindelijk sluit het af met 2 dense layers. Kijk dat zou ook bij mijn probleem moeten passen!

Ook hier vindt het algoritme slechts enkele verbeteringen in de eerste ronde waarna het ook weer 'zwijgt'. Ik begrijp nog niet hoe dat mogelijk is. Er zou toch af en toe toevallig een iets betere oplossing gevonden moeten worden?!