Vetorização de condicionais com NumPy
Python é uma linguagem fantástica para desenvolver modelos de IA, realizar tarefas de análise de dados, scripts de automação e muito mais. No entanto, todos nós sabemos que, quando se trata de velocidade, a cobra Python parece mais uma tartaruga! Quando precisamos escrever códigos eficientes, muitas vezes ficamos presos em loops ou enfrentando lentidão ao manipular grandes conjuntos de dados manualmente usando listas tradicionais do Python. Felizmente, Python conta com NumPy!
NumPy é a super biblioteca de computação numérica do Python. Ela oferece uma ampla gama de recursos que podem nos ajudar a superar problemas de lentidão e códigos ineficazes. Através do uso do NumPy, podemos melhorar significativamente o desempenho dos códigos Python sem sacrificar a legibilidade da nossa linguagem preferida!
Neste post, exploraremos como usar o NumPy para acelerar condicionais em códigos Python. Para acompanhar o post, será preciso instalar a biblioteca caso você não a possua ainda. A instalação pode ser feita com pip:
uv pip install numpy
Para verificar sua instalação, você pode executar os seguintes comandos, eles irão imprimir a versão do NumPy instalada em seu sistema:
import numpy as np
print(np.__version__)
Primeiro passo: substitua for-loops por operações vetorizadas
Quando pensamos em velocidade e NumPy, a vetorização é a palavra de ordem! Ela permite a realização de operações matemáticas em listas grandes e complexas de uma só vez. Com isso, economizamos tempo e tornamos nossos códigos mais enxutos. Para exemplificar a maravilha da vetorização, começaremos com um exemplo simples:
import numpy as np # importa NumPy
minha_lista = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100] # uma lista tradicional do Python
meu_arr = np.array(minha_lista) # converte lista em NumPy array
meu_novo_arr = meu_arr * 0.1 # calcula 10% de todo o array em uma linha
# resultado: [ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
O mesmo método pode ser usado para calcular operações mais complexas. Suponha que nossa lista seja uma lista de preços e desejamos calcular novos preços com um desconto de 10%. Nesse caso, além de calcular os 10% como mostrado acima, precisamos também realizar uma operação de subtração do preço original. Tudo pode ser feito em apenas uma linha de código:
meu_novo_arr2 = meu_arr - meu_arr * 0.1 # calcula um desconto de 10% nos valores originais: [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
# resultado: [ 0. 9. 18. 27. 36. 45. 54. 63. 72. 81. 90.]
Condicionais vetorizados com np.where()
Nos exemplos de vetorização acima, usamos o poder do NumPy para executar a mesma operação em todos os elementos de um array. Embora esse tipo de cenário ocorra, frequentemente nos deparamos com situações mais complexas que exigem o uso de condicionais (if, else, elif). NumPy também pode ser usado nesses casos. Vamos entender como fazer isso pensando num exemplo.
Suponha que você precisa escrever um código para uma grande rede de supermercados para calcular novos preços para todos os produtos. Você precisa calcular uma redução de 10% em produtos que custam 100,00 reais ou mais e um aumento de 10% nos produtos que custam abaixo desse valor. Com uma lista tradicional, esse código envolve alguns condicionais e um loop bem lento. Mas, com o método np.where(), você calcula tudo de uma vez e com apenas uma linha de código!
meus_precos = np.array([100, 50, 200, 300, 10, 20, 400])
# calcula novos valores com np.where()
meus_novos_precos = np.where(meus_precos >= 100, meus_precos - meus_precos * 0.1, meus_precos + meus_precos * 0.1)
# resultado: [ 90. 55. 180. 270. 11. 22. 360.]
Neste código enxuto, primeiro criamos um array a partir de uma lista de preços hipotéticos. Depois, calculamos novos preços usando np.where().
Todo poder do np.where() vem do fato dele ser uma das funções universais do NumPy. As funções universais do NumPy (ufuncs) nos permitem realizar cálculos elementares em arrays sem ter que usar loops, resultando em códigos mais rápidos e legíveis! Usando a função np.where(), podemos filtrar facilmente elementos com base em certas condições enquanto aplicamos transformações simultaneamente em um array inteiro.
Entenda o método np.where()
Segundo a documentação do NumPy, o método np.where() é descrito da seguinte maneira:
np.where(condição, [x, y, ]/)
Na prática, essa descrição críptica significa que o método np.where() retorna os índices dos elementos verdadeiros para a condição testada. Geralmente, usamos esses índices para aplicar operações específicas sobre esses elementos e outras operações sobre os elementos que não seguem a condição testada. Pense nisso como uma operação equivalente ao uso de if… else. Para esses cenários, podemos entender o método np.where() assim:
np.where(condição, faz operação A sobre elementos onde condição == True, faz operação B sobre elementos onde condição == False)
condição se refere ao condicional que queremos testar nos nossos dados. Ela é o equivalente do condicional if tradicional do NumPy. No nosso exemplo anterior, testamos se os valores do nosso array são maiores ou iguais a 100, mas poderíamos ter cenários mais complexos.
Assim como fazemos com um if tradicional, para os elementos que têm a condição testada (são True para ela) podemos aplicar uma operação A (uma redução de preço no nosso exemplo). Ja para os elementos que não têm a condição que buscamos (são False), podemos aplicar uma operação diferente (um aumento de preços no nosso caso). Veja outro exemplo para reforçar a ideia. Desta vez, testamos quais produtos possuem preços maiores do que 10 e menores do que 100. Apenas para esses produtos, calculamos um desconto de 10%. Para os demais produtos, não fazemos nada (mantemos os preços originais):
meus_novos_precos = np.where((meus_precos > 10) & (meus_precos < 100), meus_precos - meus_precos * 0.1, meus_precos)
# resultado: [100. 45. 200. 300. 10. 18. 400.]
Condicionais vetorizados com operações booleanas
Outra forma ainda mais concisa de realizar condicionais com NumPy é com operações booleanas aplicadas diretamente sobre arrays. Esta forma de condicionais vetorizados é mais enxuta e ideal para situações com condições simples. Vamos explorar alguns exemplos.
Voltando ao nosso caso do supermercado. Suponha que você precisa aumentar em 20% os preços acima de 100. Isso pode ser feito assim:
meus_precos = np.array([100, 50, 200, 300, 10, 20, 400])
mask = meus_precos>100 # define uma máscara com a condição que deve ser testada
meus_precos[mask] = meus_precos[mask] + 0.2 * meus_precos[mask] # aplica operação em elementos onde a condição for verdadeira
# resultados: [100 50 240 360 10 20 480]
Neste trecho, usamos uma máscara (mask) para executar uma operação apenas em certos elementos. Neste caso, testamos quais elementos do nosso array são acima de 100 e calculamos um aumento de 20% sobre seus valores originais. Veja mais um exemplo para fixar o procedimento. Neste caso, testamos quais elementos de um array são pares (isso é feito verificando se, ao dividí-los por 2, o resto é zero) e somamos 2 a eles.
arr = np.array([1, 2, 3, 4, 5, 6])
arr[arr % 2 == 0] += 2
# resultados: [1 4 3 6 5 8]
Último exemplo com uma condição mais complexa. Desta vez, testamos quais elementos de um array são maiores do que 3 e menores do que 6. Os valores encontrados são multiplicados por 0.5:
arr = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
arr[(arr > 3) & (arr < 6)] *= 0.5
# resultados: [1. 2. 3. 2. 2.5 6. ]
Note que, nos exemplos acima, o uso de uma linguagem muito concisa pode tornar o código mais difícil de ser compreendido. Por isso, para testar condições complexas, o método np.where() pode ser mais adequado. Mas isso é uma questão de preferência pessoal.
Conclusões
Neste post, exploramos algumas maneiras de usar o NumPy para realizar operações condicionais vetorizadas de forma rápida, eficiente e com linguagem enxuta. A vetorização dessas operações aumenta a eficiência e clareza dos códigos e acelera consideravelmente suas velocidades de execução. Mas atenção: abusar da linguagem muito concisa do NumPy pode comprometer a clareza dos códigos Python em cenários que envolvem condicionais complexos.
