.. _sec_ndarray:
Manipulação de Dados
====================
Para fazer qualquer coisa, precisamos de alguma forma de armazenar e
manipular dados. Geralmente, há duas coisas importantes que precisamos
fazer com os dados: (i) adquirir eles; e (ii) processá-los assim que
estiverem dentro do computador. Não há sentido em adquirir dados sem
alguma forma de armazená-los, então vamos brincar com dados sintéticos.
Para começar, apresentamos o *array* :math:`n`-dimensional, também
chamado de *tensor*.
Se você trabalhou com NumPy, o mais amplamente utilizado pacote de
computação científica em Python, então você achará esta seção familiar.
Não importa qual estrutura você usa, sua *classe de tensor* (``ndarray``
em MXNet, ``Tensor`` em PyTorch e TensorFlow) é semelhante
ao\ ``ndarray`` do NumPy com alguns recursos interessantes. Primeiro, a
GPU é bem suportada para acelerar a computação enquanto o NumPy suporta
apenas computação de CPU. Em segundo lugar, a classe tensor suporta
diferenciação automática. Essas propriedades tornam a classe tensor
adequada para aprendizado profundo. Ao longo do livro, quando dizemos
tensores, estamos nos referindo a instâncias da classe tensorial, a
menos que seja declarado de outra forma.
Iniciando
---------
Nesta seção, nosso objetivo é colocá-lo em funcionamento, equipando você
com as ferramentas básicas de matemática e computação numérica que você
desenvolverá conforme progride no livro. Não se preocupe se você lutar
para grocar alguns dos os conceitos matemáticos ou funções de
biblioteca. As seções a seguir revisitarão este material no contexto de
exemplos práticos e irá afundar. Por outro lado, se você já tem alguma
experiência e quiser se aprofundar no conteúdo matemático, basta pular
esta seção.
.. raw:: html
.. raw:: html
Para começar, importamos o ``np`` (``numpy``) e Módulos ``npx``
(``numpy_extension``) da MXNet. Aqui, o módulo ``np`` inclui funções
suportadas por NumPy, enquanto o módulo ``npx`` contém um conjunto de
extensões desenvolvido para capacitar o *Deep Learning* em um ambiente
semelhante ao NumPy. Ao usar tensores, quase sempre invocamos a função
``set_np``: isso é para compatibilidade de processamento de tensor por
outros componentes do MXNet.
.. code:: python
from mxnet import np, npx
npx.set_np()
.. raw:: html
.. raw:: html
Para começar, importamos ``torch``. Note que apesar de ser chamado
PyTorch, devemos importar ``torch`` ao invés de ``pytorch``.
.. code:: python
import torch
.. raw:: html
.. raw:: html
Importamos ``tensorflow``. Como o nome é longo, importamos abreviando
``tf``.
.. code:: python
import tensorflow as tf
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
x = np.arange(12)
x
.. parsed-literal::
:class: output
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11.])
.. raw:: html
.. raw:: html
.. code:: python
x = torch.arange(12)
x
.. parsed-literal::
:class: output
tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
.. raw:: html
.. raw:: html
.. code:: python
x = tf.range(12)
x
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
x.shape
.. parsed-literal::
:class: output
(12,)
.. raw:: html
.. raw:: html
.. code:: python
x.shape
.. parsed-literal::
:class: output
torch.Size([12])
.. raw:: html
.. raw:: html
.. code:: python
x.shape
.. parsed-literal::
:class: output
TensorShape([12])
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
x.size
.. parsed-literal::
:class: output
12
.. raw:: html
.. raw:: html
.. code:: python
x.numel()
.. parsed-literal::
:class: output
12
.. raw:: html
.. raw:: html
.. code:: python
tf.size(x)
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X = x.reshape(3, 4)
X
.. parsed-literal::
:class: output
array([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
.. raw:: html
.. raw:: html
.. code:: python
X = x.reshape(3, 4)
X
.. parsed-literal::
:class: output
tensor([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
.. raw:: html
.. raw:: html
.. code:: python
X = tf.reshape(x, (3, 4))
X
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
np.zeros((2, 3, 4))
.. parsed-literal::
:class: output
array([[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]],
[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]]])
.. raw:: html
.. raw:: html
.. code:: python
torch.zeros((2, 3, 4))
.. parsed-literal::
:class: output
tensor([[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]],
[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]]])
.. raw:: html
.. raw:: html
.. code:: python
tf.zeros((2, 3, 4))
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
np.ones((2, 3, 4))
.. parsed-literal::
:class: output
array([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]])
.. raw:: html
.. raw:: html
.. code:: python
torch.ones((2, 3, 4))
.. parsed-literal::
:class: output
tensor([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]])
.. raw:: html
.. raw:: html
.. code:: python
tf.ones((2, 3, 4))
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
np.random.normal(0, 1, size=(3, 4))
.. parsed-literal::
:class: output
array([[ 2.2122064 , 1.1630787 , 0.7740038 , 0.4838046 ],
[ 1.0434405 , 0.29956347, 1.1839255 , 0.15302546],
[ 1.8917114 , -1.1688148 , -1.2347414 , 1.5580711 ]])
.. raw:: html
.. raw:: html
.. code:: python
torch.randn(3, 4)
.. parsed-literal::
:class: output
tensor([[-1.0383, 2.7221, 1.6101, 0.3270],
[ 1.2290, 0.3447, -0.8467, -1.8943],
[ 0.7013, -1.5338, -0.2593, -0.6438]])
.. raw:: html
.. raw:: html
.. code:: python
tf.random.normal(shape=[3, 4])
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
np.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
.. parsed-literal::
:class: output
array([[2., 1., 4., 3.],
[1., 2., 3., 4.],
[4., 3., 2., 1.]])
.. raw:: html
.. raw:: html
.. code:: python
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
.. parsed-literal::
:class: output
tensor([[2, 1, 4, 3],
[1, 2, 3, 4],
[4, 3, 2, 1]])
.. raw:: html
.. raw:: html
.. code:: python
tf.constant([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
x = np.array([1, 2, 4, 8])
y = np.array([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y # O ** é o operador exponenciação
.. parsed-literal::
:class: output
(array([ 3., 4., 6., 10.]),
array([-1., 0., 2., 6.]),
array([ 2., 4., 8., 16.]),
array([0.5, 1. , 2. , 4. ]),
array([ 1., 4., 16., 64.]))
.. raw:: html
.. raw:: html
.. code:: python
x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y # O ** é o operador exponenciação
.. parsed-literal::
:class: output
(tensor([ 3., 4., 6., 10.]),
tensor([-1., 0., 2., 6.]),
tensor([ 2., 4., 8., 16.]),
tensor([0.5000, 1.0000, 2.0000, 4.0000]),
tensor([ 1., 4., 16., 64.]))
.. raw:: html
.. raw:: html
.. code:: python
x = tf.constant([1.0, 2, 4, 8])
y = tf.constant([2.0, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y # O ** é o operador exponenciação
.. parsed-literal::
:class: output
(,
,
,
,
)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
np.exp(x)
.. parsed-literal::
:class: output
array([2.7182817e+00, 7.3890562e+00, 5.4598148e+01, 2.9809580e+03])
.. raw:: html
.. raw:: html
.. code:: python
torch.exp(x)
.. parsed-literal::
:class: output
tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])
.. raw:: html
.. raw:: html
.. code:: python
tf.exp(x)
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X = np.arange(12).reshape(3, 4)
Y = np.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
np.concatenate([X, Y], axis=0), np.concatenate([X, Y], axis=1)
.. parsed-literal::
:class: output
(array([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[ 2., 1., 4., 3.],
[ 1., 2., 3., 4.],
[ 4., 3., 2., 1.]]),
array([[ 0., 1., 2., 3., 2., 1., 4., 3.],
[ 4., 5., 6., 7., 1., 2., 3., 4.],
[ 8., 9., 10., 11., 4., 3., 2., 1.]]))
.. raw:: html
.. raw:: html
.. code:: python
X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)
.. parsed-literal::
:class: output
(tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[ 2., 1., 4., 3.],
[ 1., 2., 3., 4.],
[ 4., 3., 2., 1.]]),
tensor([[ 0., 1., 2., 3., 2., 1., 4., 3.],
[ 4., 5., 6., 7., 1., 2., 3., 4.],
[ 8., 9., 10., 11., 4., 3., 2., 1.]]))
.. raw:: html
.. raw:: html
.. code:: python
X = tf.reshape(tf.range(12, dtype=tf.float32), (3, 4))
Y = tf.constant([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
tf.concat([X, Y], axis=0), tf.concat([X, Y], axis=1)
.. parsed-literal::
:class: output
(,
)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X == Y
.. parsed-literal::
:class: output
array([[False, True, False, True],
[False, False, False, False],
[False, False, False, False]])
.. raw:: html
.. raw:: html
.. code:: python
X == Y
.. parsed-literal::
:class: output
tensor([[False, True, False, True],
[False, False, False, False],
[False, False, False, False]])
.. raw:: html
.. raw:: html
.. code:: python
X == Y
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X.sum()
.. parsed-literal::
:class: output
array(66.)
.. raw:: html
.. raw:: html
.. code:: python
X.sum()
.. parsed-literal::
:class: output
tensor(66.)
.. raw:: html
.. raw:: html
.. code:: python
tf.reduce_sum(X)
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
a = np.arange(3).reshape(3, 1)
b = np.arange(2).reshape(1, 2)
a, b
.. parsed-literal::
:class: output
(array([[0.],
[1.],
[2.]]),
array([[0., 1.]]))
.. raw:: html
.. raw:: html
.. code:: python
a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b
.. parsed-literal::
:class: output
(tensor([[0],
[1],
[2]]),
tensor([[0, 1]]))
.. raw:: html
.. raw:: html
.. code:: python
a = tf.reshape(tf.range(3), (3, 1))
b = tf.reshape(tf.range(2), (1, 2))
a, b
.. parsed-literal::
:class: output
(,
)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
a + b
.. parsed-literal::
:class: output
array([[0., 1.],
[1., 2.],
[2., 3.]])
.. raw:: html
.. raw:: html
.. code:: python
a + b
.. parsed-literal::
:class: output
tensor([[0, 1],
[1, 2],
[2, 3]])
.. raw:: html
.. raw:: html
.. code:: python
a + b
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X[-1], X[1:3]
.. parsed-literal::
:class: output
(array([ 8., 9., 10., 11.]),
array([[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]]))
Além da leitura, também podemos escrever elementos de uma matriz
especificando índices.
.. code:: python
X[1, 2] = 9
X
.. parsed-literal::
:class: output
array([[ 0., 1., 2., 3.],
[ 4., 5., 9., 7.],
[ 8., 9., 10., 11.]])
.. raw:: html
.. raw:: html
.. code:: python
X[-1], X[1:3]
.. parsed-literal::
:class: output
(tensor([ 8., 9., 10., 11.]),
tensor([[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]]))
Além da leitura, também podemos escrever elementos de uma matriz
especificando índices.
.. code:: python
X[1, 2] = 9
X
.. parsed-literal::
:class: output
tensor([[ 0., 1., 2., 3.],
[ 4., 5., 9., 7.],
[ 8., 9., 10., 11.]])
.. raw:: html
.. raw:: html
.. code:: python
X[-1], X[1:3]
.. parsed-literal::
:class: output
(,
)
``Tensors`` in TensorFlow are immutable, and cannot be assigned to.
``Variables`` in TensorFlow are mutable containers of state that support
assignments. Keep in mind that gradients in TensorFlow do not flow
backwards through ``Variable`` assignments. Os ``Tensors`` no TensorFlow
são imutáveis e não podem ser atribuídos a eles. ``Variables`` no
TensorFlow são contêineres mutáveis de estado que suportam atribuições.
Lembre-se de que gradientes no TensorFlow não fluem para trás por meio
de atribuições ``Variable``.
Beyond assigning a value to the entire ``Variable``, we can write
elements of a ``Variable`` by specifying indices. Além de atribuir um
valor a toda a ``Variable``, podemos escrever elementos de um
``Variable`` especificando índices.
.. code:: python
X_var = tf.Variable(X)
X_var[1, 2].assign(9)
X_var
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X[0:2, :] = 12
X
.. parsed-literal::
:class: output
array([[12., 12., 12., 12.],
[12., 12., 12., 12.],
[ 8., 9., 10., 11.]])
.. raw:: html
.. raw:: html
.. code:: python
X[0:2, :] = 12
X
.. parsed-literal::
:class: output
tensor([[12., 12., 12., 12.],
[12., 12., 12., 12.],
[ 8., 9., 10., 11.]])
.. raw:: html
.. raw:: html
.. code:: python
X_var = tf.Variable(X)
X_var[0:2, :].assign(tf.ones(X_var[0:2,:].shape, dtype = tf.float32) * 12)
X_var
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
before = id(Y)
Y = Y + X
id(Y) == before
.. parsed-literal::
:class: output
False
.. raw:: html
.. raw:: html
.. code:: python
before = id(Y)
Y = Y + X
id(Y) == before
.. parsed-literal::
:class: output
False
.. raw:: html
.. raw:: html
.. code:: python
before = id(Y)
Y = Y + X
id(Y) == before
.. parsed-literal::
:class: output
False
.. raw:: html
.. raw:: html
.. raw:: html
Felizmente, executar operações no local é fácil. Podemos atribuir o
resultado de uma operação para uma matriz previamente alocada com
notação de fatia, por exemplo, ``Y [:] = ``. Para ilustrar
este conceito, primeiro criamos uma nova matriz ``Z`` com a mesma forma
de outro ``Y``, usando ``zeros_like`` para alocar um bloco de :math:`0`
entradas. : end_tab:
.. code:: python
Z = np.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))
.. parsed-literal::
:class: output
id(Z): 140128414209472
id(Z): 140128414209472
Se o valor de ``X`` não for reutilizado em cálculos subsequentes, também
podemos usar ``X [:] = X + Y`` ou\ ``X + = Y`` para reduzir a sobrecarga
de memória da operação.
.. code:: python
before = id(X)
X += Y
id(X) == before
.. parsed-literal::
:class: output
True
.. raw:: html
.. raw:: html
Felizmente, executar operações no local é fácil. Podemos atribuir o
resultado de uma operação para uma matriz previamente alocada com
notação de fatia, por exemplo, ``Y [:] = ``. Para ilustrar
este conceito, primeiro criamos uma nova matriz ``Z`` com a mesma forma
de outro ``Y``, usando ``zeros_like`` para alocar um bloco de :math:`0`
entradas. : end_tab:
.. code:: python
Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))
.. parsed-literal::
:class: output
id(Z): 140194801216832
id(Z): 140194801216832
Se o valor de ``X`` não for reutilizado em cálculos subsequentes, também
podemos usar ``X [:] = X + Y`` ou\ ``X + = Y`` para reduzir a sobrecarga
de memória da operação.
.. code:: python
before = id(X)
X += Y
id(X) == before
.. parsed-literal::
:class: output
True
.. raw:: html
.. raw:: html
``Variables`` são contêineres mutáveis de estado no TensorFlow. Eles
providenciam uma maneira de armazenar os parâmetros do seu modelo.
Podemos atribuir o resultado de uma operação para uma ``Variable``
com\ ``assign``. Para ilustrar este conceito, criamos uma
:literal:`Variable`` Z` com a mesma forma de outro tensor ``Y``, usando
``zeros_like`` para alocar um bloco de :math:`0` entradas.
.. code:: python
Z = tf.Variable(tf.zeros_like(Y))
print('id(Z):', id(Z))
Z.assign(X + Y)
print('id(Z):', id(Z))
.. parsed-literal::
:class: output
id(Z): 140017345889040
id(Z): 140017345889040
Mesmo depois de armazenar o estado persistentemente em uma ``Variável``,
você pode querer reduzir ainda mais o uso de memória, evitando o excesso
de alocações para tensores que não são os parâmetros do seu modelo.
Porque os ``Tensors``\ do TensorFlow são imutáveis e gradientes não
fluem através de atribuições de ``Variable``, o TensorFlow não fornece
uma maneira explícita de executar uma operação individual no local.
No entanto, o TensorFlow fornece o decorador ``tf.function`` para
encerrar a computação dentro de um gráfico do TensorFlow que é compilado
e otimizado antes da execução. Isso permite que o TensorFlow remova
valores não utilizados e reutilize alocações anteriores que não são mais
necessárias. Isso minimiza a sobrecarga de memória de cálculos do
TensorFlow.
.. code:: python
@tf.function
def computation(X, Y):
Z = tf.zeros_like(Y) # Este valor não utilizado será esvaziado
A = X + Y # Alocações serão reutilizadas quando não mais necessárias
B = A + Y
C = B + Y
return C + Y
computation(X, Y)
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
A = X.asnumpy()
B = np.array(A)
type(A), type(B)
.. parsed-literal::
:class: output
(numpy.ndarray, mxnet.numpy.ndarray)
.. raw:: html
.. raw:: html
.. code:: python
A = X.numpy()
B = torch.tensor(A)
type(A), type(B)
.. parsed-literal::
:class: output
(numpy.ndarray, torch.Tensor)
.. raw:: html
.. raw:: html
.. code:: python
A = X.numpy()
B = tf.constant(A)
type(A), type(B)
.. parsed-literal::
:class: output
(numpy.ndarray, tensorflow.python.framework.ops.EagerTensor)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
a = np.array([3.5])
a, a.item(), float(a), int(a)
.. parsed-literal::
:class: output
(array([3.5]), 3.5, 3.5, 3)
.. raw:: html
.. raw:: html
.. code:: python
a = torch.tensor([3.5])
a, a.item(), float(a), int(a)
.. parsed-literal::
:class: output
(tensor([3.5000]), 3.5, 3.5, 3)
.. raw:: html
.. raw:: html
.. code:: python
a = tf.constant([3.5]).numpy()
a, a.item(), float(a), int(a)
.. parsed-literal::
:class: output
(array([3.5], dtype=float32), 3.5, 3.5, 3)
.. raw:: html
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html