Apache MXNet - gluón de API de Python
Como ya hemos comentado en capítulos anteriores, MXNet Gluon proporciona una API clara, concisa y sencilla para proyectos DL. Permite a Apache MXNet prototipar, construir y entrenar modelos DL sin perder la velocidad de entrenamiento.
Módulos centrales
Aprendamos los módulos centrales de la interfaz de programación de aplicaciones (API) de Apache MXNet Python gluon.
gluon.nn
Gluon proporciona una gran cantidad de capas NN integradas en el módulo gluon.nn. Esa es la razón por la que se le llama módulo principal.
Métodos y sus parámetros
A continuación se muestran algunos de los métodos importantes y sus parámetros cubiertos por mxnet.gluon.nn módulo principal -
| Métodos y sus parámetros | Definición |
|---|---|
| Activación (activación, ** kwargs) | Como su nombre lo indica, este método aplica una función de activación a la entrada. |
| AvgPool1D ([pool_size, strides, padding,…]) | Esta es una operación de agrupación promedio para datos temporales. |
| AvgPool2D ([pool_size, strides, padding,…]) | Esta es una operación de agrupación promedio para datos espaciales. |
| AvgPool3D ([pool_size, strides, padding,…]) | Esta es la operación de agrupación promedio para datos 3D. Los datos pueden ser espaciales o espacio-temporales. |
| BatchNorm ([eje, impulso, épsilon, centro,…]) | Representa la capa de normalización por lotes. |
| BatchNormReLU ([eje, impulso, épsilon,…]) | También representa la capa de normalización por lotes pero con la función de activación Relu. |
| Bloquear ([prefijo, parámetros]) | Proporciona la clase base para todas las capas y modelos de redes neuronales. |
| Conv1D (canales, kernel_size [, zancadas,…]) | Este método se utiliza para la capa de convolución 1-D. Por ejemplo, convolución temporal. |
| Conv1DTranspose (canales, kernel_size [,…]) | Este método se utiliza para la capa de convolución 1D transpuesta. |
| Conv2D (canales, kernel_size [, zancadas,…]) | Este método se utiliza para la capa de convolución 2D. Por ejemplo, convolución espacial sobre imágenes). |
| Conv2DTranspose (canales, kernel_size [,…]) | Este método se utiliza para la capa de convolución 2D transpuesta. |
| Conv3D (canales, kernel_size [, zancadas,…]) | Este método se utiliza para la capa de convolución 3D. Por ejemplo, convolución espacial sobre volúmenes. |
| Conv3DTranspose (canales, kernel_size [,…]) | Este método se utiliza para la capa de convolución 3D transpuesta. |
| Denso (unidades [, activación, use_bias,…]) | Este método representa su capa NN regular densamente conectada. |
| Abandono (tasa [, ejes]) | Como su nombre lo indica, el método aplica Dropout a la entrada. |
| ELU ([alpha]) | Este método se utiliza para la unidad lineal exponencial (ELU). |
| Incorporación (input_dim, output_dim [, dtype,…]) | Convierte números enteros no negativos en vectores densos de tamaño fijo. |
| Aplanar (** kwargs) | Este método aplana la entrada a 2-D. |
| GELU (** kwargs) | Este método se utiliza para la unidad lineal exponencial gaussiana (GELU). |
| GlobalAvgPool1D ([diseño]) | Con la ayuda de este método, podemos realizar una operación de agrupación promedio global para datos temporales. |
| GlobalAvgPool2D ([diseño]) | Con la ayuda de este método, podemos realizar una operación de agrupación promedio global para datos espaciales. |
| GlobalAvgPool3D ([diseño]) | Con la ayuda de este método, podemos realizar una operación de agrupación promedio global para datos 3-D. |
| GlobalMaxPool1D ([diseño]) | Con la ayuda de este método, podemos realizar una operación de agrupación máxima global para datos 1-D. |
| GlobalMaxPool2D ([diseño]) | Con la ayuda de este método, podemos realizar una operación de agrupación máxima global para datos 2-D. |
| GlobalMaxPool3D ([diseño]) | Con la ayuda de este método, podemos realizar una operación de agrupación máxima global para datos 3-D. |
| GroupNorm ([num_groups, epsilon, center, ...]) | Este método aplica la normalización de grupo a la matriz de entrada nD. |
| HybridBlock ([prefijo, parámetros]) | Este método admite el reenvío con ambos Symbol y NDArray. |
| HybridLambda(función [, prefijo]) | Con la ayuda de este método podemos envolver un operador o una expresión como un objeto HybridBlock. |
| HybridSequential ([prefix, params]) | Apila HybridBlocks secuencialmente. |
| InstanceNorm ([eje, épsilon, centro, escala,…]) | Este método aplica la normalización de instancias a la matriz de entrada nD. |
Ejemplos de implementación
En el siguiente ejemplo, usaremos Block () que proporciona la clase base para todas las capas y modelos de redes neuronales.
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
Verá la siguiente salida:
[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 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;En el siguiente ejemplo, usaremos HybridBlock () que admite el reenvío tanto con Symbol como 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
La salida se menciona a continuación:
[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 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 proporciona una gran cantidad de funciones recurrent neural network(RNN) capas en el módulo gluon.rnn. Esa es la razón, se llama módulo central.
Métodos y sus parámetros
A continuación se muestran algunos de los métodos importantes y sus parámetros cubiertos por mxnet.gluon.nn módulo principal:
| Métodos y sus parámetros | Definición |
|---|---|
| BidirectionalCell (l_cell, r_cell [,…]) | Se utiliza para la celda de red neuronal recurrente bidireccional (RNN). |
| DropoutCell (tasa [, ejes, prefijo, parámetros]) | Este método aplicará la deserción en la entrada dada. |
| GRU (hidden_size [, num_layers, layout,…]) | Aplica una unidad recurrente con compuerta (GRU) multicapa RNN a una secuencia de entrada dada. |
| GRUCell (hidden_size [,…]) | Se utiliza para celdas de red de unidades rectificadas con compuerta (GRU). |
| HybridRecurrentCell ([prefix, params]) | Este método admite hibridación. |
| HybridSequentialRNNCell ([prefix, params]) | Con la ayuda de este método, podemos apilar secuencialmente múltiples células HybridRNN. |
| LSTM (hidden_size [, num_layers, layout,…]) 0 | Aplica un RNN de memoria a corto plazo a largo plazo (LSTM) multicapa a una secuencia de entrada determinada. |
| LSTMCell (hidden_size [,…]) | Se utiliza para celdas de red de memoria a largo plazo (LSTM). |
| ModifierCell (celda_base) | Es la clase Base para células modificadoras. |
| RNN (hidden_size [, núm_capas, activación,…]) | Aplica un Elman RNN multicapa con tanh o ReLU no linealidad a una secuencia de entrada dada. |
| RNNCell (hidden_size [, activación,…]) | Se utiliza para la célula de red neuronal recurrente Elman RNN. |
| RecurrentCell ([prefijo, parámetros]) | Representa la clase base abstracta para células RNN. |
| SequentialRNNCell ([prefix, params]) | Con la ayuda de este método, podemos apilar secuencialmente múltiples celdas RNN. |
| ZoneoutCell (base_cell [, zoneout_outputs,…]) | Este método aplica Zoneout en la celda base. |
Ejemplos de implementación
En el siguiente ejemplo, vamos a usar GRU () que aplica una unidad recurrente con compuerta multicapa (GRU) RNN a una secuencia de entrada dada.
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_seqOutput
Esto produce la siguiente salida:
[[[ 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
hnOutput
Esto produce la siguiente salida:
[[[-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
………………………….En el siguiente ejemplo, usaremos LSTM () que aplica un RNN de memoria a largo-corto plazo (LSTM) a una secuencia de entrada dada.
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_seqOutput
La salida se menciona a continuación:
[[[ 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
hnOutput
Cuando ejecute el código, verá el siguiente resultado:
[
[[[ 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
……………………Módulos de formación
Los módulos de formación en Gluon son los siguientes:
pérdida de gluón
En mxnet.gluon.lossmódulo, Gluon proporciona una función de pérdida predefinida. Básicamente, tiene las pérdidas por entrenar la red neuronal. Por eso se llama módulo de formación.
Métodos y sus parámetros
A continuación se muestran algunos de los métodos importantes y sus parámetros cubiertos por mxnet.gluon.loss modulo de entrenamiento:
| Métodos y sus parámetros | Definición |
|---|---|
| Pérdida (peso, eje_lote, ** kwargs) | Esto actúa como la clase base para pérdidas. |
| L2Loss ([peso, eje_lote]) | Calcula el error cuadrático medio (MSE) entre label y prediction(pred). |
| L1Loss ([peso, eje_lote]) | Calcula el error absoluto medio (MAE) entre label y pred. |
| SigmoidBinaryCrossEntropyLoss ([…]) | Este método se utiliza para la pérdida de entropía cruzada para la clasificación binaria. |
| SigmoidBCELoss | Este método se utiliza para la pérdida de entropía cruzada para la clasificación binaria. |
| SoftmaxCrossEntropyLoss ([eje,…]) | Calcula la pérdida de entropía cruzada softmax (CEL). |
| SoftmaxCELoss | También calcula la pérdida de entropía cruzada softmax. |
| KLDivLoss ([from_logits, eje, peso,…]) | Se utiliza para la pérdida de divergencia de Kullback-Leibler. |
| CTCLoss ([layout, label_layout, weight]) | Se utiliza para la pérdida de clasificación temporal conexionista (TCL). |
| HuberLoss ([rho, weight, batch_axis]) | Calcula la pérdida L1 suavizada. La pérdida de L1 suavizada será igual a la pérdida de L1 si el error absoluto excede rho pero es igual a la pérdida de L2 en caso contrario. |
| HingeLoss ([margin, weight, batch_axis]) | Este método calcula la función de pérdida de bisagra que se utiliza a menudo en SVM: |
| SquaredHingeLoss ([margin, weight, batch_axis]) | Este método calcula la función de pérdida de margen blando utilizada en SVM: |
| LogisticLoss ([peso, eje_lote, formato_etiqueta]) | Este método calcula la pérdida logística. |
| TripletLoss ([margin, weight, batch_axis]) | Este método calcula la pérdida de triplete dados tres tensores de entrada y un margen positivo. |
| PoissonNLLLoss ([peso, from_logits,…]) | La función calcula la pérdida de probabilidad del registro negativo. |
| CosineEmbeddingLoss ([peso, eje_lote, margen]) | La función calcula la distancia del coseno entre los vectores. |
| SDMLLoss ([smoothing_parameter, weight,…]) | Este método calcula la pérdida de aprendizaje métrico profundo suavizado por lotes (SDML) dados dos tensores de entrada y una pérdida de SDM de peso suavizado. Aprende similitudes entre muestras emparejadas utilizando muestras no emparejadas en el minibatch como posibles ejemplos negativos. |
Ejemplo
Como sabemos que mxnet.gluon.loss.losscalculará el MSE (error cuadrático medio) entre la etiqueta y la predicción (pred). Se realiza con la ayuda de la siguiente fórmula:
parámetro gluon.
mxnet.gluon.parameter es un contenedor que contiene los parámetros, es decir, los pesos de los Bloques.
Métodos y sus parámetros
A continuación se muestran algunos de los métodos importantes y sus parámetros cubiertos por mxnet.gluon.parameter módulo de formación -
| Métodos y sus parámetros | Definición |
|---|---|
| emitir (dtype) | Este método convertirá los datos y el gradiente de este parámetro a un nuevo tipo de datos. |
| datos ([ctx]) | Este método devolverá una copia de este parámetro en un contexto. |
| grad ([ctx]) | Este método devolverá un búfer de gradiente para este parámetro en un contexto. |
| inicializar ([init, ctx, default_init,…]) | Este método inicializará las matrices de parámetros y gradientes. |
| list_ctx () | Este método devolverá una lista de contextos en los que se inicializa este parámetro. |
| list_data () | Este método devolverá copias de este parámetro en todos los contextos. Se hará en el mismo orden que la creación. |
| list_grad () | Este método devolverá búferes de degradado en todos los contextos. Esto se hará en el mismo orden quevalues(). |
| list_row_sparse_data (row_id) | Este método devolverá copias del parámetro 'row_sparse' en todos los contextos. Esto se hará en el mismo orden que la creación. |
| reset_ctx (ctx) | Este método reasignará el parámetro a otros contextos. |
| row_sparse_data (row_id) | Este método devolverá una copia del parámetro 'row_sparse' en el mismo contexto que row_id's. |
| set_data (datos) | Este método establecerá el valor de este parámetro en todos los contextos. |
| var () | Este método devolverá un símbolo que representa este parámetro. |
| zero_grad () | Este método establecerá el búfer de degradado en todos los contextos en 0. |
Ejemplo de implementación
En el siguiente ejemplo, inicializaremos los parámetros y las matrices de gradientes utilizando el método initialize () de la siguiente manera:
weight = mx.gluon.Parameter('weight', shape=(2, 2))
weight.initialize(ctx=mx.cpu(0))
weight.data()Output
La salida se menciona a continuación:
[[-0.0256899 0.06511251]
[-0.00243821 -0.00123186]]
<NDArray 2x2 @cpu(0)>Example
weight.grad()Output
La salida se da a continuación:
[[0. 0.]
[0. 0.]]
<NDArray 2x2 @cpu(0)>Example
weight.initialize(ctx=[mx.gpu(0), mx.gpu(1)])
weight.data(mx.gpu(0))Output
Verá la siguiente salida:
[[-0.00873779 -0.02834515]
[ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(0)>Example
weight.data(mx.gpu(1))Output
Cuando ejecute el código anterior, debería ver el siguiente resultado:
[[-0.00873779 -0.02834515]
[ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(1)>entrenador de gluon
mxnet.gluon.trainer aplica un Optimizador en un conjunto de parámetros. Debe usarse junto con autograd.
Métodos y sus parámetros
A continuación se muestran algunos de los métodos importantes y sus parámetros cubiertos por mxnet.gluon.trainer módulo de formación -
| Métodos y sus parámetros | Definición |
|---|---|
| allreduce_grads () | Este método reducirá los gradientes de diferentes contextos para cada parámetro (peso). |
| load_states (fname) | Como su nombre lo indica, este método cargará estados del entrenador. |
| save_states (fname) | Como su nombre lo indica, este método salvará los estados del entrenador. |
| set_learning_rate (lr) | Este método establecerá una nueva tasa de aprendizaje del optimizador. |
| paso (tamaño_lote [, ignore_stale_grad]) | Este método hará un paso de actualización de parámetros. Debería llamarse despuésautograd.backward() y fuera de record() alcance. |
| actualizar (tamaño_de_lote [, ignore_stale_grad]) | Este método también hará un paso de actualización de parámetros. Debería llamarse despuésautograd.backward() y fuera de record() scope y después de trainer.update (). |
Módulos de datos
Los módulos de datos de Gluon se explican a continuación:
gluon.data
Gluon proporciona una gran cantidad de utilidades de conjuntos de datos incorporadas en el módulo gluon.data. Por eso se le llama módulo de datos.
Clases y sus parámetros
A continuación se muestran algunos de los métodos importantes y sus parámetros cubiertos por el módulo principal mxnet.gluon.data. Estos métodos suelen estar relacionados con conjuntos de datos, muestreo y cargador de datos.
Conjunto de datos| Métodos y sus parámetros | Definición |
|---|---|
| ArrayDataset (* args) | Este método representa un conjunto de datos que combina dos o más de dos objetos similares a conjuntos de datos. Por ejemplo, conjuntos de datos, listas, matrices, etc. |
| BatchSampler (muestreador, batch_size [, last_batch]) | Este método envuelve otro Sampler. Una vez envuelto devuelve los mini lotes de muestras. |
| DataLoader (conjunto de datos [, batch_size, shuffle,…]) | Similar a BatchSampler, pero este método carga datos de un conjunto de datos. Una vez cargado, devuelve los mini lotes de datos. |
| Esto representa la clase de conjunto de datos abstracto. | |
| FilterSampler (fn, conjunto de datos) | Este método representa los elementos de muestra de un conjunto de datos para el que devuelve fn (función) True. |
| RandomSampler (longitud) | Este método representa elementos de muestra de [0, longitud) aleatoriamente sin reemplazo. |
| RecordFileDataset (nombre de archivo) | Representa un conjunto de datos que se envuelve sobre un archivo RecordIO. La extensión del archivo es.rec. |
| Dechado | Esta es la clase base para muestreadores. |
| SequentialSampler (longitud [, inicio]) | Representa los elementos de muestra del conjunto [inicio, inicio + duración) secuencialmente. |
| Representa los elementos de muestra del conjunto [inicio, inicio + duración) secuencialmente. | Esto representa el contenedor de conjunto de datos simple, especialmente para listas y matrices. |
Ejemplos de implementación
En el siguiente ejemplo, usaremos gluon.data.BatchSampler()API, que envuelve otra muestra. Devuelve los mini lotes de muestras.
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
La salida se menciona a continuación:
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14]]gluon.data.vision.datasets
Gluon proporciona una gran cantidad de funciones de conjuntos de datos de visión predefinidos en gluon.data.vision.datasets módulo.
Clases y sus parámetros
MXNet nos proporciona conjuntos de datos útiles e importantes, cuyas clases y parámetros se dan a continuación:
| Clases y sus parámetros | Definición |
|---|---|
| MNIST ([root, train, transform]) | Este es un conjunto de datos útil que nos proporciona los dígitos escritos a mano. La URL del conjunto de datos MNIST es http://yann.lecun.com/exdb/mnist |
| FashionMNIST ([root, train, transform]) | Este conjunto de datos consiste en imágenes de artículos de Zalando que consisten en productos de moda. Es un reemplazo directo del conjunto de datos MNIST original. Puede obtener este conjunto de datos en https://github.com/zalandoresearch/fashion-mnist |
| CIFAR10 ([root, train, transform]) | Este es un conjunto de datos de clasificación de imágenes de https://www.cs.toronto.edu/~kriz/cifar.html. En este conjunto de datos, cada muestra es una imagen con forma (32, 32, 3). |
| CIFAR100 ([root, fine_label, train, transform]) | Este es el conjunto de datos de clasificación de imágenes CIFAR100 de https://www.cs.toronto.edu/~kriz/cifar.html. También tiene cada muestra es una imagen con forma (32, 32, 3). |
| ImageRecordDataset (nombre de archivo [, marca, transformación]) | Este conjunto de datos se envuelve sobre un archivo RecordIO que contiene imágenes. En este cada muestra es una imagen con su etiqueta correspondiente. |
| ImageFolderDataset (root [, flag, transform]) | Este es un conjunto de datos para cargar archivos de imagen que se almacenan en una estructura de carpetas. |
| ImageListDataset ([root, imglist, flag]) | Este es un conjunto de datos para cargar archivos de imagen que se especifican mediante una lista de entradas. |
Ejemplo
En el siguiente ejemplo, vamos a mostrar el uso de ImageListDataset (), que se utiliza para cargar archivos de imagen que se especifican mediante una lista de entradas:
# 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]]Módulos de utilidad
Los módulos de utilidad en Gluon son los siguientes:
gluon.utils
Gluon proporciona una gran cantidad de optimizadores de utilidad de paralelización incorporados en el módulo gluon.utils. Proporciona variedad de utilidades para la formación. Esa es la razón por la que se llama módulo de utilidad.
Funciones y sus parámetros
A continuación se muestran las funciones y sus parámetros que consisten en este módulo de utilidad denominado gluon.utils −
| Funciones y sus parámetros | Definición |
|---|---|
| split_data (datos, num_slice [, batch_axis,…]) | Esta función se usa generalmente para el paralelismo de datos y cada segmento se envía a un dispositivo, es decir, GPU. Divide un NDArray ennum_slice rebanadas a lo largo batch_axis. |
| split_and_load (datos, ctx_list [, batch_axis,…]) | Esta función divide un NDArray en len(ctx_list) rebanadas a lo largo batch_axis. La única diferencia con la función split_data () anterior es que también carga cada segmento en un contexto en ctx_list. |
| clip_global_norm (matrices, max_norm [,…]) | El trabajo de esta función es reescalar NDArrays de tal manera que la suma de su 2-norma sea menor que max_norm. |
| check_sha1 (nombre de archivo, sha1_hash) | Esta función comprobará si el hash sha1 del contenido del archivo coincide con el hash esperado o no. |
| descargar (url [, ruta, sobrescribir, sha1_hash,…]) | Como el nombre lo especifica, esta función descargará una URL determinada. |
| reemplazar_archivo (src, dst) | Esta función implementará atomic os.replace. se hará con Linux y OSX. |