TensorFlow-beeldclassificatie: CNN (convolutioneel neuraal netwerk)

Inhoudsopgave:

Anonim

Wat is een convolutioneel neuraal netwerk?

Convolutioneel neuraal netwerk, ook bekend als convnets of CNN, is een bekende methode in computer vision-toepassingen. Dit type architectuur is dominant om objecten uit een foto of video te herkennen.

In deze tutorial leer je hoe je een convnet construeert en hoe je TensorFlow gebruikt om de handgeschreven dataset op te lossen.

In deze tutorial leer je

  • Convolutioneel neuraal netwerk
  • Architectuur van een convolutioneel neuraal netwerk
  • Onderdelen van Convnets
  • Train CNN met TensorFlow
  • Stap 1: upload gegevensset
  • Stap 2: Invoerlaag
  • Stap 3: Convolutionele laag
  • Stap 4: Pooling-laag
  • Stap 5: Tweede convolutionele laag en poollaag
  • Stap 6: Dichte laag
  • Stap 7: Logit-laag

Architectuur van een convolutioneel neuraal netwerk

Denk aan Facebook een paar jaar geleden, nadat je een foto naar je profiel had geüpload, werd je gevraagd om handmatig een naam aan het gezicht op de foto toe te voegen. Tegenwoordig gebruikt Facebook convnet om je vriend automatisch op de foto te taggen.

Een convolutioneel neuraal netwerk is niet erg moeilijk te begrijpen. Een invoerbeeld wordt verwerkt tijdens de convolutiefase en later een label toegekend.

Een typische convnet-architectuur kan in de onderstaande afbeelding worden samengevat. Allereerst wordt een afbeelding naar het netwerk gepusht; dit wordt het invoerbeeld genoemd. Vervolgens doorloopt het invoerbeeld een oneindig aantal stappen; dit is het convolutionele deel van het netwerk. Ten slotte kan het neurale netwerk het cijfer op de afbeelding voorspellen.

Een afbeelding is samengesteld uit een reeks pixels met hoogte en breedte. Een afbeelding in grijstinten heeft slechts één kanaal, terwijl de afbeelding in kleur drie kanalen heeft (elk voor Rood, Groen en Blauw). Een kanaal wordt over elkaar gestapeld. In deze zelfstudie gebruikt u een afbeelding in grijstinten met slechts één kanaal. Elke pixel heeft een waarde van 0 tot 255 om de intensiteit van de kleur weer te geven. Een pixel gelijk aan 0 zal bijvoorbeeld een witte kleur hebben, terwijl een pixel met een waarde dichtbij 255 donkerder zal zijn.

Laten we eens kijken naar een afbeelding die is opgeslagen in de MNIST-gegevensset. De onderstaande afbeelding laat zien hoe u de afbeelding van links in een matrixformaat kunt weergeven. Merk op dat de originele matrix gestandaardiseerd is om tussen 0 en 1 te liggen. Voor donkere kleuren is de waarde in de matrix ongeveer 0,9, terwijl witte pixels de waarde 0 hebben.

Convolutionele werking

De meest kritische component in het model is de convolutionele laag. Dit deel is bedoeld om de grootte van de afbeelding te verkleinen voor snellere berekeningen van de gewichten en om de generalisatie ervan te verbeteren.

Tijdens het convolutionele gedeelte behoudt het netwerk de essentiële kenmerken van het beeld en sluit het irrelevante ruis uit. Zo leert het model een olifant te herkennen van een foto met een berg op de achtergrond. Als u een traditioneel neuraal netwerk gebruikt, kent het model een gewicht toe aan alle pixels, inclusief die van de berg, wat niet essentieel is en het netwerk kan misleiden.

In plaats daarvan zal een convolutioneel neuraal netwerk een wiskundige techniek gebruiken om alleen de meest relevante pixels te extraheren. Deze wiskundige bewerking wordt convolutie genoemd. Deze techniek stelt het netwerk in staat om steeds complexere functies op elke laag te leren. De convolutie verdeelt de matrix in kleine stukjes om de meest essentiële elementen binnen elk stuk te leren.

Onderdelen van Convnets

Er zijn vier componenten van een Convnets

  1. Convolutie
  2. Niet-lineariteit (ReLU)
  3. Pooling of subsampling
  4. Classificatie (volledig verbonden laag)
  • Convolutie

Het doel van de convolutie is om de kenmerken van het object lokaal op de afbeelding te extraheren. Het betekent dat het netwerk specifieke patronen in de afbeelding leert en deze overal op de afbeelding kan herkennen.

Convolutie is een elementgewijze vermenigvuldiging. Het concept is gemakkelijk te begrijpen. De computer scant een deel van de afbeelding, meestal met een afmeting van 3x3, en vermenigvuldigt dit tot een filter. De output van de elementgewijze vermenigvuldiging wordt een feature map genoemd. Deze stap wordt herhaald totdat de hele afbeelding is gescand. Merk op dat, na de convolutie, de grootte van de afbeelding wordt verkleind.

Hieronder is er een URL om in actie te zien hoe convolutie werkt.

Er zijn tal van kanalen beschikbaar. Hieronder hebben we een aantal kanalen op een rijtje gezet. U kunt zien dat elk filter een specifiek doel heeft. Let op, in de onderstaande afbeelding; de kernel is een synoniem van het filter.

Bron

Rekenen achter de convolutie

De convolutionele fase past het filter toe op een kleine reeks pixels in de afbeelding. Het filter beweegt langs het invoerbeeld met een algemene vorm van 3x3 of 5x5. Het betekent dat het netwerk deze vensters over het hele invoerbeeld schuift en de convolutie berekent. De onderstaande afbeelding laat zien hoe de convolutie werkt. De grootte van de patch is 3x3 en de outputmatrix is ​​het resultaat van de elementaire bewerking tussen de beeldmatrix en het filter.

Bron

Je merkt dat de breedte en hoogte van de output kan verschillen van de breedte en hoogte van de input. Het gebeurt vanwege het randeffect.

Grens effect

Afbeelding heeft een 5x5 features map en een 3x3 filter. Er is maar één venster in het midden waar het filter een 3x3 rooster kan afschermen. De output feature map krimpt twee tegels naast met een 3x3 dimensie.

Om dezelfde uitvoerdimensie te krijgen als de invoerdimensie, moet u opvulling toevoegen. Opvulling bestaat uit het toevoegen van het juiste aantal rijen en kolommen aan elke kant van de matrix. Hierdoor kan de convolutie in het midden van elke invoertegel passen. In de onderstaande afbeelding heeft de input / output-matrix dezelfde afmeting 5x5

Wanneer u het netwerk definieert, worden de geconvolueerde functies bestuurd door drie parameters:

  1. Diepte: het definieert het aantal filters dat tijdens de convolutie moet worden toegepast. In het vorige voorbeeld zag je een diepte van 1, wat betekent dat er maar één filter wordt gebruikt. In de meeste gevallen is er meer dan één filter. De onderstaande afbeelding toont de bewerkingen die worden uitgevoerd in een situatie met drie filters

  1. Pas: het definieert het aantal "pixelsprongen" tussen twee segmenten. Als de pas gelijk is aan 1, bewegen de vensters met een pixelafstand van één. Als de pas gelijk is aan twee, verspringen de vensters met 2 pixels. Als u de pas vergroot, heeft u kleinere functiekaarten.

Voorbeeld stap 1

Afbeelding stap 2

  1. Nul-opvulling: Een opvulling is een bewerking waarbij een overeenkomstig aantal rijen en kolommen aan elke kant van de invoertoepassingen wordt toegevoegd. In dit geval heeft de output dezelfde dimensie als de input.
  2. Niet-lineariteit (ReLU)

Aan het einde van de convolutiebewerking wordt de uitgang onderworpen aan een activeringsfunctie om niet-lineariteit mogelijk te maken. De gebruikelijke activeringsfunctie voor convnet is de Relu. Alle pixels met een negatieve waarde worden vervangen door nul.

  • Max-pooling operatie

Deze stap is gemakkelijk te begrijpen. Het doel van de pooling is om de dimensionaliteit van het invoerbeeld te verminderen. De stappen worden uitgevoerd om de rekenkundige complexiteit van de bewerking te verminderen. Door de dimensionaliteit te verminderen, heeft het netwerk lagere gewichten om te berekenen, zodat overfitting wordt voorkomen.

In deze fase moet u de grootte en de pas definiëren. Een standaardmanier om de invoerafbeelding te poolen, is door de maximale waarde van de functiekaart te gebruiken. Kijk naar de afbeelding hieronder. De "pooling" zal een vier submatrix van de 4x4 feature map screenen en de maximale waarde retourneren. De pooling neemt de maximale waarde van een 2x2-array en verplaatst dit venster vervolgens met twee pixels. De eerste submatrix is ​​bijvoorbeeld [3,1,3,2], de pooling levert het maximum op, namelijk 3.

Er is nog een andere pooling-operatie, zoals het gemiddelde.

Deze bewerking verkleint op agressieve wijze de grootte van de feature map

  • Volledig verbonden lagen

De laatste stap bestaat uit het bouwen van een traditioneel kunstmatig neuraal netwerk zoals je deed in de vorige tutorial. Je verbindt alle neuronen van de vorige laag met de volgende laag. U gebruikt een softmax-activeringsfunctie om het nummer op de invoerafbeelding te classificeren.

Samenvatting:

Convolutioneel neuraal netwerk compileert verschillende lagen voordat een voorspelling wordt gedaan. Een neuraal netwerk heeft:

  • Een convolutionele laag
  • Relu Activation-functie
  • Pooling-laag
  • Dicht verbonden laag

De convolutionele lagen passen verschillende filters toe op een subregio van de afbeelding. De Relu-activeringsfunctie voegt niet-lineariteit toe, en de poolinglagen verminderen de dimensionaliteit van de features maps.

Al deze lagen halen essentiële informatie uit de afbeeldingen. Eindelijk worden de features map doorgevoerd naar een primaire, volledig verbonden laag met een softmax-functie om een ​​voorspelling te doen.

Train CNN met TensorFlow

Nu je bekend bent met de bouwsteen van een convnets, ben je klaar om er een te bouwen met TensorFlow. We zullen de MNIST-dataset gebruiken voor beeldclassificatie.

De datavoorbereiding is hetzelfde als de vorige tutorial. U kunt de codes uitvoeren en rechtstreeks naar de architectuur van de CNN springen.

U volgt de onderstaande stappen:

Stap 1: upload gegevensset

Stap 2: Invoerlaag

Stap 3: Convolutionele laag

Stap 4: Pooling-laag

Stap 5: Tweede convolutionele laag en poollaag

Stap 6: Dichte laag

Stap 7: Logit-laag

Stap 1: upload gegevensset

De MNIST-gegevensset is beschikbaar bij scikit om te leren op deze URL. Download het en sla het op in Downloads. Je kunt het uploaden met fetch_mldata ('MNIST origineel').

Maak een trein- / testset

U moet de dataset splitsen met train_test_split

Schaal de functies

Ten slotte kunt u de functie schalen met MinMaxScaler

import numpy as npimport tensorflow as tffrom sklearn.datasets import fetch_mldata#Change USERNAME by the username of your machine## Windows USERmnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')## Mac Usermnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')print(mnist.data.shape)print(mnist.target.shape)from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)y_train = y_train.astype(int)y_test = y_test.astype(int)batch_size =len(X_train)print(X_train.shape, y_train.shape,y_test.shape )## resclaefrom sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()# TrainX_train_scaled = scaler.fit_transform(X_train.astype(np.float64))# testX_test_scaled = scaler.fit_transform(X_test.astype(np.float64))feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]X_train_scaled.shape[1:]

Definieer de CNN

Een CNN gebruikt filters op de onbewerkte pixel van een afbeelding om het patroon van details te vergelijken met het globale patroon met een traditioneel neuraal netwerk. Om een ​​CNN te maken, moet u het volgende definiëren:

  1. Een convolutionele laag: pas n aantal filters toe op de objectkaart. Na de convolutie moet u een Relu-activeringsfunctie gebruiken om niet-lineariteit aan het netwerk toe te voegen.
  2. Pooling-laag: de volgende stap na de convolutie is het downsamplen van de feature max. Het doel is om de dimensionaliteit van de feature map te verminderen om overfitting te voorkomen en de rekensnelheid te verbeteren. Max pooling is de conventionele techniek, die de feature maps verdeelt in subregio's (meestal met een 2x2-formaat) en alleen de maximale waarden behoudt.
  3. Volledig verbonden lagen: alle neuronen uit de vorige lagen zijn verbonden met de volgende lagen. De CNN classificeert het label volgens de kenmerken van de convolutionele lagen en verminderd met de pooling-laag.

CNN-architectuur

  • Convolutionele laag: past 14 5x5-filters toe (extraheren van 5x5-pixel subregio's), met ReLU-activeringsfunctie
  • Pooling Layer: voert max pooling uit met een 2x2 filter en stride van 2 (wat aangeeft dat gepoolde regio's elkaar niet overlappen)
  • Convolutionele laag: past 36 5x5-filters toe, met ReLU-activeringsfunctie
  • Pooling Layer # 2: Nogmaals, voert max pooling uit met een 2x2 filter en stride van 2
  • 1.764 neuronen, met een uitval-regularisatiesnelheid van 0,4 (kans van 0,4 dat een bepaald element tijdens de training zal vallen)
  • Dichte laag (Logits-laag): 10 neuronen, één voor elke cijfer-doelklasse (0-9).

Er zijn drie belangrijke modules die u kunt gebruiken om een ​​CNN te maken:

  • conv2d (). Construeert een tweedimensionale convolutionele laag met het aantal filters, filterkernelgrootte, opvulling en activeringsfunctie als argumenten.
  • max_pooling2d (). Construeert een tweedimensionale pooling-laag met behulp van het max-pooling-algoritme.
  • dicht(). Construeert een dichte laag met de verborgen lagen en eenheden

U definieert een functie om de CNN te bouwen. Laten we eerst in detail bekijken hoe we elk bouwblok kunnen construeren om alles samen in de functie te verpakken.

Stap 2: Invoerlaag

def cnn_model_fn(features, labels, mode):input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

U moet een tensor definiëren met de vorm van de gegevens. Daarvoor kun je de module tf.reshape gebruiken. In deze module moet je aangeven dat de tensor een nieuwe vorm moet krijgen en de vorm van de tensor. Het eerste argument zijn de kenmerken van de gegevens, die worden gedefinieerd in het argument van de functie.

Een foto heeft een hoogte, een breedte en een kanaal. De MNIST-dataset is een monochroom beeld met een afmeting van 28x28. We stellen de batchgrootte in op -1 in het vormargument zodat het de vorm aanneemt van de features ["x"]. Het voordeel is om de hyperparameters van de batchgrootte af te stemmen. Als de batchgrootte is ingesteld op 7, zal de tensor 5.488 waarden (28 * 28 * 7) invoeren.

Step 3: Convolutional layer
# first Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)

De eerste convolutionele laag heeft 14 filters met een korrelgrootte van 5x5 met dezelfde opvulling. Dezelfde opvulling betekent dat zowel de uitgangstensor als de ingangstensor dezelfde hoogte en breedte moeten hebben. Tensorflow voegt nullen toe aan de rijen en kolommen om dezelfde grootte te garanderen.

Je gebruikt de Relu-activeringsfunctie. Het uitvoergrootte is [28, 28, 14].

Stap 4: Pooling-laag

De volgende stap na de convolutie is de pooling-berekening. De pooling-berekening zal de dimensionaliteit van de gegevens verminderen. Je kunt de module max_pooling2d gebruiken met een grootte van 2x2 en stride van 2. Je gebruikt de vorige laag als invoer. De uitvoergrootte is [batch_size, 14, 14, 14]

# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Stap 5: Tweede convolutionele laag en poollaag

De tweede convolutionele laag heeft 32 filters, met een uitvoergrootte van [batch_size, 14, 14, 32]. De pooling-laag heeft dezelfde grootte als hiervoor en de uitvoervorm is [batch_size, 14, 14, 18].

conv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

Stap 6: Dichte laag

Vervolgens moet u de volledig verbonden laag definiëren. De objectkaart moet worden afgevlakt voordat deze wordt verbonden met de dichte laag. U kunt de module opnieuw vormgeven met een afmeting van 7 * 7 * 36.

De dichte laag zal 1764 neuronen verbinden. Je voegt een Relu-activeringsfunctie toe. Bovendien voegt u een uitval-regularisatieterm toe met een snelheid van 0,3, wat betekent dat 30 procent van de gewichten op 0 worden gezet. Merk op dat de uitval alleen plaatsvindt tijdens de trainingsfase. De functie cnn_model_fn heeft een argumentmodus om aan te geven of het model moet worden getraind of geëvalueerd.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Stap 7: Logit-laag

Ten slotte kunt u de laatste laag definiëren met de voorspelling van het model. De uitvoervorm is gelijk aan de batchgrootte en 10, het totale aantal afbeeldingen.

# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)

U kunt een woordenboek maken met de klassen en de waarschijnlijkheid van elke klas. De module tf.argmax () met retourneert de hoogste waarde als de logit-lagen. De functie softmax retourneert de waarschijnlijkheid van elke klasse.

predictions = {# Generate predictions"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor") }

U wilt alleen de woordenboekvoorspelling retourneren als de modus is ingesteld op voorspelling. U voegt deze codes toe om de voorspellingen weer te geven

if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

De volgende stap is om het verlies van het model te berekenen. In de laatste zelfstudie hebt u geleerd dat de verliesfunctie voor een model met meerdere klassen cross-entropie is. Het verlies is eenvoudig te berekenen met de volgende code:

# Calculate Loss (for both TRAIN and EVAL modes)loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

De laatste stap is het optimaliseren van het model, dat wil zeggen het vinden van de beste waarden van de gewichten. Daarvoor gebruik je een Gradient Descent Optimizer met een leertempo van 0,001. Het doel is om het verlies tot een minimum te beperken

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())

Je bent klaar met de CNN. U wilt echter de prestatiestatistieken weergeven tijdens de evaluatiemodus. De prestatiestatistieken voor een model met meerdere klassen zijn de nauwkeurigheidsstatistieken. Tensorflow is uitgerust met een module-nauwkeurigheid met twee argumenten, de labels en de voorspelde waarden.

eval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Dat is het. Je hebt je eerste CNN gemaakt en je bent klaar om alles in een functie te verpakken om deze te gebruiken om het model te trainen en te evalueren.

def cnn_model_fn(features, labels, mode):"""Model function for CNN."""# Input Layerinput_layer = tf.reshape(features["x"], [-1, 28, 28, 1])# Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=32,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)# Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)# Convolutional Layer #2 and Pooling Layerconv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)# Dense Layerpool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)predictions = {# Generate predictions (for PREDICT and EVAL mode)"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor")}if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)# Calculate Lossloss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)# Configure the Training Op (for TRAIN mode)if mode == tf.estimator.ModeKeys.TRAIN:optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)# Add evaluation metrics Evaluation modeeval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

De onderstaande stappen zijn hetzelfde als de vorige tutorials.

Allereerst definieer je een schatter met het CNN-model.

# Create the Estimatormnist_classifier = tf.estimator.Estimator(model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")

Een CNN duurt vaak om te trainen, daarom maakt u een logging hook om de waarden van de softmax-lagen elke 50 iteraties op te slaan.

# Set up logging for predictionstensors_to_log = {"probabilities": "softmax_tensor"}logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

U bent klaar om het model te schatten. U stelt een batchgrootte van 100 in en schudt de gegevens. Merk op dat we trainingsstappen van 16.000 hebben ingesteld, het kan veel tijd kosten om te trainen. Wees geduldig.

# Train the modeltrain_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_train_scaled},y=y_train,batch_size=100,num_epochs=None,shuffle=True)mnist_classifier.train(input_fn=train_input_fn,steps=16000,hooks=[logging_hook])

Nu het model is getraind, kunt u het evalueren en de resultaten afdrukken

# Evaluate the model and print resultseval_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_test_scaled},y=y_test,num_epochs=1,shuffle=False)eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)print(eval_results)
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}

Met de huidige architectuur haal je een nauwkeurigheid van 97%. U kunt de architectuur, de batchgrootte en het aantal iteraties wijzigen om de nauwkeurigheid te verbeteren. Het neurale netwerk van CNN heeft veel beter gepresteerd dan ANN of logistische regressie. In de tutorial over kunstmatig neuraal netwerk had je een nauwkeurigheid van 96%, wat lager is dan de CNN. De prestaties van de CNN zijn indrukwekkend met een grotere beeldset , zowel wat betreft snelheidsberekening als nauwkeurigheid.

Overzicht

Een convolutioneel neuraal netwerk werkt heel goed om het beeld te evalueren. Dit type architectuur is dominant om objecten uit een foto of video te herkennen.

Om een ​​CNN te bouwen, moet u zes stappen volgen:

Stap 1: Invoerlaag:

Deze stap geeft de gegevens een nieuwe vorm. De vorm is gelijk aan de vierkantswortel van het aantal pixels. Als een afbeelding bijvoorbeeld 156 pixels heeft, is de vorm 26x26. U moet aangeven of de afbeelding al dan niet in kleur is. Zo ja, dan had je 3 aan de vorm- 3 voor RGB-, anders 1.

input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Stap 2: Convolutionele laag

Vervolgens moet u de convolutionele lagen maken. U past verschillende filters toe om het netwerk een belangrijke functie te laten leren. U specificeert de grootte van de kernel en het aantal filters.

conv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)

Stap 3: Pooling-laag

In de derde stap voegt u een poollaag toe. Deze laag verkleint de grootte van de invoer. Het doet dit door de maximale waarde van de a-submatrix te nemen. Als de submatrix bijvoorbeeld [3,1,3,2] is, retourneert de pooling het maximum, namelijk 3.

pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Stap 4: voeg convolutionele laag en poollaag toe

In deze stap kunt u zoveel conv-lagen en pooling-lagen toevoegen als u wilt. Google gebruikt architectuur met meer dan 20 conv-lagen.

Stap 5: Dichte laag

Stap 5 maakt de vorige plat om volledig verbonden lagen te maken. In deze stap kunt u verschillende activeringsfuncties gebruiken en een uitvaleffect toevoegen.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Stap 6: Logit-laag

De laatste stap is de voorspelling.

logits = tf.layers.dense(inputs=dropout, units=10)