Hur du förbättrar din maskininlärningsmodell med TensorFlows dataökning

Dataökning är processen att tillämpa olika transformationer på träningsdata. Det hjälper till att öka mångfalden av datamängden och förhindrar överanpassning. Överanpassning sker oftast när du har begränsad data för att träna din modell.

Här kommer du att lära dig hur du använder TensorFlows dataförstärkningsmodul för att diversifiera din datauppsättning. Detta kommer att förhindra överanpassning genom att generera nya datapunkter som skiljer sig något från originaldata.

Exempeldatauppsättningen du kommer att använda

Du kommer att använda datauppsättningen för katter och hundar från Kuggla. Denna datauppsättning innehåller cirka 3 000 bilder av katter och hundar. Dessa bilder är uppdelade i utbildnings-, test- och valideringsuppsättningar.

Etiketten 1.0 representerar en hund medan etiketten 0.0 representerar en katt.

Den fullständiga källkoden som implementerar dataförstärkningstekniker och den som inte gör det är tillgänglig i en GitHub-förråd.

Installera och importera TensorFlow

För att gå igenom bör du ha en grundläggande förståelse för Python. Du bör även ha grundläggande kunskaper om maskininlärning. Om du behöver en repetitionskurs kan du överväga att följa några handledning om maskininlärning.

Öppen Google Colab. Ändra körtidstyp till GPU. Utför sedan följande magiska kommando på den första kodcellen för att installera TensorFlow i din miljö.

!pip installera tensorflow

Importera TensorFlow och dess relevanta moduler och klasser.

importera tensorflöde som tf
från tensorflow.keras.preprocessing.image importera ImageDataGenerator
från tensorflow.keras.modeller importera Sekventiell
från tensorflow.keras.lager importera Conv2D, MaxPooling2D, Flatten, Dense, Dropout

De tensorflow.keras.preprocessing.image gör det möjligt för dig att utföra dataförstärkning på din datauppsättning.

Skapa instanser av klassen ImageDataGenerator

Skapa en instans av ImageDataGenerator klass för tågdata. Du kommer att använda detta objekt för att förbearbeta träningsdata. Det kommer att generera partier av utökade bilddata i realtid under modellträning.

I uppgiften att klassificera om en bild är en katt eller en hund kan du använda teknikerna vändning, slumpmässig bredd, slumpmässig höjd, slumpmässig ljusstyrka och zoomning av dataförstärkning. Dessa tekniker kommer att generera ny data som innehåller varianter av originaldata som representerar verkliga scenarier.

# definiera bilddatageneratorn för träning
train_datagen = ImageDataGenerator (omskala=1./255,
 horizontal_flip=Sann,
 width_shift_range=0.2,
 height_shift_range=0.2,
 ljusstyrkeområde=[0.2,1.0],
 zoom_range=0.2)

Skapa en annan instans av ImageDataGenerator klass för testdata. Du kommer att behöva skala om parameter. Det kommer att normalisera pixelvärdena för testbilderna för att matcha formatet som används under träningen.

# definiera bilddatageneratorn för testning
test_datagen = ImageDataGenerator (omskala=1./255)

Skapa en sista instans av ImageDataGenerator klass för valideringsdata. Skala om valideringsdata på samma sätt som testdata.

# definiera bilddatageneratorn för validering
validation_datagen = ImageDataGenerator (rescale=1./255)

Du behöver inte tillämpa de andra förstärkningsteknikerna på test- och valideringsdata. Detta beror på att modellen använder test- och valideringsdata endast för utvärderingsändamål. De bör återspegla den ursprungliga datadistributionen.

Laddar din data

Skapa en DirectoryIterator objekt från träningskatalogen. Det kommer att generera partier av utökade bilder. Ange sedan katalogen som lagrar träningsdata. Ändra storlek på bilderna till en fast storlek på 64x64 pixlar. Ange antalet bilder som varje batch ska använda. Slutligen, ange vilken typ av etikett som ska vara binär (dvs katt eller hund).

# definierar träningskatalogen
train_data = train_datagen.flow_from_directory (katalog=r'/content/drive/MyDrive/cats_and_dogs_filtred/train',
 target_size=(64, 64),
 batch_size=32,
 class_mode='binär')

Skapa en till DirectoryIterator objekt från testkatalogen. Ställ in parametrarna på samma värden som för träningsdata.

# definierar testkatalogen
test_data = test_datagen.flow_from_directory (katalog='/content/drive/MyDrive/cats_and_dogs_filtred/test',
 target_size=(64, 64),
 batch_size=32,
 class_mode='binär')

Skapa en final DirectoryIterator objekt från valideringskatalogen. Parametrarna förblir desamma som för tränings- och testdata.

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

Katalogiteratorerna utökar inte validerings- och testdatauppsättningarna.

Definiera din modell

Definiera arkitekturen för ditt neurala nätverk. Använda en Konvolutionellt neuralt nätverk (CNN). CNN: er är designade för att känna igen mönster och funktioner i bilder.

modell = Sequential()
# faltningslager med 32 filter i storleken 3x3
model.add (Conv2D(32, (3, 3), aktivering='relu', input_shape=(64, 64, 3))) 
# max poollager med poolstorlek 2x2
model.add (MaxPooling2D(pool_size=(2, 2))) 
# faltningslager med 64 filter i storleken 3x3
model.add (Conv2D(64, (3, 3), aktivering='relu'))
# max poollager med poolstorlek 2x2 
model.add (MaxPooling2D(pool_size=(2, 2))) 
# platta ut utdata från faltnings- och poollagren
model.add (Flatten()) 
# fullt anslutet lager med 128 enheter och ReLU-aktivering
model.add (Dense(128, aktivering='relu')) 
# släpp slumpmässigt 50 % av enheterna för att förhindra övermontering
model.add (Dropout(0.5)) 
# utdatalager med sigmoidaktivering (binär klassificering)
model.add (Dense(1, aktivering='sigmoid'))

Kompilera modellen med hjälp av binären korsentropi förlustfunktion. Binära klassificeringsproblem använder ofta It. För optimeraren, använd Adam optimizer. Det är en adaptiv algoritm för optimering av inlärningshastigheten. Slutligen, utvärdera modellen i termer av noggrannhet.

model.compile (förlust="binary_crossentropy", optimizer='Adam', statistik=['noggrannhet'])

Skriv ut en sammanfattning av modellens arkitektur till konsolen.

model.summary()

Följande skärmdump visar visualiseringen av modellarkitekturen.

Detta ger dig en överblick över hur din modelldesign ser ut.

Träna din modell

Träna modellen med hjälp av passa() metod. Ställ in antalet steg per epok till antalet träningsprov dividerat med satsstorlek. Ställ även in valideringsdata och antalet valideringssteg.

# Träna modellen på träningsdata
historia = model.fit (tågdata,
 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 klass tillämpar dataökning på träningsdata i realtid. Detta gör träningsprocessen för modellen långsammare.

Utvärdera din modell

Utvärdera prestandan för din modell på testdata med hjälp av utvärdera() metod. Skriv även ut testförlusten och noggrannheten till konsolen.

test_loss, test_acc = model.evaluate (test_data,
 steps=test_data.n // test_data.batch_size)
skriva ut(f'Testförlust: {test_loss}')
skriva ut(f'Testnoggrannhet: {test_acc}')

Följande skärmdump visar modellens prestanda.

Modellen presterar hyfsat bra på aldrig sett data.

När du kör kod som inte implementerar dataförstärkningsteknikerna är modellträningsnoggrannheten 1. Vilket betyder att den passar över. Den presterar också dåligt på data som den aldrig har sett förut. Detta beror på att den lär sig datauppsättningens egenheter.

När är dataökning inte användbart?

• När datasetet redan är mångsidigt och stort: Dataförstärkning ökar storleken och mångfalden av en datauppsättning. Om datauppsättningen redan är stor och mångsidig kommer dataförstärkning inte att vara användbar.
• När datasetet är för litet: Dataökning kan inte skapa nya funktioner som inte finns i den ursprungliga datamängden. Därför kan den inte kompensera för en liten datauppsättning som saknar de flesta funktioner som modellen kräver för att lära sig.
• När typen av dataökning är olämplig: Roterande bilder kanske inte är till hjälp där objektens orientering är viktig.

Vad är TensorFlow kapabel till

TensorFlow är ett mångsidigt och kraftfullt bibliotek. Den kan träna komplexa djupinlärningsmodeller och kan köras på en rad enheter från smartphones till kluster av servrar. Det har hjälpt till att utveckla datorenheter som använder maskininlärning.