Les débutants lisent "Introduction à TensorFlow 2.0 pour les experts"

Que faire: point_up:

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.

Contexte

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.

environnement

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

Commentaire

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

Les débutants lisent "Introduction à TensorFlow 2.0 pour les experts"
[Explication pour les débutants] Introduction au traitement du pliage (expliqué dans TensorFlow)
Mémo n ° 4 que les débutants Python lisent "Explication détaillée de la grammaire Python"
Une introduction à la programmation orientée objet pour les débutants par les débutants
Mémo n ° 3 que les débutants Python lisent "Explication détaillée de la grammaire Python"
Mémo n ° 1 que les débutants Python lisent "Explication détaillée de la grammaire Python"
Mémo n ° 2 que les débutants Python lisent "Explication détaillée de la grammaire Python"
Mémo n ° 7 que les débutants Python lisent "Explication détaillée de la grammaire Python"
Introduction à la programmation (Python) TA Tendency pour les débutants
Mémo n ° 6 pour les débutants Python à lire "Explication détaillée de la grammaire Python"
Mémo n ° 5 que les débutants Python lisent "Explication détaillée de la grammaire Python"
[Pour les débutants] Introduction à la vectorisation dans l'apprentissage automatique
~ Conseils pour les débutants de Python présentés avec amour par Pythonista ③ ~
Introduction à Python pour, pendant
Méthode d'apprentissage TensorFlow pour les professionnels des arts libéraux et les débutants en Python
[Python] Introduction à la création de graphiques à l'aide de données de virus corona [Pour les débutants]
Traduction TensorFlow MNIST pour les débutants en ML
Premiers pas avec Python pour les non-ingénieurs
Tutoriel TensorFlow -MNIST pour les débutants en ML
TensorFlow Deep MNIST pour la traduction d'experts
[Explication pour les débutants] Tutoriel TensorFlow Deep MNIST
Une introduction à OpenCV pour l'apprentissage automatique
Probablement l'introduction la plus simple à TensorFlow
Introduction à discord.py (1er jour) -Préparation pour discord.py-
Notes supplémentaires pour TensorFlow MNIST pour les débutants en ML
[Python] Lire des images avec OpenCV (pour les débutants)
Une introduction à Python pour l'apprentissage automatique
Une introduction à Python pour les programmeurs en langage C
[Pour les débutants] Super introduction aux réseaux de neurones que même les chats peuvent comprendre
Introduction à la base de données Graph Neo4j en Python pour les débutants (pour Mac OS X)
Introduction au Deep Learning (1) --Chainer est expliqué d'une manière facile à comprendre pour les débutants-
Introduction à MQTT (Introduction)
Introduction à Scrapy (1)
[Explication pour les débutants] Syntaxe et concept de base de TensorFlow
Introduction à Scrapy (3)
Premiers pas avec Supervisor
Pour les débutants à créer un environnement Anaconda. (Note)
Introduction à Tkinter 1: Introduction
Comment créer un plug-in Spigot (pour les débutants Java)
Python pour les super débutants Super débutants Python # Facile à éliminer
Introduction à PyQt
Introduction à Scrapy (2)
Introduction à la modélisation statistique pour l'analyse des données
Comment utiliser les outils d'analyse de données pour les débutants
[Introduction à TensorBoard] Visualisez le traitement TensorFlow pour approfondir la compréhension
Essayez de calculer RPN avec Python (pour les débutants)
[Linux] Introduction à Linux
[Introduction à l'application Udemy Python3 +] 43. instruction for else
Introduction à Scrapy (4)
Introduction à discord.py (2)
Réalisation du didacticiel TensorFlow MNIST pour débutants en ML
Tensorufuro, Tensafuro Après tout, lequel (Comment lire Tensorflow)
Une introduction à l'analyse vocale pour les applications musicales
Installation de TensorFlow sur Windows Easy pour les débutants en Python
Comment rendre le Python des débutants plus rapide [numpy]
[Pour les débutants] Comment étudier la programmation Mémo privé
[Introduction pour les débutants] Manipuler MySQL avec Python
Comment forcer TensorFlow 2.3.0 à construire pour CUDA11 + cuDNN8
Comprendre le développement de Python pour Pepper. -Introduction à Python Box-