CNN-beeldclassificatie in TensorFlow met stappen en voorbeelden

Wat is een convolutief neuraal netwerk?

Convolutief neuraal netwerkConvolutionele neurale netwerken (CNN's) zijn een bekende methode in computervisie-toepassingen. Ze vormen een klasse van diepe neurale netwerken die worden gebruikt om visuele beelden te analyseren. Dit type architectuur is dominant voor het herkennen van objecten in een foto of video. Het wordt gebruikt in toepassingen zoals beeld- en videorecognitie, natuurlijke taalverwerking en aanbevelingssystemen.

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 voor beeldclassificatie is niet zo moeilijk te begrijpen. Een invoerbeeld wordt verwerkt tijdens de convolutiefase en later voorzien van een label.

Een typische convolutionele neurale netwerkarchitectuur kan worden samengevat in de onderstaande afbeelding. Allereerst wordt een afbeelding naar het netwerk gestuurd; dit wordt de invoerafbeelding genoemd. Vervolgens doorloopt de invoerafbeelding een reeks stappen; dit is het convolutionele deel van het netwerk. Ten slotte kan het neurale netwerk het cijfer op de afbeelding voorspellen.

Een afbeelding bestaat uit een raster van pixels met hoogte en breedte. Een grijswaardenafbeelding heeft slechts één kanaal, terwijl een kleurenafbeelding er drie heeft (één voor rood, één voor groen en één voor blauw). De kanalen zijn boven elkaar gestapeld. In deze tutorial gebruiken we een grijswaardenafbeelding met slechts één kanaal. Elke pixel heeft een waarde van 0 tot 255 die de intensiteit van de kleur weergeeft. Een pixel met de waarde 0 zal bijvoorbeeld wit zijn, terwijl een pixel met een waarde dicht bij 255 donkerder zal zijn.

Laten we eens kijken naar een afbeelding die is opgeslagen in de MNIST-gegevenssetDe afbeelding hieronder laat zien hoe de afbeelding links in een matrixvorm kan worden weergegeven. Merk op dat de oorspronkelijke matrix is ​​gestandaardiseerd tot waarden tussen 0 en 1. Voor donkere kleuren is de waarde in de matrix ongeveer 0.9, terwijl witte pixels een waarde van 0 hebben.

Convolutionele operatie

Het meest cruciale onderdeel van het model is de convolutionele laag. Dit onderdeel is bedoeld om de grootte van de afbeelding te verkleinen, zodat de gewichten sneller berekend kunnen worden en de generalisatie verbetert.

Tijdens het convolutionele deel behoudt het netwerk de essentiële kenmerken van het beeld en sluit het irrelevante ruis uit. Het model leert bijvoorbeeld hoe je een olifant kunt herkennen op een foto met een berg op de achtergrond. Als je een traditioneel neuraal netwerk gebruikt, zal het model een gewicht toekennen aan alle pixels, inclusief die van de berg, wat niet essentieel is en het netwerk kan misleiden.

In plaats daarvan een Keras Een convolutioneel neuraal netwerk gebruikt een wiskundige techniek om...tracAlleen de meest relevante pixels worden geselecteerd. Deze wiskundige bewerking heet convolutie. Deze techniek stelt het netwerk in staat om in elke laag steeds complexere kenmerken te leren. De convolutie verdeelt de matrix in kleine stukjes om de meest essentiële elementen binnen elk stukje te leren.

Componenten van convolutioneel neuraal netwerk (ConvNet of CNN)

Een convolutioneel neuraal netwerk (convnet) bestaat uit vier onderdelen:

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

kronkeling

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

Convolutie is een elementgewijze vermenigvuldiging. Het concept is eenvoudig te begrijpen. De computer scant een deel van de afbeelding, meestal met een afmeting van 3x3, en vermenigvuldigt dit met een filter. Het resultaat van deze 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.

Het onderstaande diagram laat zien hoe een deel van de afbeelding door het filter wordt vermenigvuldigd om een ​​enkele cel van de feature map te produceren.

De onderstaande animatie laat zien hoe dezelfde convolutie over de hele afbeelding wordt toegepast.

Er zijn talloze filters beschikbaar. Hieronder hebben we er een aantal opgesomd. Zoals u kunt zien, heeft elk filter een specifiek doel. Merk op dat in de onderstaande afbeelding de kernel een synoniem is voor filter.

Rekenkunde achter de convolutie

De convolutiefase past het filter toe op een kleine reeks pixels binnen de afbeelding. Het filter beweegt zich over de invoerafbeelding met een algemene vorm van 3×3 of 5×5. Dit betekent dat het netwerk deze vensters over de gehele invoerafbeelding schuift en de convolutie berekent. De onderstaande animatie laat zien hoe de convolutie werkt. De grootte van de patch is 3×3 en de uitvoermatrix is ​​het resultaat van de elementgewijze bewerking tussen de afbeeldingsmatrix en het filter.

Je merkt dat de breedte en hoogte van de uitvoer kunnen verschillen van de breedte en hoogte van de invoer. Het gebeurt vanwege het grenseffect.

Grenseffect

De afbeelding heeft een 5×5-objectkaart en een 3×3-filter. Er is slechts één venster in het midden waar het filter een 3×3-raster kan afschermen. De resulterende objectkaart wordt op elke as met twee tegels verkleind, waardoor een afmeting van 3×3 overblijft.

Om dezelfde afmetingen voor de uitvoer te krijgen als voor de invoer, moet je opvulling (padding) toevoegen. Opvulling bestaat uit het toevoegen van het juiste aantal rijen en kolommen aan elke zijde van de matrix. Hierdoor kan de convolutie zich centreren rond elke invoertegel. In de onderstaande afbeelding hebben de invoer- en uitvoermatrices dezelfde afmetingen, namelijk 5×5.

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

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

Stap: Het definieert het aantal "pixelsprongen" tussen twee segmenten. Als de stapgrootte gelijk is aan 1, beweegt het venster met een spreiding van één pixel. Als de stapgrootte gelijk is aan 2, springt het venster met 2 pixels. Als je de stapgrootte vergroot, krijg je kleinere feature maps. De twee onderstaande diagrammen vergelijken een stapgrootte van 1 met een stapgrootte van 2.

Voorbeeld stap 1

pas 2

Nulvulling: Padding is een bewerking waarbij aan elke zijde van de invoer-featuremaps een overeenkomend aantal rijen en kolommen wordt toegevoegd. In dit geval heeft de uitvoer dezelfde dimensie als de invoer.

Niet-lineariteit (ReLU)

Aan het einde van de convolutieoperatie wordt de uitvoer onderworpen aan een activeringsfunctie om niet-lineariteit mogelijk te maken. De gebruikelijke activeringsfunctie voor een convolutioneel neuraal netwerk is ReLU. Alle pixels met een negatieve waarde worden vervangen door nul.

Pooling Operatie

Deze stap is eenvoudig te begrijpen. Het doel van pooling is het reduceren van de dimensionaliteit van de invoerafbeelding. De stappen worden uitgevoerd om de rekenkundige complexiteit van de bewerking te verminderen. Door de dimensionaliteit te verkleinen, hoeft het netwerk minder gewichten te berekenen, waardoor overfitting wordt voorkomen.

In deze fase moet je de grootte en de stapgrootte definiëren. Een standaardmethode voor pooling van de invoerafbeelding is het gebruik van de maximale waarde van de feature map. Kijk naar de onderstaande afbeelding. De pooling filtert vier submatrices van de 4×4 feature map en retourneert de maximale waarde. De pooling neemt de maximale waarde van een 2×2 array en verschuift dit venster vervolgens met twee pixels. Als de eerste submatrix bijvoorbeeld [3,1,3,2] is, retourneert de pooling het maximum, namelijk 3.

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

Deze bewerking verkleint de omvang van de feature map aanzienlijk.

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:

Een convolutioneel neuraal netwerk van TensorFlow compileert verschillende lagen voordat het een voorspelling doet. Een neuraal netwerk bestaat uit:

• Een convolutionele laag
• ReLU activeringsfunctie
• Pooling-laag
• Dicht verbonden laag

De convolutionele lagen passen verschillende filters toe op een deelgebied van de afbeelding. De ReLU-activeringsfunctie voegt niet-lineariteit toe en de poolinglagen reduceren de dimensionaliteit van de feature maps.

Al deze lagen extracDe essentiële informatie uit de afbeeldingen wordt eruit gehaald. Ten slotte worden de feature maps ingevoerd in een volledig verbonden laag met een softmax-functie om een ​​voorspelling te doen.

Train CNN met TensorFlow

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

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

Voor beeldclassificatie met CNN volgt u onderstaande stappen:

1. Stap 1: Gegevensset uploaden
2. Stap 2: Invoerlaag
3. Stap 3: Convolutionele laag
4. Stap 4: Pooling-laag
5. Stap 5: Tweede convolutionele laag en Pooling Laag
6. Stap 6: Dichte laag
7. Stap 7: Logit-laag

Versie-opmerking: De onderstaande codefragmenten zijn bedoeld voor TensorFlow 1.x. In TensorFlow 2 bestaan ​​de namespace tf.layers en tf.estimator.inputs.numpy_input_fn niet meer; de equivalenten zijn tf.keras.layers.Conv2D en Max.Pooling2D, Dense en Dropout zijn samengevoegd in een tf.keras.Model en getraind met model.fit(). Lees de stappen voor de werking van elke laag en vertaal deze vervolgens naar de Keras API.

Stap 1: Gegevensset uploaden

De MNIST-dataset is beschikbaar via scikit-learn. Download deze en sla hem op in je Downloads-map. Je kunt hem uploaden met fetch_mldata('MNIST original').

Versie-opmerking: mldata.org is gesloten en fetch_mldata() is verwijderd in scikit-learn 0.22. Laad op elke huidige installatie dezelfde cijfers met ophalen_openml In plaats daarvan wordt fetch_openml('mnist_784', version=1) gebruikt. De rest van de pipeline blijft ongewijzigd.

Maak een trein-/testset

Je moet de dataset splitsen met train_test_split.

Schaal de functies

Ten slotte kunt u de kenmerken schalen met MinMaxScaler, zoals getoond in het onderstaande voorbeeld van beeldclassificatie met behulp van een TensorFlow CNN.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_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 )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_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 ruwe pixels van een afbeelding om detailpatronen te leren, in tegenstelling tot de globale patronen die een traditioneel neuraal netwerk leert. Om een ​​CNN te bouwen, moet je het volgende definiëren:

1. Een convolutionele laag: Pas n filters toe op de feature map. Na de convolutie moet je 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 map. Het doel hiervan is om de dimensionaliteit van de feature map te verlagen om overfitting te voorkomen en de rekensnelheid te verbeteren. Max pooling is de gebruikelijke techniek, waarbij de feature maps worden verdeeld in subregio's (meestal van 2×2 grootte) en alleen de maximale waarden behouden blijven.
3. Volledig verbonden lagen: Alle neuronen van de vorige lagen zijn verbonden met de volgende lagen. Het CNN zal het label classificeren volgens de kenmerken van de convolutionele lagen en gereduceerd met de poolinglaag.

CNN-architectuur

• Convolutionele laag: Past 14 5×5 filters toe (bijv.tracting 5×5-pixel subregio's), met ReLU-activeringsfunctie
• Pooling Laag: Voert maximale pooling uit met een 2×2-filter en een stapgrootte van 2 (wat aangeeft dat gepoolde regio's elkaar niet overlappen)
• Convolutionele laag: past 36 5×5-filters toe, met ReLU-activeringsfunctie
• Pooling Laag #2: Voert opnieuw maximale pooling uit met een 2×2-filter en een stap van 2
• 1,764 neuronen, met een uitvalregularisatiepercentage van 0.4 (waarschijnlijkheid van 0.4 dat een bepaald element tijdens de training zal vallen)
• Dichte laag (Logits-laag): 10 neuronen, één voor elke cijferdoelklasse (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, de filterkernelgrootte, de opvulling en de activeringsfunctie als argumenten.
• max_pooling2d(). Construeert een tweedimensionale poolinglaag met behulp van het max-pooling-algoritme.
• gespannen(). Construeert een dichte laag met de verborgen lagen en eenheden

Je definieert een functie om het CNN te bouwen. Laten we eens in detail bekijken hoe we elk bouwblok construeren voordat we verdergaan.ping alles samen in de functie.

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 kunt u de module tf.reshape gebruiken. In deze module moet u aangeven dat de tensor opnieuw moet worden vormgegeven en dat de vorm van de tensor moet worden gewijzigd. Het eerste argument zijn de kenmerken van de gegevens, die zijn gedefinieerd in het argument van de functie.

Een afbeelding heeft een hoogte, een breedte en een aantal kanalen. De MNIST-dataset bestaat uit monochrome afbeeldingen van 28×28 pixels. We stellen de batchgrootte in het shape-argument in op -1, zodat deze de vorm van de features["x"] aanneemt. Het voordeel hiervan is dat de batchgrootte een hyperparameter wordt die we kunnen afstemmen. Als de batchgrootte bijvoorbeeld op 7 wordt ingesteld, zal de tensor 5,488 waarden verwerken (28*28*7).

Stap 3: Convolutionele laag

# first Convolutional Layer
  conv1 = 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 kernelgrootte van 5×5 en gelijke padding. Gelijke padding betekent dat zowel de uitvoertensor als de invoertensor dezelfde hoogte en breedte moeten hebben. TensorFlow voegt nullen toe aan de rijen en kolommen om ervoor te zorgen dat ze dezelfde afmetingen hebben.

Je gebruikt de ReLU-activeringsfunctie. De uitvoergrootte zal [28, 28, 14] zijn.

Stap 4: Pooling-laag

De volgende stap na de convolutie is de poolingberekening. De poolingberekening reduceert de dimensionaliteit van de data. Je kunt de module max_pooling2d gebruiken met een grootte van 2×2 en een stapgrootte van 2. Je gebruikt de vorige laag als invoer. De uitvoergrootte zal [batch_size, 14, 14, 14] zijn.

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

Stap 5: Tweede convolutionele laag en Pooling Laag

De tweede convolutionele laag past 36 filters toe, wat resulteert in een uitvoergrootte van [batch_size, 14, 14, 36]. De poolinglaag gebruikt hetzelfde 2×2 venster en dezelfde stapgrootte van 2 als voorheen, waardoor elke ruimtelijke as wordt gehalveerd en de uitvoervorm [batch_size, 7, 7, 36] wordt.

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 je de volledig verbonden laag definiëren. De feature map moet worden afgevlakt voordat deze met de dense laag wordt verbonden. Je kunt hiervoor de module 'reshape' gebruiken met een afmeting van 7*7*36.

De dense laag verbindt 1,764 neuronen. Je voegt een ReLU-activeringsfunctie toe. Daarnaast voeg je een dropout-regularisatieterm toe met een waarde van 0.3, wat betekent dat 30 procent van de activaties op 0 wordt gezet. Merk op dat de dropout alleen plaatsvindt tijdens de trainingsfase. De functie `cnn_model_fn` heeft een argument `mode` om aan te geven of het model getraind of geëvalueerd moet worden, zoals te zien is in het onderstaande TensorFlow-voorbeeld voor CNN-beeldclassificatie.

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

Tot slot kunt u in het TensorFlow-voorbeeld voor beeldclassificatie de laatste laag definiëren met de voorspelling van het model. De uitvoervorm is gelijk aan de batchgrootte plus 10, het totale aantal doelklassen.

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

Je kunt een dictionary maken met de klassen en de waarschijnlijkheid van elke klasse. De functie tf.argmax() retourneert de index van de hoogste waarde in de logits-laag. De softmax-functie retourneert de waarschijnlijkheid van elke klasse.

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

Je wilt het voorspellingswoordenboek alleen retourneren wanneer de modus is ingesteld op 'prediction'. Je voegt deze code 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 het berekenen van het verlies van het model. In de vorige tutorial heb je geleerd dat de verliesfunctie voor een multiclass-model kruisentropie is. Het verlies kan eenvoudig worden berekend 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 van het TensorFlow CNN-voorbeeld is het optimaliseren van het model, oftewel het vinden van de beste waarden voor de gewichten. Hiervoor gebruik je een gradient descent optimizer met een leerfrequentie van 0.001. Het doel is om het verlies te minimaliseren.

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 het CNN. Je wilt echter de prestatiestatistieken weergeven tijdens de evaluatiemodus. De prestatiestatistiek voor een multiclass-model is nauwkeurigheid. TensorFlow is uitgerust met een nauwkeurigheidsmodule die twee argumenten accepteert: 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 Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

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

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

  # Convolutional Layer #2 and Pooling Layer
  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)

  # Dense Layer
  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.4, training=mode == tf.estimator.ModeKeys.TRAIN)

  # Logits Layer
  logits = 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 Loss
  loss = 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 mode
  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)

Opmerking over de samengestelde functie: De bovenstaande, ingekapselde versie stelt de eerste convolutionele laag in op 32 filters en dropout op 0.4, terwijl de stapsgewijze codefragmenten 14 filters en 0.3 gebruiken. Beide werken, maar kies één paar waarden en houd dit consistent, zodat de afgedrukte vormen overeenkomen met de laagtabel.

De onderstaande stappen zijn hetzelfde als de vorige tutorials.

Allereerst definieer je een schatter met het CNN-model voor beeldclassificatie.

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

Het trainen van een CNN duurt lang, daarom maak je een logging hook aan om de waarden van de softmax-lagen elke 50 iteraties op te slaan.

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

Je bent klaar om het model te schatten. Je stelt een batchgrootte van 100 in en schudt de gegevens. Houd er rekening mee dat we 16,000 trainingsstappen hebben ingesteld, wat veel tijd in beslag kan nemen. Wees geduldig.

# Train the model
train_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 getraind is, kunt u het evalueren en de resultaten afdrukken.

# Evaluate the model and print results
eval_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)

De evaluatie print het herstelde checkpoint, de stap waar het is gestopt en het uiteindelijke woordenboek met meetwaarden.

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO: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 rapporteert het evaluatiewoordenboek een nauwkeurigheid van 0.9689286, oftewel ongeveer 97%. U kunt de architectuur, de batchgrootte en het aantal iteraties aanpassen om de nauwkeurigheid te verbeteren. Het CNN heeft aanzienlijk beter gepresteerd dan een kunstmatig neuraal netwerk Of logistische regressie: in de tutorial over kunstmatige neurale netwerken behaalde je een nauwkeurigheid van 96%, wat lager is dan die van het CNN. De prestaties van het CNN zijn indrukwekkend met een grotere dataset, zowel qua rekensnelheid als nauwkeurigheid.

Veelgestelde vragen