Apache MXNet - Simbolo API Python
In questo capitolo, impareremo a conoscere un'interfaccia in MXNet che viene definita Simbolo.
Mxnet.ndarray
L'API Symbol di Apache MXNet è un'interfaccia per la programmazione simbolica. L'API dei simboli offre l'uso di quanto segue:
Grafici computazionali
Utilizzo della memoria ridotto
Ottimizzazione della funzione pre-utilizzo
L'esempio riportato di seguito mostra come creare un'espressione semplice utilizzando l'API dei simboli di MXNet:
Un NDArray utilizzando un 'array' 1-D e 2-D da un normale elenco Python -
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
Vedrai il seguente output:
<Symbol _plus0>Example
(x, y, z)Output
L'output è fornito di seguito:
(<Symbol x>, <Symbol y>, <Symbol _plus0>)Ora parliamo in dettaglio delle classi, delle funzioni e dei parametri dell'API ndarray di MXNet.
Classi
La seguente tabella è composta dalle classi di Symbol API di MXNet -
| Classe | Definizione |
|---|---|
| Simbolo (maniglia) | Questa classe, ovvero il simbolo, è il grafico simbolico di Apache MXNet. |
Funzioni e loro parametri
Di seguito sono riportate alcune delle funzioni importanti e dei relativi parametri coperti da mxnet.Symbol API -
| Funzione e suoi parametri | Definizione |
|---|---|
| Attivazione ([data, act_type, out, name]) | Applica una funzione di attivazione per elemento all'ingresso. Supportarelu, sigmoid, tanh, softrelu, softsign funzioni di attivazione. |
| BatchNorm ([dati, gamma, beta, moving_mean, ...]) | Viene utilizzato per la normalizzazione batch. Questa funzione normalizza un batch di dati per media e varianza. Applica una scalagamma e offset beta. |
| BilinearSampler ([data, grid, 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. |
| Questa funzione eseguirà il cast di tutti gli elementi dell'input in un nuovo tipo. | Questa funzione, come specificato dal nome, restituisce un nuovo simbolo di forma e tipo dati, riempito con zeri. |
| quelli (forma [, dtype]) | Questa funzione, come specificato dal nome, restituisce un nuovo simbolo di forma e tipo dati, riempito con uno. |
| full (shape, val [, dtype]) | Questa funzione, come il nome specificato, restituisce un nuovo array di forma e tipo dati, riempito con il valore dato val. |
| arange (start [, stop, step, repeat, ...]) | Restituirà valori equidistanti entro un dato intervallo. I valori vengono generati all'interno dell'intervallo semiaperto [avvio, arresto), il che significa che l'intervallo includestart ma esclude stop. |
| linspace (inizio, fine, num [, punto finale, nome, ...]) | Restituirà numeri equidistanti entro un intervallo specificato. Analogamente alla funzione organizzare (), i valori vengono generati entro un intervallo semiaperto [start, stop), il che significa che l'intervallo includestart ma esclude stop. |
| istogramma (a [, bin, range]) | Come suggerisce il nome, questa funzione calcolerà l'istogramma dei dati di input. |
| potenza (base, esp) | Come suggerisce il nome, questa funzione restituirà il risultato in termini di elemento di base elemento elevato a potenze da expelemento. Entrambi gli input, ovvero base ed exp, possono essere Symbol o scalare. Si noti che la trasmissione non è consentita. Puoi usarebroadcast_pow se vuoi usare la funzione di trasmissione. |
| SoftmaxActivation ([data, mode, name, attr, out]) | Questa funzione applica l'attivazione softmax all'ingresso. È inteso per strati interni. In realtà è deprecato, possiamo usaresoftmax() anziché. |
Esempi di implementazione
Nell'esempio seguente useremo la funzione power() che restituirà il risultato in termini di elemento dell'elemento base elevato alle potenze dell'elemento exp:
import mxnet as mx
mx.sym.power(3, 5)Output
Vedrai il seguente output:
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
Questo produce il seguente output:
array([1., 8.], dtype=float32)Example
z = mx.sym.power(4, y)
z.eval(y=mx.nd.array([2,3]))[0].asnumpy()Output
Quando esegui il codice sopra, dovresti vedere il seguente output:
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
L'output è menzionato di seguito:
array([ 16., 125.], dtype=float32)Nell'esempio riportato di seguito, utilizzeremo la funzione SoftmaxActivation() (or softmax()) che verrà applicato all'input ed è inteso per i livelli interni.
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
Vedrai il seguente output:
[[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]]symbol.contrib
L'API Contrib NDArray è definita nel pacchetto symbol.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.symbol.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 (body, data, init_states) | Come suggerisce il nome, questa funzione esegue un ciclo con il 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. |
| 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 dati che vengono quantizzati in int32 e le soglie corrispondenti, in int8 utilizzando le soglie min e max calcolate a runtime o dalla calibrazione. |
| index_copy ([old_tensor, index_vector,…]) | Questa funzione copia gli elementi di un file 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 ([query,…]) | Questo operatore calcola la moltiplicazione della matrice tra le proiezioni di query e chiavi nell'uso dell'attenzione multi-head come codificatore-decodificatore. La condizione è che gli input siano un tensore delle proiezioni delle query che segue il layout: (seq_length, batch_size, num_heads *, head_dim). |
Esempi di implementazione
Nell'esempio seguente useremo la funzione rand_zipfian per disegnare campioni casuali da una distribuzione approssimativamente Zipfian -
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
Vedrai il seguente output:
array([4, 0, 2, 1, 5], dtype=int64)Example
exp_count_true.eval(true_cls=mx.nd.array([3]))[0].asnumpy()Output
L'output è menzionato di seguito:
array([0.57336551])Example
exp_count_sample.eval(true_cls=mx.nd.array([3]))[0].asnumpy()Output
Vedrai il seguente output:
array([1.78103594, 0.46847373, 1.04183923, 0.57336551, 1.04183923])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_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
L'output è fornito di seguito:
[<Symbol _while_loop0>]Example
Print(States)Output
Questo produce il seguente output:
[<Symbol _while_loop0>, <Symbol _while_loop0>]Nell'esempio seguente useremo la funzione index_copy che copia gli elementi di new_tensor in 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
Quando esegui il codice sopra, dovresti vedere il seguente output:
[[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 dei simboli immagine è definita nel pacchetto symbol.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.symbol.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. |
| ritaglio ([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 W x C) alla dimensione fornita dall'utente. |
| normalizzare ([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 sesrc è più piccolo di size. |
| 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 l'aspetto. |
| ridimensiona ([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.sym.random.uniform(0, 255, (4, 2, 3)).astype(dtype=np.uint8)
mx.sym.image.to_tensor(img)Output
L'output è indicato di seguito:
<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
L'output è menzionato di seguito:
<Symbol to_tensor5>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.sym.random.uniform(0, 1, (3, 4, 2))
mx.sym.image.normalize(img, mean=(0, 1, 2), std=(3, 2, 1))Output
Di seguito è riportato l'output del codice:
<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
L'output è mostrato di seguito:
<Symbol normalize1>symbol.random
L'API Random Symbol è definita nel pacchetto symbol.random. Come suggerisce il nome, è un generatore di distribuzione casuale Symbol API di MXNet.
Funzioni e loro parametri
Di seguito sono riportate alcune delle funzioni importanti e dei relativi parametri coperti da mxnet.symbol.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). |
| poisson ([lam, shape, dtype, ctx, out]) | Genera campioni casuali da una distribuzione di Poisson. |
| 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, mescoleremo gli elementi in modo casuale usando la funzione shuffle (). Mescolerà l'array lungo il primo asse.
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
Vedrai il seguente output:
[
[[ 9. 10. 11.]
[ 0. 1. 2.]
[ 6. 7. 8.]
[ 3. 4. 5.]]
<NDArray 4x3 @cpu(0)>]Example
y.eval(x=data)Output
Quando esegui il codice sopra, dovresti vedere il seguente output:
[
[[ 6. 7. 8.]
[ 0. 1. 2.]
[ 3. 4. 5.]
[ 9. 10. 11.]]
<NDArray 4x3 @cpu(0)>]Nell'esempio seguente, trarremo campioni casuali da una distribuzione binomiale negativa generalizzata. Per questo utilizzerà la funzionegeneralized_negative_binomial().
mx.sym.random.generalized_negative_binomial(10, 0.1)Output
L'output è fornito di seguito:
<Symbol _random_generalized_negative_binomial0>symbol.sparse
L'API dei simboli sparse è definita nel pacchetto mxnet.symbol.sparse. Come suggerisce il nome, fornisce grafici di rete neurale sparsi e auto-differenziazione sulla CPU.
Funzioni e loro parametri
Di seguito sono riportate alcune delle funzioni importanti (include routine per la creazione di simboli, routine di manipolazione dei simboli, funzioni matematiche, funzione trigonometrica, funzioni iberboliche, funzioni di riduzione, arrotondamento, poteri, rete neurale) e relativi parametri coperti da mxnet.symbol.sparse API -
| Funzione e suoi parametri | Definizione |
|---|---|
| ElementWiseSum (* args, ** kwargs) | Questa funzione aggiungerà tutti gli argomenti di input in base agli elementi. Ad esempio, _ (1,2,… = 1 + 2 + ⋯ +). Qui, possiamo vedere che add_n è potenzialmente più efficiente della chiamata add by n volte. |
| Incorporamento ([data, weight, input_dim, ...]) | Mapperà gli indici interi su rappresentazioni vettoriali, ovvero incorporamenti. In realtà mappa le parole su vettori di valore reale nello spazio ad alta dimensione che viene chiamato word embedding. |
| LinearRegressionOutput ([data, label, ...]) | Calcola e ottimizza la perdita al quadrato durante la propagazione all'indietro fornendo solo i dati di output durante la propagazione in avanti. |
| LogisticRegressionOutput ([data, label, ...]) | Applica all'ingresso una funzione logistica chiamata anche funzione sigmoide. La funzione è calcolata come 1/1 + exp (−x). |
| MAERegressionOutput ([data, label, ...]) | Questo operatore calcola l'errore assoluto medio dell'input. MAE è in realtà una metrica di rischio corrispondente al valore atteso dell'errore assoluto. |
| abs ([data, name, attr, out]) | Come suggerisce il nome, questa funzione restituirà il valore assoluto dell'input in termini di elemento. |
| adagrad_update ([weight, grad, history, lr, ...]) | È una funzione di aggiornamento per AdaGrad optimizer. |
| adam_update ([weight, grad, mean, var, lr,…]) | È una funzione di aggiornamento per Adam optimizer. |
| add_n (* args, ** kwargs) | Come suggerisce il nome, aggiungerà tutti gli argomenti di input per elemento. |
| arccos ([data, name, attr, out]) | Questa funzione restituirà il coseno inverso rispetto agli elementi della matrice di input. |
| punto ([lhs, rhs, transpose_a, transpose_b, ...]) | Come suggerisce il nome, darà il prodotto scalare di due array. Dipenderà dalla dimensione della matrice di input: 1-D: prodotto interno dei vettori 2-D: moltiplicazione di matrici ND: un prodotto di somma sull'ultimo asse del primo ingresso e sul primo asse del secondo ingresso. |
| elemwise_add ([lhs, rhs, name, attr, out]) | Come suggerisce il nome, lo farà add argomento saggio elemento. |
| elemwise_div ([lhs, rhs, name, attr, out]) | Come suggerisce il nome, lo farà divide argomento saggio elemento. |
| elemwise_mul ([lhs, rhs, name, attr, out]) | Come suggerisce il nome, lo farà Multiply argomento saggio elemento. |
| elemwise_sub ([lhs, rhs, name, attr, out]) | Come suggerisce il nome, sottrarrà gli argomenti in base agli elementi. |
| exp ([data, name, attr, out]) | Questa funzione restituirà il valore esponenziale saggio dell'elemento dell'input fornito. |
| sgd_update ([weight, grad, lr, wd, ...]) | Agisce come una funzione di aggiornamento per l'ottimizzatore Stochastic Gradient Descent. |
| sigmoid ([data, name, attr, out]) | Come suggerisce il nome, calcolerà sigmoid di x elemento saggio. |
| sign ([data, name, attr, out]) | Restituirà il segno saggio dell'elemento dell'input fornito. |
| sin ([data, name, attr, out]) | Come suggerisce il nome, questa funzione calcolerà il seno saggio dell'elemento dell'array di input specificato. |
Esempio di implementazione
Nell'esempio seguente, mescoleremo gli elementi in modo casuale usando ElementWiseSum()funzione. Mapperà gli indici interi a rappresentazioni vettoriali, cioè incorporamenti di parole.
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.]]]