Hvordan forbedre maskinlæringsmodellen din med TensorFlows dataforsterkning

Dataforsterkning er prosessen med å bruke ulike transformasjoner til treningsdataene. Det bidrar til å øke mangfoldet i datasettet og forhindre overtilpasning. Overtilpasning skjer for det meste når du har begrenset data for å trene modellen din.

Her vil du lære hvordan du bruker TensorFlows dataforstørrelsesmodul for å diversifisere datasettet ditt. Dette vil forhindre overtilpasning ved å generere nye datapunkter som er litt forskjellige fra de opprinnelige dataene.

Eksempeldatasettet du skal bruke

Du skal bruke datasettet for katter og hunder fra Kaggle. Dette datasettet inneholder omtrent 3000 bilder av katter og hunder. Disse bildene er delt inn i trenings-, test- og valideringssett.

Etiketten 1.0 representerer en hund mens etiketten 0.0 representerer en katt.

Den fullstendige kildekoden som implementerer dataforsterkningsteknikker og den som ikke gjør det, er tilgjengelig i en GitHub-depot.

Installere og importere TensorFlow

For å følge opp, bør du ha en grunnleggende forståelse av Python. Du bør også ha grunnleggende kunnskap om maskinlæring. Hvis du trenger en oppfriskning, kan det være lurt å vurdere å følge noen veiledninger om maskinlæring.

Åpen Google Colab. Endre kjøretidstypen til GPU. Utfør deretter følgende magiske kommando på den første kodecellen for å installere TensorFlow i miljøet ditt.

!pip installer tensorflow

Importer TensorFlow og relevante moduler og klasser.

import tensorflyt som tf
fra tensorflow.keras.preprocessing.image import ImageDataGenerator
fra tensorflow.keras.modeller import Sekvensiell
fra tensorflow.keras.lag import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

De tensorflow.keras.preprocessing.image vil gjøre deg i stand til å utføre dataforstørrelse på datasettet ditt.

Opprette forekomster av ImageDataGenerator-klassen

Opprett en forekomst av ImageDataGenerator klasse for togdataene. Du vil bruke dette objektet til å forhåndsbehandle treningsdataene. Den vil generere grupper med utvidede bildedata i sanntid under modelltrening.

I oppgaven med å klassifisere om et bilde er en katt eller en hund, kan du bruke teknikker for vending, tilfeldig bredde, tilfeldig høyde, tilfeldig lysstyrke og zooming av data. Disse teknikkene vil generere nye data som inneholder varianter av de originale dataene som representerer virkelige scenarier.

# definer bildedatageneratoren for trening
train_datagen = ImageDataGenerator (rescale=1./255,
 horisontal_flip=ekte,
 width_shift_range=0.2,
 height_shift_range=0.2,
 lysstyrkeområde=[0.2,1.0],
 zoom_range=0.2)

Opprett en annen forekomst av ImageDataGenerator klasse for testdataene. Du trenger skalere om parameter. Den vil normalisere pikselverdiene til testbildene for å matche formatet som brukes under trening.

# definer bildedatageneratoren for testing
test_datagen = ImageDataGenerator (rescale=1./255)

Lag en siste forekomst av ImageDataGenerator klasse for valideringsdataene. Omskaler valideringsdataene på samme måte som testdataene.

# definer bildedatageneratoren for validering
validation_datagen = ImageDataGenerator (rescale=1./255)

Du trenger ikke bruke de andre utvidelsesteknikkene på test- og valideringsdataene. Dette er fordi modellen bruker test- og valideringsdata kun til evalueringsformål. De skal gjenspeile den opprinnelige datadistribusjonen.

Laster dataene dine

Lage en DirectoryIterator objekt fra opplæringskatalogen. Det vil generere grupper med utvidede bilder. Deretter spesifiser katalogen som lagrer treningsdataene. Endre størrelsen på bildene til en fast størrelse på 64 x 64 piksler. Spesifiser antall bilder som hver batch skal bruke. Til slutt, spesifiser hvilken type etikett som skal være binær (dvs. katt eller hund).

# definere treningskatalogen
train_data = train_datagen.flow_from_directory (katalog=r'/content/drive/MyDrive/cats_and_dogs_filtered/train',
 target_size=(64, 64),
 batch_size=32,
 klasse_modus='binær')

Lag en annen DirectoryIterator objekt fra testkatalogen. Sett parametrene til samme verdier som treningsdataene.

# definerer testkatalogen
test_data = test_datagen.flow_from_directory (katalog='/content/drive/MyDrive/cats_and_dogs_filtered/test',
 target_size=(64, 64),
 batch_size=32,
 klasse_modus='binær')

Lag en finale DirectoryIterator objekt fra valideringskatalogen. Parametrene forblir de samme som for trenings- og testdataene.

# definerer valideringskatalogen
validation_data = validation_datagen.flow_from_directory (katalog='/content/drive/MyDrive/cats_and_dogs_filtered/validation',
 target_size=(64, 64),
 batch_size=32,
 klasse_modus='binær')

Katalogiteratorene forsterker ikke validerings- og testdatasettene.

Definere modellen din

Definer arkitekturen til ditt nevrale nettverk. Bruk en Konvolusjonelt nevralt nettverk (CNN). CNN-er er designet for å gjenkjenne mønstre og funksjoner i bilder.

modell = Sekvensiell()
# konvolusjonslag med 32 filtre i størrelsen 3x3
model.add (Conv2D(32, (3, 3), aktivering='relu', input_shape=(64, 64, 3))) 
# maks poollag med bassengstørrelse 2x2
model.add (MaxPooling2D(pool_size=(2, 2))) 
# konvolusjonslag med 64 filtre i størrelsen 3x3
model.add (Conv2D(64, (3, 3), aktivering='relu'))
# maks poollag med bassengstørrelse 2x2 
model.add (MaxPooling2D(pool_size=(2, 2))) 
# flat ut utgangen fra konvolusjonslagene og sammenslåingslagene
model.add (Flatten()) 
# fullt tilkoblet lag med 128 enheter og ReLU-aktivering
model.add (Tett(128, aktivering='relu')) 
# slipp tilfeldig ut 50 % av enhetene for å forhindre overmontering
model.add (Dropout(0.5)) 
# utgangslag med sigmoid-aktivering (binær klassifisering)
model.add (Tett(1, aktivering='sigmoid'))

Kompiler modellen ved å bruke binæren kryssentropi tapsfunksjon. Binære klassifiseringsproblemer bruker det ofte. For optimalisering, bruk Adam optimizer. Det er en adaptiv algoritme for optimalisering av læringshastighet. Vurder til slutt modellen med tanke på nøyaktighet.

model.compile (tap='binær_kryssentropi', optimizer='adam', beregninger=['nøyaktighet'])

Skriv ut et sammendrag av modellens arkitektur til konsollen.

model.summary()

Følgende skjermbilde viser visualiseringen av modellarkitekturen.

Dette gir deg en oversikt over hvordan modelldesignet ditt ser ut.

Trene modellen din

Tren modellen ved hjelp av passe() metode. Angi antall trinn per epoke til å være antall treningsprøver delt på Partistørrelse, Gruppestørrelse. Angi også valideringsdata og antall valideringstrinn.

# Tren modellen på treningsdataene
historie = model.fit (togdata,
 steps_per_epoch=train_data.n // train_data.batch_size,
 epoker=50,
 validation_data=validation_data,
 validation_steps=validation_data.n // validation_data.batch_size)

De ImageDataGenerator klasse bruker dataforsterkning på treningsdataene i sanntid. Dette gjør treningsprosessen til modellen langsommere.

Evaluering av modellen din

Evaluer ytelsen til modellen din på testdataene ved å bruke evaluere() metode. Skriv også ut testtapet og nøyaktigheten til konsollen.

test_loss, test_acc = model.evaluate (test_data,
 steps=test_data.n // test_data.batch_size)
skrive ut(f'Test tap: {test_loss}')
skrive ut(f'Testnøyaktighet: {test_acc}')

Følgende skjermbilde viser modellens ytelse.

Modellen yter rimelig bra på aldri sett data.

Når du kjører kode som ikke implementerer dataforsterkningsteknikkene, er modelltreningsnøyaktigheten 1. Noe som betyr at den passer over. Den yter også dårlig på data den aldri har sett før. Dette er fordi den lærer seg særegenhetene til datasettet.

Når er dataforsterkning ikke nyttig?

• Når datasettet allerede er mangfoldig og stort: Dataforstørrelse øker størrelsen og mangfoldet til et datasett. Hvis datasettet allerede er stort og mangfoldig, vil ikke dataforstørrelse være nyttig.
• Når datasettet er for lite: Dataforstørrelse kan ikke opprette nye funksjoner som ikke finnes i det originale datasettet. Derfor kan den ikke kompensere for et lite datasett som mangler de fleste funksjonene som modellen krever for å lære.
• Når typen dataforstørrelse er upassende: Roterende bilder kan for eksempel ikke være nyttig der orienteringen til objektene er viktig.

Hva er TensorFlow i stand til

TensorFlow er et mangfoldig og kraftig bibliotek. Den er i stand til å trene komplekse dyplæringsmodeller og kan kjøres på en rekke enheter fra smarttelefoner til serverklynger. Det har hjulpet med å styrke databehandlingsenheter som bruker maskinlæring.