Apache MXNet - API Python ndarray
Questo capitolo spiega la libreria ndarray disponibile in Apache MXNet.
Mxnet.ndarray
La libreria NDArray di Apache MXNet definisce il core DS (strutture dati) per tutti i calcoli matematici. Due compiti fondamentali di NDArray sono i seguenti:
Supporta l'esecuzione rapida su un'ampia gamma di configurazioni hardware.
Parallelizza automaticamente più operazioni sull'hardware disponibile.
L'esempio riportato di seguito mostra come è possibile creare un NDArray utilizzando un 'array' 1-D e 2-D da un normale elenco Python -
import mxnet as mx
from mxnet import nd
x = nd.array([1,2,3,4,5,6,7,8,9,10])
print(x)Output
L'output è fornito di seguito:
[ 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
Questo produce il seguente output:
[[ 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)>Ora parliamo in dettaglio delle classi, delle funzioni e dei parametri dell'API ndarray di MXNet.
Classi
La seguente tabella è composta dalle classi dell'API ndarray di MXNet -
| Classe | Definizione |
|---|---|
| CachedOp (sym [, flags]) | Viene utilizzato per l'handle dell'operatore memorizzato nella cache. |
| NDArray (handle [, scrivibile]) | Viene utilizzato come un oggetto array che rappresenta un array multidimensionale e omogeneo di elementi di dimensione fissa. |
Funzioni e loro parametri
Di seguito sono riportate alcune delle funzioni importanti e dei relativi parametri coperti dall'API mxnet.ndarray:
| Funzione e suoi parametri | Definizione |
|---|---|
| Activation([data, act_type, out, name]) | Applica una funzione di attivazione per elemento all'ingresso. Supporta le funzioni di attivazione relu, sigmoid, tanh, softrelu, softsign. |
| BatchNorm([dati, gamma, beta, moving_mean, ...]) | Viene utilizzato per la normalizzazione batch. Questa funzione normalizza un batch di dati in base alla media e alla varianza. Applica una scala gamma e offset beta. |
| BilinearSampler([dati, griglia, cudnn_off, ...]) |
Questa funzione applica il campionamento bilineare alla mappa delle caratteristiche di input. In realtà è la chiave di "Spatial Transformer Networks". Se hai familiarità con la funzione di rimappatura in OpenCV, l'utilizzo di questa funzione è abbastanza simile a quello. L'unica differenza è che ha il passaggio all'indietro. |
| BlockGrad ([data, out, name]) | Come specificato dal nome, questa funzione interrompe il calcolo del gradiente. Fondamentalmente arresta il gradiente accumulato degli input dal fluire attraverso questo operatore all'indietro. |
| cast ([data, dtype, out, name]) | Questa funzione eseguirà il cast di tutti gli elementi dell'input in un nuovo tipo. |
Esempi di implementazione
Nell'esempio seguente, utilizzeremo la funzione BilinierSampler () per ingrandire i dati due volte e spostare i dati orizzontalmente di -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
Quando esegui il codice sopra, dovresti vedere il seguente output:
[[[[0. 0. 0. 0. ]
[0. 4.0000005 6.25 0. ]
[0. 1.5 4. 0. ]
[0. 0. 0. 0. ]]]]
<NDArray 1x1x4x4 @cpu(0)>L'output sopra mostra lo zoom indietro dei dati due volte.
L'esempio di spostamento dei dati di -1 pixel è il seguente:
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
L'output è indicato di seguito:
[[[[5. 3. 6. 0.]
[8. 7. 9. 0.]
[4. 1. 8. 0.]
[0. 3. 4. 0.]]]]
<NDArray 1x1x4x4 @cpu(0)>Allo stesso modo, il seguente esempio mostra l'uso della funzione cast () -
nd.cast(nd.array([300, 10.1, 15.4, -1, -2]), dtype='uint8')Output
Dopo l'esecuzione, riceverai il seguente output:
[ 44 10 15 255 254]
<NDArray 5 @cpu(0)>ndarray.contrib
L'API Contrib NDArray è definita nel pacchetto ndarray.contrib. In genere fornisce molte API sperimentali utili per nuove funzionalità. Questa API funziona come un luogo per la comunità in cui possono provare le nuove funzionalità. Anche il collaboratore della funzione riceverà il feedback.
Funzioni e loro parametri
Di seguito sono riportate alcune delle funzioni importanti e dei relativi parametri coperti da mxnet.ndarray.contrib API -
| Funzione e suoi parametri | Definizione |
|---|---|
| rand_zipfian(true_classes, num_sampled, ...) | Questa funzione estrae campioni casuali da una distribuzione approssimativamente Zipfian. La distribuzione di base di questa funzione è la distribuzione Zipfian. Questa funzione campiona casualmente num_sampled candidati e gli elementi di sampled_candidates vengono estratti dalla distribuzione di base data sopra. |
| foreach(corpo, dati, stati_iniziali) | Come suggerisce il nome, questa funzione esegue un ciclo for con calcolo definito dall'utente su NDArrays sulla dimensione 0. Questa funzione simula un ciclo for e il corpo ha il calcolo per un'iterazione del ciclo for. |
| while_loop (cond, func, loop_vars [,…]) | Come suggerisce il nome, questa funzione esegue un ciclo while con calcoli definiti dall'utente e condizioni di ciclo. Questa funzione simula un ciclo while che letteralmente esegue calcoli personalizzati se la condizione è soddisfatta. |
| cond(pred, then_func, else_func) | Come suggerisce il nome, questa funzione esegue un if-then-else utilizzando condizioni e calcoli definiti dall'utente. Questa funzione simula un ramo if-like che sceglie di eseguire uno dei due calcoli personalizzati in base alla condizione specificata. |
| isinf(dati) | Questa funzione esegue un controllo in base agli elementi per determinare se NDArray contiene un elemento infinito o meno. |
| getnnz([dati, asse, uscita, nome]) | Questa funzione ci fornisce il numero di valori memorizzati per un tensore sparso. Include anche zeri espliciti. Supporta solo la matrice CSR sulla CPU. |
| riquantizza ([dati, intervallo_min, intervallo_max, ...]) | Questa funzione riquantizza i dati forniti che vengono quantizzati in int32 e le soglie corrispondenti, in int8 utilizzando le soglie min e max calcolate a runtime o dalla calibrazione. |
Esempi di implementazione
Nell'esempio seguente, useremo la funzione rand_zipfian per disegnare campioni casuali da una distribuzione approssimativamente Zipfian -
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
Vedrai il seguente output:
[0 0 1]
<NDArray 3 @cpu(0)>Example
exp_count_trueOutput
L'output è fornito di seguito:
[0.53624076]
<NDArray 1 @cpu(0)>Example
exp_count_sampleOutput
Questo produce il seguente output:
[1.29202967 1.29202967 0.75578891]
<NDArray 3 @cpu(0)>Nell'esempio seguente, useremo la funzione while_loop per eseguire un ciclo while per il calcolo definito dall'utente e la condizione del ciclo:
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
L'output è mostrato di seguito:
[
[[ 1]
[ 2]
[ 4]
[ 7]
[ 11]
[ 16]
[ 22]
[ 29]
[3152434450384]
[ 257]]
<NDArray 10x1 @cpu(0)>]Example
StatesOutput
Questo produce il seguente output:
[
[8]
<NDArray 1 @cpu(0)>,
[29]
<NDArray 1 @cpu(0)>]ndarray.image
L'API Image NDArray è definita nel pacchetto ndarray.image. Come suggerisce il nome, viene tipicamente utilizzato per le immagini e le loro caratteristiche.
Funzioni e loro parametri
Di seguito sono riportate alcune delle funzioni importanti e dei relativi parametri coperti da mxnet.ndarray.image API-
| Funzione e suoi parametri | Definizione |
|---|---|
| adjust_lighting([data, alpha, out, name]) | Come suggerisce il nome, questa funzione regola il livello di illuminazione dell'ingresso. Segue lo stile AlexNet. |
| crop([dati, x, y, larghezza, altezza, fuori, nome]) | Con l'aiuto di questa funzione, possiamo ritagliare un'immagine NDArray di forma (H x W x C) o (N x H x L x C) alla dimensione fornita dall'utente. |
| normalize([data, mean, std, out, name]) | Normalizzerà un tensore di forma (C x H x W) o (N x C x H x W) con mean e standard deviation(SD). |
| random_crop ([data, xrange, yrange, width, ...]) | Simile a crop (), ritaglia in modo casuale un'immagine NDArray di forma (H x L x C) o (N x H x L x C) alla dimensione fornita dall'utente. Sovracampiona il risultato se src è inferiore alla dimensione. |
| random_lighting([data, alpha_std, out, name]) | Come suggerisce il nome, questa funzione aggiunge il rumore PCA in modo casuale. Segue anche lo stile AlexNet. |
| random_resized_crop([data, xrange, yrange, ...]) | Ritaglia anche un'immagine in modo casuale NDArray di forma (H x L x C) o (N x A x L x C) alla dimensione data. Sovracampiona il risultato, se src è inferiore alla dimensione. Inoltre randomizzerà anche l'area e le proporzioni. |
| resize([data, size, keep_ratio, interp, ...]) | Come suggerisce il nome, questa funzione ridimensionerà un'immagine NDArray di forma (H x W x C) o (N x H x L x C) alla dimensione fornita dall'utente. |
| to_tensor([data, out, name]) | Converte un'immagine NDArray di forma (H x W x C) o (N x H x W x C) con i valori nell'intervallo [0, 255] in un tensore NDArray di forma (C x H x W) o ( N x C x H x W) con i valori nell'intervallo [0, 1]. |
Esempi di implementazione
Nell'esempio seguente, utilizzeremo la funzione to_tensor per convertire l'immagine NDArray di forma (H x L x C) o (N x H x L x C) con i valori nell'intervallo [0, 255] in un tensore NDArray di forma (C x H x W) o (N x C x H x W) con i valori nell'intervallo [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
Vedrai il seguente output:
[[[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
Quando esegui il codice, vedrai il seguente output:
[[[[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)>Nell'esempio seguente, useremo la funzione normalize per normalizzare un tensore di forma (C x H x W) o (N x C x H x W) con mean e 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
Questo produce il seguente output:
[[[ 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
Quando esegui il codice sopra, dovresti vedere il seguente output:
[[[[ 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 è definita nel pacchetto ndarray.random. Come suggerisce il nome, è il generatore di distribuzione casuale NDArray API di MXNet.
Funzioni e loro parametri
Di seguito sono riportate alcune delle funzioni importanti e dei relativi parametri coperti da mxnet.ndarray.random API -
| Funzione e suoi parametri | Definizione |
|---|---|
| uniforme ([low, high, shape, dtype, ctx, out]) | Genera campioni casuali da una distribuzione uniforme. |
| normale ([loc, scale, shape, dtype, ctx, out]) | Genera campioni casuali da una distribuzione normale (gaussiana). |
| randn (* forma, ** kwargs) | Genera campioni casuali da una distribuzione normale (gaussiana). |
| esponenziale ([scale, shape, dtype, ctx, out]) | Genera campioni da una distribuzione esponenziale. |
| gamma ([alpha, beta, shape, dtype, ctx, out]) | Genera campioni casuali da una distribuzione gamma. |
| multinomiale (data [, shape, get_prob, out, dtype]) | Genera campionamento simultaneo da più distribuzioni multinomiali. |
| negativo_binomiale ([k, p, forma, dtype, ctx, out]) | Genera campioni casuali da una distribuzione binomiale negativa. |
| generalized_negative_binomial ([mu, alpha,…]) | Genera campioni casuali da una distribuzione binomiale negativa generalizzata. |
| shuffle (dati, ** kwargs) | Mescola gli elementi in modo casuale. |
| randint (basso, alto [, forma, dtype, ctx, out]) | Genera campioni casuali da una distribuzione uniforme discreta. |
| exponential_like ([data, lam, out, name]) | Genera campioni casuali da una distribuzione esponenziale in base alla forma dell'array di input. |
| gamma_like ([data, alpha, beta, out, name]) | Genera campioni casuali da una distribuzione gamma in base alla forma dell'array di input. |
| generalized_negative_binomial_like ([data,…]) | Genera campioni casuali da una distribuzione binomiale negativa generalizzata, in base alla forma dell'array di input. |
| negative_binomial_like ([data, k, p, out, name]) | Genera campioni casuali da una distribuzione binomiale negativa, in base alla forma dell'array di input. |
| normal_like ([data, loc, scale, out, name]) | Genera campioni casuali da una distribuzione normale (gaussiana), in base alla forma dell'array di input. |
| poisson_like ([data, lam, out, name]) | Genera campioni casuali da una distribuzione di Poisson, in base alla forma dell'array di input. |
| uniform_like ([data, low, high, out, name]) | Genera campioni casuali da una distribuzione uniforme, in base alla forma dell'array di input. |
Esempi di implementazione
Nell'esempio seguente, disegneremo campioni casuali da una distribuzione uniforme. Per questo utilizzerà la funzioneuniform().
mx.nd.random.uniform(0, 1)Output
L'output è menzionato di seguito:
[0.12381998]
<NDArray 1 @cpu(0)>Example
mx.nd.random.uniform(-1, 1, shape=(2,))Output
L'output è fornito di seguito:
[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
Vedrai il seguente output:
[[1.8649333 1.8073189]
[2.4113967 2.5691009]
[3.1399727 3.4071832]]
<NDArray 3x2 @cpu(0)>Nell'esempio seguente, trarremo campioni casuali da una distribuzione binomiale negativa generalizzata. Per questo, useremo la funzionegeneralized_negative_binomial().
mx.nd.random.generalized_negative_binomial(10, 0.5)Output
Quando esegui il codice sopra, dovresti vedere il seguente output:
[1.]
<NDArray 1 @cpu(0)>Example
mx.nd.random.generalized_negative_binomial(10, 0.5, shape=(2,))Output
L'output è fornito di seguito:
[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
Di seguito è riportato l'output del codice:
[[0. 0.]
[4. 1.]
[9. 3.]]
<NDArray 3x2 @cpu(0)>ndarray.utils
L'utilità NDArray API è definita nel pacchetto ndarray.utils. Come suggerisce il nome, fornisce le funzioni di utilità per NDArray e BaseSparseNDArray.
Funzioni e loro parametri
Di seguito sono riportate alcune delle funzioni importanti e dei relativi parametri coperti da mxnet.ndarray.utils API -
| Funzione e suoi parametri | Definizione |
|---|---|
| zeri (forma [, ctx, dtype, stype]) | Questa funzione restituirà un nuovo array di forma e tipo dati, riempito con zeri. |
| vuoto (forma [, ctx, dtype, stype]) | Restituirà un nuovo array di forma e tipo dati, senza inizializzare le voci. |
| array (array_origine [, ctx, dtype]) | Come suggerisce il nome, questa funzione creerà un array da qualsiasi oggetto che espone l'interfaccia dell'array. |
| caricare (fname) | Caricherà un array dal file. |
| load_frombuffer (buf) | Come suggerisce il nome, questa funzione caricherà un dizionario o un elenco di array da un buffer |
| salva (fname, dati) | Questa funzione salverà un elenco di array o un dict di str-> array in un file. |
Esempi di implementazione
Nell'esempio seguente, restituiremo un nuovo array di una determinata forma e tipo, riempito con zeri. Per questo, useremo la funzionezeros().
mx.nd.zeros((1,2), mx.cpu(), stype='csr')Output
Questo produce il seguente output:
<CSRNDArray 1x2 @cpu(0)>Example
mx.nd.zeros((1,2), mx.cpu(), 'float16', stype='row_sparse').asnumpy()Output
Riceverai il seguente output:
array([[0., 0.]], dtype=float16)Nell'esempio seguente, salveremo un elenco di array e un dizionario di stringhe. Per questo, useremo la funzionesave().
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
Dopo l'esecuzione, riceverai il seguente output:
[
[[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
L'output è mostrato di seguito:
{'x':
[[0. 0. 0.]
[0. 0. 0.]]
<NDArray 2x3 @cpu(0)>, 'y':
[[1. 1. 1. 1.]]
<NDArray 1x4 @cpu(0)>}