Hoe u uw machine learning-model kunt verbeteren met de gegevensvergroting van TensorFlow

Gegevensaugmentatie is het proces van het toepassen van verschillende transformaties op de trainingsgegevens. Het helpt de diversiteit van de dataset te vergroten en overfitting te voorkomen. Overfitting treedt meestal op wanneer u beperkte gegevens heeft om uw model te trainen.

Hier leert u hoe u de data-augmentatiemodule van TensorFlow kunt gebruiken om uw dataset te diversifiëren. Dit voorkomt overfitting door nieuwe gegevenspunten te genereren die enigszins afwijken van de oorspronkelijke gegevens.

De voorbeeldgegevensset die u gaat gebruiken

U gebruikt de dataset katten en honden van Kaggle. Deze dataset bevat ongeveer 3.000 afbeeldingen van katten en honden. Deze afbeeldingen zijn opgesplitst in trainings-, test- en validatiesets.

Het label 1.0 vertegenwoordigt een hond terwijl het label 0.0 een kat vertegenwoordigt.

De volledige broncode die technieken voor gegevensvergroting implementeert en degene die niet beschikbaar is in een

instagram viewer

GitHub-opslagplaats.

TensorFlow installeren en importeren

Om door te gaan, moet u een basiskennis van Python. Je moet ook basiskennis hebben van machine learning. Als je een opfriscursus nodig hebt, kun je overwegen om er een paar te volgen tutorials over machine learning.

Open Google Colab. Wijzig het runtime-type in GPU. Voer vervolgens de volgende magische opdracht uit op de eerste codecel om TensorFlow in uw omgeving te installeren.

!pip installeertensorflow

Importeer TensorFlow en de bijbehorende modules en klassen.

importeren tensorstroom als tf
van tensorflow.keras.preprocessing.image importeren ImageDataGenerator
van tensorflow.keras.models importeren Opeenvolgend
van tensorflow.keras.lagen importeren Conv2D, MaxPooling2D, Flatten, Dense, Dropout

De tensorflow.keras.preprocessing.image stelt u in staat om gegevensaugmentatie uit te voeren op uw dataset.

Instanties maken van de ImageDataGenerator-klasse

Maak een instantie van de ImageDataGenerator klasse voor de treingegevens. U gebruikt dit object voor het voorbewerken van de trainingsgegevens. Tijdens de modeltraining genereert het in realtime batches van verbeterde beeldgegevens.

Bij het classificeren of een afbeelding een kat of een hond is, kunt u de gegevensvergrotingstechnieken omdraaien, willekeurige breedte, willekeurige hoogte, willekeurige helderheid en zoomen gebruiken. Deze technieken zullen nieuwe gegevens genereren die variaties op de oorspronkelijke gegevens bevatten die scenario's uit de echte wereld vertegenwoordigen.

# definieer de beeldgegevensgenerator voor training
train_datagen = ImageDataGenerator (opnieuw schalen=1./255,
 horizontal_flip=WAAR,
 width_shift_range=0.2,
 height_shift_range=0.2,
 helderheid_bereik=[0.2,1.0],
 zoombereik=0.2)

Maak een ander exemplaar van de ImageDataGenerator klasse voor de testgegevens. Je hebt de nodig opnieuw schalen parameter. Het normaliseert de pixelwaarden van de testbeelden zodat ze overeenkomen met het formaat dat tijdens de training wordt gebruikt.

# definieer de beeldgegevensgenerator voor testen
test_datagen = ImageDataGenerator (opnieuw schalen=1./255)

Maak een laatste instantie van de ImageDataGenerator klasse voor de validatiegegevens. Herschaal de validatiegegevens op dezelfde manier als de testgegevens.

# definieer de afbeeldingsgegevensgenerator voor validatie
validation_datagen = ImageDataGenerator (opnieuw schalen=1./255)

U hoeft de andere augmentatietechnieken niet toe te passen op de test- en validatiegegevens. Dit komt omdat het model de test- en validatiegegevens alleen voor evaluatiedoeleinden gebruikt. Ze moeten de oorspronkelijke gegevensdistributie weerspiegelen.

Uw gegevens laden

Maak een DirectoryIterator object uit de trainingsmap. Het genereert batches van augmented afbeeldingen. Geef vervolgens de map op waarin de trainingsgegevens worden opgeslagen. Verklein de afbeeldingen naar een vaste grootte van 64x64 pixels. Geef het aantal afbeeldingen op dat elke batch zal gebruiken. Geef ten slotte het type label op dat moet worden binair (d.w.z. kat of hond).

# het definiëren van de trainingsmap
train_data = train_datagen.flow_from_directory (directory=r'/content/drive/MyDrive/cats_and_dogs_filtered/train',
 target_size=(64, 64),
 batchgrootte=32,
 class_mode='binair')

Maak een ander DirectoryIterator object uit de testdirectory. Stel de parameters in op dezelfde waarden als die van de trainingsgegevens.

# het definiëren van de testdirectory
test_data = test_datagen.flow_from_directory (directory='/content/drive/MyDrive/cats_and_dogs_filtered/test',
 target_size=(64, 64),
 batchgrootte=32,
 class_mode='binair')

Maak een finale DirectoryIterator object uit de validatiedirectory. De parameters blijven hetzelfde als die van de trainings- en testgegevens.

# de validatiedirectory definiëren
validation_data = validation_datagen.flow_from_directory (directory='/content/drive/MyDrive/cats_and_dogs_filtered/validation',
 target_size=(64, 64),
 batchgrootte=32,
 class_mode='binair')

De directory-iterators vergroten de validatie- en testdatasets niet.

Uw model definiëren

Definieer de architectuur van uw neurale netwerk. Gebruik een Convolutioneel neuraal netwerk (CNN). CNN's zijn ontworpen om patronen en kenmerken in afbeeldingen te herkennen.

model = Opeenvolgend()
# convolutionele laag met 32 ​​filters van maat 3x3
model.add (Conv2D(32, (3, 3), activatie='relu', invoer_vorm=(64, 64, 3))) 
# max pooling layer met zwembadmaat 2x2
model.add (MaxPooling2D(pool_size=(2, 2))) 
# convolutionele laag met 64 filters van maat 3x3
model.add (Conv2D(64, (3, 3), activatie='relu'))
# max pooling layer met zwembadmaat 2x2 
model.add (MaxPooling2D(pool_size=(2, 2))) 
# maak de uitvoer van de convolutionele en poolinglagen plat
model.add (Flatten()) 
# volledig verbonden laag met 128 eenheden en ReLU-activering
model.add (Dense(128, activering='relu')) 
# laat willekeurig 50% van de eenheden vallen om overfitting te voorkomen
model.add (Dropout(0.5)) 
# uitvoerlaag met sigmoïde activering (binaire classificatie)
model.add (Dense(1, activering='sigmoïde'))

Compileer het model met behulp van het binaire bestand cross-entropie verlies functie. Binaire classificatieproblemen gebruiken het vaak. Gebruik voor de optimalisatie de Adam-optimizer. Het is een adaptief algoritme voor het optimaliseren van de leersnelheid. Beoordeel ten slotte het model op nauwkeurigheid.

model.compile (verlies='binary_crossentropy', optimalisatie='Adam', statistieken=['nauwkeurigheid'])

Druk een samenvatting van de architectuur van het model af naar de console.

Model Samenvatting()

De volgende schermafbeelding toont de visualisatie van de modelarchitectuur.

Dit geeft u een overzicht van hoe uw modelontwerp eruit ziet.

Uw model trainen

Train het model met behulp van de fit() methode. Stel het aantal stappen per tijdvak in als het aantal trainingsvoorbeelden gedeeld door de seriegrootte. Stel ook de validatiegegevens en het aantal validatiestappen in.

# Train het model op de trainingsgegevens
geschiedenis = model.fit (train_data,
 steps_per_epoch=train_data.n // train_data.batch_size,
 tijdperken=50,
 validation_data=validation_data,
 validation_steps=validation_data.n // validation_data.batch_size)

De ImageDataGenerator class past data augmentation toe op de trainingsdata in real time. Dit maakt het trainingsproces van het model langzamer.

Uw model evalueren

Evalueer de prestaties van uw model op de testgegevens met behulp van de evalueren() methode. Druk ook het testverlies en de nauwkeurigheid af naar de console.

test_loss, test_acc = model.evaluate (test_data,
 stappen=test_data.n // test_data.batch_size)
afdrukken(f'Test verlies: {testverlies}')
afdrukken(f'Test-nauwkeurigheid: {test_acc}')

De volgende schermafbeelding toont de prestaties van het model.

Het model presteert redelijk goed op nooit geziene data.

Wanneer u code uitvoert die de technieken voor gegevensvergroting niet implementeert, is de nauwkeurigheid van de modeltraining 1. Wat betekent dat het overfit is. Het presteert ook slecht op gegevens die het nog nooit eerder heeft gezien. Dit komt omdat het de eigenaardigheden van de dataset leert.

Wanneer is gegevensvergroting niet nuttig?

• Wanneer de dataset al divers en groot is: Data-augmentatie vergroot de omvang en diversiteit van een dataset. Als de dataset al groot en divers is, heeft data-augmentatie geen zin.
• Wanneer de dataset te klein is: Gegevensvergroting kan geen nieuwe kenmerken creëren die niet aanwezig zijn in de oorspronkelijke gegevensset. Daarom kan het geen compensatie bieden voor een kleine dataset die de meeste functies mist die het model nodig heeft om te leren.
• Wanneer het type gegevensvergroting niet geschikt is: Roterende afbeeldingen zijn bijvoorbeeld misschien niet handig wanneer de oriëntatie van de objecten belangrijk is.

Waartoe is TensorFlow in staat

TensorFlow is een diverse en krachtige bibliotheek. Het is in staat om complexe deep learning-modellen te trainen en kan op een reeks apparaten worden uitgevoerd, van smartphones tot clusters van servers. Het heeft geholpen edge computing-apparaten aan te drijven die gebruik maken van machine learning.