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 dati
Metodi 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.