Sådan forbedrer du din maskinlæringsmodel med TensorFlows dataforøgelse

Dataforøgelse er processen med at anvende forskellige transformationer til træningsdataene. Det hjælper med at øge mangfoldigheden af ​​datasættet og forhindre overfitting. Overfitting sker for det meste, når du har begrænset data til at træne din model.

Her lærer du, hvordan du bruger TensorFlows dataforstærkningsmodul til at diversificere dit datasæt. Dette vil forhindre overtilpasning ved at generere nye datapunkter, der er lidt forskellige fra de originale data.

Eksempeldatasættet, du vil bruge

Du skal bruge katte- og hundedatasættet fra Kaggle. Dette datasæt indeholder cirka 3.000 billeder af katte og hunde. Disse billeder er opdelt i trænings-, test- og valideringssæt.

Etiketten 1.0 repræsenterer en hund, mens etiketten 0.0 repræsenterer en kat.

Den fulde kildekode, der implementerer dataforøgelsesteknikker, og den, der ikke gør, er tilgængelig i en GitHub-depot.

Installation og import af TensorFlow

For at følge op skal du have en grundlæggende forståelse af Python. Du skal også have grundlæggende viden om maskinlæring. Hvis du har brug for en genopfriskning, kan du overveje at følge nogle tutorials om maskinlæring.

Åben Google Colab. Skift runtime-typen til GPU. Udfør derefter følgende magiske kommando på den første kodecelle for at installere TensorFlow i dit miljø.

!pip installer tensorflow

Importer TensorFlow og dets relevante moduler og klasser.

importere tensorflow som tf
fra tensorflow.keras.preprocessing.image importere ImageDataGenerator
fra tensorflow.keras.modeller importere Sekventiel
fra tensorflow.keras.lag importere Conv2D, MaxPooling2D, Flatten, Dense, Dropout

Det tensorflow.keras.preprocessing.image vil gøre dig i stand til at udføre dataforøgelse på dit datasæt.

Oprettelse af forekomster af ImageDataGenerator-klassen

Opret en instans af ImageDataGenerator klasse for togdataene. Du skal bruge dette objekt til at forbehandle træningsdataene. Det vil generere batcher af udvidede billeddata i realtid under modeltræning.

I opgaven med at klassificere, om et billede er en kat eller en hund, kan du bruge teknikkerne til vending, tilfældig bredde, tilfældig højde, tilfældig lysstyrke og zoomende dataforøgelse. Disse teknikker vil generere nye data, som indeholder variationer af de originale data, der repræsenterer scenarier i den virkelige verden.

# definere billeddatageneratoren til træning
train_datagen = ImageDataGenerator (rescale=1./255,
 horizontal_flip=Rigtigt,
 width_shift_range=0.2,
 height_shift_range=0.2,
 lysstyrkeområde=[0.2,1.0],
 zoom_range=0.2)

Opret en anden forekomst af ImageDataGenerator klasse for testdataene. Du skal bruge omskalere parameter. Det vil normalisere pixelværdierne for testbillederne, så de matcher det format, der bruges under træningen.

# definer billeddatageneratoren til test
test_datagen = ImageDataGenerator (rescale=1./255)

Opret en sidste forekomst af ImageDataGenerator klasse for valideringsdataene. Omskaler valideringsdataene på samme måde som testdataene.

# definer billeddatageneratoren til validering
validation_datagen = ImageDataGenerator (rescale=1./255)

Du behøver ikke at anvende de andre augmentationsteknikker på test- og valideringsdataene. Dette skyldes, at modellen udelukkende bruger test- og valideringsdata til evalueringsformål. De skal afspejle den oprindelige datafordeling.

Indlæsning af dine data

Lave en DirectoryIterator objekt fra træningsmappen. Det vil generere partier af udvidede billeder. Angiv derefter den mappe, der gemmer træningsdataene. Ændr størrelsen på billederne til en fast størrelse på 64x64 pixels. Angiv antallet af billeder, som hver batch vil bruge. Til sidst skal du angive, hvilken type etiket der skal være binær (dvs. kat eller hund).

# definerer træningsmappen
train_data = train_datagen.flow_from_directory (mappe=r'/content/drive/MyDrive/cats_and_dogs_filtred/train',
 target_size=(64, 64),
 batch_size=32,
 klasse_tilstand='binær')

Opret en anden DirectoryIterator objekt fra testbiblioteket. Indstil parametrene til de samme værdier som træningsdataene.

# definerer testbiblioteket
test_data = test_datagen.flow_from_directory (mappe='/content/drive/MyDrive/cats_and_dogs_filtred/test',
 target_size=(64, 64),
 batch_size=32,
 klasse_tilstand='binær')

Opret en finale DirectoryIterator objekt fra valideringsmappen. Parametrene forbliver de samme som for trænings- og testdata.

# definerer valideringsbiblioteket
validation_data = validation_datagen.flow_from_directory (mappe='/content/drive/MyDrive/cats_and_dogs_filtred/validation',
 target_size=(64, 64),
 batch_size=32,
 klasse_tilstand='binær')

Biblioteks-iteratorerne øger ikke validerings- og testdatasættene.

Definition af din model

Definer arkitekturen af ​​dit neurale netværk. Brug en Konvolutionelt neuralt netværk (CNN). CNN'er er designet til at genkende mønstre og funktioner i billeder.

model = Sequential()
# foldningslag med 32 filtre i størrelsen 3x3
model.add (Conv2D(32, (3, 3), aktivering='relu', input_shape=(64, 64, 3))) 
# max pooling lag med pool størrelse 2x2
model.add (MaxPooling2D(pool_size=(2, 2))) 
# foldningslag med 64 filtre i størrelsen 3x3
model.add (Conv2D(64, (3, 3), aktivering='relu'))
# max pooling lag med pool størrelse 2x2 
model.add (MaxPooling2D(pool_size=(2, 2))) 
# flad outputtet fra foldnings- og poolingslagene
model.add (Flatten()) 
# fuldt tilsluttet lag med 128 enheder og ReLU-aktivering
model.add (Dense(128, aktivering='relu')) 
# falder tilfældigt ud af 50 % af enhederne for at forhindre overmontering
model.add (Frafald(0.5)) 
# outputlag med sigmoid-aktivering (binær klassificering)
model.add (Dense(1, aktivering='sigmoid'))

Kompiler modellen ved at bruge det binære krydsentropi tabsfunktion. Binære klassifikationsproblemer bruger det ofte. Til optimering skal du bruge Adam optimizer. Det er en adaptiv algoritme til optimering af læringshastigheder. Vurder til sidst modellen med hensyn til nøjagtighed.

model.compile (tab='binær_krydsentropi', optimizer='adam', metrics=['nøjagtighed'])

Udskriv en oversigt over modellens arkitektur til konsollen.

model.summary()

Følgende skærmbillede viser visualiseringen af ​​modelarkitekturen.

Dette giver dig et overblik over, hvordan dit modeldesign ser ud.

Træning af din model

Træn modellen vha passe() metode. Indstil antallet af trin pr. epoke til at være antallet af træningsprøver divideret med batch_size. Indstil også valideringsdata og antallet af valideringstrin.

# Træn modellen på træningsdataene
historie = model.fit (tog_data,
 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)

Det ImageDataGenerator klasse anvender dataforøgelse på træningsdataene i realtid. Dette gør træningsprocessen af ​​modellen langsommere.

Evaluering af din model

Evaluer ydeevnen af ​​din model på testdata ved hjælp af vurdere() metode. Udskriv også testtabet og nøjagtigheden til konsollen.

test_tab, test_acc = model.evaluate (test_data,
 steps=test_data.n // test_data.batch_size)
Print(f'Testtab: {test_tab}')
Print(f'Test nøjagtighed: {test_acc}')

Følgende skærmbillede viser modellens ydeevne.

Modellen klarer sig rimeligt godt på aldrig sete data.

Når du kører kode, der ikke implementerer dataforøgelsesteknikkerne, er modeltræningsnøjagtigheden 1. Hvilket betyder, at den passer over. Den klarer sig også dårligt på data, den aldrig har set før. Dette er fordi den lærer datasættets særegenheder.

Hvornår er dataforøgelse ikke nyttigt?

• Når datasættet allerede er mangfoldigt og stort: Dataforøgelse øger størrelsen og mangfoldigheden af ​​et datasæt. Hvis datasættet allerede er stort og mangfoldigt, vil dataforøgelse ikke være nyttigt.
• Når datasættet er for lille: Dataforøgelse kan ikke skabe nye funktioner, der ikke er til stede i det originale datasæt. Derfor kan den ikke kompensere for et lille datasæt, der mangler de fleste funktioner, som modellen kræver for at lære.
• Når typen af ​​dataforøgelse er upassende: F.eks. er roterende billeder muligvis ikke nyttigt, hvor orienteringen af ​​objekterne er vigtig.

Hvad er TensorFlow i stand til

TensorFlow er et mangfoldigt og kraftfuldt bibliotek. Den er i stand til at træne komplekse deep learning-modeller og kan køre på en række enheder fra smartphones til klynger af servere. Det har hjulpet med at styrke computerenheder, der udnytter maskinlæring.