Os Comandos mais Fundamentais do NumPy

Posts Relacionados:

04.04.24

NumPy é a principal biblioteca Python para computação numérica. Comandos NumPy são comumente usados em algoritmos de inteligência artificial e em técnicas de manipulação e análises de dados. Portanto, conhecer NumPy é um passo crucial para adquirir proficiência em IA, machine learning e ciência de dados.

Receba nossa newsletter

O NumPy é uma poderosa biblioteca Python de código aberto para computação numérica e científica. Ele fornece suporte para matrizes, arranjos (arrays) e tensores (matrizes multidimensionais) grandes, e conta com uma grande coleção de funções matemáticas de alto nível para operar nessas estruturas.

O que pode ser feito com NumPy?

Entre algumas tarefas de computação científica que podem ser executadas usando o NumPy estão:

Operações Numéricas e Álgebra Linear:

Operações matriciais como multiplicação, inversão e decomposição de eigenvalue/eigenvector.
Resolução de sistemas de equações lineares.
Realização de transformadas de Fourier.

Análises Estatísticas

Cálculo de medidas estatísticas como média, mediana, desvio padrão e variância.
Geração de números aleatórios a partir de várias distribuições de probabilidade para simulações e modelagem estatística.

Manipulação e Pré-Processamento de Dados

Manipulação eficiente de grandes conjuntos de dados multidimensionais.
Realização de limpeza, reamostragem e manipulação de dados de valores ausentes.
Remodelação, empilhamento e concatenação de matrizes.

Processamento de Sinais

Filtragem e análises de dados de séries temporais.
Realização de tarefas de processamento de sinais como convolução e correlação.

Processamento de Imagens

Execução de tarefas de manipulação e análise de imagens, como segmentação, filtragem e extração de recursos.

Simulações e Modelagem

Modelagem e análise de sistemas complexos, como os encontrados em finanças ou biologia.

Visualização e Análise de Dados

Integração com bibliotecas de visualização de dados como Matplotlib e seaborn para criar gráficos.

NumPy e Inteligência Artificial

O NumPy é uma biblioteca fundamental para inteligência artificial (IA) e opera de forma integrada com muitas bibliotecas de IA, machine learning e ciência de dados. Ele fornece as ferramentas necessárias para o manuseio, manipulação e análise eficiente de dados. NumPy também é muito utilizado em implementações de algoritmos de machine learning e redes neurais. Portanto, dominar o NumPy é um passo crucial para adquirir proficiência em várias áreas, incluindo ciência de dados e IA. Por isso, neste post, o foco será nos comandos mais importantes do NumPy para essas áreas.

Métodos para a Criação de Arranjos e Matrizes

A principal estrutura de dados no NumPy é o ndarray (matriz N-dimensional), que é mais eficiente em termos de memória e mais rápido (aqui e aqui) do que as listas tradicionais do Python para cálculos numéricos.

np.array

Comando usado para criar arrays NumPy, ou seja, matrizes unidimensionais ou multidimensionais (tensores). Possui vários parâmetros, sendo o mais importante o object, que se refere aos elementos que integrarão a matriz ou tensor. Os outros são opcionais.

				
					import numpy as np

# Definição do Método
np.array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, like=None)

				
					# Exemplo
meu_array = np.array([[0,1], [2,3]])
print(meu_array)

# output:
# [[0 1]
#  [2 3]]

O comando np.array também pode ser usado para converter DataFrames do Pandas em arranjos NumPy.

np.zeros e np.ones

As funções np.zeros e np.ones criam matrizes apenas com zeros ou uns, respectivamente. Os parâmetros de ambos são praticamente idênticos, a maioria é opcional. O parâmetro shape é obrigatório e se refere às dimensões da matriz.

				
					# Definição do Método
numpy.zeros(shape, dtype=float, order='C', *, like=None)
numpy.ones(shape, dtype=None, order='C', *, like=None)

				
					
# Exemplos
array_zeros = np.zeros([3, 5])
print(array_zeros)
# output:
# [[0. 0. 0. 0. 0.]
#  [0. 0. 0. 0. 0.]
#  [0. 0. 0. 0. 0.]]

array_ones = np.ones([3, 5])
print(array_ones)
# output:
# [[1. 1. 1. 1. 1.]
#  [1. 1. 1. 1. 1.]
#  [1. 1. 1. 1. 1.]]

np.random.randint e np.random.random

O comando random.randint retorna uma matriz ou tensor populado com números aleatórios (randômicos) inteiros com distribuição “uniforme discreta”.

				
					# Definição do Método (random.randint)
np.random.randint(low, high=None, size=None, dtype=int)

Já random.random pode ser usado para criar matrizes compostas por floats aleatórios.

				
					
# Definição do Método
np.random.random(size)

				
					# Exemplo
array_randint = np.random.randint(3, 50, size=(2,3)) # intevalo de 3 a 50
print(array_randint)
# output:
# [[ 8 28 37]
# [15 39 34]]

array_random = np.random.random(3)
print(array_random)
# output:
# [0.58051868 0.34434653 0.73756051]

np.arange

O comando np.arange retorna valores espaçados uniformemente num determinado intervalo. Ele pode ser definido com uma posição de início, parada e um intervalo.

				
					# Definição do Método
numpy.arange([start, ]stop, [step, ]dtype=None, *, like=None)

				
					# Exemplo
array_arange = np.arange(1, 10, 2)
print(array_arange)
# output:
# [1 3 5 7 9]

Métodos para Obter Informações sobre Matrizes

np.shape, np.ndim e np.size

Os comandos np.shape, np.ndim e np.size retornam, respectivamente, os tamanhos de cada dimensão de uma matriz, seu número de dimensões e seu tamanho (composição).

				
					# Exemplo
meu_array = np.array([[ 6,  8,  4], [10,  9,  6]])
print(meu_array.shape, meu_array.ndim, meu_array.size)
# output
# (2, 3) 2 6

np.where

O comando np.where é uma espécie de condicional. Ele pode ser usado para verificar a presença de uma condição, retornando os índices onde ela é verdadeira. O mesmo comando também pode ser usado para fazer substituições a partir de uma condição.

				
					# Exemplo
meu_array = np.array([[1, 2, 3, 4, 5],[6, 7, 8, 9, 0]])
meu_array_novo = np.where(meu_array==5, 100, meu_array)
print(meu_array_novo)
# output
# [[  1   2   3   4 100]
#  [  6   7   8   9   0]]

np.unique

Encontra os elementos únicos de uma matriz.

				
					# Exemplo
meu_array = np.array([[1, 2, 2, 4, 5],[3, 5, 4, 1, 0]])
print(np.unique(meu_array))
# output
# [0 1 2 3 4 5]

np.argmax, np.argmin

Np.argmax e np.argmin retornam, respectivamente, os índices do maior e menor valor de uma matriz ou de uma de suas dimensões.

				
					# Exemplos
meu_array = np.array([[1, 2, 3, 4, 5],[6, 7, 8, 9, 0]])
ex_argmax1 = np.argmax(meu_array) # retorna índices do maior valor da matriz inteira
print(ex_argmax1)
# output = 8

ex_argmax2 = np.argmax(meu_array, axis=0) # retorna índices do maior valor apenas para axis=0
print(ex_argmax2)
# output : [1 1 1 1 0]

Outros dois comandos bem parecidos são o np.max e np.min que retornam o maior e menor valor de uma matriz ou de uma de suas dimensões.

Operações Estatísticas

Os métodos np.mean (média), np.var (variância), np.std (desvio padrão) são alguns dos disponíveis para realização de operações estatísticas. Seus usos são muito parecidos. Eles podem ser aplicados a uma matriz completa ou especificamente sobre um de seus eixos.

				
					
# Exemplos
meu_array = np.array([[1, 2, 3, 4, 5],[6, 7, 8, 9, 0]])
ex_mean = np.mean(meu_array) 
ex_std = np.std(meu_array) 
ex_var = np.var(meu_array) 
print(ex_mean, ex_std, ex_var)
# output = 4.5 2.8722813232690143 8.25

Transformações de Matrizes

np.reshape

A função np.reshape cria uma nova forma para uma matriz sem alterar seus dados. O comando consiste em indicar a matriz que será transformada e sua nova forma.

				
					
# numpy.reshape(array, newshape) <- estrutura do comando

# Exemplo
meu_array = np.array([[1, 2, 3],[6, 7, 8]])
meu_array_nova_forma = np.reshape(meu_array, (meu_array.shape[0], meu_array.shape[1], 1))
print(meu_array_nova_forma)
# output
# [[[1]
#   [2]
#   [3]]

#  [[6]
#   [7]
#   [8]]]

np.transpose

Retorna uma matriz com eixos transpostos.

				
					# Exemplo
meu_array = np.array([[10, 20, 30],[40, 50, 60]])
matriz_transposta = np.transpose(meu_array)
print(matriz_transposta)
# output
# [[10 40]
#  [20 50]
#  [30 60]]

np.squeeze

Remove os eixos de comprimento um. Esse comando aparece bastante em implementações de redes neurais quando existem tensores com uma das dimensões igual a um.

				
					# Exemplo
meu_array = np.array([[[10, 20, 30],[40, 50, 60] ,[70, 80, 90]]])
print('antes do squeeze:', meu_array, '\n', 'formato da matriz:', meu_array.shape)
# output:
# antes do squeeze: [[[10 20 30]
#   [40 50 60]
#   [70 80 90]]] 
#  formato da matriz: (1, 3, 3)

squeezed_array = np.squeeze(meu_array)
print('depois do squeeze:', squeezed_array, '\n', 'formato da matriz:', squeezed_array.shape)
# output
# depois do squeeze: [[10 20 30]
#  [40 50 60]
#  [70 80 90]] 
#  formato da matriz: (3, 3)

np.concatenate

Usado para combinar matrizes ou tensores.

				
					# Exemplo
meu_array1 = np.array([[10, 20, 30],[40, 50, 60]])
meu_array2 = np.array([[1, 2, 3],[4, 5, 6]])
novo_array = np.concatenate((meu_array1, meu_array2), axis=0)
print(novo_array)
# output
# [[10 20 30]
#  [40 50 60]
#  [ 1  2  3]
#  [ 4  5  6]]

Operações de Matrizes

O NumPy tem funcionalidades para realizar várias operações com matrizes e tensores como soma, multiplicação, divisão, cálculos logaritmos e exponenciais. Mostraremos alguns exemplos a seguir.

np.sum

Soma em matrizes. Pode ser feita apenas em um eixo como mostrado abaixo.

				
					# Exemplo 1
arr = np.array([[10, 20, 30],[40, 50, 60]])
arr_sum = np.sum(arr, axis=0)
print(arr_sum)
# output
# [50 70 90]

Adicionalmente, o comando np.sum pode ser usado para retornar a soma total de uma matriz ou tensor.

				
					# Exemplo 2
arr = np.array([[10, 20, 30],[40, 50, 60]])
arr_sum = np.sum(arr)
print(arr_sum)
# output
# 210

np.dot e np.multiply

O comando np.dot realiza o produto de ponto de duas matrizes a e b. Especificamente, se a e b são matrizes 1-D, o np.dot é o produto interno de vetores (sem conjugação complexa). Se a e b são matrizes 2D, o np.dot é multiplicação de matriz. Nesse caso, o uso das funções matmul ou @ b é preferível. Se a ou b é 0-D (escalar), o np.dot é equivalente a multiplicar. Nesse caso, o uso do numpy.multiply(a, b) ou a * b é preferível.

				
					# Exemplo 
arr1 = np.array([[10, 20, 30],[40, 50, 60]])
arr2 = np.array([[10, 20, 30],[40, 50, 60]])
arr_dot = np.dot(arr1, np.transpose(arr2))
print(arr_dot)
# output
# [[1400 3200]
#  [3200 7700]]

Abaixo mostramos um exemplo da função np.multiply. Ela realiza multiplicações por elementos (element-wise).

				
					# Exemplo 
arr1 = np.array([[10, 20, 30],[40, 50, 60]])
arr2 = np.array([[10, 20, 30],[40, 50, 60]])
arr_dot = np.multiply(arr1, arr2)
print(arr_dot)
# output
# [50 70 90]
# [[ 100  400  900]
#  [1600 2500 3600]]

np.exp

O comando np.exp calcula o exponencial de todos os elementos de uma matriz ou tensor.

				
					
# Exemplo
arr = np.array([[10, 20, 30],[40, 50, 60]])
arr_exp = np.exp(arr)
print(arr_exp)
# output
# [[2.20264658e+04 4.85165195e+08 1.06864746e+13]
#  [2.35385267e+17 5.18470553e+21 1.14200739e+26]]

Como Aprender NumPy?

Aprender a usar o NumPy com proficiência requer prática. O mais recomendado é começar com os tutoriais oficiais, como o NumPy Quickstart Tutorial e o Tentative NumPy Tutorial. Eles fornecem uma base sólida sobre as funcionalidades principais do NumPy. A melhor maneira de aprender NumPy é começar a usá-lo em seus próprios projetos. Sempre que encontrar um problema que possa ser resolvido com o NumPy, obrigue-se a usá-lo, consultando a documentação conforme necessário. Após ter uma boa compreensão dos conceitos básicos, explore os conceitos mais avançados do NumPy, como indexação avançada, divisão e operações de álgebra linear.