NumPy Crash Course – Como construir matrizes n-dimensionais poderosas com NumPy

NumPy Crash Course – Como construir matrizes n-dimensionais poderosas com NumPy

22 de September, 2020 0 By António César de Andrade


NumPy é uma biblioteca Python para realizar cálculos numéricos em grande escala. É extremamente útil, especialmente no aprendizado de máquina. Vejamos o que o NumPy tem a oferecer.

NumPy é uma biblioteca Python usada para realizar cálculos numéricos com grandes conjuntos de dados. O nome significa Numerical Python e é uma biblioteca popular usada por cientistas de dados, especialmente para problemas de aprendizado de máquina.

O NumPy é útil durante o pré-processamento dos dados antes de treiná-los usando um algoritmo de aprendizado de máquina.

Trabalhar com matrizes n-dimensionais é mais fácil no NumPy em comparação com as listas do Python. Os arrays NumPy também são mais rápidos do que as listas Python, pois, ao contrário das listas, os arrays NumPy são armazenados em um local contínuo na memória. Isso permite que o processador execute cálculos com eficiência.

Neste artigo, veremos os fundamentos do trabalho com NumPy, incluindo operações de array, transformações de matriz, geração de valores aleatórios e assim por diante.

Instruções claras de instalação são fornecidas no site oficial do NumPy, então não vou repeti-las neste artigo. Encontre essas instruções aqui.

Importando NumPy

Para começar a usar o NumPy em seu script, você deve importá-lo.

import numpy as np

Convertendo matrizes em matrizes NumPy

Você pode converter suas listas Python existentes em matrizes NumPy usando o método np.array (), como este:

arr = [1,2,3]
np.array(arr)

Isso também se aplica a matrizes multidimensionais. NumPy controlará a forma (dimensões) do array.

nested_arr = [[1,2],[3,4],[5,6]]
np.array(nested_arr)

Função NumPy Arrange

Ao trabalhar com dados, você frequentemente encontrará casos de uso em que precisa gerar dados.

NumPy como um método “organize ()” com o qual você pode gerar um intervalo de valores entre dois números. A função de arranjo usa o parâmetro inicial, final e um parâmetro de distância opcional.

print(np.arrange(0,10)) # without distance parameter
OUTPUT:[0 1 2 3 4 5 6 7 8 9]

print(np.arrange(0,10,2)) # with distance parameter
OUTPUT: [0 2 4 6 8]

Zeros e uns

Você também pode gerar um array ou matriz de zeros ou uns usando NumPy (acredite, você vai precisar). Veja como.

print(np.zeros(3))
OUTPUT: [0. 0. 0.]

print(np.ones(3))
OUTPUT: [1. 1. 1.]

Ambas as funções também suportam matrizes n-dimensionais. Você pode adicionar a forma como uma tupla com linhas e colunas.

print(np.zeros((4,5)))
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.]
]

print(np.ones((4,5)))
OUTPUT:
[
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
]

Matriz de identidade

Você também pode gerar um matriz de identidade usando uma função NumPy integrada chamada “olho”.

np.eye(5)
OUTPUT:
[[1., 0., 0., 0., 0.]
[0., 1., 0., 0., 0.]
[0., 0., 1., 0., 0.]
[0., 0., 0., 1., 0.]
[0., 0., 0., 0., 1.]]

Função NumPy Linspace

NumPy tem um método linspace que gera pontos uniformemente espaçados entre dois números.

print(np.linspace(0,10,3))
OUTPUT:[ 0.  5. 10.]

No exemplo acima, o primeiro e o segundo parâmetros são os pontos inicial e final, enquanto o terceiro parâmetro é o número de pontos necessários entre o início e o fim.

Aqui está o mesmo intervalo com 20 pontos.

print(np.linspace(0,10,20))
OUTPUT:[ 0. 0.52631579  1.05263158  1.57894737  2.10526316  2.63157895   3.15789474  3.68421053  4.21052632  4.73684211  5.26315789  5.78947368   6.31578947  6.84210526  7.36842105  7.89473684  8.42105263  8.94736842   9.47368421 10.]

Geração de número aleatório

Quando você está trabalhando em problemas de aprendizado de máquina, geralmente precisa gerar números aleatórios. O NumPy também possui funções integradas para isso.

Mas antes de começarmos a gerar números aleatórios, vamos examinar dois tipos principais de distribuição.

Distribuição normal

Em um distribuição normal padrão, os valores atingem o pico no meio.

A distribuição normal é um conceito muito importante em estatística, visto que pode ser vista em muitos fenômenos naturais. Também é chamada de “curva de sino”.

Distribuição uniforme

Se os valores na distribuição têm a probabilidade como uma constante, ela é chamada de distribuição uniforme.

Por exemplo, o cara ou coroa tem uma distribuição uniforme, pois a probabilidade de obter cara ou coroa no cara ou coroa é a mesma.

Agora que você sabe como as duas distribuições principais funcionam, vamos gerar alguns números aleatórios.

  • Para gerar números aleatórios em uma distribuição uniforme, use o rand () função de np.random:

print(np.random.rand(10)) # array
OUTPUT: [0.46015141 0.89326339 0.22589334 0.29874476 0.5664353  0.39257603  0.77672998 0.35768031 0.95087408 0.34418542]

print(np.random.rand(3,4)) # 3x4 matrix
OUTPUT:[[0.63775985 0.91746663 0.41667645 0.28272243]  [0.14919547 0.72895922 0.87147748 0.94037953]  [0.5545835  0.30870297 0.49341904 0.27852723]]

  • Para gerar números aleatórios em uma distribuição normal, use o randn () função de np.random:

print(np.random.randn(10))
OUTPUT:[-1.02087155 -0.75207769 -0.22696798  0.86739858  0.07367362 -0.41932541   0.86303979  0.13739312  0.13214285  1.23089936]

print(np.random.randn(3,4))
OUTPUT: [[ 1.61013773  1.37400445  0.55494053  0.23133522]  [ 0.31290971 -0.30866402  0.33093618  0.34868954]  [-0.11659865 -1.22311073  0.36676476  0.40819545]]

  • Para gerar inteiros aleatórios entre um valor baixo e alto, use o randint () função de np.random:

print(np.random.randint(1,100,10))
OUTPUT:[64 37 62 27  4 33 23 52 70  7]

print(np.random.randint(1,100,(2,3)))
OUTPUT:[[92 42 38]  [87 69 38]]

UMA valor semente é usado se você quiser que seus números aleatórios sejam os mesmos durante cada cálculo. Aqui está como você define um valor de semente em NumPy.

  • Para definir um valor de semente em NumPy, faça o seguinte:

np.random.seed(42)
print(np.random.rand(4))
OUTPUT:[0.37454012, 0.95071431, 0.73199394, 0.59865848]

Sempre que você usar um número de semente, sempre obterá o mesmo array gerado sem qualquer alteração.

Remodelando Matrizes

Como cientista de dados, você trabalhará com a reformulação dos conjuntos de dados para diferentes tipos de cálculos. Nesta seção, veremos como trabalhar com as formas de arrays.

  • Para obter a forma de uma matriz, use o forma propriedade.

arr = np.random.rand(2,2)
print(arr)
print(arr.shape)
OUTPUT:[
[0.19890857 0.00806693]
[0.48199837 0.55373954]
]
(2, 2)

  • Para remodelar uma matriz, use o remodelar () função.

print(arr.reshape(1,4))
OUTPUT: [[0.19890857 0.00806693 0.48199837 0.55373954]]
print(arr.reshape(4,1))
OUTPUT:[
[0.19890857]
[0.00806693]
[0.48199837]
[0.55373954]
]

Para remodelar permanentemente um array, você deve atribuir o array remodelado à variável ‘arr’.

Além disso, remodelar só funciona se a estrutura existente fizer sentido. Você não pode remodelar uma matriz 2×2 em uma matriz 3×1.

Fatiar dados

Vejamos como obter dados de matrizes NumPy. Os arrays NumPy funcionam de maneira semelhante às listas Python durante as operações de busca.

  • Para fatiar uma matriz, faça o seguinte:

myarr = np.arange(0,11)
print(myarr)
OUTPUT:[ 0  1  2  3  4  5  6  7  8  9 10]

sliced = myarr[0:5]
print(sliced)
OUTPUT: [0 1 2 3 4]

sliced[:] = 99
print(sliced)
OUTPUT: [99 99 99 99 99]

print(myarr)
OUTPUT:[99 99 99 99 99  5  6  7  8  9 10]

Se você olhar o exemplo acima, embora tenhamos atribuído a fatia de “myarr” à variável “fatiado”, alterar o valor de “fatiado” afeta o array original. Isso ocorre porque a “fatia” estava apenas apontando para a matriz original.

Para fazer uma seção independente de uma matriz, use o cópia de() função.

sliced = myarr.copy()[0:5]

  • O fatiamento de arrays multidimensionais funciona de maneira semelhante a arrays unidimensionais.

my_matrix = np.random.randint(1,30,(3,3))
print(my_matrix)
OUTPUT: [
[21  1 20]
[22 16 27]
[24 14 22]
]

print(my_matrix[0]) # print a single row
OUTPUT: [21  1 20]

print(my_matrix[0][0]) # print a single value or row 0, column 0
OUTPUT: 21

print(my_matrix[0,0]) #alternate way to print value from row0,col0
OUTPUT: 21

Array Computations

Agora, vamos examinar os cálculos de array. O NumPy é conhecido por sua velocidade ao realizar cálculos complexos em grandes matrizes multidimensionais.

Vamos tentar algumas operações básicas.

new_arr = np.arange(1,11)
print(new_arr)
OUTPUT: [ 1  2  3  4  5  6  7  8  9 10]

print(new_arr + 5)
OUTPUT: [ 6  7  8  9 10 11 12 13 14 15]

print(new_arr - 5)
OUTPUT: [-4 -3 -2 -1  0  1  2  3  4  5]

print(new_arr + new_arr)
OUTPUT: [ 2  4  6  8 10 12 14 16 18 20]

print(new_arr / new_arr)
OUTPUT:[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

Para erros de divisão zero, Numpy irá converter o valor para NaN (não um número).

Existem também alguns métodos de computação embutidos disponíveis no NumPy para calcular valores como média, desvio padrão, variância e outros.

  • Soma – np.sum ()
  • Raiz quadrada – np.sqrt ()
  • Média – np.mean ()
  • Variância – np.var ()
  • Desvio Padrão – np.std ()

Ao trabalhar com matrizes 2D, você geralmente precisará calcular a soma das linhas ou das colunas, a média, a variância e assim por diante. Você pode usar o parâmetro opcional do eixo para especificar se deseja escolher uma linha ou coluna.

arr2d = np.arange(25).reshape(5,5)
print(arr2d)
OUTPUT: [
[ 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]
]

print(arr2d.sum())
OUTPUT: 300

print(arr2d.sum(axis=0))  # sum of columns
OUTPUT: [50 55 60 65 70]

print(arr2d.sum(axis=1)) #sum of rows
OUTPUT: [ 10  35  60  85 110]

Operações Condicionais

Você também pode fazer filtragem condicional com NumPy usando a notação de colchetes. Aqui está um exemplo:

arr = np.arange(0,10)
OUTPUT: [0,2,3,4,5,6,7,8,9]

print(arr > 4)
OUTPUT: [False False False False False  True  True  True  True  True]

print(arr[arr > 4])
OUTPUT: [5 6 7 8 9]

Quando se trata de trabalhar com grandes conjuntos de dados, o NumPy é uma ferramenta poderosa para ter em seu kit de ferramentas. Ele é capaz de lidar com cálculos numéricos avançados e operações complexas de matriz n-dimensional.

Recomendo enfaticamente que você aprenda o NumPy se planeja iniciar uma carreira em aprendizado de máquina.

Aqui está um bloco de notas colab do Google, se você quiser experimentar esses exemplos.

Obtenha um resumo dos meus artigos e vídeos enviados para seu e-mail todas as manhãs de segunda-feira. Você também pode conecte-se comigo aqui.



Fonte

Click to rate this post!
[Total: 0 Average: 0]