Apache MXNet - API Python ndarray
Ce chapitre explique la bibliothèque ndarray disponible dans Apache MXNet.
Mxnet.ndarray
La bibliothèque NDArray d'Apache MXNet définit le noyau DS (structures de données) pour tous les calculs mathématiques. Deux tâches fondamentales de NDArray sont les suivantes:
Il prend en charge une exécution rapide sur une large gamme de configurations matérielles.
Il met automatiquement en parallèle plusieurs opérations sur le matériel disponible.
L'exemple ci-dessous montre comment créer un NDArray en utilisant un 'tableau' 1-D et 2-D à partir d'une liste Python régulière -
import mxnet as mx
from mxnet import nd
x = nd.array([1,2,3,4,5,6,7,8,9,10])
print(x)Output
La sortie est donnée ci-dessous:
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
<NDArray 10 @cpu(0)>Example
y = nd.array([[1,2,3,4,5,6,7,8,9,10], [1,2,3,4,5,6,7,8,9,10], [1,2,3,4,5,6,7,8,9,10]])
print(y)Output
Cela produit la sortie suivante -
[[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]]
<NDArray 3x10 @cpu(0)>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 l'API ndarray de MXNet -
| Classe | Définition |
|---|---|
| CachedOp (sym [, indicateurs]) | Il est utilisé pour le handle d'opérateur mis en cache. |
| NDArray (handle [, accessible en écriture]) | Il est utilisé comme un objet de tableau qui représente un tableau homogène et multidimensionnel d'éléments de taille fixe. |
Fonctions et leurs paramètres
Voici quelques-unes des fonctions importantes et leurs paramètres couverts par l'API mxnet.ndarray -
| Fonction et ses paramètres | Définition |
|---|---|
| Activation([données, type_act, sortie, nom]) | Il applique une fonction d'activation élément par élément à l'entrée. Il prend en charge les fonctions d'activation relu, sigmoid, tanh, softrelu et softsign. |
| 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 échelle gamma et un décalage bêta. |
| 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. |
Exemples de mise en œuvre
Dans l'exemple ci-dessous, nous utiliserons la fonction BilinierSampler () pour effectuer un zoom arrière deux fois sur les données et décaler les données horizontalement de -1 pixel -
import mxnet as mx
from mxnet import nd
data = nd.array([[[[2, 5, 3, 6],
[1, 8, 7, 9],
[0, 4, 1, 8],
[2, 0, 3, 4]]]])
affine_matrix = nd.array([[2, 0, 0],
[0, 2, 0]])
affine_matrix = nd.reshape(affine_matrix, shape=(1, 6))
grid = nd.GridGenerator(data=affine_matrix, transform_type='affine', target_shape=(4, 4))
output = nd.BilinearSampler(data, grid)Output
Lorsque vous exécutez le code ci-dessus, vous devriez voir la sortie suivante:
[[[[0. 0. 0. 0. ]
[0. 4.0000005 6.25 0. ]
[0. 1.5 4. 0. ]
[0. 0. 0. 0. ]]]]
<NDArray 1x1x4x4 @cpu(0)>La sortie ci-dessus montre le zoom arrière des données deux fois.
Voici un exemple de décalage des données de -1 pixel -
import mxnet as mx
from mxnet import nd
data = nd.array([[[[2, 5, 3, 6],
[1, 8, 7, 9],
[0, 4, 1, 8],
[2, 0, 3, 4]]]])
warp_matrix = nd.array([[[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]],
[[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]]]])
grid = nd.GridGenerator(data=warp_matrix, transform_type='warp')
output = nd.BilinearSampler(data, grid)Output
La sortie est indiquée ci-dessous -
[[[[5. 3. 6. 0.]
[8. 7. 9. 0.]
[4. 1. 8. 0.]
[0. 3. 4. 0.]]]]
<NDArray 1x1x4x4 @cpu(0)>De même, l'exemple suivant montre l'utilisation de la fonction cast () -
nd.cast(nd.array([300, 10.1, 15.4, -1, -2]), dtype='uint8')Output
Lors de l'exécution, vous recevrez la sortie suivante -
[ 44 10 15 255 254]
<NDArray 5 @cpu(0)>ndarray.contrib
L'API Contrib NDArray est définie dans le package ndarray.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.ndarray.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 for 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 selon la condition spécifiée. |
| isinf(Les données) | Cette fonction effectue une vérification élément par élément pour déterminer si le NDArray contient un élément infini ou non. |
| 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. |
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
from mxnet import nd
trueclass = mx.nd.array([2])
samples, exp_count_true, exp_count_sample = mx.nd.contrib.rand_zipfian(trueclass, 3, 4)
samplesOutput
Vous verrez la sortie suivante -
[0 0 1]
<NDArray 3 @cpu(0)>Example
exp_count_trueOutput
La sortie est donnée ci-dessous:
[0.53624076]
<NDArray 1 @cpu(0)>Example
exp_count_sampleOutput
Cela produit la sortie suivante:
[1.29202967 1.29202967 0.75578891]
<NDArray 3 @cpu(0)>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_var = (mx.nd.array([0], dtype="int64"), mx.nd.array([1], dtype="int64"))
outputs, states = mx.nd.contrib.while_loop(cond, func, loop_vars, max_iterations=10)
outputsOutput
La sortie est indiquée ci-dessous -
[
[[ 1]
[ 2]
[ 4]
[ 7]
[ 11]
[ 16]
[ 22]
[ 29]
[3152434450384]
[ 257]]
<NDArray 10x1 @cpu(0)>]Example
StatesOutput
Cela produit la sortie suivante -
[
[8]
<NDArray 1 @cpu(0)>,
[29]
<NDArray 1 @cpu(0)>]ndarray.image
L'API Image NDArray est définie dans le package ndarray.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.ndarray.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. |
| crop([données, x, y, largeur, hauteur, sortie, 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. |
| normalize([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 si src est plus petit que la taille. |
| 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. |
| resize([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.nd.random.uniform(0, 255, (4, 2, 3)).astype(dtype=np.uint8)
mx.nd.image.to_tensor(img)Output
Vous verrez la sortie suivante -
[[[0.972549 0.5058824 ]
[0.6039216 0.01960784]
[0.28235295 0.35686275]
[0.11764706 0.8784314 ]]
[[0.8745098 0.9764706 ]
[0.4509804 0.03529412]
[0.9764706 0.29411766]
[0.6862745 0.4117647 ]]
[[0.46666667 0.05490196]
[0.7372549 0.4392157 ]
[0.11764706 0.47843137]
[0.31764707 0.91764706]]]
<NDArray 3x4x2 @cpu(0)>Example
img = mx.nd.random.uniform(0, 255, (2, 4, 2, 3)).astype(dtype=np.uint8)
mx.nd.image.to_tensor(img)Output
Lorsque vous exécutez le code, vous verrez la sortie suivante -
[[[[0.0627451 0.5647059 ]
[0.2627451 0.9137255 ]
[0.57254905 0.27450982]
[0.6666667 0.64705884]]
[[0.21568628 0.5647059 ]
[0.5058824 0.09019608]
[0.08235294 0.31764707]
[0.8392157 0.7137255 ]]
[[0.6901961 0.8627451 ]
[0.52156866 0.91764706]
[0.9254902 0.00784314]
[0.12941177 0.8392157 ]]]
[[[0.28627452 0.39607844]
[0.01960784 0.36862746]
[0.6745098 0.7019608 ]
[0.9607843 0.7529412 ]]
[[0.2627451 0.58431375]
[0.16470589 0.00392157]
[0.5686275 0.73333335]
[0.43137255 0.57254905]]
[[0.18039216 0.54901963]
[0.827451 0.14509805]
[0.26666668 0.28627452]
[0.24705882 0.39607844]]]]
<NDArgt;ray 2x3x4x2 @cpu(0)>Dans l'exemple ci-dessous, nous utiliserons la fonction normalize normaliser un tenseur de forme (C x H x L) ou (N x C x H x L) avec mean et standard deviation(SD).
img = mx.nd.random.uniform(0, 1, (3, 4, 2))
mx.nd.image.normalize(img, mean=(0, 1, 2), std=(3, 2, 1))Output
Cela produit la sortie suivante -
[[[ 0.29391178 0.3218054 ]
[ 0.23084386 0.19615503]
[ 0.24175143 0.21988946]
[ 0.16710812 0.1777354 ]]
[[-0.02195817 -0.3847335 ]
[-0.17800489 -0.30256534]
[-0.28807247 -0.19059572]
[-0.19680339 -0.26256624]]
[[-1.9808068 -1.5298678 ]
[-1.6984252 -1.2839255 ]
[-1.3398265 -1.712009 ]
[-1.7099224 -1.6165378 ]]]
<NDArray 3x4x2 @cpu(0)>Example
img = mx.nd.random.uniform(0, 1, (2, 3, 4, 2))
mx.nd.image.normalize(img, mean=(0, 1, 2), std=(3, 2, 1))Output
Lorsque vous exécutez le code ci-dessus, vous devriez voir la sortie suivante -
[[[[ 2.0600514e-01 2.4972327e-01]
[ 1.4292289e-01 2.9281738e-01]
[ 4.5158025e-02 3.4287784e-02]
[ 9.9427439e-02 3.0791296e-02]]
[[-2.1501756e-01 -3.2297665e-01]
[-2.0456362e-01 -2.2409186e-01]
[-2.1283737e-01 -4.8318747e-01]
[-1.7339960e-01 -1.5519112e-02]]
[[-1.3478968e+00 -1.6790028e+00]
[-1.5685816e+00 -1.7787373e+00]
[-1.1034534e+00 -1.8587360e+00]
[-1.6324382e+00 -1.9027401e+00]]]
[[[ 1.4528830e-01 3.2801408e-01]
[ 2.9730779e-01 8.6780310e-02]
[ 2.6873133e-01 1.7900752e-01]
[ 2.3462953e-01 1.4930873e-01]]
[[-4.4988656e-01 -4.5021546e-01]
[-4.0258706e-02 -3.2384416e-01]
[-1.4287934e-01 -2.6537544e-01]
[-5.7649612e-04 -7.9429924e-02]]
[[-1.8505517e+00 -1.0953522e+00]
[-1.1318740e+00 -1.9624406e+00]
[-1.8375070e+00 -1.4916846e+00]
[-1.3844404e+00 -1.8331525e+00]]]]
<NDArray 2x3x4x2 @cpu(0)>ndarray.random
L'API Random NDArray est définie dans le package ndarray.random. Comme son nom l'indique, il s'agit de l'API NDArray du générateur de distribution aléatoire de MXNet.
Fonctions et leurs paramètres
Voici quelques-unes des fonctions importantes et leurs paramètres couverts par mxnet.ndarray.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). |
| 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 tirer des échantillons aléatoires à partir d'une distribution uniforme. Pour cela, nous utiliserons la fonctionuniform().
mx.nd.random.uniform(0, 1)Output
La sortie est mentionnée ci-dessous -
[0.12381998]
<NDArray 1 @cpu(0)>Example
mx.nd.random.uniform(-1, 1, shape=(2,))Output
La sortie est donnée ci-dessous -
[0.558102 0.69601643]
<NDArray 2 @cpu(0)>Example
low = mx.nd.array([1,2,3])
high = mx.nd.array([2,3,4])
mx.nd.random.uniform(low, high, shape=2)Output
Vous verrez la sortie suivante -
[[1.8649333 1.8073189]
[2.4113967 2.5691009]
[3.1399727 3.4071832]]
<NDArray 3x2 @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.nd.random.generalized_negative_binomial(10, 0.5)Output
Lorsque vous exécutez le code ci-dessus, vous devriez voir la sortie suivante -
[1.]
<NDArray 1 @cpu(0)>Example
mx.nd.random.generalized_negative_binomial(10, 0.5, shape=(2,))Output
La sortie est donnée ici -
[16. 23.]
<NDArray 2 @cpu(0)>Example
mu = mx.nd.array([1,2,3])
alpha = mx.nd.array([0.2,0.4,0.6])
mx.nd.random.generalized_negative_binomial(mu, alpha, shape=2)Output
Ci-dessous est la sortie du code -
[[0. 0.]
[4. 1.]
[9. 3.]]
<NDArray 3x2 @cpu(0)>ndarray.utils
L'API NDArray de l'utilitaire est définie dans le package ndarray.utils. Comme son nom l'indique, il fournit les fonctions utilitaires pour NDArray et BaseSparseNDArray.
Fonctions et leurs paramètres
Voici quelques-unes des fonctions importantes et leurs paramètres couverts par mxnet.ndarray.utils API -
| Fonction et ses paramètres | Définition |
|---|---|
| zéros (forme [, ctx, dtype, stype]) | Cette fonction renverra un nouveau tableau de forme et de type donnés, rempli de zéros. |
| vide (forme [, ctx, dtype, stype]) | Il retournera un nouveau tableau de forme et de type donnés, sans initialiser les entrées. |
| array (source_array [, ctx, dtype]) | Comme son nom l'indique, cette fonction créera un tableau à partir de n'importe quel objet exposant l'interface du tableau. |
| charge (fname) | Il chargera un tableau à partir du fichier. |
| load_frombuffer (buf) | Comme son nom l'indique, cette fonction chargera un dictionnaire ou une liste de tableaux à partir d'un tampon |
| save (fname, données) | Cette fonction enregistrera une liste de tableaux ou un dict de str-> array dans un fichier. |
Exemples de mise en œuvre
Dans l'exemple ci-dessous, nous allons retourner un nouveau tableau de forme et de type donnés, rempli de zéros. Pour cela, nous utiliserons la fonctionzeros().
mx.nd.zeros((1,2), mx.cpu(), stype='csr')Output
Cela produit la sortie suivante -
<CSRNDArray 1x2 @cpu(0)>Example
mx.nd.zeros((1,2), mx.cpu(), 'float16', stype='row_sparse').asnumpy()Output
Vous recevrez la sortie suivante -
array([[0., 0.]], dtype=float16)Dans l'exemple ci-dessous, nous allons enregistrer une liste de tableaux et un dictionnaire de chaînes. Pour cela, nous utiliserons la fonctionsave().
Example
x = mx.nd.zeros((2,3))
y = mx.nd.ones((1,4))
mx.nd.save('list', [x,y])
mx.nd.save('dict', {'x':x, 'y':y})
mx.nd.load('list')Output
Lors de l'exécution, vous recevrez la sortie suivante -
[
[[0. 0. 0.]
[0. 0. 0.]]
<NDArray 2x3 @cpu(0)>,
[[1. 1. 1. 1.]]
<NDArray 1x4 @cpu(0)>]Example
mx.nd.load('my_dict')Output
La sortie est indiquée ci-dessous -
{'x':
[[0. 0. 0.]
[0. 0. 0.]]
<NDArray 2x3 @cpu(0)>, 'y':
[[1. 1. 1. 1.]]
<NDArray 1x4 @cpu(0)>}