NumPy: Uma Biblioteca Poderosa de Machine Learning com Python

NumPy, abreviação de Numerical Python, é mais do que uma biblioteca – é um alicerce robusto para a computação científica em Python. Essencial para machine learning e análise de dados, o NumPy é amplamente reconhecido por sua capacidade de oferecer suporte para arrays e matrizes multidimensionais, conhecidos como ndarrays. Esta principal estrutura de dados é o coração da biblioteca e a chave para a manipulação eficiente de números e operações matemáticas complexas.

Na computação científica, lidamos com grandes quantidades de números e cálculos. Entretanto, o tipo de dado array nativo do Python é limitado e não está otimizado para operações numéricas de larga escala. É aqui que o NumPy brilha, pois fornece um objeto array que é tanto compacto quanto capaz de realizar operações em alta velocidade. Além disso, ao limitar o tipo de dados para criação de um array, o NumPy reduz as sobrecargas significativamente, facilitando assim operações que seriam complexas e onerosas com as listas padrão de Python.

No vasto ecossistema científico do Python, NumPy se posiciona como um pilar, servindo de base para outras bibliotecas populares, como Pandas, Matplotlib e Scikit-learn. Estas bibliotecas tiram proveito da estrutura ndarray para aumentar a eficiência e a velocidade na análise de dados e modelagem de machine learning, realçando a importância insubstituível do NumPy nesse domínio.

Agora, vamos mergulhar na instalação e na utilização prática desta poderosa ferramenta, garantindo que você, como estudante de programação ou cientista de dados, esteja equipado com o conhecimento necessário para impulsionar seus projetos no Jupyter Notebooks com a competência que o NumPy oferece.

Como Importar a Biblioteca NumPy no Google Colab

O Google Colab fornece um ambiente de computação em nuvem acessível e colaborativo para ciência de dados e aprendizado de máquina. Um de seus grandes benefícios é a inclusão de muitas bibliotecas populares de Python pré-instaladas, o que simplifica o processo de configuração e permite que você se concentre na análise de dados e no desenvolvimento de modelos.

Importando NumPy: Para começar a usar a biblioteca NumPy no Google Colab, você não precisará instalar a biblioteca, pois ela já está pré-instalada. Tudo o que você precisa fazer é importá-la para o seu notebook. A importação padrão da biblioteca NumPy segue a seguinte sintaxe:

Ao executar esta linha, você estará importando toda a funcionalidade do NumPy para o seu ambiente de trabalho no Colab e, com o uso do alias ‘np', você poderá acessar todas as funções, métodos e constantes da biblioteca de forma rápida e prática.

Testando a Instalação: Depois de importar o NumPy, é uma boa prática verificar se tudo está funcionando como esperado. Você pode fazer isso executando um simples comando que usa a biblioteca, como criar um array NumPy.

Se o comando imprimir o array como esperado, você terá a confirmação de que o NumPy foi importado corretamente e está pronto para ser usado no Google Colab.

Usando o Google Colab, você tem o PODER de explorar a vasta gama de funcionalidades do NumPy sem se preocupar com detalhes de instalação, permitindo-lhe mergulhar diretamente na parte divertida: resolver problemas complexos com dados.

 Como Importar a Biblioteca NumPy no Jupyter com Anaconda

Anaconda é uma distribuição popular de Python, especialmente projetada para ciência de dados e aprendizado de máquina, que simplifica o gerenciamento de pacotes e distribuição. O Jupyter Notebook, uma aplicação web que permite criar e compartilhar documentos que contêm código, equações, visualizações e texto explicativo, é uma das ferramentas incluídas no Anaconda. Vamos explorar como importar NumPy em um Jupyter Notebook usando o Anaconda.

Passo 1: Verifique se o NumPy está Instalado Anaconda vem com a biblioteca NumPy pré-instalada. No entanto, caso você precise verificar ou instalar, pode usar o seguinte comando no Anaconda Prompt:

Passo 2: Abra o Jupyter Notebook Para iniciar o Jupyter Notebook através do Anaconda, você pode usar o Anaconda Navigator, uma interface gráfica onde você encontra o Jupyter Notebook, ou simplesmente digitar:

no Anaconda Prompt.

Passo 3: Importe o NumPy Com seu Jupyter Notebook aberto, você importa o NumPy na primeira célula do seu notebook assim:

Após digitar o comando, pressione Shift + Enter para executar a célula e importar a biblioteca.

Passo 4: Confirmação da Importação Para ter certeza que o NumPy está pronto para ser usado, você pode criar um array simples como teste:

Executando essa célula, o Jupyter deve retornar a saída com o array que você criou, confirmando que a biblioteca NumPy foi importada com sucesso.

O Jupyter Notebook é uma ferramenta poderosa para desenvolvimento iterativo e documentação de análises de dados e processos de modelagem. Com o NumPy, você tem acesso a uma ampla gama de funcionalidades matemáticas e de array, que são essenciais para essas tarefas. Ao trabalhar com o Jupyter no ambiente Anaconda, você garante uma configuração robusta e otimizada para suas necessidades analíticas.

Criando seu Primeiro Array NumPy

Dominar a criação de ndarrays é um passo essencial na jornada para aproveitar tudo que o NumPy tem a oferecer. Existem duas formas comuns de criar um ndarray no NumPy: diretamente a partir de uma lista de Python ou através de funções específicas do NumPy.

Conversão de Lista para ndarray: Você pode transformar uma lista Python em um ndarray usando a função np.array(). Aqui está um exemplo:

Após a conversão, você pode verificar o tipo de dados com print(meu_array.dtype), que, a menos que especificado de outra forma, será o tipo que melhor acomoda os elementos da lista.

Criação usando Funções do NumPy: O NumPy também oferece várias funções para criar arrays com conteúdo inicial específico. Por exemplo, np.zeros() ou np.ones() para criar arrays preenchidos com zeros ou uns, respectivamente.

Após a criação, você pode explorar as propriedades do ndarray. Use print(meu_array.shape) para verificar suas dimensões, que retornará uma tupla refletindo o tamanho em cada dimensão.

Quando você executa o comando print(meu_array.shape) no contexto da biblioteca NumPy e recebe a saída (5,), isso indica que meu_array é um array unidimensional (1D) com 5 elementos.

Vamos desmembrar a saída para entender melhor:

• A primeira parte da saída, que é o número 5, representa o número de elementos ao longo da primeira (e única, nesse caso) dimensão do array.

• O uso da vírgula seguida de um parêntese fechado é a notação do Python para indicar que se trata de uma tupla de um único elemento. Tuplas são estruturas de dados que podem conter uma sequência de valores separados por vírgulas. No caso do .shape, é usada uma tupla para representar as dimensões do array.

Então, (5,) significa que você tem um vetor linha ou uma série que contém 5 elementos. Se o array fosse bidimensional (2D), você veria duas dimensões na saída, algo como (5, 3), que indicaria que o array tem 5 linhas e 3 colunas, por exemplo.

No caso de arrays NumPy, o método .shape é extremamente útil para verificar a estrutura dos dados, o que é vital para o pré-processamento e o entendimento de como os dados estão organizados antes de aplicar operações de análises ou algoritmos de aprendizado de máquina.

A Função linspace(): Outra função poderosa é np.linspace(start, stop, num), que cria arrays com valores igualmente espaçados dentro de um intervalo especificado. Por exemplo:

Isso cria um array de cinco números, começando em 0 e terminando em 10, espaçados uniformemente. O linspace é particularmente útil quando você precisa de um conjunto de pontos para avaliação de funções em matemática, física ou engenharia.

Exemplos de Criação de Arrays:

Conhecer esses métodos para criar um array NumPy não só fortalece seu entendimento sobre operações fundamentais mas também abre portas para um manuseio mais sofisticado de dados e números no seu ambiente de programação. Experimente com essas funções e veja a eficiência que o NumPy oferece na prática.

Seleção e Manipulação de Dados

Quando se trabalha com NumPy, entender como selecionar e manipular dados de um array é FUNDAMENTAL. Com o seguinte array declarado:

Vamos explorar a SELEÇÃO de elementos individuais e grupos de elementos (slices).

Acessar Elementos Individuais: Para acessar um único elemento, utilize índices que correspondam à sua posição na matriz. Lembre-se, a indexação começa pelo número 0. Por exemplo:

Slicing: Para acessar um SUBCONJUNTO do array, utilizamos a técnica conhecida como slicing. O slicing pode ser aplicado em arrays 1D, 2D, e além. Em um array de duas dimensões, você pode realizar um slice tanto nas linhas quanto nas colunas.

Vamos detalhar as operações de slice no NumPy, utilizando como exemplo os comandos para acessar a primeira linha inteira e a terceira coluna inteira de um array 2D.

Para a primeira operação:

• array_2d[0, :] indica que estamos interessados em operar no array_2d.
• 0 especifica a primeira dimensão, ou seja, a linha que queremos acessar. O NumPy usa indexação baseada em zero, portanto o índice 0 representa a primeira linha do array.
• : é o operador de slice para a segunda dimensão, que neste caso, nos permite selecionar todos os elementos da linha especificada.

Quando não especificamos um início ou um fim para o slice, o Python entende que queremos todos os elementos daquela dimensão. Assim, : sozinho equivale a “pegar tudo”. O resultado da operação primeira_linha = array_2d[0, :] será um array contendo todos os elementos da primeira linha do array_2d.

Para a segunda operação:

• array_2d[:, 2] indica que estamos operando novamente no array_2d.
• : sozinho, agora na primeira parte da indexação, significa que estamos selecionando todas as linhas do array.
• 2 na segunda parte da indexação indica que queremos acessar apenas a terceira coluna de todas as linhas selecionadas. Lembre-se que, sendo a indexação baseada em zero, o índice 2 refere-se ao terceiro elemento na dimensão das colunas.

O resultado do comando terceira_coluna = array_2d[:, 2] será um array contendo todos os elementos da terceira coluna do array_2d.

Ambos os slices, para a linha e para a coluna, são exemplos do poderoso recurso de indexação do NumPy que proporciona um meio eficiente para acessar subconjuntos de dados em um array. Essa capacidade é fundamental em muitas aplicações de processamento de dados, onde frequentemente precisamos manipular e analisar partes específicas de um conjunto maior de informações.

Adição de Step ao Slice: O ‘step' pode ser especialmente útil em arrays maiores, onde talvez você queira acessar elementos saltando um certo intervalo.

No universo do NumPy, quando você ouve falar em “step” dentro do contexto de slicing, ou fatiamento, refere-se ao intervalo com o qual você seleciona elementos de um array. Adicionar um ‘step' ao seu slice permite que você acesse elementos de forma não contínua, pulando um determinado número de posições entre eles.

Vamos analisar em detalhes o comando linha_com_step = array_2d[1, ::2]:

• array_2d: Trata-se de um array bidimensional criado pelo NumPy, onde a primeira dimensão pode ser interpretada como linhas e a segunda como colunas.

• [1, ::2]: Esta é a parte que define como o array será fatiado.

  • O primeiro número 1 refere-se ao índice da linha que queremos acessar. NumPy utiliza indexação baseada em zero, portanto 1 indica a segunda linha do array.

  • Após a vírgula, temos ::2 que é onde definimos o ‘step' para o slice. O que estamos dizendo aqui é: a partir do início da linha (omissão do primeiro valor antes dos dois pontos), selecione elementos até o final da linha (segundo valor omitido após o segundo dois pontos) e faça isso a cada dois elementos (2 é o step).

Em outras palavras, ::2 pega um elemento sim, um elemento não. Por exemplo, em um array de cinco elementos [0, 1, 2, 3, 4], o slice ::2 retornaria [0, 2, 4].

Vamos aplicar isso a um exemplo prático:

O resultado de linha_com_step será [5, 7, 9]. Estamos acessando a segunda linha e pegando os elementos a partir do índice 0, pulando de dois em dois.

Agora vamos ilustrar um exemplo onde o segundo valor após o segundo dois pontos não é omitido e ainda aplicamos um ‘step' de 2, consideremos um array bidimensional array_2d. Suponha que queiramos selecionar elementos da segunda linha, começando do primeiro elemento (índice 0) até o quarto elemento (índice 3), mas saltando de dois em dois. O comando de slice seria o seguinte:

Vamos detalhar o que cada parte do slice 1, 0:4:2 faz:

• 1: Especificamos que queremos acessar a segunda linha do array (pois a indexação começa em 0).
• 0:4:2 é a expressão de fatiamento onde:
  • 0 é o índice inicial do slice – começamos no primeiro elemento da linha.
  • 4 é o índice final do slice, não inclusivo – ou seja, queremos ir até antes do quinto elemento, que é o índice 4.
  • 2 é o ‘step', que nos diz que queremos selecionar elementos saltando de dois em dois.

Portanto, a expressão 0:4:2 nos dirá para pegar os elementos que começam no índice 0, terminam antes do índice 4, e selecionam apenas a cada dois índices. Isso resultará na seleção dos elementos com índices 0 e 2 da segunda linha do array_2d.

Executando o comando acima, o slice_com_step retornaria os seguintes valores do array_2d:

Nesse caso, selecionamos apenas os elementos 20 e 22 da segunda linha, ignorando os índices 1 e 3, que teriam sido 21 e 23 respectivamente. O uso dessa técnica de slicing é essencial para manipulações eficientes de dados e pode significativamente reduzir o tempo de computação em operações de processamento de dados em larga escala.

Por que isso é útil? Imagine que você está trabalhando com um array grande e está interessado apenas em elementos específicos que seguem um padrão regular de intervalo. Ao invés de coletar manualmente esses elementos ou usar loops, você pode simplesmente utilizar o ‘step' no slicing para acessá-los de maneira eficiente.

O uso de ‘step' em operações de slice é uma ferramenta poderosa na manipulação de arrays no NumPy, que potencializa a análise de dados e o processamento de sinais em várias aplicações, desde a redução de resolução de imagens até a seleção de pontos de dados para down-sampling em séries temporais.

Tabela Ilustrativa para Arrays 2D: Para visualizar o array array_2d de forma mais intuitiva, pense nele como uma tabela com índices de linha e coluna:

Essa representação visual é extremamente útil para planejar como você quer manipular seu array. Ao entender e utilizar essas técnicas de indexação e slicing, você terá o controle necessário para explorar e analisar conjuntos de dados complexos de forma eficaz, o que é vital em machine learning e análise de dados.

Veja por exemplo o que acontece ao aplicar o seguinte slice no array array_2d:

Ao aplicar o slice slice_2d = array_2d[1:3, ::2] no array array_2d, você está instruindo o NumPy a realizar duas ações simultâneas:

1. Selecionar Linhas: O primeiro par de índices 1:3 define quais linhas do array serão incluídas no slice. Neste caso, ele começa no índice 1 e vai até o índice 3, sem incluir o próprio índice 3, porque no Python o índice final é exclusivo. Então, as linhas selecionadas são as que correspondem aos índices 1 e 2.
2. Selecionar Colunas com Step: A segunda parte, ::2, é aplicada nas colunas. Aqui, o :: informa que você deseja incluir todas as colunas, mas o 2 adicionado ao final indica que você quer fazer isso em passos de dois, ou seja, selecionar uma coluna sim e a próxima não, a partir da coluna de índice 0.

Portanto, o resultado do slice slice_2d será um novo array contendo as linhas de índice 1 e 2 do array original, e das colunas, apenas as de índice par (0, 2, 4). Aplicando isso ao nosso array_2d, o resultado será:

Isso nos mostra a potência da indexação e slicing no NumPy para acessar e manipular subconjuntos de dados de maneira eficiente e precisa. É uma habilidade essencial para análise de dados e manipulação de grandes datasets, comum em cenários de ciência de dados e machine learning.

A manipulação eficiente de ndarrays com essas técnicas abre um leque de possibilidades na preparação e tratamento de dados. Pratique e torne-se fluente na manipulação dos dados com NumPy, e logo você estará realizando operações de análise de dados com grande habilidade.

Explorando Métodos ndarray

Os arrays do NumPy possuem uma variedade de métodos que facilitam as operações matemáticas e a reestruturação de dados. Vamos aprofundar no uso dos métodos sum(), mean() e reshape(), essenciais no dia a dia da análise de dados.

O Método sum(): O método sum() é usado para somar todos os elementos de um array ou somar elementos ao longo de um determinado eixo. Vejamos dois exemplos, utilizando os parâmetros axis=0 e axis=1.

Aqui, soma_colunas resultará em [9, 12] porque soma os elementos de cada coluna individualmente (1+3+5 e 2+4+6). Enquanto isso, soma_linhas dará [3, 7, 11], somando os elementos linha por linha.

Ao trabalhar com arrays multidimensionais no NumPy, você pode realizar operações matemáticas ao longo de diferentes eixos (axis). No contexto do seu exemplo, array_2d é um array bidimensional que pode ser visualizado como uma tabela com linhas e colunas. Quando utilizamos o método sum do NumPy, somamos os elementos do array. O parâmetro axis define a dimensão ao longo da qual a soma será realizada.

Para somar elementos de cada coluna (axis=0):

Ao definir axis=0, estamos instruindo o NumPy a somar os elementos ao longo das colunas. Isso significa que ele irá somar os elementos de todas as linhas correspondentes a cada coluna individualmente. Visualmente:

A soma é feita verticalmente, resultando em:

Para somar elementos de cada linha (axis=1):

Com axis=1, a operação de soma é realizada ao longo das linhas. Ou seja, o NumPy soma os elementos de todas as colunas dentro de cada linha. Visualmente:

A soma é realizada horizontalmente, gerando o seguinte resultado:

Compreender o conceito de eixos é fundamental no processamento e análise de dados multidimensionais. Ao manipular o valor do parâmetro axis, você tem um controle granular sobre as operações de redução (como a soma) aplicadas ao array, permitindo a realização de cálculos específicos de forma eficiente e intuitiva.

O Método mean(): Já o método mean() calcula a média aritmética de um array. Quando não especificado, ele calcula a média de todos os elementos.

Essa função é amplamente usada para análise estatística de conjuntos de dados.

O Método reshape(): Com reshape(), você pode alterar a estrutura de um array sem alterar seus dados. É vital compreender essa função pois, por exemplo, a biblioteca Scikit-Learn muitas vezes requer arrays de 2 dimensões como entrada para seus modelos de machine learning.

Suponha que você tenha um array de 1 dimensão com 10 elementos:

Você pode transformar esse array em uma matriz de 2 linhas e 5 colunas da seguinte maneira:

O reshape também é flexível o suficiente para que você não precise especificar um dos parâmetros de forma, o que é útil quando você está trabalhando com arrays de tamanho desconhecido ou variável. Passar -1 em uma das dimensões instrui o NumPy a calcular automaticamente o tamanho dessa dimensão.

Em ambos os casos, o NumPy inferirá a dimensão faltante.

Reshape com (1, -1): Usar (1, -1) converterá um array de 1 dimensão em um array 2D com 1 linha e tantas colunas quantos forem os elementos.

Esta operação é útil quando uma função requer uma matriz de uma única linha (por exemplo, uma única amostra em um modelo de machine learning).

Dominar reshape() é crucial, pois a adequação dos dados à forma esperada pelos algoritmos é uma etapa constante no pré-processamento de dados para análises complexas e algoritmos de aprendizado de máquina. Ao entender profundamente como manipular a estrutura dos dados, você maximiza a eficiência e a compatibilidade dos seus conjuntos de dados com diversas bibliotecas e frameworks.

No NumPy, reshape() pode ser utilizado tanto como função quanto como método de um objeto array NumPy. Isso confere flexibilidade na forma como você pode estruturar seu código.

Como método de um array, reshape() é chamado a partir de uma instância do array e é usado para dar a essa instância uma nova forma sem alterar seus dados. Aqui está um exemplo:

Neste exemplo, array_reshaped agora tem a forma de um array com 2 linhas e 3 colunas.

Também é possível usar reshape() como uma função diretamente do módulo NumPy, passando o array original como um argumento junto com a nova forma desejada:

Ambas as abordagens são válidas e funcionam da mesma maneira, retornando um novo array com a forma especificada. A escolha entre usar reshape() como método ou como função pode depender de preferências pessoais ou de estilo de codificação.

Funções Essenciais do NumPy

Além dos métodos internos dos arrays NumPy, a biblioteca oferece funções adicionais que são CRUCIAIS para manipulação avançada e otimizada de dados. Entre elas, vamos destacar a função concatenate() e discutir sobre wrapper functions e as diferenças entre funções e métodos no contexto do NumPy.

Concatenação com concatenate(): A função concatenate() é utilizada quando você precisa unir dois ou mais arrays NumPy, seja por linhas ou colunas. Vamos exemplificar a concatenação de dois arrays 2D:

No NumPy, concatenate() é uma função e não um método. Ela é usada para unir dois ou mais arrays ao longo de um eixo especificado.

Aqui está um exemplo de como usar a função concatenate() para unir dois arrays:

Neste exemplo, array_unido será [1 2 3 4 5 6]. A função np.concatenate() tomou uma tupla contendo os arrays array1 e array2 e os uniu ao longo do eixo padrão (eixo 0).

A função np.concatenate() no NumPy é utilizada para combinar arrays ao longo de um eixo especificado. No exemplo dado, temos dois arrays bidimensionais, array_2d_1 e array_2d_2, que queremos concatenar:

Aqui, array_2d_1 é um array 2×2, e array_2d_2 é um array 1×2. Vamos olhar para as suas estruturas antes da concatenação:

Quando você realiza a concatenação ao longo das linhas, especificando axis=0, você está informando ao NumPy que deseja adicionar o segundo array (array_2d_2) como novas linhas ao final do primeiro array (array_2d_1). É importante observar que para a concatenação ao longo do eixo das linhas ser possível, o número de colunas dos arrays deve ser o mesmo, o que é o caso neste exemplo.

O resultado da concatenação ao longo do eixo 0 seria:

A nova estrutura do array concat_linhas seria:

Aqui, você pode ver que o array_2d_2 foi adicionado como uma nova linha ao array_2d_1, expandindo-o para um array 3×2. Este resultado mantém todos os elementos dos arrays originais e os une seguindo a ordem que foram passados para a função np.concatenate().

O eixo 0 corresponde às linhas em um array 2D. Portanto, concatenar ao longo do eixo 0 implica adicionar mais linhas ao array. Lembre-se que a concatenação só funciona se todas as dimensões, exceto aquela ao longo da qual você está concatenando, forem iguais entre os arrays. Se array_2d_1 e array_2d_2 tivessem um número diferente de colunas, a concatenação ao longo das linhas geraria um erro.

Por ser uma função, np.concatenate() é chamada no escopo do módulo NumPy e não como um método de um objeto array. Isto é importante para distinguir entre as duas possibilidades de chamar operações no NumPy: algumas são chamadas como métodos diretamente de instâncias de arrays NumPy, enquanto outras são funções no módulo NumPy que aceitam arrays NumPy como argumentos.

Wrapper Functions no NumPy: Wrapper functions, ou funções de envolvimento, são aquelas que “embrulham” outras funções, possibilitando uma abstração adicional, manipulação de entradas ou saídas, e outros comportamentos úteis. No NumPy, existem funções que são wrappers em torno dos métodos de ndarray, proporcionando um meio alternativo, mas funcionalmente similar, de realizar operações.

Funções vs Métodos: A principal diferença entre funções e métodos em NumPy é que os métodos são chamados a partir de um objeto ndarray (ou seja, são funções associadas a um objeto específico), enquanto as funções podem operar em uma variedade de inputs. Por exemplo, a função np.sum() pode somar elementos de qualquer array-like object, incluindo listas do Python, enquanto o método .sum() é específico para objetos ndarray.

Ambas as abordagens acima irão produzir o mesmo resultado, a soma dos elementos do array array_2d_1.

No desenvolvimento com NumPy, compreender quando usar uma função ou um método pode simplificar seu código e otimizar a performance. As funções wrapper podem agregar flexibilidade extra às suas rotinas de manipulação de dados, enquanto os métodos podem muitas vezes oferecer uma sintaxe mais direta e orientada a objeto.

Dominar essas funções e métodos é de grande importância para aproveitar ao máximo as capacidades que o NumPy oferece para o processamento e análise de dados em ambientes científicos e de engenharia.

Exemplos Práticos e Aplicações

Vamos ver o NumPy em ação com alguns exemplos práticos:

1. Normalização de Dados: Normalizar os dados é um passo crítico em muitos algoritmos de machine learning. Utilize o NumPy para subtrair a média e dividir pelo desvio padrão.
2. Manipulação de Imagens: Em processamento de imagem, converta uma imagem em um array NumPy e aplique operações como filtros e transformações.
3. Simulação Monte Carlo: Use NumPy para gerar amostras aleatórias para simulações estatísticas.

Esses são apenas alguns exemplos de como o NumPy pode ser aplicado imediatamente em seus projetos de Jupyter Notebooks.