Lisez le Tutoriel tensorflow 2.0. Je voudrais enquêter et compléter ce que je n'ai pas compris dans le tutoriel comme un mémorandum. Il peut donc être bon de le lire côte à côte avec le tutoriel.
J'utilisais le chainer jusqu'à présent Quand j'étais sur le point d'apprendre le tensorflow, le courant dominant était passé à 2.0 avant que je ne le sache. Je ne connais même pas le système tensorflow1, mais si je le fais maintenant, je pense qu'il est logique de commencer avec le 2ème système, alors j'ai commencé à lire le tutoriel tensorflow2.
windows10 Je l'ai fait dans l'environnement virtuel d'anaconda La construction de l'environnement est la suivante
#python3.Il semble qu'il ne prend en charge que jusqu'à 6, donc la version est 3.6
conda create -n tensorflow2.0 python=3.6 anaconda
conda install tensorflow==2.0.0
conda install jupyter
Tout d'abord, importez la bibliothèque TensorFlow dans votre programme.
from __future__ import absolute_import, division, print_function, unicode_literals
!pip install -q tensorflow-gpu==2.0.0-rc1
import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten, Conv2D
from tensorflow.keras import Model
Chargez et préparez le jeu de données MNIST.
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
#Valeur de pixel (0~255) à 0~Pousser en 1
x_train, x_test = x_train / 255.0, x_test / 255.0
# tf.Il semble que le nombre de dimensions peut être retiré avec un nouvel axe
#Ajouter des informations de numéro de dimension à chaque donnée (chaque image)
#CNN semble avoir besoin d'informations dimensionnelles. Cela peut être un processus qui ne devrait pas être fait à l'envers avec une jointure complète
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
Utilisez tf.data pour mélanger et regrouper les ensembles de données.
#10000 est la taille du tampon. Est-ce que 10 000 suffisent pour CNN? ??
#32 est la taille du lot.
train_ds = tf.data.Dataset.from_tensor_slices(
(x_train, y_train)).shuffle(10000).batch(32)
test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
Créez un modèle tf.keras à l'aide de l'API de sous-classification de modèle de Keras.
#Héritage de la classe Model
class MyModel(Model):
#Construire un modèle avec init
def __init__(self):
super(MyModel, self).__init__()
#32 types de filtres
#La taille du filtre est de 3*3
#La fonction d'activation est Relu
self.conv1 = Conv2D(32, 3, activation='relu')
#Données bidimensionnelles*Aplatir le nombre de données de filtres à une dimension
self.flatten = Flatten()
self.d1 = Dense(128, activation='relu')
#Puisqu'il s'agit d'une couche de sortie, la fonction d'activation est une fonction softmax
self.d2 = Dense(10, activation='softmax')
#X est-il le groupe d'images d'entrée? ??
# -> tf.Il semble que ce soit des données de type tensoriel.
def call(self, x):
x = self.conv1(x)
x = self.flatten(x)
x = self.d1(x)
#Crachez-vous le résultat calculé par NN? ??
return self.d2(x)
model = MyModel()
Choisissez un optimiseur et une fonction de perte pour l'entraînement.
#Erreur d'entropie croisée stable
loss_object = tf.keras.losses.SparseCategoricalCrossentropy()
#Selon la rumeur, ADAM est le meilleur maintenant (il y a longtemps?)
optimizer = tf.keras.optimizers.Adam()
Sélectionnez des métriques pour mesurer la perte et la précision du modèle. Ces métriques regroupent les valeurs pour chaque époque et produisent le résultat final.
#Instance qui fait la moyenne de la matrice
train_loss = tf.keras.metrics.Mean(name='train_loss')
#Instance qui donne le taux de réponse correct
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')
test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')
Entraînez votre modèle avec tf.GradientTape.
@tf.function
def train_step(image, label):
#Avec enregistrement des calculs internes. ruban.~~Je le sors
with tf.GradientTape() as tape:
#Prédiction basée sur l'image, calcul des pertes
predictions = model(image)
loss = loss_object(label, predictions)
# model.trainable_Passer des poids avec des variables
gradients = tape.gradient(loss, model.trainable_variables)
#Mettre à jour les poids avec l'optimiseur
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
#Calculer la perte et la précision avec l'instance précédente
train_loss(loss)
train_accuracy(label, predictions)
Référence: Introduction à TensorFlow 2.0 pour les utilisateurs d'API de bas niveau
À propos de @ tf.function
Il existe deux méthodes principales pour activer le NN.
Définir et exécuter: définissez le graphique de calcul, puis exécutez les données pour obtenir le résultat.
Define-by-run: Comme le code python normal, le graphe est exécuté en même temps que x + y et le résultat est obtenu (Source))
Il semble que tensorflow 2.0.0 utilise «par» parce que «par» est plus facile à écrire.
Cependant, «by» est très lent, donc l'ajout de «@ tf.function» semble activer la même opération que «et».
Pour plus de détails, reportez-vous à l'article de vérification (https://qiita.com/nj_ryoo0/items/7f4495aaef07ccc6a303)
Testez ensuite le modèle.
@tf.function
def test_step(image, label):
predictions = model(image)
t_loss = loss_object(label, predictions)
test_loss(t_loss)
test_accuracy(label, predictions)
EPOCHS = 5
for epoch in range(EPOCHS):
#Exécutez le train sur toutes les images pour chaque lot
for image, label in train_ds:
train_step(image, label)
#Exécutez des tests sur toutes les images pour chaque lot
for test_image, test_label in test_ds:
test_step(test_image, test_label)
#Différents affichages
template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}'
print (template.format(epoch+1,
train_loss.result(),
train_accuracy.result()*100,
test_loss.result(),
test_accuracy.result()*100))
résultat
WARNING:tensorflow:Layer my_model is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2. The layer has dtype float32 because it's dtype defaults to floatx.
If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.
To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.
Epoch 1, Loss: 0.14364087581634521, Accuracy: 95.62000274658203, Test Loss: 0.06367728859186172, Test Accuracy: 97.88999938964844
Epoch 2, Loss: 0.09373863786458969, Accuracy: 97.1483383178711, Test Loss: 0.056961096823215485, Test Accuracy: 98.07500457763672
Epoch 3, Loss: 0.07041392475366592, Accuracy: 97.84444427490234, Test Loss: 0.05455232039093971, Test Accuracy: 98.17666625976562
Epoch 4, Loss: 0.05662970244884491, Accuracy: 98.25749969482422, Test Loss: 0.05664524435997009, Test Accuracy: 98.19499969482422
Epoch 5, Loss: 0.047065384685993195, Accuracy: 98.54966735839844, Test Loss: 0.057572390884160995, Test Accuracy: 98.23799896240234
P.S. @```C'était pratique de s'inscrire dans le dictionnaire avec
Recommended Posts