Apache MXNet - Python API gluon

Como já discutimos nos capítulos anteriores, o MXNet Gluon fornece uma API clara, concisa e simples para projetos DL. Ele permite que o Apache MXNet crie protótipos, construa e treine modelos DL sem perder a velocidade de treinamento.

Módulos principais

Vamos aprender os módulos principais do gluon da interface de programação de aplicativos (API) Apache MXNet Python.

gluon.nn

O Gluon fornece um grande número de camadas NN integradas no módulo gluon.nn. Essa é a razão pela qual é chamado de módulo principal.

Métodos e seus parâmetros

A seguir estão alguns dos métodos importantes e seus parâmetros cobertos por mxnet.gluon.nn módulo central -

Métodos e seus parâmetros	Definição
Ativação (ativação, ** kwargs)	Como o nome indica, este método aplica uma função de ativação à entrada.
AvgPool1D ([pool_size, strides, padding, ...])	Esta é a operação de agrupamento média para dados temporais.
AvgPool2D ([pool_size, strides, padding, ...])	Esta é a operação de agrupamento média para dados espaciais.
AvgPool3D ([pool_size, strides, padding, ...])	Esta é a operação média de pooling para dados 3D. Os dados podem ser espaciais ou espaço-temporais.
BatchNorm ([eixo, momento, épsilon, centro, ...])	Ele representa a camada de normalização do lote.
BatchNormReLU ([eixo, momento, épsilon, ...])	Também representa a camada de normalização de lote, mas com função de ativação Relu.
Bloco ([prefixo, parâmetros])	Ele fornece a classe base para todas as camadas e modelos de rede neural.
Conv1D (canais, kernel_size [, passos, ...])	Este método é usado para camada de convolução 1-D. Por exemplo, convolução temporal.
Conv1DTranspose (canais, kernel_size [,…])	Este método é usado para a camada de convolução 1D transposta.
Conv2D (canais, kernel_size [, passos, ...])	Este método é usado para a camada de convolução 2D. Por exemplo, convolução espacial sobre imagens).
Conv2DTranspose (canais, kernel_size [,…])	Este método é usado para a camada de convolução 2D transposta.
Conv3D (canais, kernel_size [, passos, ...])	Este método é usado para camada de convolução 3D. Por exemplo, convolução espacial sobre volumes.
Conv3DTranspose (canais, kernel_size [,…])	Este método é usado para a camada de convolução 3D transposta.
Denso (unidades [, ativação, use_bias, ...])	Este método representa sua camada NN densamente conectada regular.
Dropout (taxa [, eixos])	Como o nome indica, o método aplica Dropout à entrada.
ELU ([alfa])	Este método é usado para Unidade Linear Exponencial (ELU).
Incorporação (input_dim, output_dim [, dtype, ...])	Ele transforma inteiros não negativos em vetores densos de tamanho fixo.
Flatten (** kwargs)	Este método nivela a entrada para 2-D.
GELU (** kwargs)	Este método é usado para Unidade Linear Exponencial Gaussiana (GELU).
GlobalAvgPool1D ([layout])	Com a ajuda deste método, podemos fazer uma operação global de agrupamento médio para dados temporais.
GlobalAvgPool2D ([layout])	Com a ajuda deste método, podemos fazer uma operação global de agrupamento médio para dados espaciais.
GlobalAvgPool3D ([layout])	Com a ajuda desse método, podemos fazer a operação global de agrupamento médio para dados 3-D.
GlobalMaxPool1D ([layout])	Com a ajuda desse método, podemos fazer a operação global max pooling para dados 1-D.
GlobalMaxPool2D ([layout])	Com a ajuda desse método, podemos fazer a operação global max pooling para dados 2-D.
GlobalMaxPool3D ([layout])	Com a ajuda desse método, podemos fazer a operação global max pooling para dados 3-D.
GroupNorm ([núm_grupos, épsilon, centro, ...])	Este método aplica a normalização de grupo à matriz de entrada nD.
HybridBlock ([prefixo, parâmetros])	Este método suporta o encaminhamento com ambos Symbol e NDArray.
HybridLambda(função [, prefixo])	Com a ajuda deste método, podemos envolver um operador ou uma expressão como um objeto HybridBlock.
HybridSequential ([prefixo, params])	Ele empilha HybridBlocks sequencialmente.
InstanceNorm ([eixo, épsilon, centro, escala, ...])	Este método aplica a normalização da instância ao array de entrada nD.

Exemplos de implementação

No exemplo abaixo, vamos usar Block () que fornece a classe base para todas as camadas e modelos de rede neural.

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

Você verá a seguinte saída -

[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 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;

No exemplo abaixo, usaremos HybridBlock () que oferece suporte ao encaminhamento com Symbol e 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

O resultado é mencionado abaixo -

[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 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

O Gluon oferece um grande número de componentes recurrent neural network(RNN) camadas no módulo gluon.rnn. É por isso que é chamado de módulo principal.

Métodos e seus parâmetros

A seguir estão alguns dos métodos importantes e seus parâmetros cobertos por mxnet.gluon.nn módulo central:

Métodos e seus parâmetros	Definição
BidirectionalCell (l_cell, r_cell [, ...])	É usado para a célula da Rede Neural Recorrente Bidirecional (RNN).
DropoutCell (taxa [, eixos, prefixo, parâmetros])	Este método aplicará o dropout na entrada fornecida.
GRU (oculto_size [, núm_camadas, layout, ...])	Ele aplica uma unidade recorrente com portas multicamadas (GRU) RNN a uma determinada sequência de entrada.
GRUCell (oculto_size [,…])	É usado para célula de rede Gated Rectified Unit (GRU).
HybridRecurrentCell ([prefixo, params])	Este método suporta hibridização.
HybridSequentialRNNCell ([prefixo, params])	Com a ajuda deste método, podemos empilhar sequencialmente várias células HybridRNN.
LSTM (oculto_size [, núm_camadas, layout, ...]) 0	Ele aplica um RNN de memória longa de curto prazo multicamadas (LSTM) a uma determinada sequência de entrada.
LSTMCell (oculto_size [,…])	É usado para a célula de rede Long-Short Term Memory (LSTM).
ModifierCell (base_cell)	É a classe base para células modificadoras.
RNN (oculto_size [, núm_camadas, ativação, ...])	Ele aplica um Elman RNN multicamadas com tanh ou ReLU não linearidade para uma determinada sequência de entrada.
RNNCell (oculto_size [, ativação, ...])	É usado para células de rede neural recorrente Elman RNN.
RecurrentCell ([prefixo, params])	Ele representa a classe base abstrata para células RNN.
SequentialRNNCell ([prefixo, params])	Com a ajuda deste método, podemos empilhar sequencialmente várias células RNN.
ZoneoutCell (base_cell [, zoneout_outputs,…])	Este método aplica Zoneout na célula base.

Exemplos de implementação

No exemplo abaixo, vamos usar GRU () que aplica uma unidade recorrente com portas multicamadas (GRU) RNN a uma determinada sequência de entrada.

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

Isso produz a seguinte saída -

[[[ 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

Isso produz a seguinte saída -

[[[-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
………………………….

No exemplo abaixo, vamos usar LSTM (), que aplica uma memória de longo-curto prazo (LSTM) RNN a uma determinada sequência de entrada.

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

O resultado é mencionado abaixo -

[[[ 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

Ao executar o código, você verá a seguinte saída -

[
[[[ 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 treinamento

Os módulos de treinamento no Gluon são os seguintes -

gluon.loss

No mxnet.gluon.lossmódulo, Gluon fornece função de perda pré-definida. Basicamente, tem as perdas para treinar a rede neural. É por isso que é chamado de módulo de treinamento.

Métodos e seus parâmetros

A seguir estão alguns dos métodos importantes e seus parâmetros cobertos por mxnet.gluon.loss módulo de treinamento:

Métodos e seus parâmetros	Definição
Perda (peso, lote_eixo, ** kwargs)	Isso atua como a classe base para perdas.
L2Loss ([peso, lote_axis])	Ele calcula o erro quadrático médio (MSE) entre label e prediction(pred).
L1Loss ([weight, batch_axis])	Ele calcula o erro absoluto médio (MAE) entre label e pred.
SigmoidBinaryCrossEntropyLoss ([...])	Este método é usado para a perda de entropia cruzada para classificação binária.
SigmoidBCELoss	Este método é usado para a perda de entropia cruzada para classificação binária.
SoftmaxCrossEntropyLoss ([eixo, ...])	Ele calcula a perda de entropia cruzada softmax (CEL).
SoftmaxCELoss	Ele também calcula a perda de entropia cruzada softmax.
KLDivLoss ([from_logits, eixo, peso, ...])	É usado para a perda de divergência de Kullback-Leibler.
CTCLoss ([layout, label_layout, weight])	É usado para perda de classificação temporal (TCL) conexionista.
HuberLoss ([rho, weight, batch_axis])	Ele calcula a perda L1 suavizada. A perda L1 suavizada será igual à perda L1 se o erro absoluto exceder rho, mas será igual à perda L2 caso contrário.
HingeLoss ([margem, peso, lote_eixo])	Este método calcula a função de perda de dobradiça frequentemente usada em SVMs:
SquaredHingeLoss ([margin, weight, batch_axis])	Este método calcula a função de perda de margem suave usada em SVMs:
LogisticLoss ([weight, batch_axis, label_format])	Este método calcula a perda logística.
TripletLoss ([margem, peso, lote_eixo])	Este método calcula a perda de tripleto dados três tensores de entrada e uma margem positiva.
PoissonNLLLoss ([peso, from_logits, ...])	A função calcula a perda de probabilidade de log negativo.
CosineEmbeddingLoss ([weight, batch_axis, margin])	A função calcula a distância cosseno entre os vetores.
SDMLLoss ([smoothing_parameter, weight, ...])	Este método calcula a perda de aprendizado métrico profundo suavizado em lote (SDML), dados dois tensores de entrada e um peso de suavização SDM Loss. Ele aprende a similaridade entre amostras emparelhadas usando amostras não emparelhadas no minibatch como exemplos negativos em potencial.

Exemplo

Como sabemos disso mxnet.gluon.loss.lossirá calcular o MSE (erro quadrático médio) entre o rótulo e a previsão (pred). Isso é feito com a ajuda da seguinte fórmula:

gluon.parameter

mxnet.gluon.parameter é um contêiner que contém os parâmetros, ou seja, os pesos dos blocos.

Métodos e seus parâmetros

A seguir estão alguns dos métodos importantes e seus parâmetros cobertos por mxnet.gluon.parameter módulo de treinamento -

Métodos e seus parâmetros	Definição
elenco (tipo d)	Este método lançará dados e gradiente deste parâmetro para um novo tipo de dados.
dados ([ctx])	Este método retornará uma cópia deste parâmetro em um contexto.
grad ([ctx])	Este método retornará um buffer de gradiente para este parâmetro em um contexto.
inicializar ([init, ctx, default_init, ...])	Este método inicializará matrizes de parâmetros e gradientes.
list_ctx ()	Este método retornará uma lista de contextos nos quais este parâmetro foi inicializado.
list_data ()	Este método retornará cópias deste parâmetro em todos os contextos. Isso será feito na mesma ordem da criação.
list_grad ()	Este método retornará buffers de gradiente em todos os contextos. Isso será feito na mesma ordem quevalues().
list_row_sparse_data (row_id)	Este método retornará cópias do parâmetro 'row_sparse' em todos os contextos. Isso será feito na mesma ordem da criação.
reset_ctx (ctx)	Este método irá reatribuir Parameter a outros contextos.
row_sparse_data (row_id)	Este método retornará uma cópia do parâmetro 'row_sparse' no mesmo contexto que row_id's.
set_data (dados)	Este método irá definir o valor deste parâmetro em todos os contextos.
var ()	Este método retornará um símbolo que representa este parâmetro.
zero_grad ()	Este método definirá o buffer de gradiente em todos os contextos como 0.

Exemplo de Implementação

No exemplo abaixo, inicializaremos os parâmetros e as matrizes de gradientes usando o método initialize () da seguinte maneira -

weight = mx.gluon.Parameter('weight', shape=(2, 2))
weight.initialize(ctx=mx.cpu(0))
weight.data()

Output

O resultado é mencionado abaixo -

[[-0.0256899 0.06511251]
[-0.00243821 -0.00123186]]
<NDArray 2x2 @cpu(0)>

Example

weight.grad()

Output

O resultado é dado abaixo -

[[0. 0.]
[0. 0.]]
<NDArray 2x2 @cpu(0)>

Example

weight.initialize(ctx=[mx.gpu(0), mx.gpu(1)])
weight.data(mx.gpu(0))

Output

Você verá a seguinte saída -

[[-0.00873779 -0.02834515]
 [ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(0)>

Example

weight.data(mx.gpu(1))

Output

Ao executar o código acima, você verá a seguinte saída -

[[-0.00873779 -0.02834515]
 [ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(1)>

gluon.trainer

mxnet.gluon.trainer aplica um Otimizador em um conjunto de parâmetros. Deve ser usado junto com o autograd.

Métodos e seus parâmetros

A seguir estão alguns dos métodos importantes e seus parâmetros cobertos por mxnet.gluon.trainer módulo de treinamento -

Métodos e seus parâmetros	Definição
allreduce_grads ()	Este método irá reduzir os gradientes de diferentes contextos para cada parâmetro (peso).
load_states (fname)	Como o nome indica, este método carregará os estados do treinador.
save_states (fname)	Como o nome indica, esse método salvará os estados do treinador.
set_learning_rate (lr)	Este método definirá uma nova taxa de aprendizado do otimizador.
etapa (batch_size [, ignore_stale_grad])	Este método fará uma etapa de atualização do parâmetro. Deve ser chamado apósautograd.backward() e fora de record() escopo.
atualizar (batch_size [, ignore_stale_grad])	Este método também fará uma etapa de atualização do parâmetro. Deve ser chamado apósautograd.backward() e fora de record() escopo e depois de trainer.update ().

Módulos de Dados

Os módulos de dados do Gluon são explicados abaixo -

gluon.data

O Gluon fornece um grande número de utilitários de conjunto de dados integrados no módulo gluon.data. É por isso que é chamado de módulo de dados.

Classes e seus parâmetros

A seguir estão alguns dos métodos importantes e seus parâmetros cobertos pelo módulo principal mxnet.gluon.data. Esses métodos geralmente estão relacionados a Datasets, Sampling e DataLoader.

Conjunto de Dados

Métodos e seus parâmetros	Definição
ArrayDataset (* args)	Este método representa um conjunto de dados que combina dois ou mais de dois objetos semelhantes a conjuntos de dados. Por exemplo, conjuntos de dados, listas, matrizes, etc.
BatchSampler (sampler, batch_size [, last_batch])	Este método envolve outro Sampler. Depois de embalado, ele retorna os mini lotes de amostras.
DataLoader (dataset [, batch_size, shuffle, ...])	Semelhante ao BatchSampler, mas este método carrega dados de um conjunto de dados. Uma vez carregado, ele retorna os minilotes de dados.
Isso representa a classe abstrata do conjunto de dados.
FilterSampler (fn, conjunto de dados)	Este método representa os elementos de amostra de um conjunto de dados para o qual fn (função) retorna True.
RandomSampler (comprimento)	Este método representa elementos de amostra de [0, comprimento) aleatoriamente sem substituição.
RecordFileDataset (nome do arquivo)	Ele representa um conjunto de dados envolvendo um arquivo RecordIO. A extensão do arquivo é.rec.
Sampler	Esta é a classe base para amostradores.
SequentialSampler (comprimento [, início])	Ele representa os elementos de amostra do conjunto [início, início + comprimento) sequencialmente.
Ele representa os elementos de amostra do conjunto [início, início + comprimento) sequencialmente.	Isso representa o invólucro do Conjunto de dados simples, especialmente para listas e matrizes.

Exemplos de implementação

No exemplo abaixo, vamos usar gluon.data.BatchSampler()API, que envolve outro amostrador. Ele retorna os mini lotes de amostras.

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

O resultado é mencionado abaixo -

[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14]]

gluon.data.vision.datasets

O Gluon fornece um grande número de funções de conjunto de dados de visão predefinidos em gluon.data.vision.datasets módulo.

Classes e seus parâmetros

MXNet nos fornece conjuntos de dados úteis e importantes, cujas classes e parâmetros são fornecidos abaixo -

Classes e seus parâmetros	Definição
MNIST ([root, treinar, transformar])	Este é um conjunto de dados útil que nos fornece os dígitos manuscritos. O url para o conjunto de dados MNIST é http://yann.lecun.com/exdb/mnist
FashionMNIST ([root, treinar, transformar])	Este conjunto de dados consiste em imagens de artigos de Zalando que consistem em produtos de moda. É uma substituição imediata do conjunto de dados MNIST original. Você pode obter este conjunto de dados em https://github.com/zalandoresearch/fashion-mnist
CIFAR10 ([root, treinar, transformar])	Este é um conjunto de dados de classificação de imagens de https://www.cs.toronto.edu/~kriz/cifar.html. Neste conjunto de dados, cada amostra é uma imagem com forma (32, 32, 3).
CIFAR100 ([root, fine_label, treinar, transformar])	Este é o conjunto de dados de classificação de imagem CIFAR100 de https://www.cs.toronto.edu/~kriz/cifar.html. Também tem cada amostra é uma imagem com forma (32, 32, 3).
ImageRecordDataset (nome do arquivo [, sinalizar, transformar])	Este conjunto de dados está envolvendo um arquivo RecordIO que contém imagens. Neste, cada amostra é uma imagem com seu rótulo correspondente.
ImageFolderDataset (root [, sinalizar, transformar])	Este é um conjunto de dados para carregar arquivos de imagem armazenados em uma estrutura de pastas.
ImageListDataset ([root, imglist, flag])	Este é um conjunto de dados para carregar arquivos de imagem que são especificados por uma lista de entradas.

Exemplo

No exemplo abaixo, vamos mostrar o uso de ImageListDataset (), que é usado para carregar arquivos de imagem que são especificados por uma 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 Utilitários

Os módulos utilitários no Gluon são os seguintes -

gluon.utils

O Gluon fornece um grande número de otimizadores de utilitário de paralelização integrados no módulo gluon.utils. Ele fornece vários utilitários para treinamento. É por isso que é chamado de módulo de utilitário.

Funções e seus parâmetros

A seguir estão as funções e seus parâmetros que consistem neste módulo de utilitário denominado gluon.utils −

Funções e seus parâmetros	Definição
split_data (data, num_slice [, batch_axis,…])	Esta função é geralmente usada para paralelismo de dados e cada fatia é enviada para um dispositivo, ou seja, GPU. Ele divide um NDArray emnum_slice fatias junto batch_axis.
split_and_load (dados, ctx_list [, batch_axis, ...])	Esta função divide um NDArray em len(ctx_list) fatias junto batch_axis. A única diferença da função split_data () acima é que ela também carrega cada fatia para um contexto em ctx_list.
clip_global_norm (matrizes, max_norm [,…])	O trabalho desta função é redimensionar NDArrays de tal forma que a soma de suas normas 2 seja menor que max_norm.
check_sha1 (nome do arquivo, sha1_hash)	Esta função irá verificar se o hash sha1 do conteúdo do arquivo corresponde ao hash esperado ou não.
download (url [, caminho, sobrescrever, sha1_hash, ...])	Como o nome especifica, esta função fará o download de um determinado URL.
substituir_arquivo (src, dst)	Esta função irá implementar atômicas os.replace. isso será feito com Linux e OSX.

↰ Previous page Next page ↱