Array NumPy
NumPy é certamente uma das bibliotecas Python mais populares para desenvolver modelos de IA e machine learning em Python. Portanto, conhecer NumPy é uma necessidade para atuar na área. O principal elemento do NumPy é o array NumPy, que será o foco deste post.
Um array NumPy é uma estrutura de dados fundamental usada para armazenar uma coleção de elementos.
Esses elementos são indexados a partir do 0. A indexação permite que qualquer elemento seja acessado diretamente por sua posição.
Todos os elementos de um array NumPy devem ser do mesmo tipo de dados (por exemplo, inteiros, floats, strings).
Após criado, o tamanho total do array não pode ser alterado.
A forma do array NumPy precisa ser regular, isso significa que, por exemplo, cada linha de uma matriz bidimensional deve ter o mesmo número de colunas.
Criação de arrays NumPy
Os arrays NumPy podem ser criados de diversas maneiras. Nos concentraremos nas mais comuns usadas em machine learning.
Método array()
O método array() fornece uma forma simples de criar arrays NumPy usando listas, matrizes ou tensores como argumentos:
import numpy as np
# cria um array a partir de um vetor
meu_vetor = np.array([1, 2, 3, 4])
# cria um array a partir de uma matriz
minha_matriz = np.array([[1,2,3], [4,5,6]])
# cria um array a partir de um tensor
meu_tensor = np.array([[[1,2,3], [4,5,6]], [[1,2,3], [4,5,6]]])
Um array NumPy pode conter números, listas, strings e vários outros tipos de elementos. Veja um exemplo abaixo:
meu_arr = np.array([[['Ana', 'telefone', 'cadeira'], [list[1,2,3],5,6]], [[1,2,3], [4,5,6]]])
print((meu_arr).dtype)
# resultado: object
Neste exemplo, o array foi usado para armazenar strings, números e até uma lista. Porém, o array identifica seus elementos como do tipo object. Um array NumPy do tipo object é geralmente usado para armazenar dados diversos.
No exemplo acima, note também que precisamos usar o constructor list para inserir uma lista no array. Sem isso, o NumPy iria interpretar a lista como uma dimensão heterogênea no array e geraria um erro.
Abaixo, mostramos um exemplo de array de elementos do tipo int e outro de float. Veja que basta a adição de um ponto em alguns elementos do array para que todos os seus itens sejam convertidos em float.
arr = np.array([[1,2,3], [4,5,6], [1,2,3]])
print((arr).dtype)
# resultado: int64
arr = np.array([[1.,2.,3.], [4.,5.,6.], [1,2,3]])
print((arr).dtype)
# resultado: float64
Arrays de zeros e de uns
Arrays totalmente formados por zeros ou uns são ocorrências comuns em machine learning. Eles são criados como os métodos np.zeros() e np.ones(), respectivamente. Ambos os métodos precisam receber as dimensões do array como argumentos.
arr_zeros = np.zeros((10, 10, 10, 10)) # exemplo de array de zeros com dimensão 10 x 10 x 10 x 10
arr_ones = np.ones((10, 5, 7)) # cria um array de uns com dimensão 10 x 5 x 7
No exemplo acima, os números entre parenteses são as dimensões dos arrays.
Uma variação do método np.zeros() é o método np.zero_like(). Ele aceita um array como argumento para extrair suas dimensões e criar um array NumPy de zeros com a forma desejada.
meu_arr = np.array([[1,2,3],[4,5,6]])
meu_arr_zeros = np.zeros_like(meu_arr)# cria um array de zeros com a dimensão do array meu_arr
print(meu_arr_zeros)
# resultado:
# [[0 0 0]
# [0 0 0]]
Arrays de números aleatórios
O NumPy conta com vários métodos para trabalhar com números randômicos. Nos concentraremos nos mais usados em implementações de machine learning.
O método np.random.rand() gera um array de números aleatórios do tipo float no intervalo [0, 1) com distribuição uniforme. Se nenhum argumento for passado, ele retorna apenas um número. Opcionalmente, podemos passar valores de n-dimensões e ele retornará um array n-dimensional com números aleatórios, como ilustrado no exemplo abaixo:
arr1 = np.random.rand(3, 3)
print(arr1)
# resultado
# [[0.19550904 0.78911216 0.04711812]
# [0.66424817 0.38541458 0.77819541]
# [0.84466973 0.77643781 0.29918163]]
Um método parecido é o np.random.randn() que retorna números aleatórios, mas com distribuição “normal padrão”.
Outro método comum é o np.random.randint(). Sua sintaxe é mostrada abaixo:
np.random.randint(lim_inferior, lim_superior, size=None, dtype=int)
Esse método é apropriado para criar arrays de números randômicos inteiros. Ele tem um valor inferior como parâmetro (lim_inferior) e um superior (lim_superior). Se apenas um número for fornecido, o método o entenderá como o limite superior. Outro argumento opcional é a dimensão (size) do array NumPy. Se for deixado em branco, ele retornará um único número.
print(np.random.randint(0, 10, (2, 5))) # cria um array com valores entre 0 e 10 e tamanho 2 x 5
# resultado
# [[2 4 9 4 6]
# [7 7 0 8 8]]
Métodos arange() e linspace()
Outra forma frequentemente usada para criar arrays é com o método arange(). Ele requer pelo menos um valor como argumento e cria um array começando em zero até o valor desejado (não incluído) com incremento padrão de 1.
import numpy as np
arr = np.arange(100)
print(arr)
# resultado:
# [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
# 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
# 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
# 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
# 96 97 98 99]
O valor de início pode ser especificado como parâmetro opcional:
arr = np.arange(50, 100)
print(arr)
# resultado
# [50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
# 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
# 98 99]
Também é possível usar um passo para o incremento do array:
arr = np.arange(50, 100, 5)
print(arr)
# resultado
# [50 55 60 65 70 75 80 85 90 95]
Um método parecido com np.arange() é o np.linspace(). A diferença entre os dois é que, ao invés de aceitar um passo de incremento, o np.linspace() aceita um valor que indica o número de elementos que deverão ser retornados. Ele divide o intervalo uniformemente para retornar os resultados estipulados.
arr = np.linspace(50, 100, 5) # retorna 5 elementos entre 50 e 100
print(arr)
# resultado
# [ 50. 62.5 75. 87.5 100. ]
Atributos de arrays
Método shape()
Como explicado anteriormente, o método np.shape() retorna a forma do array. Ou seja, o tamanho de cada uma de suas dimensões, também referidas como eixos.
arr = np.random.rand(3, 5)
print(arr.shape)
# resultado: (3, 5)
Para verificar o tamanho de uma dimensão específica, basta indicar o eixo de interesse, lembrando que a indexação NumPy começa em 0.
arr = np.linspace(3, 30, 10)
print(arr) # resultado: [ 3. 6. 9. 12. 15. 18. 21. 24. 27. 30.]
print(arr.shape[0]) # retorna a forma do primeiro eixo
# resultado: 10
Assim como listas em Python, o NumPy aceita indexação negativa e ela pode ser usada para verificar o tamanho de cada eixo.
arr = np.array([[[1,2,3], [4, 5, 6]],[[1,2,3], [4, 5, 6]]])
print(arr.shape) # verifica a forma do arry inteiro
# resultado: (2, 2, 3)
print(arr.shape[-1]) # verifica o tamanho do último eixo
# resultado: 3
print(arr.shape[-2]) # verifica o tamanho do penúltimo eixo
# resultado: 2
Métodos ndim() e size()
O método ndim retorna quantas dimensões um array possui.
arr = np.array([[[[1,2,3], [4, 5, 6]],[[1,2,3], [4, 5, 6]]],[[[1,2,3], [4, 5, 6]],[[1,2,3], [4, 5, 6]]]])
print(arr.ndim) # verifica quantas dimensões o array possui
# resultado: 4
O método size retorna o tamanho total do array. Ou seja, seu número de elementos:
arr = np.array([[[[1,2,3], [4, 5, 6]],[[1,2,3], [4, 5, 6]]],[[[1,2,3], [4, 5, 6]],[[1,2,3], [4, 5, 6]]]])
print(arr.size) # verifica o tamanho total em elementos de um array
# resultado: 24
Esses métodos são essenciais quando precisamos treinar um modelo com um conjunto de dados grandes e impossível de se inspecionar diretamente. Por isso, eles são muito comuns em implementações de machine learning, particularmente em modelos de redes neurais e deep learning.
Veja também:
Encontrou algum erro ou quer fazer uma sugestão? Por favor, entre em contato usando nosso formulário de contatos.
