Apache MXNet - Symbole d'API Python
Dans ce chapitre, nous allons découvrir une interface dans MXNet qui est appelée Symbol.
Mxnet.ndarray
L'API Symbol d'Apache MXNet est une interface pour la programmation symbolique. Symbol API propose l'utilisation des éléments suivants -
Graphiques informatiques
Utilisation de la mémoire réduite
Optimisation des fonctions de pré-utilisation
L'exemple donné ci-dessous montre comment créer une expression simple en utilisant l'API Symbol de MXNet -
Un NDArray en utilisant un 'tableau' 1-D et 2-D à partir d'une liste Python régulière -
import mxnet as mx
# Two placeholders namely x and y will be created with mx.sym.variable
x = mx.sym.Variable('x')
y = mx.sym.Variable('y')
# The symbol here is constructed using the plus ‘+’ operator.
z = x + yOutput
Vous verrez la sortie suivante -
<Symbol _plus0>Example
(x, y, z)Output
La sortie est donnée ci-dessous -
(<Symbol x>, <Symbol y>, <Symbol _plus0>)Voyons maintenant en détail les classes, les fonctions et les paramètres de l'API ndarray de MXNet.
Des classes
Le tableau suivant comprend les classes de Symbol API de MXNet -
| Classe | Définition |
|---|---|
| Symbole (poignée) | Cette classe à savoir symbol est le graphe symbolique d'Apache MXNet. |
Fonctions et leurs paramètres
Voici quelques-unes des fonctions importantes et leurs paramètres couverts par l'API mxnet.Symbol -
| Fonction et ses paramètres | Définition |
|---|---|
| Activation ([data, act_type, out, name]) | Il applique une fonction d'activation élément par élément à l'entrée. Ça supporterelu, sigmoid, tanh, softrelu, softsign fonctions d'activation. |
| BatchNorm ([données, gamma, bêta, Moving_mean,…]) | Il est utilisé pour la normalisation des lots. Cette fonction normalise un lot de données par la moyenne et la variance. Il applique une échellegamma et offset beta. |
| BilinearSampler ([données, grille, cudnn_off,…]) | Cette fonction applique un échantillonnage bilinéaire à la carte d'entités en entrée. En fait, c'est la clé des «Réseaux de Transformateurs Spatiaux». Si vous êtes familier avec la fonction de remappage dans OpenCV, l'utilisation de cette fonction est assez similaire à cela. La seule différence est qu'il a la passe arrière. |
| BlockGrad ([données, sortie, nom]) | Comme son nom l'indique, cette fonction arrête le calcul du gradient. Il empêche essentiellement le gradient accumulé des entrées de traverser cet opérateur dans le sens inverse. |
| cast ([données, type, sortie, nom]) | Cette fonction convertira tous les éléments de l'entrée dans un nouveau type. |
| Cette fonction convertira tous les éléments de l'entrée dans un nouveau type. | Cette fonction, comme son nom est spécifié, renvoie un nouveau symbole de forme et de type donnés, rempli de zéros. |
| uns (forme [, dtype]) | Cette fonction, en tant que nom spécifié, renvoie un nouveau symbole de forme et de type donnés, rempli de uns. |
| plein (forme, val [, dtype]) | Cette fonction, comme nom spécifié, retourne un nouveau tableau de forme et de type donnés, rempli avec la valeur donnée val. |
| organiser (démarrer [, arrêter, avancer, répéter,…]) | Il renverra des valeurs régulièrement espacées dans un intervalle donné. Les valeurs sont générées dans un intervalle semi-ouvert [démarrage, arrêt) ce qui signifie que l'intervalle comprendstart mais exclut stop. |
| linspace (start, stop, num [, endpoint, name,…]) | Il renverra des nombres régulièrement espacés dans un intervalle spécifié. Similaire à la fonction arrange (), les valeurs sont générées dans un intervalle à moitié ouvert [start, stop) ce qui signifie que l'intervalle comprendstart mais exclut stop. |
| histogramme (a [, bins, range]) | Comme son nom l'indique, cette fonction calculera l'histogramme des données d'entrée. |
| puissance (base, exp) | Comme son nom l'indique, cette fonction retournera le résultat élément par élément de base élément élevé aux pouvoirs de expélément. Les deux entrées, c'est-à-dire base et exp, peuvent être symboliques ou scalaires. Notez ici que la diffusion n'est pas autorisée. Vous pouvez utiliserbroadcast_pow si vous souhaitez utiliser la fonction de diffusion. |
| SoftmaxActivation ([données, mode, nom, attr, sortie]) | Cette fonction applique l'activation softmax à l'entrée. Il est destiné aux couches internes. Il est en fait obsolète, nous pouvons utilisersoftmax() au lieu. |
Exemples de mise en œuvre
Dans l'exemple ci-dessous, nous utiliserons la fonction power() qui retournera le résultat élément par élément de l'élément de base élevé aux puissances de l'élément exp:
import mxnet as mx
mx.sym.power(3, 5)Output
Vous verrez la sortie suivante -
243Example
x = mx.sym.Variable('x')
y = mx.sym.Variable('y')
z = mx.sym.power(x, 3)
z.eval(x=mx.nd.array([1,2]))[0].asnumpy()Output
Cela produit la sortie suivante -
array([1., 8.], dtype=float32)Example
z = mx.sym.power(4, y)
z.eval(y=mx.nd.array([2,3]))[0].asnumpy()Output
Lorsque vous exécutez le code ci-dessus, vous devriez voir la sortie suivante -
array([16., 64.], dtype=float32)Example
z = mx.sym.power(x, y)
z.eval(x=mx.nd.array([4,5]), y=mx.nd.array([2,3]))[0].asnumpy()Output
La sortie est mentionnée ci-dessous -
array([ 16., 125.], dtype=float32)Dans l'exemple ci-dessous, nous utiliserons la fonction SoftmaxActivation() (or softmax()) qui sera appliqué à l'entrée et est destiné aux couches internes.
input_data = mx.nd.array([[2., 0.9, -0.5, 4., 8.], [4., -.7, 9., 2., 0.9]])
soft_max_act = mx.nd.softmax(input_data)
print (soft_max_act.asnumpy())Output
Vous verrez la sortie suivante -
[[2.4258138e-03 8.0748333e-04 1.9912292e-04 1.7924475e-02 9.7864312e-01]
[6.6843745e-03 6.0796250e-05 9.9204916e-01 9.0463174e-04 3.0112563e-04]]symbole.contrib
L'API Contrib NDArray est définie dans le package symbol.contrib. Il fournit généralement de nombreuses API expérimentales utiles pour les nouvelles fonctionnalités. Cette API fonctionne comme un endroit pour la communauté où ils peuvent essayer les nouvelles fonctionnalités. Le contributeur de la fonctionnalité recevra également les commentaires.
Fonctions et leurs paramètres
Voici quelques-unes des fonctions importantes et leurs paramètres couverts par mxnet.symbol.contrib API -
| Fonction et ses paramètres | Définition |
|---|---|
| rand_zipfian (true_classes, num_sampled,…) | Cette fonction tire des échantillons aléatoires d'une distribution approximativement Zipfienne. La distribution de base de cette fonction est la distribution Zipfian. Cette fonction échantillonne aléatoirement les candidats num_sampled et les éléments de sampled_candidates sont extraits de la distribution de base donnée ci-dessus. |
| foreach (corps, données, init_states) | Comme son nom l'indique, cette fonction exécute une boucle avec un calcul défini par l'utilisateur sur NDArrays sur la dimension 0. Cette fonction simule une boucle for et le corps a le calcul pour une itération de la boucle for. |
| while_loop (cond, func, loop_vars [,…]) | Comme son nom l'indique, cette fonction exécute une boucle while avec un calcul et une condition de boucle définis par l'utilisateur. Cette fonction simule une boucle while qui effectue un calcul personnalisé si la condition est satisfaite. |
| cond (pred, then_func, else_func) | Comme son nom l'indique, cette fonction exécute un if-then-else en utilisant une condition et un calcul définis par l'utilisateur. Cette fonction simule une branche de type if qui choisit de faire l'un des deux calculs personnalisés en fonction de la condition spécifiée. |
| getnnz ([données, axe, sortie, nom]) | Cette fonction nous donne le nombre de valeurs stockées pour un tenseur clairsemé. Il comprend également des zéros explicites. Il ne prend en charge que la matrice CSR sur le processeur. |
| requantize ([données, plage_min, plage_max,…]) | Cette fonction requantise les données données qui sont quantifiées dans int32 et les seuils correspondants, dans int8 en utilisant les seuils min et max calculés à l'exécution ou à partir de l'étalonnage. |
| index_copy ([ancien_tenseur, vecteur_index,…]) | Cette fonction copie les éléments d'un new_tensor into the old_tensor by selecting the indices in the order given in index. The output of this operator will be a new tensor that contains the rest elements of old tensor and the copied elements of new tensor. |
| interleaved_matmul_encdec_qk ([requêtes,…]) | Cet opérateur calcule la multiplication matricielle entre les projections de requêtes et de clés en utilisation attention multi-têtes comme encodeur-décodeur. La condition est que les entrées doivent être un tenseur de projections de requêtes qui suit le layout: (seq_length, batch_size, num_heads *, head_dim). |
Exemples de mise en œuvre
Dans l'exemple ci-dessous, nous utiliserons la fonction rand_zipfian pour tirer des échantillons aléatoires à partir d'une distribution approximativement Zipfienne -
import mxnet as mx
true_cls = mx.sym.Variable('true_cls')
samples, exp_count_true, exp_count_sample = mx.sym.contrib.rand_zipfian(true_cls, 5, 6)
samples.eval(true_cls=mx.nd.array([3]))[0].asnumpy()Output
Vous verrez la sortie suivante -
array([4, 0, 2, 1, 5], dtype=int64)Example
exp_count_true.eval(true_cls=mx.nd.array([3]))[0].asnumpy()Output
La sortie est mentionnée ci-dessous -
array([0.57336551])Example
exp_count_sample.eval(true_cls=mx.nd.array([3]))[0].asnumpy()Output
Vous verrez la sortie suivante -
array([1.78103594, 0.46847373, 1.04183923, 0.57336551, 1.04183923])Dans l'exemple ci-dessous, nous utiliserons la fonction while_loop pour exécuter une boucle while pour un calcul défini par l'utilisateur et une condition de boucle -
cond = lambda i, s: i <= 7
func = lambda i, s: ([i + s], [i + 1, s + i])
loop_vars = (mx.sym.var('i'), mx.sym.var('s'))
outputs, states = mx.sym.contrib.while_loop(cond, func, loop_vars, max_iterations=10)
print(outputs)Output
La sortie est donnée ci-dessous:
[<Symbol _while_loop0>]Example
Print(States)Output
Cela produit la sortie suivante -
[<Symbol _while_loop0>, <Symbol _while_loop0>]Dans l'exemple ci-dessous, nous utiliserons la fonction index_copy qui copie les éléments de new_tensor dans le old_tensor.
import mxnet as mx
a = mx.nd.zeros((6,3))
b = mx.nd.array([[1,2,3],[4,5,6],[7,8,9]])
index = mx.nd.array([0,4,2])
mx.nd.contrib.index_copy(a, index, b)Output
Lorsque vous exécutez le code ci-dessus, vous devriez voir la sortie suivante -
[[1. 2. 3.]
[0. 0. 0.]
[7. 8. 9.]
[0. 0. 0.]
[4. 5. 6.]
[0. 0. 0.]]
<NDArray 6x3 @cpu(0)>symbol.image
L'API Image Symbol est définie dans le package symbol.image. Comme son nom l'indique, il est généralement utilisé pour les images et leurs caractéristiques.
Fonctions et leurs paramètres
Voici quelques-unes des fonctions importantes et leurs paramètres couverts par mxnet.symbol.image API -
| Fonction et ses paramètres | Définition |
|---|---|
| Adjust_lighting ([données, alpha, sortie, nom]) | Comme son nom l'indique, cette fonction ajuste le niveau d'éclairage de l'entrée. Il suit le style AlexNet. |
| rognage ([données, x, y, largeur, hauteur, extérieur, nom]) | Avec l'aide de cette fonction, nous pouvons recadrer une image NDArray de forme (H x L x C) ou (N x H x L x C) à la taille donnée par l'utilisateur. |
| normaliser ([données, moyenne, std, sortie, nom]) | Il normalisera un tenseur de forme (C x H x L) ou (N x C x H x L) avec mean et standard deviation(SD). |
| random_crop ([data, xrange, yrange, width,…]) | Similaire à crop (), il recadre aléatoirement une image NDArray de forme (H x L x C) ou (N x H x L x C) à la taille donnée par l'utilisateur. Il suréchantillonnera le résultat sisrc est plus petit que le size. |
| random_lighting([données, alpha_std, sortie, nom]) | Comme son nom l'indique, cette fonction ajoute le bruit PCA de manière aléatoire. Il suit également le style AlexNet. |
| random_resized_crop ([data, xrange, yrange,…]) | Il recadre également une image au hasard NDArray de forme (H x L x C) ou (N x H x L x C) à la taille donnée. Il suréchantillonnera le résultat si src est plus petit que la taille. Cela randomisera également la zone et l'aspect rationnel. |
| redimensionner ([données, taille, keep_ratio, interp,…]) | Comme son nom l'indique, cette fonction redimensionnera une image NDArray de forme (H x L x C) ou (N x H x L x C) à la taille donnée par l'utilisateur. |
| to_tensor ([données, sortie, nom]) | Il convertit une image NDArray de forme (H x L x C) ou (N x H x L x C) avec les valeurs dans l'intervalle [0, 255] en un tenseur NDArray de forme (C x H x L) ou ( N x C x H x L) avec les valeurs dans la plage [0, 1]. |
Exemples de mise en œuvre
Dans l'exemple ci-dessous, nous allons utiliser la fonction to_tensor pour convertir l'image NDArray de forme (H x L x C) ou (N x H x L x C) avec les valeurs dans l'intervalle [0, 255] en un tenseur NDArray de forme (C x H x L) ou (N x C x H x L) avec les valeurs dans la plage [0, 1].
import numpy as np
img = mx.sym.random.uniform(0, 255, (4, 2, 3)).astype(dtype=np.uint8)
mx.sym.image.to_tensor(img)Output
La sortie est indiquée ci-dessous -
<Symbol to_tensor4>Example
img = mx.sym.random.uniform(0, 255, (2, 4, 2, 3)).astype(dtype=np.uint8)
mx.sym.image.to_tensor(img)Output
La sortie est mentionnée ci-dessous:
<Symbol to_tensor5>Dans l'exemple ci-dessous, nous utiliserons la fonction normalize () pour normaliser un tenseur de forme (C x H x W) ou (N x C x H x W) avec mean et standard deviation(SD).
img = mx.sym.random.uniform(0, 1, (3, 4, 2))
mx.sym.image.normalize(img, mean=(0, 1, 2), std=(3, 2, 1))Output
Ci-dessous est la sortie du code -
<Symbol normalize0>Example
img = mx.sym.random.uniform(0, 1, (2, 3, 4, 2))
mx.sym.image.normalize(img, mean=(0, 1, 2), std=(3, 2, 1))Output
La sortie est indiquée ci-dessous -
<Symbol normalize1>symbole aléatoire
L'API Random Symbol est définie dans le package symbol.random. Comme son nom l'indique, il s'agit du générateur de distribution aléatoire Symbol API de MXNet.
Fonctions et leurs paramètres
Voici quelques-unes des fonctions importantes et leurs paramètres couverts par mxnet.symbol.random API -
| Fonction et ses paramètres | Définition |
|---|---|
| uniforme ([faible, élevé, forme, type d, ctx, sortie]) | Il génère des échantillons aléatoires à partir d'une distribution uniforme. |
| normal ([loc, scale, shape, dtype, ctx, out]) | Il génère des échantillons aléatoires à partir d'une distribution normale (gaussienne). |
| randn (* forme, ** kwargs) | Il génère des échantillons aléatoires à partir d'une distribution normale (gaussienne). |
| poisson ([lam, forme, type d, ctx, sortie]) | Il génère des échantillons aléatoires à partir d'une distribution de Poisson. |
| exponentielle ([scale, shape, dtype, ctx, out]) | Il génère des échantillons à partir d'une distribution exponentielle. |
| gamma ([alpha, beta, shape, dtype, ctx, out]) | Il génère des échantillons aléatoires à partir d'une distribution gamma. |
| multinomial (data [, shape, get_prob, out, dtype]) | Il génère un échantillonnage simultané à partir de plusieurs distributions multinomiales. |
| négatif_binomial ([k, p, forme, dtype, ctx, sortie]) | Il génère des échantillons aléatoires à partir d'une distribution binomiale négative. |
| generalized_negative_binomial ([mu, alpha,…]) | Il génère des échantillons aléatoires à partir d'une distribution binomiale négative généralisée. |
| mélange (données, ** kwargs) | Il mélange les éléments au hasard. |
| randint (bas, haut [, forme, type, ctx, sortie]) | Il génère des échantillons aléatoires à partir d'une distribution uniforme discrète. |
| exponential_like ([data, lam, out, name]) | Il génère des échantillons aléatoires à partir d'une distribution exponentielle en fonction de la forme du tableau d'entrée. |
| gamma_like ([données, alpha, bêta, sortie, nom]) | Il génère des échantillons aléatoires à partir d'une distribution gamma en fonction de la forme du tableau d'entrée. |
| generalized_negative_binomial_like ([données,…]) | Il génère des échantillons aléatoires à partir d'une distribution binomiale négative généralisée en fonction de la forme du tableau d'entrée. |
| négatif_binomial_like ([données, k, p, sortie, nom]) | Il génère des échantillons aléatoires à partir d'une distribution binomiale négative en fonction de la forme du tableau d'entrée. |
| normal_like ([data, loc, scale, out, name]) | Il génère des échantillons aléatoires à partir d'une distribution normale (gaussienne) en fonction de la forme du tableau d'entrée. |
| poisson_like ([données, lam, out, nom]) | Il génère des échantillons aléatoires à partir d'une distribution de Poisson en fonction de la forme du tableau d'entrée. |
| uniform_like ([données, faible, élevé, sortie, nom]) | Il génère des échantillons aléatoires à partir d'une distribution uniforme en fonction de la forme du tableau d'entrée. |
Exemples de mise en œuvre
Dans l'exemple ci-dessous, nous allons mélanger les éléments de manière aléatoire en utilisant la fonction shuffle (). Il mélangera le tableau le long du premier axe.
data = mx.nd.array([[0, 1, 2], [3, 4, 5], [6, 7, 8],[9,10,11]])
x = mx.sym.Variable('x')
y = mx.sym.random.shuffle(x)
y.eval(x=data)Output
Vous verrez la sortie suivante:
[
[[ 9. 10. 11.]
[ 0. 1. 2.]
[ 6. 7. 8.]
[ 3. 4. 5.]]
<NDArray 4x3 @cpu(0)>]Example
y.eval(x=data)Output
Lorsque vous exécutez le code ci-dessus, vous devriez voir la sortie suivante -
[
[[ 6. 7. 8.]
[ 0. 1. 2.]
[ 3. 4. 5.]
[ 9. 10. 11.]]
<NDArray 4x3 @cpu(0)>]Dans l'exemple ci-dessous, nous allons tirer des échantillons aléatoires à partir d'une distribution binomiale négative généralisée. Pour cela, nous utiliserons la fonctiongeneralized_negative_binomial().
mx.sym.random.generalized_negative_binomial(10, 0.1)Output
La sortie est donnée ci-dessous -
<Symbol _random_generalized_negative_binomial0>symbol.sparse
L'API Sparse Symbol est définie dans le package mxnet.symbol.sparse. Comme son nom l'indique, il fournit des graphiques de réseau neuronal clairsemés et une différenciation automatique sur le processeur.
Fonctions et leurs paramètres
Voici quelques-unes des fonctions importantes (comprend les routines de création de symboles, les routines de manipulation de symboles, les fonctions mathématiques, la fonction trigonométrique, les fonctions hyberboliques, les fonctions de réduction, l'arrondi, les puissances, le réseau neuronal) et leurs paramètres couverts par mxnet.symbol.sparse API -
| Fonction et ses paramètres | Définition |
|---|---|
| ElementWiseSum (* args, ** kwargs) | Cette fonction ajoutera tous les arguments d'entrée par élément. Par exemple, _ (1,2,… = 1 + 2 + ⋯ +). Ici, nous pouvons voir que add_n est potentiellement plus efficace que d'appeler add par n fois. |
| Incorporation ([données, poids, input_dim,…]) | Il mappera les indices entiers sur des représentations vectorielles, c'est-à-dire des plongements. Il mappe en fait les mots sur des vecteurs à valeur réelle dans un espace de grande dimension, appelé embeddings de mots. |
| LinearRegressionOutput ([données, étiquette,…]) | Il calcule et optimise la perte au carré lors de la propagation vers l'arrière en ne donnant que les données de sortie pendant la propagation vers l'avant. |
| LogisticRegressionOutput ([données, étiquette,…]) | Applique une fonction logistique également appelée fonction sigmoïde à l'entrée. La fonction est calculée comme 1/1 + exp (−x). |
| MAERegressionOutput ([données, étiquette,…]) | Cet opérateur calcule l'erreur absolue moyenne de l'entrée. MAE est en fait une mesure de risque correspondant à la valeur attendue de l'erreur absolue. |
| abs ([données, nom, attr, sortie]) | Comme son nom l'indique, cette fonction retournera la valeur absolue élément par élément de l'entrée. |
| adagrad_update ([poids, diplôme, historique, lr,…]) | C'est une fonction de mise à jour pour AdaGrad optimizer. |
| adam_update ([poids, grad, moyenne, var, lr,…]) | C'est une fonction de mise à jour pour Adam optimizer. |
| add_n (* args, ** kwargs) | Comme son nom l'indique, il ajoutera tous les arguments d'entrée élément par élément. |
| arccos ([données, nom, attr, sortie]) | Cette fonction renvoie le cosinus inverse élément par élément du tableau d'entrée. |
| point ([lhs, rhs, transpose_a, transpose_b,…]) | Comme son nom l'indique, il donnera le produit scalaire de deux tableaux. Cela dépendra de la dimension du tableau d'entrée: 1-D: produit interne des vecteurs 2-D: multiplication matricielle ND: un produit de somme sur le dernier axe de la première entrée et le premier axe de la deuxième entrée. |
| elemwise_add ([lhs, rhs, nom, attr, sortie]) | Comme son nom l'indique, il sera add arguments élément par élément. |
| elemwise_div ([lhs, rhs, nom, attr, sortie]) | Comme son nom l'indique, il sera divide arguments élément par élément. |
| elemwise_mul ([lhs, rhs, nom, attr, sortie]) | Comme son nom l'indique, il sera Multiply arguments élément par élément. |
| elemwise_sub ([lhs, rhs, nom, attr, sortie]) | Comme son nom l'indique, il soustrayera les arguments par élément. |
| exp ([données, nom, attr, sortie]) | Cette fonction retournera la valeur exponentielle élément par élément de l'entrée donnée. |
| sgd_update ([poids, grad, lr, wd,…]) | Il agit comme une fonction de mise à jour pour l'optimiseur Stochastic Gradient Descent. |
| sigmoïde ([données, nom, attr, sortie]) | Comme son nom l'indique, il calculera sigmoid de x élément par élément. |
| signe ([données, nom, attr, sortie]) | Il renverra le signe élémentaire de l'entrée donnée. |
| sin ([données, nom, attr, sortie]) | Comme son nom l'indique, cette fonction calcule le sinus élément par élément du tableau d'entrée donné. |
Exemple d'implémentation
Dans l'exemple ci-dessous, nous allons mélanger les éléments au hasard en utilisant ElementWiseSum()fonction. Il mappera les indices entiers sur des représentations vectorielles, c'est-à-dire des embeddings de mots.
input_dim = 4
output_dim = 5Example
/* Here every row in weight matrix y represents a word. So, y = (w0,w1,w2,w3)
y = [[ 0., 1., 2., 3., 4.],
[ 5., 6., 7., 8., 9.],
[ 10., 11., 12., 13., 14.],
[ 15., 16., 17., 18., 19.]]
/* Here input array x represents n-grams(2-gram). So, x = [(w1,w3), (w0,w2)]
x = [[ 1., 3.],
[ 0., 2.]]
/* Now, Mapped input x to its vector representation y.
Embedding(x, y, 4, 5) = [[[ 5., 6., 7., 8., 9.],
[ 15., 16., 17., 18., 19.]],
[[ 0., 1., 2., 3., 4.],
[ 10., 11., 12., 13., 14.]]]