Apache MXNet - Gluon API Python
Come abbiamo già discusso nei capitoli precedenti, MXNet Gluon fornisce un'API chiara, concisa e semplice per i progetti DL. Consente ad Apache MXNet di prototipare, costruire e addestrare modelli DL senza perdere la velocità di addestramento.
Moduli principali
Impariamo i moduli principali di Apache MXNet Python application programming interface (API) gluon.
gluon.nn
Gluon fornisce un gran numero di livelli NN incorporati nel modulo gluon.nn. Questo è il motivo per cui è chiamato il modulo principale.
Metodi e loro parametri
Di seguito sono riportati alcuni dei metodi importanti e dei relativi parametri coperti da mxnet.gluon.nn modulo principale -
Metodi e suoi parametri | Definizione |
---|---|
Attivazione (attivazione, ** kwargs) | Come suggerisce il nome, questo metodo applica una funzione di attivazione all'input. |
AvgPool1D ([pool_size, strides, padding, ...]) | Questa è un'operazione di pooling media per i dati temporali. |
AvgPool2D ([pool_size, strides, padding, ...]) | Questa è un'operazione di pooling media per i dati spaziali. |
AvgPool3D ([pool_size, strides, padding, ...]) | Questa è un'operazione di pooling media per i dati 3D. I dati possono essere spaziali o spazio-temporali. |
BatchNorm ([asse, quantità di moto, epsilon, centro, ...]) | Rappresenta il livello di normalizzazione batch. |
BatchNormReLU ([axis, momentum, epsilon, ...]) | Rappresenta anche il livello di normalizzazione batch ma con la funzione di attivazione Relu. |
Blocca ([prefix, params]) | Fornisce la classe base per tutti i livelli e modelli di rete neurale. |
Conv1D (canali, kernel_size [, strides, ...]) | Questo metodo viene utilizzato per lo strato di convoluzione 1-D. Ad esempio, convoluzione temporale. |
Conv1DTranspose (canali, kernel_size [, ...]) | Questo metodo viene utilizzato per il livello di convoluzione 1D trasposto. |
Conv2D (canali, kernel_size [, strides, ...]) | Questo metodo viene utilizzato per il livello di convoluzione 2D. Ad esempio, convoluzione spaziale sulle immagini). |
Conv2DTranspose (canali, kernel_size [, ...]) | Questo metodo viene utilizzato per il livello di convoluzione 2D trasposto. |
Conv3D (canali, kernel_size [, strides, ...]) | Questo metodo viene utilizzato per il livello di convoluzione 3D. Ad esempio, convoluzione spaziale sui volumi. |
Conv3DTranspose (canali, kernel_size [, ...]) | Questo metodo viene utilizzato per il livello di convoluzione 3D trasposto. |
Denso (unità [, attivazione, use_bias, ...]) | Questo metodo rappresenta per il tuo normale livello NN densamente connesso. |
Abbandono (tasso [, assi]) | Come suggerisce il nome, il metodo applica Dropout all'input. |
ELU ([alpha]) | Questo metodo viene utilizzato per Exponential Linear Unit (ELU). |
Incorporamento (input_dim, output_dim [, dtype, ...]) | Trasforma interi non negativi in vettori densi di dimensione fissa. |
Appiattisci (** kwargs) | Questo metodo appiattisce l'input a 2-D. |
GELU (** kwargs) | Questo metodo viene utilizzato per Gaussian Exponential Linear Unit (GELU). |
GlobalAvgPool1D ([layout]) | Con l'aiuto di questo metodo, possiamo eseguire un'operazione di pooling medio globale per i dati temporali. |
GlobalAvgPool2D ([layout]) | Con l'aiuto di questo metodo, possiamo eseguire un'operazione di pooling medio globale per i dati spaziali. |
GlobalAvgPool3D ([layout]) | Con l'aiuto di questo metodo, possiamo eseguire operazioni di pooling medio globale per dati 3-D. |
GlobalMaxPool1D ([layout]) | Con l'aiuto di questo metodo, possiamo eseguire l'operazione di pooling massimo globale per i dati 1-D. |
GlobalMaxPool2D ([layout]) | Con l'aiuto di questo metodo, possiamo eseguire l'operazione di pooling massimo globale per i dati 2D. |
GlobalMaxPool3D ([layout]) | Con l'aiuto di questo metodo, possiamo eseguire l'operazione di pooling massimo globale per i dati 3-D. |
GroupNorm ([num_groups, epsilon, center, ...]) | Questo metodo applica la normalizzazione del gruppo all'array di input nD. |
HybridBlock ([prefix, params]) | Questo metodo supporta l'inoltro con entrambi Symbol e NDArray. |
HybridLambda(funzione [, prefisso]) | Con l'aiuto di questo metodo possiamo racchiudere un operatore o un'espressione come oggetto HybridBlock. |
HybridSequential ([prefix, params]) | Impila gli HybridBlock in sequenza. |
InstanceNorm ([asse, epsilon, centro, scala, ...]) | Questo metodo applica la normalizzazione dell'istanza all'array di input nD. |
Esempi di implementazione
Nell'esempio seguente, useremo Block () che fornisce la classe base per tutti i livelli e modelli di rete neurale.
from mxnet.gluon import Block, nn
class Model(Block):
def __init__(self, **kwargs):
super(Model, self).__init__(**kwargs)
# use name_scope to give child Blocks appropriate names.
with self.name_scope():
self.dense0 = nn.Dense(20)
self.dense1 = nn.Dense(20)
def forward(self, x):
x = mx.nd.relu(self.dense0(x))
return mx.nd.relu(self.dense1(x))
model = Model()
model.initialize(ctx=mx.cpu(0))
model(mx.nd.zeros((5, 5), ctx=mx.cpu(0)))
Output
Vedrai il seguente output:
[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]
<NDArray 5x20 @cpu(0)*gt;
Nell'esempio seguente, utilizzeremo HybridBlock () che supporta l'inoltro sia con Symbol che con NDArray.
import mxnet as mx
from mxnet.gluon import HybridBlock, nn
class Model(HybridBlock):
def __init__(self, **kwargs):
super(Model, self).__init__(**kwargs)
# use name_scope to give child Blocks appropriate names.
with self.name_scope():
self.dense0 = nn.Dense(20)
self.dense1 = nn.Dense(20)
def forward(self, x):
x = nd.relu(self.dense0(x))
return nd.relu(self.dense1(x))
model = Model()
model.initialize(ctx=mx.cpu(0))
model.hybridize()
model(mx.nd.zeros((5, 5), ctx=mx.cpu(0)))
Output
L'output è menzionato di seguito:
[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]
<NDArray 5x20 @cpu(0)>
gluon.rnn
Gluon fornisce un gran numero di build-in recurrent neural network(RNN) strati nel modulo gluon.rnn. Questo è il motivo, è chiamato il modulo principale.
Metodi e loro parametri
Di seguito sono riportati alcuni dei metodi importanti e dei relativi parametri coperti da mxnet.gluon.nn modulo principale:
Metodi e suoi parametri | Definizione |
---|---|
BidirectionalCell (l_cell, r_cell [,…]) | Viene utilizzato per la cella Bidirectional Recurrent Neural Network (RNN). |
DropoutCell (tasso [, assi, prefisso, parametri]) | Questo metodo applicherà il dropout sull'input fornito. |
GRU (hidden_size [, num_layers, layout, ...]) | Applica un RNN multi-layer gated recurrent unit (GRU) a una determinata sequenza di input. |
GRUCell (hidden_size [,…]) | Viene utilizzato per la cella di rete Gated Rectified Unit (GRU). |
HybridRecurrentCell ([prefix, params]) | Questo metodo supporta l'ibridazione. |
HybridSequentialRNNCell ([prefix, params]) | Con l'aiuto di questo metodo possiamo impilare sequenzialmente più celle HybridRNN. |
LSTM (hidden_size [, num_layers, layout, ...]) 0 | Applica un RNN di memoria a lungo termine (LSTM) multistrato a una determinata sequenza di input. |
LSTMCell (hidden_size [,…]) | Viene utilizzato per celle di rete LSTM (Long-Short Term Memory). |
ModifierCell (base_cell) | È la classe Base per le celle modificatrici. |
RNN (hidden_size [, num_layers, activation, ...]) | Applica un Elman RNN multistrato con tanh o ReLU non linearità a una data sequenza di input. |
RNNCell (hidden_size [, attivazione, ...]) | Viene utilizzato per la cella di rete neurale ricorrente Elman RNN. |
RecurrentCell ([prefix, params]) | Rappresenta la classe base astratta per le celle RNN. |
SequentialRNNCell ([prefix, params]) | Con l'aiuto di questo metodo possiamo impilare sequenzialmente più celle RNN. |
ZoneoutCell (base_cell [, zoneout_outputs, ...]) | Questo metodo applica Zoneout sulla cella di base. |
Esempi di implementazione
Nell'esempio seguente, utilizzeremo GRU () che applica un RNN di unità ricorrente (GRU) a più livelli a una data sequenza di input.
layer = mx.gluon.rnn.GRU(100, 3)
layer.initialize()
input_seq = mx.nd.random.uniform(shape=(5, 3, 10))
out_seq = layer(input_seq)
h0 = mx.nd.random.uniform(shape=(3, 3, 100))
out_seq, hn = layer(input_seq, h0)
out_seq
Output
Questo produce il seguente output:
[[[ 1.50152072e-01 5.19012511e-01 1.02390535e-01 ... 4.35803324e-01
1.30406499e-01 3.30152437e-02]
[ 2.91542172e-01 1.02243155e-01 1.73325196e-01 ... 5.65296151e-02
1.76546033e-02 1.66693389e-01]
[ 2.22257316e-01 3.76294643e-01 2.11277917e-01 ... 2.28903517e-01
3.43954474e-01 1.52770668e-01]]
[[ 1.40634328e-01 2.93247789e-01 5.50393537e-02 ... 2.30207980e-01
6.61415309e-02 2.70989928e-02]
[ 1.11081995e-01 7.20834285e-02 1.08342394e-01 ... 2.28330195e-02
6.79589901e-03 1.25501186e-01]
[ 1.15944080e-01 2.41565228e-01 1.18612610e-01 ... 1.14908054e-01
1.61080107e-01 1.15969211e-01]]
………………………….
Example
hn
Output
Questo produce il seguente output:
[[[-6.08105101e-02 3.86217088e-02 6.64453954e-03 8.18805695e-02
3.85607071e-02 -1.36945639e-02 7.45836645e-03 -5.46515081e-03
9.49622393e-02 6.39371723e-02 -6.37890724e-03 3.82240303e-02
9.11015049e-02 -2.01375950e-02 -7.29381144e-02 6.93765879e-02
2.71829776e-02 -6.64435029e-02 -8.45306814e-02 -1.03075653e-01
6.72040805e-02 -7.06537142e-02 -3.93818803e-02 5.16211614e-03
-4.79770005e-02 1.10734522e-01 1.56721435e-02 -6.93409378e-03
1.16915874e-01 -7.95962065e-02 -3.06530762e-02 8.42394680e-02
7.60370195e-02 2.17055440e-01 9.85361822e-03 1.16660878e-01
4.08297703e-02 1.24978097e-02 8.25245082e-02 2.28673983e-02
-7.88266212e-02 -8.04114193e-02 9.28791538e-02 -5.70827350e-03
-4.46166918e-02 -6.41122833e-02 1.80885363e-02 -2.37745279e-03
4.37298454e-02 1.28888980e-01 -3.07202265e-02 2.50503756e-02
4.00907174e-02 3.37077095e-03 -1.78839862e-02 8.90695080e-02
6.30150884e-02 1.11416787e-01 2.12221760e-02 -1.13236710e-01
5.39616570e-02 7.80710578e-02 -2.28817668e-02 1.92073174e-02
………………………….
Nell'esempio seguente useremo LSTM () che applica un RNN di memoria a lungo termine (LSTM) a una data sequenza di input.
layer = mx.gluon.rnn.LSTM(100, 3)
layer.initialize()
input_seq = mx.nd.random.uniform(shape=(5, 3, 10))
out_seq = layer(input_seq)
h0 = mx.nd.random.uniform(shape=(3, 3, 100))
c0 = mx.nd.random.uniform(shape=(3, 3, 100))
out_seq, hn = layer(input_seq,[h0,c0])
out_seq
Output
L'output è menzionato di seguito:
[[[ 9.00025964e-02 3.96071747e-02 1.83841765e-01 ... 3.95872220e-02
1.25569820e-01 2.15555862e-01]
[ 1.55962542e-01 -3.10300849e-02 1.76772922e-01 ... 1.92474753e-01
2.30574399e-01 2.81707942e-02]
[ 7.83204585e-02 6.53361529e-03 1.27262697e-01 ... 9.97719541e-02
1.28254429e-01 7.55299702e-02]]
[[ 4.41036932e-02 1.35250352e-02 9.87644792e-02 ... 5.89378644e-03
5.23949116e-02 1.00922674e-01]
[ 8.59075040e-02 -1.67027581e-02 9.69351009e-02 ... 1.17763653e-01
9.71239135e-02 2.25218050e-02]
[ 4.34580036e-02 7.62207608e-04 6.37005866e-02 ... 6.14888743e-02
5.96345589e-02 4.72368896e-02]]
……………
Example
hn
Output
Quando esegui il codice, vedrai il seguente output:
[
[[[ 2.21408084e-02 1.42750628e-02 9.53067932e-03 -1.22849066e-02
1.78788435e-02 5.99269159e-02 5.65306023e-02 6.42553642e-02
6.56616641e-03 9.80876666e-03 -1.15729487e-02 5.98640442e-02
-7.21173314e-03 -2.78371759e-02 -1.90690923e-02 2.21447181e-02
8.38765781e-03 -1.38521893e-02 -9.06938594e-03 1.21346042e-02
6.06449470e-02 -3.77471633e-02 5.65885007e-02 6.63008019e-02
-7.34188128e-03 6.46054149e-02 3.19911093e-02 4.11194898e-02
4.43960279e-02 4.92892228e-02 1.74766723e-02 3.40303481e-02
-5.23341820e-03 2.68163737e-02 -9.43402853e-03 -4.11836170e-02
1.55221792e-02 -5.05655073e-02 4.24557598e-03 -3.40388380e-02
……………………
Moduli di formazione
I moduli di formazione in Gluon sono i seguenti:
gluon.loss
Nel mxnet.gluon.lossmodulo, Gluon fornisce una funzione di perdita predefinita. Fondamentalmente, ha le perdite per l'addestramento della rete neurale. Questo è il motivo per cui si chiama modulo di formazione.
Metodi e loro parametri
Di seguito sono riportati alcuni dei metodi importanti e dei relativi parametri coperti da mxnet.gluon.loss modulo di formazione:
Metodi e suoi parametri | Definizione |
---|---|
Perdita (peso, batch_axis, ** kwarg) | Questo funge da classe base per la perdita. |
L2Loss ([peso, batch_axis]) | Calcola l'errore quadratico medio (MSE) tra label e prediction(pred). |
L1Loss ([weight, batch_axis]) | Calcola l'errore medio assoluto (MAE) tra label e pred. |
SigmoidBinaryCrossEntropyLoss ([…]) | Questo metodo viene utilizzato per la perdita di entropia incrociata per la classificazione binaria. |
SigmoidBCELoss | Questo metodo viene utilizzato per la perdita di entropia incrociata per la classificazione binaria. |
SoftmaxCrossEntropyLoss ([axis,…]) | Calcola la softmax cross-entropy loss (CEL). |
SoftmaxCELoss | Calcola anche la perdita di entropia incrociata softmax. |
KLDivLoss ([from_logits, axis, weight, ...]) | Viene utilizzato per la perdita di divergenza Kullback-Leibler. |
CTCLoss ([layout, label_layout, weight]) | Viene utilizzato per la perdita di classificazione temporale (TCL) connessionista. |
HuberLoss ([rho, weight, batch_axis]) | Calcola la perdita L1 livellata. La perdita L1 livellata sarà uguale alla perdita L1 se l'errore assoluto supera rho, altrimenti è uguale alla perdita L2. |
HingeLoss ([margin, weight, batch_axis]) | Questo metodo calcola la funzione di perdita della cerniera spesso utilizzata negli SVM: |
SquaredHingeLoss ([margin, weight, batch_axis]) | Questo metodo calcola la funzione di perdita di margine flessibile utilizzata negli SVM: |
LogisticLoss ([weight, batch_axis, label_format]) | Questo metodo calcola la perdita logistica. |
TripletLoss ([margin, weight, batch_axis]) | Questo metodo calcola la perdita di triplette dati tre tensori di input e un margine positivo. |
PoissonNLLLoss ([weight, from_logits,…]) | La funzione calcola la perdita di probabilità del log negativo. |
CosineEmbeddingLoss ([weight, batch_axis, margin]) | La funzione calcola la distanza del coseno tra i vettori. |
SDMLLoss ([smoothing_parameter, weight,…]) | Questo metodo calcola la perdita SDML (Batchwise Smoothed Deep Metric Learning) data due tensori di input e una perdita SDM di peso livellante. Apprende la somiglianza tra campioni accoppiati utilizzando campioni non accoppiati nel minibatch come potenziali esempi negativi. |
Esempio
Come lo sappiamo mxnet.gluon.loss.losscalcolerà il MSE (Mean Squared Error) tra etichetta e previsione (pred). È fatto con l'aiuto della seguente formula:
gluon.parameter
mxnet.gluon.parameter è un contenitore che contiene i parametri cioè i pesi dei blocchi.
Metodi e loro parametri
Di seguito sono riportati alcuni dei metodi importanti e dei relativi parametri coperti da mxnet.gluon.parameter modulo di formazione -
Metodi e suoi parametri | Definizione |
---|---|
cast (dtype) | Questo metodo eseguirà il cast dei dati e del gradiente di questo parametro su un nuovo tipo di dati. |
dati ([ctx]) | Questo metodo restituirà una copia di questo parametro in un contesto. |
grad ([ctx]) | Questo metodo restituirà un buffer del gradiente per questo parametro in un contesto. |
inizializza ([init, ctx, default_init, ...]) | Questo metodo inizializzerà gli array di parametri e gradienti. |
list_ctx () | Questo metodo restituirà un elenco di contesti in cui questo parametro è inizializzato. |
list_data () | Questo metodo restituirà copie di questo parametro in tutti i contesti. Verrà eseguito nello stesso ordine della creazione. |
list_grad () | Questo metodo restituirà buffer sfumati in tutti i contesti. Ciò avverrà nello stesso ordine divalues(). |
list_row_sparse_data (row_id) | Questo metodo restituirà copie del parametro "row_sparse" in tutti i contesti. Ciò avverrà nello stesso ordine della creazione. |
reset_ctx (ctx) | Questo metodo riassegnerà il parametro ad altri contesti. |
row_sparse_data (row_id) | Questo metodo restituirà una copia del parametro "row_sparse" nello stesso contesto di row_id. |
set_data (dati) | Questo metodo imposterà il valore di questo parametro in tutti i contesti. |
var () | Questo metodo restituirà un simbolo che rappresenta questo parametro. |
zero_grad () | Questo metodo imposterà il buffer del gradiente su tutti i contesti su 0. |
Esempio di implementazione
Nell'esempio seguente, inizializzeremo i parametri e le matrici dei gradienti utilizzando il metodo initialize () come segue:
weight = mx.gluon.Parameter('weight', shape=(2, 2))
weight.initialize(ctx=mx.cpu(0))
weight.data()
Output
L'output è menzionato di seguito:
[[-0.0256899 0.06511251]
[-0.00243821 -0.00123186]]
<NDArray 2x2 @cpu(0)>
Example
weight.grad()
Output
L'output è fornito di seguito:
[[0. 0.]
[0. 0.]]
<NDArray 2x2 @cpu(0)>
Example
weight.initialize(ctx=[mx.gpu(0), mx.gpu(1)])
weight.data(mx.gpu(0))
Output
Vedrai il seguente output:
[[-0.00873779 -0.02834515]
[ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(0)>
Example
weight.data(mx.gpu(1))
Output
Quando esegui il codice sopra, dovresti vedere il seguente output:
[[-0.00873779 -0.02834515]
[ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(1)>
gluon.trainer
mxnet.gluon.trainer applica un ottimizzatore a una serie di parametri. Dovrebbe essere usato insieme ad autograd.
Metodi e loro parametri
Di seguito sono riportati alcuni dei metodi importanti e dei relativi parametri coperti da mxnet.gluon.trainer modulo di formazione -
Metodi e suoi parametri | Definizione |
---|---|
allreduce_grads () | Questo metodo ridurrà i gradienti da diversi contesti per ogni parametro (peso). |
load_states (fname) | Come suggerisce il nome, questo metodo caricherà gli stati del trainer. |
save_states (fname) | Come suggerisce il nome, questo metodo salverà gli stati del trainer. |
set_learning_rate (lr) | Questo metodo imposterà una nuova velocità di apprendimento dell'ottimizzatore. |
passaggio (batch_size [, ignore_stale_grad]) | Questo metodo eseguirà un passaggio dell'aggiornamento dei parametri. Dovrebbe essere chiamato dopoautograd.backward() e al di fuori di record() scopo. |
aggiornamento (batch_size [, ignore_stale_grad]) | Questo metodo eseguirà anche un passaggio dell'aggiornamento dei parametri. Dovrebbe essere chiamato dopoautograd.backward() e al di fuori di record() scope e dopo trainer.update (). |
Moduli dati
I moduli dati di Gluon sono spiegati di seguito:
gluon.data
Gluon fornisce un gran numero di utilità per set di dati incorporate nel modulo gluon.data. Questo è il motivo per cui è chiamato modulo dati.
Classi e loro parametri
Di seguito sono riportati alcuni dei metodi importanti e dei relativi parametri coperti dal modulo principale mxnet.gluon.data. Questi metodi sono in genere correlati a set di dati, campionamento e DataLoader.
Set di datiMetodi e suoi parametri | Definizione |
---|---|
ArrayDataset (* args) | Questo metodo rappresenta un set di dati che combina due o più di due oggetti simili a un set di dati. Ad esempio, set di dati, elenchi, array, ecc. |
BatchSampler (campionatore, batch_size [, last_batch]) | Questo metodo avvolge un altro Sampler. Una volta confezionato restituisce i mini lotti di campioni. |
DataLoader (set di dati [, batch_size, shuffle, ...]) | Simile a BatchSampler ma questo metodo carica i dati da un set di dati. Una volta caricato restituisce i mini batch di dati. |
Questo rappresenta la classe del set di dati astratto. | |
FilterSampler (fn, set di dati) | Questo metodo rappresenta gli elementi di esempio da un set di dati per il quale fn (funzione) restituisce True. |
RandomSampler (lunghezza) | Questo metodo rappresenta campioni di elementi da [0, length) in modo casuale senza sostituzione. |
RecordFileDataset (nome file) | Rappresenta un set di dati che avvolge un file RecordIO. L'estensione del file è.rec. |
Campionatore | Questa è la classe base per i campionatori. |
SequentialSampler (lunghezza [, inizio]) | Rappresenta gli elementi campione dell'insieme [inizio, inizio + lunghezza) in sequenza. |
Rappresenta gli elementi campione dell'insieme [inizio, inizio + lunghezza) in sequenza. | Questo rappresenta il semplice wrapper del set di dati soprattutto per elenchi e array. |
Esempi di implementazione
Nell'esempio seguente, useremo gluon.data.BatchSampler()API, che avvolge un altro campionatore. Restituisce i mini lotti di campioni.
import mxnet as mx
from mxnet.gluon import data
sampler = mx.gluon.data.SequentialSampler(15)
batch_sampler = mx.gluon.data.BatchSampler(sampler, 4, 'keep')
list(batch_sampler)
Output
L'output è menzionato di seguito:
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14]]
gluon.data.vision.datasets
Gluon fornisce un gran numero di funzioni di dataset di visione predefinite in gluon.data.vision.datasets modulo.
Classi e loro parametri
MXNet ci fornisce set di dati utili e importanti, le cui classi e parametri sono riportati di seguito:
Classi e suoi parametri | Definizione |
---|---|
MNIST ([root, train, transform]) | Questo è un set di dati utile che ci fornisce le cifre scritte a mano. L'URL per il set di dati MNIST è http://yann.lecun.com/exdb/mnist |
FashionMNIST ([root, train, transform]) | Questo set di dati è costituito dalle immagini degli articoli di Zalando costituite da prodotti di moda. È una sostituzione immediata del set di dati MNIST originale. Puoi ottenere questo set di dati da https://github.com/zalandoresearch/fashion-mnist |
CIFAR10 ([root, train, transform]) | Questo è un set di dati di classificazione delle immagini da https://www.cs.toronto.edu/~kriz/cifar.html. In questo set di dati ogni campione è un'immagine con forma (32, 32, 3). |
CIFAR100 ([root, fine_label, train, transform]) | Questo è il set di dati di classificazione delle immagini CIFAR100 da https://www.cs.toronto.edu/~kriz/cifar.html. Inoltre, ogni campione è un'immagine con forma (32, 32, 3). |
ImageRecordDataset (nomefile [, flag, transform]) | Questo set di dati sta avvolgendo un file RecordIO che contiene immagini. In questo ogni campione è un'immagine con la sua etichetta corrispondente. |
ImageFolderDataset (root [, flag, transform]) | Questo è un set di dati per il caricamento di file di immagine archiviati in una struttura di cartelle. |
ImageListDataset ([root, imglist, flag]) | Questo è un set di dati per il caricamento di file di immagine specificati da un elenco di voci. |
Esempio
Nell'esempio seguente, mostreremo l'uso di ImageListDataset (), che viene utilizzato per caricare file di immagine specificati da un elenco di voci:
# written to text file *.lst
0 0 root/cat/0001.jpg
1 0 root/cat/xxxa.jpg
2 0 root/cat/yyyb.jpg
3 1 root/dog/123.jpg
4 1 root/dog/023.jpg
5 1 root/dog/wwww.jpg
# A pure list, each item is a list [imagelabel: float or list of float, imgpath]
[[0, root/cat/0001.jpg]
[0, root/cat/xxxa.jpg]
[0, root/cat/yyyb.jpg]
[1, root/dog/123.jpg]
[1, root/dog/023.jpg]
[1, root/dog/wwww.jpg]]
Moduli di utilità
I moduli di utilità in Gluon sono i seguenti:
gluon.utils
Gluon fornisce un gran numero di ottimizzatori di utilità di parallelizzazione incorporati nel modulo gluon.utils. Fornisce una varietà di utilità per la formazione. Questo è il motivo per cui è chiamato modulo di utilità.
Funzioni e loro parametri
Di seguito sono riportate le funzioni ei relativi parametri costituiti da questo modulo di utilità denominato gluon.utils −
Funzioni e suoi parametri | Definizione |
---|---|
split_data (data, num_slice [, batch_axis, ...]) | Questa funzione viene solitamente utilizzata per il parallelismo dei dati e ogni slice viene inviata a un dispositivo, ad esempio GPU. Divide un NDArray innum_slice fette lungo batch_axis. |
split_and_load (data, ctx_list [, batch_axis, ...]) | Questa funzione divide un NDArray in len(ctx_list) fette lungo batch_axis. L'unica differenza dalla funzione split_data () sopra è che carica anche ogni slice in un contesto in ctx_list. |
clip_global_norm (array, max_norm [,…]) | Il compito di questa funzione è riscalare gli NDArray in modo tale che la somma della loro 2-norma sia inferiore a max_norm. |
check_sha1 (nome file, sha1_hash) | Questa funzione controllerà se l'hash sha1 del contenuto del file corrisponde o meno all'hash previsto. |
download (url [, path, overwrite, sha1_hash, ...]) | Come specificato dal nome, questa funzione scaricherà un determinato URL. |
sostituire_file (src, dst) | Questa funzione implementerà atomic os.replace. sarà fatto con Linux e OSX. |