Entendendo a biblioteca NumPy

Para mais detalhes Clique Aqui.

O que é o NumPy?

O NumPy é uma poderosa biblioteca Python que é usada principalmente para realizar cálculos em Arrays Multidimensionais. O NumPy fornece um grande conjunto de funções e operações de biblioteca que ajudam os programadores a executar facilmente cálculos numéricos. Esses tipos de cálculos numéricos são amplamente utilizados em tarefas como:

  • Modelos de Machine Learning: Ao escrever algoritmos de Machine Learning, supõe-se que se realize vários cálculos numéricos em Array. Por exemplo, multiplicação de Arrays, transposição, adição, etc. O NumPy fornece uma excelente biblioteca para cálculos fáceis (em termos de escrita de código) e rápidos (em termos de velocidade). Os Arrays NumPy são usados para armazenar os dados de treinamento, bem como os parâmetros dos modelos de Machine Learning.
  • Processamento de Imagem e Computação Gráfica: Imagens no computador são representadas como Arrays Multidimensionais de números. NumPy torna-se a escolha mais natural para o mesmo. O NumPy, na verdade, fornece algumas excelentes funções de biblioteca para rápida manipulação de imagens. Alguns exemplos são o espelhamento de uma imagem, a rotação de uma imagem por um determinado ângulo etc.
  • Tarefas matemáticas: NumPy é bastante útil para executar várias tarefas matemáticas como integração numérica, diferenciação, interpolação, extrapolação e muitas outras. O NumPy possui também funções incorporadas para álgebra linear e geração de números aleatórios. É uma biblioteca frequentemente usada junto com pacotes como SciPy e Mat-plotlib. Um combinação amplamente usada como substituto do MATLAB baseada em Python quando se trata de tarefas matemáticas.
Python (Scipy, NumPy e Matplotlib) x MATLAB

Instalação da biblioteca NumPy

O caminho mais rápido e mais fácil de instalar a biblioteca NumPy em sua máquina é usar o seguinte comando no shell:

pip install numpy

Isso instalará a versão mais recente e mais estável do NumPy em sua máquina. Instalar através do pip é a maneira mais simples de instalar qualquer pacote Python.

Podemos também Instalar através da Distribuição Anaconda:

Clique aqui caso queira instalar a Distribuição Anaconda em sua Maquina!

Agora vamos seguir e falar sobre o conceito mais importante no NumPy: Arrays.

Arrays NumPy

A estrutura de dados mais importante que o NumPy fornece é um objeto poderoso, um tipo de Array, chamada ndarray. O objeto ndarray consiste em um segmento unidimensional contíguo da memória do computador, combinado com um esquema de indexação que mapeia cada item para um local no bloco de memória. O bloco de memória contém os elementos em uma ordem principal de linha (estilo a linguagem C) ou uma ordem de coluna principal (estilo FORTRAN ou MATLAB), mas não vamos nos aprofundar tanto nesses detalhes. Essa Array NumPy é uma tabela de elementos (geralmente números), todos do mesmo tipo, indexados por uma tupla de inteiros positivos. No NumPy, as dimensões são chamadas de eixos. Por exemplo, as coordenadas de um ponto no espaço 3D: [1, 2, 1] têm um eixo. Esse eixo tem 3 elementos, então dizemos que ele tem um comprimento de 3. No exemplo mostrado abaixo, a Array tem 2 eixos. O primeiro eixo tem um comprimento de 2, o segundo eixo tem um comprimento de 3:

# Exemplo sobre a estrutura da tabela de elementos na Array NumPy.
[[ 1., 0., 0.] 
[ 0., 1., 2.]]

Exemplificando, vamos imaginar que os eixos seja como uma tabela que fazemos no Excel por exemplo, onde temos linhas e colunas. No exemplo acima, temos 2 linhas e 3 colunas por assim dizer.

Ou seja, no exemplo da estrutura de elementos que visualizamos anteriormente tem o primeiro eixo com o comprimento de 2, sendo essas as linhas. O segundo eixo com o comprimento de 3 sendo assim as colunas. Olhando dessa maneira e mentalizando essa ideia, fica bem mais simples de aplica um ‘slicing’ ou fatiamento em uma Array Numpy.

Um Array NumPy é uma extensão de um Array Python, que lida apenas com Arrays Unidimensionais e oferece menos funcionalidade. Os Arrays NumPy são equipados com um grande número de funções e operadores que ajudam a escrever rapidamente códigos de alto desempenho para vários tipos de cálculos que discutimos acima. Vamos ver a seguir como podemos definir rapidamente um Array NumPy Unidimensional.

Arrays NumPy Unidimensional

Vamos começar com o seguinte código:

# Importando a biblioteca NumPy.

import numpy as np


# Exemplo de uma Array NumPy.

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


# Imprimindo a Array.

print(my_array)

No exemplo acima, nós importamos a biblioteca NumPy usando import numpy as np, veja que essa forma de importar e nomear como np é uma forma padrão muito utilizada. Então seguindo adiante nós criamos um Array NumPy simples de 5 números inteiros e depois o imprimimos. Vá em frente e experimente em sua própria máquina. Use as etapas na seção “Instalação da biblioteca NumPy”, descrita acima para certificar-se de que você instalou a biblioteca NumPy em sua máquina. Vamos ver agora o que podemos fazer com esse Array NumPy em particular.

# atributo de retorno da forma atual da nossa Array.

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

print(my_array.shape)

Isso imprimirá a forma da array que criamos tendo como resultado:

(5,)

Isso indica que my_array é uma Array com 5 elementos. O atributo shape retorna uma tupla que consiste nas dimensões da Array, mostrando quantas linha e colunas temos para exemplificar. Percebemos que na saída mostrou apenas 5 elementos, por conta de existir apenas um linha ou por ser uma unica dimensão por assim dizer. Caso fosse uma Array Bidimensional por exemplo seria algo como:

Input:

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

print(my_array)

Output:

(2, 5)

Agora ele retorna mostrando que temos 2 dimensões com 5 elementos.

Também podemos usar o atributo reshape para redimensionar a Array NumPy:

# Exemplo: 

a = np.arange(6).reshape((3, 2))
print(a)

Saída:

array([[0, 1],
[2, 3],
[4, 5]])

Podemos também imprimir os elementos individuais. Assim como um Array Python, os Arrays NumPy são indexados começando do 0.

# Exemplo:

print(my_array[0]) # Imprimindo o primeiro elemento da Array

print(my_array[1]) # Imprimindo o segundo elemento da Array

Os comandos acima imprimirão 1 e 2 respectivamente no terminal. Falaremos mais sobre indexação logo adiante.

Também podemos modificar os elementos de um Array. Por exemplo, suponha que escrevamos o seguinte comando:

# aqui estamos alterando o primeiro elemento da Array
# atribuindo um novo valor ao índice 0

my_array[0] = -1

print(my_array)

Vamos ter como saída:

[-1, 2, 3, 4, 5]

Agora, suponha que queremos criar uma Array NumPy vazia? podemos usar a função empty,Ele cria uma Array não inicializada e dtype especificados:

# exemplo da estrutura da função, ela possui 3 parâmetro.

np.empty(shape, dtype = float, order = 'C')

O código a seguir mostra um exemplo de uma Array NumPy vazia:

import numpy as np 
x = np.empty([3,2], dtype = int) 
print(x)

Teremos a seguinte saída:

[[22649312    1701344351] 
[1818321759 1885959276]
[16779776 156368896]]

Os elementos acima mostram valores aleatórios, pois não são inicializados.

Agora digamos que queremos criar um Array NumPy que retorne todos os valores 0? Sim e possível!

A função zeros torna isso simples e fácil, vejamos um exemplo a seguir:

my_new_array = np.zeros((5)) 
print(my_new_array)

Saída:

[0, 0, 0, 0, 0]

Semelhante a função zeros nós também temos a função ones e de forma semelhante retornaremos:

[1, 1, 1, 1, 1]

E se quisermos criar uma Array de valores aleatórios?

my_random_array = np.random.random((5)) 
print(my_random_array)

A saída que obteremos será algo como:

[0.48691037 0.70332792 0.8123029 0.18101876 0.82146451]

Vamos imprimir números aleatorios que esteja entre 0 e 10:

a = np.floor(10*np.random.random((3,4))) 
print(a)

Saída:

[[7. 9. 0. 3.]
[4. 0. 9. 1.]
[1. 7. 9. 6.]]

E claro que a saída que você terá pode variar já que estamos usando uma função aleatória que atribui a cada elemento um valor aleatório.

Vamos voltar a falar um pouco mais sobre indexação.

my_array2 = np.array([3, 2, 8, 22, 127]) 
my_array2[3]

Acima fatiamos my_array2 e teremos de saída:

(22,)

Elemento que se encontra no índice 3.

Podemos ir mais a fundo por fatiar mais elementos dentro da Array, por exemplo:

my_array2 = np.array([3, 2, 8, 22, 127]) 
print(my_array2[1:])

Saída:

array([ 2, 8, 22, 127])

Acima fatiamos todos os elementos a partir do índice 1, o mesmo pode ser feito de com o exemplo a seguir:

my_array2 = np.array([3, 2, 8, 22, 127]) 
print(my_array2[2:4])

Saída:

array([ 8, 22])

Agora fatiamos do índice 2 ao 4, porém o elemento 4 não será incluído como podemos ver na saída acima.

Arrays NumPy Bidimensionais

Criando uma Array Numpy bidimensionais:

my_array3 = np.zeros((2, 3)) 
print(my_array3)

Saída:

[[0. 0. 0.]
[0. 0. 0.]]

Agora vamos usar a função ones em nosso array bidimensionais:

my_array4 = np.ones((2, 4)) 
print(my_array4)

Saída:

[[1. 1. 1. 1.]
[1. 1. 1. 1.]]

Vamos prosseguir:

my_array = np.array([[4, 5], [6, 1]])
print(my_array[0][1])

A saída do trecho de código acima é 5, uma vez que é o elemento presente na coluna 0 do índice e na coluna do índice 1.

Você também pode imprimir a forma de my_array da seguinte maneira:

print(my_array.shape)

A saída é (2, 2), indicando que há 2 linhas e 2 colunas na matriz.

O NumPy fornece uma maneira poderosa de extrair linhas/colunas de um array multidimensional. Por exemplo, considere o exemplo my_array que definimos acima.

my_array = np.array([[4, 5], [6, 1]])
print(my_array)

Saída:

[[4 5]
[6 1]]

Suponha que queremos extrair todos os elementos da segunda coluna (índice 1) dela. Aqui, como pode ser visto, a segunda coluna é composta de dois elementos: 5 e 1. Para fazer isso, podemos fazer o seguinte:

my_array_column_2 = my_array[:, 1]
print(my_array_column_2)

Observe que, em vez de um número de linha, fornecemos dois-pontos ( : ) e, para o número da coluna, usamos o valor 1. A saída será: [5, 1].

Podemos similarmente extrair uma linha de um array NumPy multidimensional. Agora, vamos ver o poder que o NumPy oferece quando se trata de realizar cálculos em vários arrays.

Manipulando Arrays NumPy

Usando o NumPy, você pode facilmente executar cálculos matemáticos em Arrays. Por exemplo, você pode somar Arrays NumPy, subtraí-los, multiplicá-los e até dividi-los. Aqui estão alguns exemplos disso:

import numpy as np
a = np.array([[1.0, 2.0], [3.0, 4.0]])
b = np.array([[5.0, 6.0], [7.0, 8.0]])
sum = a + b # Soma
difference = a - b # Subtração
product = a * b # Multiplicação
quotient = a / b # Divisão
print('Sum = \n', + sum)
print('\n')
print('Difference = \n', + difference)
print('\n')
print('Product = \n', + product)
print('\n')
print('Quotient = \n', + quotient)

A saída será:

Sum = 
[[ 6. 8.]
[10. 12.]]

Difference = 
[[-4. -4.]
[-4. -4.]]

Product = 
[[ 5. 12.]
[21. 32.]]

Quotient = 
[[0.2 0.33333333]
[0.42857143 0.5 ]]

Como você pode ver, o operador de multiplicação executa a multiplicação por elementos em vez da multiplicação de arrays. Para executar a multiplicação de arrays, você pode fazer o seguinte:

matrix_product = a.dot(b) 

print('Matrix Product = \n', + matrix_product)

Saída:

Matrix Product = 
[[19. 22.]
[43. 50.]]

A função dot executa a multiplicação de Arrays.

Conclusão

Como você pode ver, o NumPy é realmente poderoso em termos da função de biblioteca que ele fornece. Você pode executar grandes cálculos em uma única linha de código com a excelente interface que o NumPy expõe. Isto é o que torna uma ferramenta elegante para vários cálculos numéricos. Você deve definitivamente considerar dominá-lo se quiser desenvolver uma carreira como matemático ou como cientista de dados. Você precisa conhecer o Python antes de se tornar proficiente no NumPy é claro. Espero que você tenha tirado proveito e que essa explicação tenha sido bem clara para você, venho abordando esse artigo pois vejo muito pouco material em português sobre ciência de dados e afins. Então até a próxima!