Notions de base de Tensorflow (bibliothèque de logiciels open source d'apprentissage automatique)

Remarque : L'exemple de cet article utilise Python version 3.5.6 et Tensorflow version 2.0

Introduction

Tensorflow est Google L'artefact open source d'apprentissage automatique lancé prend en charge le langage Python, prend en charge le matériel tel que le CPU, le GPU et Google TPU, et dispose déjà d'une variété de modèles et d'algorithmes. Actuellement, Tensorflow est largement utilisé dans de nombreux domaines d'apprentissage automatique et d'apprentissage profond tels que le traitement de texte, la reconnaissance vocale et la reconnaissance d'images.

Le framework de base

est divisé en trois couches : couche d'application, couche d'interface et couche principale

Recommandé : " Tutoriel Python》

Couche d'application

fournit des bibliothèques de formation et de prédiction liées à l'apprentissage automatique bibliothèques Et environnements de programmation pour des langages tels que Python, C++ et Java, similaires au front-end d'un système Web, réalisent principalement la construction de graphiques de calcul.

La couche d'interface

encapsule les modules de fonction Tensorflow pour faciliter les appels depuis d'autres plates-formes linguistiques.

Couche principale

La partie la plus importante, comprenant la couche de périphérique, la couche réseau, la couche d'opération de données et la couche de calcul graphique, effectue les calculs de la couche d'application.

1. Couche de périphérique

Comprend la mise en œuvre de Tensorflow sur différents périphériques matériels, prend principalement en charge les processeurs, les GPU, les appareils mobiles et autres, et implémente les commandes de calcul sur différents matériels. appareils La conversion fournit une interface unifiée à la couche supérieure pour réaliser la fonction multiplateforme du programme.

2. Couche réseau

La couche réseau comprend principalement les protocoles de communication RPC et RDMA pour réaliser la transmission de données et les mises à jour entre différents appareils. Ces protocoles seront utilisés dans l'informatique distribuée. utilisé dans.

3. La couche d'opérations de données

prend le tenseur comme objet de traitement pour mettre en œuvre diverses opérations et calculs de tenseur.

4. La couche de calcul graphique

comprend la mise en œuvre de graphiques informatiques distribués et de graphiques informatiques locaux, et réalise la création, la compilation, l'optimisation et l'exécution de graphiques.

Concept de conception

Tensorflow peut être compris comme le "flux de tenseurs" dans un graphe de calcul, où Tensor (tenseur) représente les bords et les flux représentent le flux de données formées par les opérations effectuées par les nœuds dans le graphe informatique.

Le concept de conception est basé sur le flux de données. Après avoir construit le modèle d'apprentissage automatique correspondant, les données d'entraînement sont utilisées pour diffuser les données dans le modèle et les résultats sont renvoyés aux paramètres du modèle par rétropropagation. , pour ajuster les paramètres, et utilisez les paramètres ajustés pour calculer à nouveau de manière itérative les données d'entraînement.

Fonctionnalités de programmation

Il existe deux fonctionnalités de programmation :

La définition du graphe et le fonctionnement du graphe sont complètement séparés

dans tensorflow, il est nécessaire de définir diverses variables à l'avance, d'établir des diagrammes de flux de données pertinents, de créer des relations de calcul entre différentes variables dans le diagramme de flux de données et de compléter la définition du diagramme. Les données d'entrée de l'opération doivent être. mis en place avant que la valeur de sortie puisse être formée.

Le calcul du graphique est exécuté dans la session

Les calculs pertinents du flux tensoriel sont définis dans le graphique, et l'environnement d'exécution spécifique du graphique est dans la session. Le calcul ne peut être effectué que dans la session. démarrer après l'ouverture de la session, la fermeture de la session signifie qu'aucun calcul ne peut plus être effectué.

Par exemple :

import tensorflow as tf
tf.compat.v1.disable_eager_execution()
a = 3
b = 4
c = 5
y = tf.add(a*b, c)
print(y)
a = tf.constant(3, tf.int32)
b = tf.constant(4, tf.int32)
c = tf.constant(5, tf.int32)
y = tf.add(a*b, c)
print(y)
session = tf.compat.v1.Session()
print(session.run(y))
session.close()

On peut voir qu'après la création du graphique, le calcul des données est effectué dans la session et le résultat final est affiché.

L'avantage de la conception est : dans le processus d'apprentissage, la partie la plus consommée est l'entraînement des données. Si elle est conçue de cette manière, lorsque le calcul est effectué, le graphique a été déterminé, et le. le calcul n’est qu’un processus itératif continu.

Concepts de base

Tensor

Tensor est la structure de données la plus importante dans Tensorflow est utilisé dans Pour le transfert de données. dans le graphe de calcul, après avoir créé un tenseur, vous devez l'attribuer à une variable ou à un espace réservé avant d'ajouter le tenseur au graphe de calcul.

session

La session est l'exécuteur spécifique du graphe de calcul dans Tensorflow, qui interagit réellement avec le graphe. Il peut y avoir plusieurs graphiques dans une session. L'objectif principal de la session est d'ajouter des données d'entraînement au graphique pour le calcul, ainsi que de modifier la structure du graphique.

Il est recommandé d'utiliser l'instruction with en mode d'appel :

with session:
    session.run()
Variable

variables, qui représentent divers paramètres de calcul dans le graphique, et d'optimiser l'algorithme d'apprentissage automatique en ajustant l'état de ces variables . Pour créer une variable, tf.Variable() doit être utilisé. En saisissant un tenseur, une variable est renvoyée. La variable doit être initialisée après avoir été déclarée avant de pouvoir être utilisée.

Exemple :

import tensorflow as tf
tf.compat.v1.disable_eager_execution()
tensor = tf.ones([1, 3])
test_var = tf.Variable(tensor)
# 初始化变量
init_op = tf.compat.v1.global_variables_initializer()
session = tf.compat.v1.Session()
with session:
    print("tensor is ", session.run(tensor))
    # print("test_var is ", session.run(test_var))
    session.run(init_op)
    print("after init, test_var is", session.run(test_var))

Placeholder

Placeholder, utilisé pour représenter le format des données d'entrée et de sortie, déclare l'emplacement des données et autorise les données entrantes. le type et la forme des données, obtenez les données via le paramètre feed_dict dans la session et utilisez les données obtenues pour effectuer des calculs lorsque le graphique de calcul est en cours d'exécution. Les données obtenues disparaîtront une fois le calcul terminé.

Exemple :

x = tf.compat.v1.placeholder(tf.int32)
y = tf.compat.v1.placeholder(tf.int32)
z = tf.add(x, y)
session = tf.compat.v1.Session()
with session:
    print(session.run([z], feed_dict={x: [1, 2], y: [2, 3]}))

Opération

L'opération est un nœud dans le graphique L'entrée et la sortie sont Tensor, et sa fonction est de compléter divers. opérations. Comprend :

Opérations mathématiques : ajouter, sous, mul, div, exp...

Opérations sur les tableaux : concaténer, trancher, diviser, classer...

Opérations matricielles : matmul, matriceinverse ...

Construction de réseaux neuronaux : softmax, sigmoïde, relu ...

检查点：save, restore ...

队列和同步：enqueue, dequeue, mutexacquire, mutexrelease ...

张量控制：merge, switch, enter, leave ...

Queue

队列，图中有状态的节点。包含入列（endqueue）和出列（dequeue）两个操作，入列返回计算图中的一个操作节点，出列返回一个tensor值。

其中，队列有两种：

1. FIFOQueue

按入列顺序出列的队列，在需要读入的训练样本有序时使用。举个例子：

fifo_queue = tf.compat.v1.FIFOQueue(10, 'int32')
init = fifo_queue.enqueue_many(([1, 2, 3, 4, 5, 6], ))
with tf.compat.v1.Session() as session:
    session.run(init)
    queue_size = session.run(fifo_queue.size())
    for item in range(queue_size):
        print('fifo_queue', session.run(fifo_queue.dequeue()))

2. RandomShuffleQueue

以随机顺序出列的队列，读入的训练样本无序时使用。举个例子：

rs_queue = tf.compat.v1.RandomShuffleQueue(capacity=5, min_after_dequeue=0, dtypes='int32')
init = rs_queue.enqueue_many(([1, 2, 3, 4, 5], ))
with tf.compat.v1.Session() as session:
    session.run(init)
    queue_size = session.run(rs_queue.size())
    for i in range(queue_size):
        print('rs_queue', session.run(rs_queue.dequeue()))

本文来自 python教程 栏目，欢迎学习！  

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!