MobileNetV2 med tf.keras: Den Komplette Guide

For mange udviklere kan landskabet inden for dyb læring, især når det kommer til brugen af forudtrænede modeller som MobileNetV2 i TensorFlow/Keras, virke forvirrende. Spørgsmål som 'Er MobileNetV2 en Keras-model?', 'Hvorfor får jeg en ImportError?', og 'Er der en foruddefineret MobileNetV2-applikation med tf.keras?' er almindelige. Denne artikel vil afklare disse spørgsmål og give en dybdegående forståelse af, hvordan du effektivt kan anvende MobileNetV2 med tf.keras til overfør læring og finjustering, selv med ældre versioner som TensorFlow 1.10.

Lad os starte med at adressere den grundlæggende forvirring: Keras er et højniveau API for neurale netværk, der kan køre oven på TensorFlow, Theano eller CNTK. Med tiden er Keras blevet fuldt integreret i TensorFlow som tf.keras, hvilket er den anbefalede og mest udbredte måde at bruge Keras på i dag. Derfor, når du ser tf.keras.applications.MobileNetV2(), refererer det til den officielle implementering af MobileNetV2, der er tilgængelig direkte i TensorFlow. Hvis du støder på en ImportError, skyldes det ofte en specifik version af TensorFlow (især ældre versioner som 1.10) eller en forkert importsti. Den korrekte måde at importere MobileNetV2 på er via tf.keras.applications.MobileNetV2, som er en del af TensorFlows applikationsmodul, der indeholder mange forudtrænede modeller til billedklassifikation.

MobileNetV2 og tf.keras: Klarhed i Forvirringen

Den primære kilde til forvirring for mange brugere, især dem der arbejder med ældre TensorFlow-versioner, synes at være importstien for MobileNetV2. Det er vigtigt at forstå, at tf.keras er den integrerede Keras-implementering inden for TensorFlow. Dette betyder, at alle de kraftfulde værktøjer og forudtrænede modeller, der er tilgængelige i Keras, nu er direkte tilgængelige via tf.keras-navneområdet.

Når du forsøger at importere MobileNetV2 direkte fra tensorflow.keras.applications import MobileNetV2 og får en ImportError, kan det skyldes flere ting. I ældre versioner af TensorFlow 1.x kan stien til MobileNetV2 have været anderledes, eller den var måske ikke fuldt ud eksponeret på samme måde som i nyere versioner af TensorFlow 2.x. Dog bekræfter din observation mobilenet = tf.keras.applications.MobileNetV2(), at selve modellen er tilgængelig. Dette indikerer, at problemet sandsynligvis ligger i den specifikke importkald, ikke i fraværet af modellen i tf.keras. Den korrekte og moderne tilgang er at bruge tf.keras.applications.MobileNetV2, som uden tvivl er en foruddefineret, brugbar applikation.

TensorFlows API-dokumentation for tf.keras.applications.MobileNet (og tilsvarende for V2) bekræfter eksistensen af disse modeller som Keras-modelinstanser. Selvom Keras' egen hjemmeside måske ikke lister alle applikationer for alle versioner, betyder integrationen i TensorFlow, at tf.keras er den autoritative kilde til Keras-modeller inden for TensorFlow-økosystemet. Linket, der fører til den klassiske Keras-hjemmeside, kan potentielt være misvisende, da det ikke altid afspejler den seneste integration og tilgængelighed via tf.keras, især for nyere modeller som MobileNetV2, der blev populære efter Keras' dybere integration med TensorFlow.

Hvad er MobileNetV2?

MobileNetV2 er en state-of-the-art konvolutionelt neuralt netværk (CNN) arkitektur, der er designet specifikt til at være yderst effektiv og ressourcebesparende. Den er ideel til brug i mobile enheder og indlejrede systemer, hvor computational power og hukommelse er begrænsede. Modellen blev introduceret af Google i 2018 og bygger videre på principperne fra MobileNetV1 med væsentlige forbedringer.

En af de mest bemærkelsesværdige innovationer i MobileNetV2 er brugen af "inverted residuals" og "linear bottlenecks". Traditionelle residuale blokke starter med en flaskehals (færre kanaler), udvider sig og ender med en flaskehals. MobileNetV2 vender dette på hovedet: den starter med et lavdimensionelt input, udvider det til et højdimensionelt rum ved hjælp af dybdeseparerbare konvolutioner og projekterer det derefter tilbage til et lavdimensionelt rum. Dette design maksimerer informationsflowet gennem netværket og reducerer samtidig antallet af parametre og beregninger.

MobileNetV2 er, ligesom mange andre populære modeller, forudtrænet på det massive ImageNet-datasæt. ImageNet er et omfattende billeddatasæt, der indeholder millioner af billeder kategoriseret i 1.000 forskellige objekttyper. Denne forudtræning giver MobileNetV2 evnen til at genkende en bred vifte af visuelle mønstre og funktioner, hvilket gør den til en fremragende udgangspunkt for nye billedklassifikationsopgaver gennem overfør læring og finjustering.

Når du arbejder med MobileNetV2, er der to vigtige detaljer vedrørende inputdata:

• Pixelværdier: Billedernes pixelværdier skal normaliseres til et interval mellem -1.0 og +1.0. Dette afviger fra den mere almindelige 0-1 eller 0-255 normalisering og er afgørende for, at modellen fungerer korrekt, da den er trænet med dette specifikke inputområde.
• Billedstørrelse: Den mindste billedstørrelse, MobileNetV2 kan behandle, er 96x96 pixels. Selvom den ofte bruges med 224x224, giver 96x96 mulighed for mere ressourceeffektiv inferens, hvilket er ideelt for mobile applikationer.

Disse specifikationer kræver, at din dataforbehandling tilpasses, så den matcher MobileNetV2's forventede inputformat. Modulet load.py, der er beskrevet i eksemplet, håndterer netop denne normalisering og resizing, hvilket er et kritisk skridt for at sikre kompatibilitet og optimal ydeevne.

Overfør læring og Finjustering med MobileNetV2

At genbruge en forudtrænet model som MobileNetV2 er hjørnestenen i moderne dyb læring, især når man arbejder med begrænsede datasæt. De to primære teknikker til dette er overfør læring (transfer learning) og finjustering (fine-tuning).

Overfør læring (Transfer Learning)

Ved overfør læring bruger du den forudtrænede models evne til at udtrække generiske funktioner fra billeder. Ideen er, at de første lag af et CNN lærer at genkende grundlæggende funktioner som kanter, teksturer og former, som er universelle for de fleste billedklassifikationsopgaver. De dybere lag lærer mere specifikke, højere niveau-funktioner, der er relevante for det datasæt, modellen er trænet på (f.eks. ImageNet).

I overfør læring fryser du alle lag i den forudtrænede basismodel, så deres vægte forbliver uændrede. Derefter tilføjer du et nyt klassifikationslag (eller flere lag) oven på basismodellen. Kun disse nye lag trænes på dit specifikke datasæt. Dette er en hurtig og ressourceeffektiv metode, da du kun træner et lille antal parametre. Det er særligt effektivt, når dit datasæt er lille, og det minder om det datasæt, som basismodellen oprindeligt blev trænet på.

Finjustering (Fine-tuning)

Finjustering tager overfør læring et skridt videre. Efter at have trænet de nye klassifikationslag, "optøer" du nogle af eller alle lagene i basismodellen og træner dem yderligere på dit nye datasæt. Formålet er at tilpasse de generiske funktioner, som basismodellen har lært, til de mere specifikke karakteristika ved dit eget datasæt. Dette gøres typisk med en meget lavere læringshastighed for at undgå at ødelægge de værdifulde forudtrænede vægte.

Finjustering er mere beregningsintensiv end ren overfør læring, men det kan give betydeligt bedre resultater, især hvis dit datasæt er større og/eller afviger mere fra det originale træningsdatasæt. Processen foregår ofte i faser, hvor man gradvist optøer flere lag og justerer læringshastigheden. Dette giver modellen mulighed for at tilpasse sig dit datasæt mere præcist, mens den stadig drager fordel af ImageNet-træningens brede viden.

Valget mellem overfør læring og finjustering afhænger af dit datasæts størrelse og lighed med ImageNet, samt de tilgængelige ressourcer. I mange tilfælde er en kombination af de to – først overfør læring for at få en god baseline, derefter finjustering for at optimere ydeevnen – den mest effektive strategi.

Arkitekturen af MobileNetV2 og Tilpasning

For at udnytte MobileNetV2 til dine egne klassifikationsopgaver er det essentielt at forstå, hvordan du tilpasser dens struktur. Standard MobileNetV2-modellen er, som nævnt, trænet på ImageNet til at klassificere 1.000 kategorier. For at bruge den til et nyt antal klasser, skal den øverste klassifikationslag fjernes, og nye tilføjes.

At indlæse basismodellen gøres typisk som følger:

basemodel = tf.keras.applications.MobileNetV2()

Dette indlæser hele modellen, inklusive dens øverste lag, der er designet til ImageNet-klassifikation. Kigger man på dens struktur med basemodel.summary(showtrainable=True, expandnested=True), vil man se et predictions (Dense) lag med en output-form på (None, 1000) og et betydeligt antal trænbar parametre (ca. 1,28 millioner for dette lag alene).

For at tilpasse modellen til din egen opgave skal du fjerne dette øverste lag og specificere den ønskede inputstørrelse. Dette gøres ved at sætte includetop=False og angive inputshape:

basemodel = tf.keras.applications.MobileNetV2(
 includetop=False, weights='imagenet', inputshape=(DIMX, DIMY, 3))
basemodel.trainable = False # Frys basismodellen i starten

Her:

• includetop=False fjerner det øverste fuldt forbundne klassifikationslag.
• weights='imagenet' sikrer, at modellen indlæses med de værdifulde vægte, den har lært fra ImageNet-datasættet.
• inputshape=(DIMX, DIMY, 3) definerer den forventede inputbilledstørrelse (f.eks. 96x96x3 for RGB-billeder).
• basemodel.trainable = False fryser alle lag i basismodellen, hvilket er standardpraksis for den indledende overfør læringsfase.

Når basismodellen er indlæst uden det øverste lag og frosset, kan du tilføje dine egne klassifikationslag ovenpå. Dette gøres ved at behandle basemodel som en funktion, der tager et input-tensor, og derefter bygge videre på dens output:

input = tf.keras.Input(shape=(DIMX, DIMY, 3), name="input")
x = basemodel(input, training=False)
x = tf.keras.layers.GlobalAveragePooling2D()(x)
x = tf.keras.layers.Dense(HIDDEN, activation='relu')(x)
predictions = tf.keras.layers.Dense(outdim, activation='softmax', name="output")(x)
model = tf.keras.models.Model(inputs=input, outputs=predictions, name="ftnet")

Her tilføjer vi:

• En GlobalAveragePooling2D-lag, som reducerer dimensionerne af funktionen fra basismodellen til en enkelt vektor pr. billede. Dette er en almindelig praksis for at overgå fra konvolutionelle lag til fuldt forbundne lag.
• Et skjult Dense-lag (med HIDDEN neuroner og ReLU-aktivering) for at give modellen yderligere kapacitet til at lære komplekse mønstre.
• Et endeligt Dense-lag (med outdim neuroner, svarende til antallet af dine klasser, og softmax-aktivering) til den endelige klassifikation.

Dette skaber en ny model, ftnet, som nu består af den forudtrænede, frosne MobileNetV2-basismodel og dine nye, trænbar klassifikationslag. Når du kører model.summary() for ftnet, vil du se, at de fleste parametre i MobileNetV2-delen er "Non-trainable", mens parametrene i dine nyoprettede Dense-lag er "Trainable".

Træning af de Øverste Lag

Den første fase i at tilpasse en forudtrænet model er at træne de nyoprettede klassifikationslag. Dette trin, ofte kaldet den rene overfør læringsfase, er afgørende for at give den nye klassifikator en baseline-forståelse af dit specifikke datasæt.

Under denne fase forbliver basismodellen (MobileNetV2-delen) frosset, hvilket betyder, at dens vægte ikke opdateres under træningen. Dette har flere fordele:

• Effektivitet: Kun et lille antal parametre (dem i de nye, øverste lag) skal trænes, hvilket gør processen meget hurtigere og mindre beregningsintensiv.
• Stabilitet: De forudtrænede vægte fra ImageNet, som er yderst effektive til generisk billedgenkendelse, bevares og ødelægges ikke af potentielt støjende eller begrænset ny data.
• Mindre data: Denne metode kræver færre træningsdata for at opnå gode resultater, da modellen allerede har en stærk grundforståelse af visuelle funktioner.

Træningsprocessen involverer at kompilere modellen med en passende optimizer og tabsfunkton. Som vist i eksemplet anvendes Adam-optimizeren med en indledende læringshastighed på 0.0015, og categoricalcrossentropy som tabsfunkton, hvilket er standard for multi-klasse klassifikationsopgaver med one-hot-kodede labels.

model = buildftnet(outdim=len(classnames), learningrate=0.0015)
fithistoryt = model.fit(traindataset, epochs=NUMTRANSFEPOCHS,
 validationdata=validationdataset, callbacks=[tensorboardcallback])
loss, accuracy = model.evaluate(testdataset)

Efter et bestemt antal træningsepoker (f.eks. 20 som i eksemplet) evalueres modellen på testdatasættet. Resultaterne fra denne fase, såsom en testnøjagtighed på 93% og et tab på 0.45, giver en indikation af, hvor godt de nyoprettede lag kan klassificere dataet, baseret udelukkende på de funktioner, som den frosne MobileNetV2-basismodel leverer.

Dette trin etablerer en solid baseline og bekræfter, at de udvalgte øverste lag er i stand til at lære at klassificere dit specifikke datasæt. Men for at opnå endnu bedre ydeevne, især hvis dit datasæt har unikke karakteristika, der afviger fra ImageNet, er det næste skridt finjustering af basisnetværket.

Finjustering af Basisnetværket

Efter den indledende træning af de øverste lag kan du forbedre modellens ydeevne yderligere ved at finjustere basisnetværket. Dette indebærer at "optø" nogle af lagene i MobileNetV2-basismodellen og træne dem sammen med de øverste lag, men typisk med en meget lavere læringshastighed.

Finjustering giver modellen mulighed for at tilpasse de generiske funktioner, den har lært fra ImageNet, til de mere specifikke detaljer i dit eget datasæt. Dette er især gavnligt, når dit datasæt er stort nok til at understøtte yderligere træning af de dybere lag, og når der er en vis forskel mellem dit datasæt og ImageNet.

Processen med finjustering udføres ofte i faser for at give en kontrolleret tilpasning. I det givne eksempel anvendes en tre-trins finjusteringsproces:

1. Fase 1: Optø de øverste 92 lag af basisnetværket. Træn med en læringshastighed på 0.0001 ved hjælp af RMSprop-optimizeren.
2. Fase 2: Optø yderligere 9 lag (i alt 101 lag). Halvér læringshastigheden til 0.00005.
3. Fase 3: Optø endnu 9 lag (i alt 110 lag). Halvér læringshastigheden igen til 0.000025.

Denne gradvise optøning og den faldende læringshastighed er nøglen til succesfuld finjustering. En lavere læringshastighed forhindrer, at de forudtrænede vægte "glemmes" for hurtigt, mens den gradvise optøning giver en mere stabil træningsproces.

Et kritisk punkt under finjustering er håndtering af BatchNormalization-lag. TensorFlow/Keras-dokumentationen understreger, at når du optøer en model, der indeholder BatchNormalization-lag, skal du holde disse lag i inferens-tilstand ved at sende training=False, når du kalder basismodellen. Dette sikrer, at BatchNormalization-lagene fortsat bruger de populationens statistikker (gennemsnit og varians), der blev lært under forudtræningen, i stedet for at lære nye, potentielt forkerte, statistikker fra dit mindre datasæt under finjusteringen. Hvis dette ikke overholdes, kan det ødelægge den viden, modellen har opbygget, og forringe ydeevnen markant.

basemodel = model.layers[1]
for layer in basemodel.layers[-min(len(basemodel), layers):]:
 layer.trainable = True
model = compilemodel(model, learningrate)
fithistoryft1 = model.fit(traindataset, epochs=NUMFINETUNEEPOCHS, ...)

Efter hver finjusteringsfase evalueres modellen igen, og træningsfremgangen kan visualiseres for at se, hvordan nøjagtigheden forbedres, og tabet reduceres over tid. Dette iterative finjusteringstrin er ofte nødvendigt for at presse den sidste smule ydeevne ud af modellen og opnå de bedst mulige resultater for din specifikke opgave.

Praktisk Implementering: Kodeeksempler og Struktur

For at gøre implementeringen af overfør læring og finjustering med MobileNetV2 overskuelig og reproducerbar, er den foreslåede løsning opdelt i flere Python-moduler. Denne modulære tilgang forbedrer kodelæsbarheden, vedligeholdelsen og gør det lettere at genbruge komponenter.

De centrale moduler, der er beskrevet i eksemplet, omfatter:

• const.py: Dette modul indeholder alle de vigtige konstante værdier og hyperparametre, der bruges i hele projektet. Dette inkluderer antallet af træningsepoker for overfør læring (NUMTRANSFEPOCHS) og finjustering (NUMFINETUNEEPOCHS), antallet af noder i det skjulte lag (HIDDEN), billeddimensioner (DIMX, DIMY), pixelværdiområde (IMGSCALEMIN, IMGSCALEMAX), og batchstørrelse (BATCHSIZE). Ved at centralisere disse værdier er det nemt at justere eksperimenter uden at skulle redigere flere filer.
• plot.py: Et dedikeret modul til visualisering af træningshistorik og billeder. Det indeholder funktioner som plottraininghistory, der viser trænings- og valideringstab samt nøjagtighed over epoker, og showimages, der hjælper med at visualisere billeder fra datasættet, inklusive forudsagte klasser. Disse værktøjer er uundværlige for at overvåge og forstå modellens adfærd under træning.
• load.py: Dette modul er ansvarligt for al dataindlæsning og forbehandling. Det omfatter funktioner til at indlæse forskellige datasæt (MNIST, CIFAR-10, Fashion MNIST), normalisere billedpixelværdier til det krævede [-1.0, +1.0]-interval for MobileNetV2, konvertere gråtonebilleder til RGB, og ændre billedstørrelsen til de ønskede dimensioner (DIMX, DIMY). Desuden håndterer det opbygning af TensorFlow Dataset-objekter, opdeling i trænings-, validerings- og testsæt, shuffling, batching og one-hot-kodning af labels. Augmenteringsfunktioner tilføjes også her for at øge datasættets mangfoldighed.
• ftnet.py: Som tidligere beskrevet, er dette kernemodulet for modelkonstruktion. Det indeholder buildftnet-funktionen, der indlæser MobileNetV2-basismodellen (uden top-lag og med ImageNet-vægte), tilføjer de brugerdefinerede klassifikationslag, og kompilerer modellen. Modulet indeholder også compilemodel til at genkompilere modellen med nye læringshastigheder og unfreezebase_layers, som dynamisk optøer specifikke lag i basismodellen under finjusteringsprocessen.

Samlet set giver denne modulære struktur et robust og fleksibelt rammeværk for at udføre avancerede dyb læringsopgaver med forudtrænede modeller. Ved at holde ansvarsområderne adskilte bliver koden lettere at fejlsøge, udvide og tilpasse til nye projekter.

Ofte Stillede Spørgsmål (FAQ)

Er MobileNetV2 en del af Keras?

Ja, MobileNetV2 er en del af Keras. Mere specifikt er den tilgængelig via tf.keras.applications.MobileNetV2, som er TensorFlows officielle og integrerede implementering af Keras-API'et. Dette betyder, at du kan indlæse og bruge MobileNetV2 direkte inden for TensorFlow-økosystemet.

Hvorfor får jeg en 'ImportError' for MobileNetV2?

En ImportError: cannot import name 'MobileNetV2' skyldes ofte, at du enten bruger en ældre version af TensorFlow (f.eks. tidlig TensorFlow 1.x), hvor API-stien måske var anderledes, eller at du forsøger at importere fra en forkert placering. Den korrekte importsti i moderne TensorFlow er from tensorflow.keras.applications import MobileNetV2, eller simpelthen at henvise til den som tf.keras.applications.MobileNetV2.

Hvad er forskellen på overfør læring og finjustering?

Overfør læring indebærer at fryse alle lag i en forudtrænet basismodel og kun træne nye, øverste klassifikationslag, der er tilføjet ovenpå. Dette er hurtigt og kræver mindre data. Finjustering går et skridt videre ved at "optø" nogle af eller alle lagene i basismodellen og træne dem yderligere på dit nye datasæt, typisk med en lavere læringshastighed. Dette giver modellen mulighed for at tilpasse sig mere specifikt til dit datasæt og kan forbedre ydeevnen yderligere.

Hvilken billedstørrelse kræver MobileNetV2?

MobileNetV2 kræver, at inputbilleder har en minimumsstørrelse på 96x96 pixels. Selvom den er trænet på 224x224, kan den tilpasses til mindre dimensioner. Det er også afgørende, at billedernes pixelværdier normaliseres til et område mellem -1.0 og +1.0.

Skal jeg normalisere billedpixelværdier?

Ja, det er absolut nødvendigt at normalisere billedpixelværdier, når du bruger MobileNetV2. Modellen er specifikt trænet på billeder, hvor pixelværdierne er skaleret til intervallet [-1.0, +1.0]. Hvis du ikke normaliserer dine inputbilleder til dette interval, vil modellen ikke fungere korrekt og give dårlige resultater.

Hvis du vil læse andre artikler, der ligner MobileNetV2 med tf.keras: Den Komplette Guide, kan du besøge kategorien Mobil.