CNN-beeldclassificatie in TensorFlow met stappen en voorbeelden
Evelien Clarke
Wat is een convolutief neuraal netwerk?
Convolutief neuraal netwerk, ook bekend als convnets of CNN, is een bekende methode in computer vision-toepassingen. Het is een klasse van diepe neurale netwerken die worden gebruikt om visuele beelden te analyseren. Dit type architectuur is dominant om objecten te herkennen in een foto of video. Het wordt gebruikt in toepassingen zoals beeld- of videoherkenning, neurale taalverwerking, etc.
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 convnet-architectuur kan worden samengevat in de onderstaande afbeelding. Allereerst wordt een afbeelding naar het netwerk gepusht; dit wordt de invoerafbeelding genoemd. Vervolgens doorloopt de invoerafbeelding 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 bestaat uit een reeks pixels met hoogte en breedte. Een grijswaardenafbeelding heeft slechts één kanaal, terwijl de kleurenafbeelding drie kanalen heeft (elk voor rood, groen en blauw). Een kanaal wordt over elkaar heen gestapeld. In deze zelfstudie gebruikt u een grijswaardenafbeelding 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 vertonen, 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. Houd er rekening mee dat de oorspronkelijke matrix is gestandaardiseerd tussen 0 en 1. Voor donkerdere kleuren is de waarde in de matrix ongeveer 0.9, terwijl witte pixels een waarde van 0 hebben.
Convolutionele operatie
De meest kritische component in het model is de convolutionele laag. Dit deel heeft tot doel de grootte van de afbeelding te verkleinen voor snellere berekeningen van de gewichten en om de generalisatie ervan te verbeteren.
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 convolutioneel neuraal netwerk zal 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 kenmerken op elke laag te leren. De convolutie verdeelt de matrix in kleine stukken om de meest essentiële elementen binnen elk stuk te leren.
Componenten van convolutioneel neuraal netwerk (ConvNet of CNN)
Er zijn vier componenten van een Convnets
- kronkeling
- Niet-lineariteit (ReLU)
- Pooling of subsampling
- Classificatie (volledig verbonden laag)
kronkeling
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 het beeld leert en deze overal in het beeld kan herkennen.
Convolutie is een elementgewijze vermenigvuldiging. Het concept is eenvoudig te begrijpen. De computer scant een deel van de afbeelding, meestal met een dimensie van 3×3, en vermenigvuldigt dit met een filter. De uitvoer 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 vindt u een URL om in actie te zien hoe convolutie werkt.
Er zijn talloze kanalen beschikbaar. Hieronder hebben we een aantal kanalen op een rij gezet. Je kunt zien dat elk filter een specifiek doel heeft. Let op, op onderstaande afbeelding; de kernel is een synoniem van het filter.
Rekenkunde achter de convolutie
De convolutionele fase zal het filter toepassen op een kleine reeks pixels binnen de afbeelding. Het filter zal langs de invoerafbeelding bewegen met een algemene vorm van 3×3 of 5×5. Dit betekent dat het netwerk deze vensters over alle invoerafbeeldingen zal schuiven en de convolutie zal berekenen. De afbeelding hieronder 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 afbeeldingmatrix 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
Afbeelding heeft een 5×5-kenmerkenkaart en een 3×3-filter. Er is slechts één venster in het midden waar het filter een 3×3 raster kan afschermen. De uitvoerfunctiekaart wordt met twee tegels verkleind, naast een dimensie van 3×3.
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 centraal op elke invoertegel passen. In de onderstaande afbeelding heeft de invoer/uitvoermatrix dezelfde afmeting 5×5
Wanneer u het netwerk definieert, worden de geconvolueerde functies bepaald door drie parameters:
- Diepte: Het definieert het aantal filters dat moet worden toegepast tijdens de convolutie. In het vorige voorbeeld zag u 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
- stride: Het definieert het aantal "pixelsprongen" tussen twee slices. Als de stap gelijk is aan 1, zullen de vensters bewegen met een pixelspreiding van één. Als de stap gelijk is aan twee, zullen de vensters springen met 2 pixels. Als u de stap vergroot, zult u kleinere feature maps hebben.
Voorbeeld stap 1
pas 2
- Geen vulling: Een padding is een bewerking waarbij een overeenkomstig aantal rijen en kolommen aan elke kant van de invoerkenmerkenkaarten wordt toegevoegd. In dit geval heeft de uitvoer dezelfde dimensie als de invoer.
Niet-lineariteit (ReLU)
Aan het einde van de convolutiebewerking wordt de uitvoer onderworpen aan een activeringsfunctie om non-lineariteit toe te staan. De gebruikelijke activeringsfunctie voor convnet is de Relu. Alle pixels met een negatieve waarde worden vervangen door nul.
Pooling Operatie
Deze stap is eenvoudig te begrijpen. Het doel van de pooling is om de dimensionaliteit van de invoerafbeelding te verminderen. De stappen worden uitgevoerd om de computationele complexiteit van de bewerking te verminderen. Door de dimensionaliteit te verminderen, heeft het netwerk lagere gewichten om te berekenen, waardoor overfitting wordt voorkomen.
In deze fase moet u de grootte en de stap definiëren. Een standaardmanier om de invoerafbeelding te poolen, is door de maximumwaarde van de feature map te gebruiken. Kijk naar de onderstaande afbeelding. De "pooling" zal een vier submatrix van de 4×4 feature map screenen en de maximumwaarde retourneren. De pooling neemt de maximumwaarde van een 2×2 array en verplaatst deze vensters vervolgens met twee pixels. Bijvoorbeeld, de eerste submatrix is [3,1,3,2], de pooling zal het maximum retourneren, namelijk 3.
Er is nog een andere pooling-bewerking, zoals het gemiddelde.
Deze bewerking verkleint de grootte van de feature map agressief
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:
Het TensorFlow Convolutional Neural-netwerk verzamelt verschillende lagen voordat een voorspelling wordt gedaan. Een neuraal netwerk heeft:
- Een convolutionele laag
- Relu-activeringsfunctie
- Pooling-laag
- Dicht verbonden laag
De convolutionele lagen passen verschillende filters toe op een subregio van de afbeelding. De Relu-activeringsfunctie voegt non-lineariteit toe en de poolinglagen verminderen de dimensionaliteit van de feature maps.
Al deze lagen halen essentiële informatie uit de beelden. Ten slotte wordt de featureskaart naar een primaire, volledig verbonden laag met een softmax-functie gevoerd om een voorspelling te doen.
Train CNN met TensorFlow
Nu u bekend bent met de bouwsteen van een convnets, bent u klaar om er 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:
Stap 1: Gegevensset uploaden
Stap 2: Invoerlaag
Stap 3: Convolutionele laag
Stap 4: Pooling-laag
Stap 5: Tweede convolutionele laag en Pooling Laag
Stap 6: Dichte laag
Stap 7: Logit-laag
Stap 1: Gegevensset uploaden
De MNIST-dataset is beschikbaar met scikit om hiervan te leren URL. Download het en sla het op in Downloads. Je kunt het uploaden met fetch_mldata('MNIST original').
Maak een trein-/testset
U moet de gegevensset splitsen met train_test_split
Schaal de functies
Ten slotte kunt u de functie schalen met MinMaxScaler, zoals weergegeven in de onderstaande afbeeldingsclassificatie met behulp van het TensorFlow CNN-voorbeeld.
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 pixel van een afbeelding om details te leren, patronen te vergelijken met globale patronen met een traditioneel neuraal netwerk. Om een CNN te construeren, moet u het volgende definiëren:
- Een convolutionele laag: pas n aantal filters toe op de featurekaart. Na de convolutie moet u een Relu-activeringsfunctie gebruiken om niet-lineariteit aan het netwerk toe te voegen.
- 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 2×2-formaat) en alleen de maximumwaarden behoudt.
- 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 (extraheert subregio's van 5×5 pixels), 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 CNN te bouwen. Laten we in detail bekijken hoe we elke bouwsteen kunnen construeren voordat we alles samen in de functie 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 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 kanaal. De MNIST-dataset is een monochrone afbeelding met een formaat van 28×28. We hebben de batchgrootte in het vormargument ingesteld op -1, zodat deze de vorm aanneemt van de objecten [“x”]. Het voordeel is dat de hyperparameters van de batchgrootte kunnen worden afgestemd. Als de batchgrootte is ingesteld op 7, zal de tensor 5,488 waarden (28*28*7) invoeren.
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 met dezelfde opvulling. Dezelfde opvulling betekent dat zowel de uitvoertensor als de invoertensor dezelfde hoogte en breedte moeten hebben. Tensorflow voegt nullen toe aan de rijen en kolommen om dezelfde grootte te garanderen.
U maakt gebruik van de Relu-activeringsfunctie. Het uitvoerformaat is [28, 28, 14].
Stap 4: Pooling-laag
De volgende stap na de convolutie is de poolingberekening. De poolingberekening zal de dimensionaliteit van de data reduceren. U kunt de module max_pooling2d gebruiken met een grootte van 2×2 en een stride van 2. U 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 heeft 32 filters, met een uitvoergrootte van [batch_size, 14, 14, 32]. De poolinglaag 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 featurekaart moet worden afgevlakt voordat deze kan worden verbonden met de dichte laag. U kunt de module opnieuw vormgeven met een formaat van 7*7*36.
De dichte laag zal 1764 neuronen verbinden. Je voegt een Relu-activeringsfunctie toe. Bovendien voegt u een regularisatieterm voor uitval toe met een snelheid van 0.3, wat betekent dat 30 procent van de gewichten op 0 wordt gezet. Houd er rekening mee 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, zoals weergegeven in het onderstaande TensorFlow-voorbeeld van 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
Ten slotte kunt u in het voorbeeld van TensorFlow-beeldclassificatie de laatste laag definiëren met de voorspelling van het model. De uitvoervorm is gelijk aan de batchgrootte en 10 aan het totale aantal afbeeldingen.
# Logits Layer logits = tf.layers.dense(inputs=dropout, units=10)
U kunt een woordenboek maken met de klassen en de waarschijnlijkheid van elke klasse. De module tf.argmax() retourneert de hoogste waarde als de logit-lagen. 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") }
U wilt de woordenboekvoorspelling alleen retourneren als de modus is ingesteld op voorspelling. Deze codes voeg je toe om de voorspellingen weer te geven
if mode == tf.estimator.ModeKeys.PREDICT:
return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
De volgende stap bestaat uit het berekenen van het verlies van het model. In de vorige tutorial leerde u dat de verliesfunctie voor een multiclass-model cross entropy is. Het verlies wordt eenvoudig 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, dat wil zeggen het vinden van de beste waarden van de gewichten. Daarvoor gebruik je een Gradient descent optimizer met een leersnelheid 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 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 modulenauwkeurigheid 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 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)
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")
Een CNN heeft vele malen nodig om te trainen, daarom creëer je een Logging hook 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)
U bent klaar om het model te schatten. U stelt een batchgrootte van 100 in en schudt de gegevens. Houd er rekening mee dat we trainingsstappen van 16.000 hebben ingesteld, het kan veel tijd kosten om te trainen. 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 is getraind, 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)
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 krijgt u een nauwkeurigheid van 97%. U kunt de architectuur, de batchgrootte en het aantal iteraties wijzigen om de nauwkeurigheid te verbeteren. Het CNN-neurale netwerk heeft veel beter gepresteerd dan ANN of logistieke regressie. In de tutorial over kunstmatige neurale netwerken had u een nauwkeurigheid van 96%, wat lager is dan het CNN. De prestaties van het CNN zijn indrukwekkend met een grotere afbeelding reeks, zowel in termen van snelheidsberekening als nauwkeurigheid.
Samenvatting
Een convolutioneel neuraal netwerk werkt erg goed om een afbeelding te evalueren. Dit type architectuur is dominant om objecten te herkennen in een afbeelding of video.
Om een TensorFlow CNN te bouwen, moet je zeven stappen volgen:
Stap 1: Gegevensset uploaden:
De MNIST-dataset is beschikbaar met scikit om te leren. Download het en sla het op in Downloads. Je kunt het uploaden met fetch_mldata('MNIST original').
Stap 2: Invoerlaag:
Deze stap hervormt de data. De vorm is gelijk aan de vierkantswortel van het aantal pixels. Bijvoorbeeld, als een afbeelding 156 pixels heeft, dan is de vorm 26×26. U moet opgeven of de afbeelding kleur heeft of niet. Zo ja, dan had u 3 voor de vorm - 3 voor RGB -, anders 1.
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Stap 3: Convolutionele laag
Vervolgens moet u de convolutionele lagen maken. U past verschillende filters toe om het netwerk belangrijke functies 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 4: Pooling-laag
In de derde stap voegt u een poolinglaag toe. Deze laag verkleint de invoer. Dit doet het door de maximumwaarde van een 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 5: Convolutionele laag toevoegen en Pooling Laag
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 6: Dichte laag
Stap 6 maakt de vorige plat om volledig verbonden lagen te creëren. 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 7: Logit-laag
De laatste stap is de voorspelling.
logits = tf.layers.dense(inputs=dropout, units=10)
