Forem: Lucas Nobre Barbosa

Uptrain como ferramenta de avaliação de aplicações de LLMs

Lucas Nobre Barbosa — Thu, 26 Feb 2026 14:31:26 +0000

A avaliação de aplicações de LLMs é um dos campos mais desafiadores da contemporânea Engenharia de Inteligência Artificial (IA). A autora Chip Huyen define que o metodismo ao avaliar uma aplicação de IA generativa é de suma importância, mas também que o esforço de pensar no sistema de avaliação pode custar mais da metade do tempo de desenvolvimento.

Pensando em mitigar o esforço gasto nessa atividade, a plataforma uptrain surge como uma poderosa aliada nesse processo.

De código aberto, a plataforma oferece ferramentas para avaliação de aplicações de LLM, além de uma ferramenta de dashboards auto-hospedada para monitoramento dessas aplicações, embora essa última aparenta ainda estar prematura e incompleta.

Como ferramenta de avaliação, uptrain apresenta um framework enxuto, mas expansível, com uma classe EvalLLM, com um método evaluate que só precisa, como parâmetros, de um tipo de avaliação (o qual o framework apresenta 17 pré-definidos e prontos para uso) e pelo menos três colunas de dados:

question: a pergunta feita ao modelo;
context: o contexto relevante para aquela pergunta; e
response: a resposta do modelo àquela pergunta.

Algumas avaliações pedem mais algumas colunas, essas são chamadas de avaliações paramétricas.

Por ser de código aberto, a plataforma permite que seus usuários desenvolvam suas próprias métricas e que contribuam com o projeto, tendo assim grandíssimo potencial no mercado e na academia.

Para finalizar, convido vocês a visitar a documentação da plataforma em: https://docs.uptrain.ai/getting-started/introduction

Mais dados é melhor que um algoritmo mais eficiente

Lucas Nobre Barbosa — Fri, 01 Dec 2023 10:58:52 +0000

Recentemente li um texto de blog do Anand Rajaraman no qual ele descreve uma atividade que ele passou para seus alunos na Universidade de Stanford na qual eles deveriam realizar qualquer tarefa de data mining não trivial, onde a maioria decidiu tentar resolver o “Netflix Chalenge”, um desafio no qual o candidato deve fazer um algoritmo de recomendação de filmes melhor que o da plataforma.

O desafio consiste em usar um dataset enviado pela empresa onde várias pessoas deram notas para filmes e o desafio é predizer a nota de filmes sem notas dadas. Um clássico problema de receber um dataset de treino, treinar um modelo com esses dados e testar esse mesmo modelo em um dataset de teste. Se você conseguir uma acurácia superior à do algoritmo da netflix respeitando uma determinada margem você leva para casa um prêmio de 1 milhão de dólares.

Continuando na descrição de sua experiência em sua aula, Rajaraman comenta que vários alunos experimentaram diversas abordagens. Entre elas, podemos destacar duas: um time A experimentou um algoritmo extremamente elaborado para resolver o problema e um time B fundiu o dataset da Netflix com dados fornecidos pelo IMDB (Internet Movie Data Base).

Resumindo a história, o time B conseguiu melhores resultados e quase alcançou a acurácia da Netflix, mesmo com um algoritmo mais simples que o do time A, que não foi muito longe.

Minha experiência no Curso de Ciência da Computação

Em uma disciplina chamada “Informática e Sociedade”, na UFPA, tínhamos aulas muito mais próximas da filosofia, onde éramos convidados a debater sobre diversos assuntos referentes aos impactos da computação na sociedade. Acredito que foi uma boa experiência para mim.

Nessa disciplina, uma das aulas era sobre dados e o professor trouxe uma provocação: “Dados são realmente o novo petróleo?”. Eu não tenho certeza absoluta se essa foi a fonte que ele nos passou para discutirmos em aula, mas eu creio que era. Segue o link:

Is Data Really The New Oil?

Lembro que eu fui o mais engajado naquela aula, até mesmo por sempre ser entusiasmado com dados. Eu realmente discordava com o ponto do professor. Para ele, na verdade, o novo petróleo eram os algoritmos que tratavam esses dados e não os dados em si.

Entretanto, para mim a analogia sempre foi bem clara: dados são a matéria prima, sem ele nada é feito. Além disso, assim como petróleo é inútil sem o processamento que ele passa, dados não servem para nada se estiverem espalhados e sujos, se não são processados e se não agregamos valor para o mesmo através de processos industriais.

O artigo do Anand Rajaraman me lembrou essa discussão novamente, me fazendo acreditar ainda mais que mais dados no fim resolvem problemas melhor que algoritmos extremamente elaborados.

Claro que isso não é um incentivo a deixar de estudar algoritmos, afinal de contas, tendo uma mesma quantidade X de dados, um algoritmo melhor vai fazer um trabalho melhor.

Conclusão

Esse foi um tema que passou pela minha cabeça nos últimos dias e me deixou curioso para ouvir a opinião de outras pessoas. Peço desculpas se cometi algum erro ao comentar sobre petróleo, estou longe de ser um especialista no assunto, diferente do querido Sérgio Sacani do Space Today.

Ademais, espero que tenham gostado da leitura. Críticas, sugestões e correções são muito bem vindas na sessão de comentários abaixo. Vejo vocês no meu próximo artigo.

PostgreSQL: Tipos de Dados

Lucas Nobre Barbosa — Sat, 25 Nov 2023 02:12:39 +0000

O PostgreSQL, carinhosamente chamado de postgres, é um dos SGBDs (Sistemas Gerenciadores de Banco de Dados) mais famosos hoje em dia, sendo o SGBD open source mais querido pelos programadores atualmente.

Nesse artigo busco apresentar os tipos de dados mais comuns suportados pelo postgres como ferramenta de consulta rápida e direta para outros desenvolvedores. Sem mais delongas, vamos ao conteúdo

Tipos de Dados

Numéricos

Inclui desde inteiros até números de ponto flutuante

smallint: armazena valores inteiros com sinal com até 2 bytes de tamanho
integer: armazena valores inteiros com sinal com até 4 bytes de tamanho
bigint: armazena valores inteiros com sinal com até 8 bytes de tamanho
decimal: armazena valores com muitos dígitos. Geralmente usado para armazenar valores financeiros. O desenvolvedor pode especificar a precisão e a escala para esse tipo
numeric: um apelido para o tipo de dados decimal
real: armazena valores de ponto flutuante com 4 bytes e precisão de 6 dígitos decimais
double precision: armazena valores de ponto flutuante com 8 bytes e precisão de 15 dígitos decimais

Caractere

Usados para lidar com alfanumérico e com textos

char(n) : armazena strings de tamanho fixo com um tamanho n específico
varchar(n) : armazena strings de tamanho variável com com um tamanho n máximo
text : armazena strings de tamanho variável sem tamanho máximo

Binários

Inclui basicamente o tipo de dados Byte

bytea : armazena uma string de binários com tamanho variável, sem tamanho máximo

Data e Tempo

Diversas formas para lidar com datas e tempo

date : armazena datas sem informação de time zone (YYYY-MM-DD)
time : armazena valores de tempo sem informação de time zone (HH:MM:SS)
timestamp : armazena valores de tempo e de data sem informações de time zone
timestamptz : armazena valores de tempo e de data com informação de time zone
interval : um intervalo de tempo, como a diferença de dois timestamps

Booleano

Um tipo de dados para lidar com verdadeiro e falso

boolean

Enumerado

Criação de tipos de dados customizados, que consistem de um conjunto de valores ordenado e estático

CREATE TYPE AS ENUM

Exemplo:

CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');

Dados Geométricos e de Rede

point, line, lseg, box, polygon, path, circle: armazena pontos, linhas e várias outras formas
inet, cidr: armazena endereços IP e subredes

Conclusão

Com esse guia você tem uma referência inicial para conhecer os principais tipos de dados suportados pelo postgres, podendo seguir seus estudos a partir daqui dependendo da sua necessidade.

Esse artigo é um guia rápido para se orientar quando precisar achar um tipo de dados específico;.

Dúvidas, sugestões e correções de conteúdo são sempre muito bem vindas. Espero que você tenha gostado do conteúdo. Espero te ver no meu próximo artigo. Até lá!

O problema de SQL que quase me enlouqueceu

Lucas Nobre Barbosa — Fri, 17 Nov 2023 12:54:53 +0000

Estou me preparando para algumas vagas de Engenheiro de Dados e para isso, é claro, eu preciso dominar SQL. Só ficar lendo livros de SQL não me ajuda nisso e por esse motivo eu gosto de ficar fazendo questões em sites como o hackerrank.

Costumo fazer umas questões toda quarta para me desafiar e em uma semana dessas eu encontrei o que, para mim, é a questão mais desafiadora que já enfrentei. Embora ela esteja classificada como “média” no site, eu demorei um certo tempo para resolver ela.

Se estou aqui agora é porque eu consegui e tenho como objetivo, nesse artigo, mostrar o passo a passo que tomei para resolver esse problema. O problema em si está no link a seguir.

Occupations | HackerRank

💡 Se desafie a tentar resolver o problema sem ler o artigo primeiro. Caso não consiga, volte aqui e veja o meu passo a passo para comparar 😊

Passo 1: Entendendo o Problema

Nesse desafio, nos é dado uma tabela chamada “OCCUPATIONS” com duas colunas: “Name” e “Occupation”. A primeira coluna é auto explicativa, nos dá o nome de uma pessoa. A segunda coluna nos apresenta a profissão da pessoa com nome definido na coluna anterior.

As profissões disponíveis na tabela são “Doctor”, “Actor”, “Singer” e “Professor”.

Nos é pedido para “Pivotar” a coluna “Occupations”, de forma que os nomes das pessoas sejam ordenados de forma alfabética e mostrados abaixo de sua profissão correspondente, sendo que no header devemos ter, respectivamente: Doctor, Professor, Singer e Actor.

Devemos mostrar NULL se não há mais nomes correspondentes para uma ocupação

💡 Pivot não tem uma tradução óbvia para o português, por isso é comum ouvir “Pivotar”, mas dá para entender como algo do tipo “girar a tabela” ou “tabela virada”.

Efetivamente, se recebemos a seguinte tabela:

Name	Occupation
Samantha	Doctor
Julia	Actor
Maria	Actor
Meera	Singer
Ashley	Professor
Ketty	Professor
Christeen	Professor
Jane	Actor
Jenny	Doctor
Priya	Singer

Devemos retornar com a nossa query a seguinte tabela:

Doctor	Professor	Singer	Actor
Jenny	Ashley	Meera	Jane
Samantha	Christeen	Priya	Julia
NULL	Ketty	NULL	Maria

Passo 2: Abstraindo o Problema

Antes de falar sobre ferramenta e quais comandos usar para resolver o problema, vamos abstrair ele. Se você é de computação você deve saber quanto a palavra “abstrair” é famosa na área.

Seguindo um passo a passo, temos a seguinte abstração para resolver o problema:

Separar as pessoas por profissão
Ordenar as pessoas de cada profissão por nome
Selecionar as pessoas na profissão “Doctor” e colocar na primeira coluna
Selecionar as pessoas na profissão “Professor” e colocar na segunda coluna
Selecionar as pessoas na profissão “Singer” e colocar na terceira coluna
Selecionar as pessoas na profissão “Actor” e colocar na última coluna

Seguindo esse algoritmo nós resolvemos o problema.

Passo 3: Entender quais técnicas usar para resolver o problema.

Passos 1 e 2 da abstração

💡 Para fins de implementação, estou usando comandos do MySQL. Pode ser que esses comandos existam ou não em outros SGBDs, ou podem ter seus próprios comandos que implementam a mesma ideia.

Seguindo o algoritmo que definimos no passo anterior, as etapas 1 e 2 podem ser facilmente resolvidas por um SELECT, usando também uma função muito interessante: a função row_number(), que retorna um número para cada linha em uma dada partição.

💡 Para saber mais sobre a função row_number() acesse o link https://www.javatpoint.com/mysql-row_number-function ou busque outras fontes de sua preferência

Dessa forma, escrevendo a query da seguinte forma:

select name, occupation, row_number() 
    over (partition by occupation order by name) as sequential_num
from Occupations;

Teremos como retorno a tabela:

Name	Occupation	s_no
Jane	Actor	1
Julia	Actor	2
Maria	Actor	3
Jenny	Doctor	1
Samantha	Doctor	2
Ashley	Professor	1
Christeen	Professor	2
Ketty	Professor	3
Meera	Singer	1
Priya	Singer	2

row_number() vai iterar sobre (over) uma partição. Nesse caso, estamos iterando sobre a partição occupation (partition by occupation), e dessa forma separando as pessoas por profissão. Além disso, estamos ordenando as pessoas por nome (order by name).

Ótimo, com essa primeira query já resolvemos os dois primeiros passos da abstração. O passo 3 até o 6, agora, só são casos de seleção dentro dessa tabela que criamos anteriormente.

Passos 3 a 6 da abstração

Com todas as pessoas organizadas por profissão e por ordem alfabética, podemos selecionar todas as pessoas de determinada profissão com um select case:

select
    case when occupation = 'Doctor' then name end,
    case when occupation = 'Professor' then name end,
    case when occupation = 'Singer' then name end,
    case when occupation = 'Actor' then name end
from (select name, occupation, row_number()
        over (partition by occupation order by name) as sequential_num
from Occupations)

Entretanto, essa query irá nos retornar uma lista muito longa e vai listar primeiro os atores, depois os médicos, depois os professores e por último os cantores tendo 3 NULL em cada linha e somente um nome de pessoa e não é isso que queremos.

O que queremos é que toda linha esteja preenchida com nomes de pessoas e que NULL só apareça caso não tenham mais pessoas em uma profissão.

Como queremos manter a ordem alfabética na nossa última seleção, vamos selecionar a primeira pessoa em cada lista de profissões, ou seja: min(case when occupation = '{profissão}' then name end

select
    min(case when occupation = 'Doctor' then name end),
    min(case when occupation = 'Professor' then name end),
    min(case when occupation = 'Singer' then name end),
    min(case when occupation = 'Actor' then name end)
from (select name, occupation, row_number()
        over (partition by occupation order by name) as sequential_num
from Occupations) P;

Além de adicionar o uso da função min para selecionar a primeira pessoa de cada lista, por determinação do SQL, toda tabela derivada (nosso select interior) precisa ter um apelido e eu chamei ele de “P”, para “Pivot”.

Com isso temos a primeira linha da nossa lista. Só falta conseguir as demais linhas e para isso usamos um famoso GROUP BY.

Pelo o que agrupamos? Pelo número de sequência que foi obtido com nosso row_number()

select
    min(case when occupation = 'Doctor' then name end),
    min(case when occupation = 'Professor' then name end),
    min(case when occupation = 'Singer' then name end),
    min(case when occupation = 'Actor' then name end)
from (select name, occupation, row_number()
        over (partition by occupation order by name) as sequential_num
from Occupations) P
group by P.sequential_num;

E pronto! Temos nosso resultado do jeitinho que queríamos.

Se você quiser ver a mágica que o GROUP BY causou, experimenta adicionar P.sequential_num as seq_num logo após o select e antes do primeiro min(…). Você vai ter algo semelhante a isso:

seq_num	Doctor	Professor	Singer	Actor
1	Jenny	Ashley	Meera	Jane
2	Samantha	Christeen	Priya	Julia
3	NULL	Ketty	NULL	Maria

Lindo, não é?

Conclusão

Com esse artigo pude explicar passo a passo meu processo de raciocínio para resolver esse problema bem desafiante e interessante.

Com ele eu espero ter te ajudado a aprender algo novo em SQL e até mesmo ter te incentivado a experimentar um pouco de “programação competitiva” em sites como o hackerrank.

Dúvidas, sugestões, críticas e comentários são muito bem vindo na sessão de comentários abaixo. Agradeço muito pelo tempo investido aqui e espero te ver nos próximos artigos. Até a próxima 🙂.

Criando Ambientes Virtuais com Venv

Lucas Nobre Barbosa — Thu, 09 Nov 2023 14:18:23 +0000

Desenvolvedores de Software precisam constantemente aprender novas tecnologias e fazer novos projetos. Quanto mais se faz isso e mais tempo passa, maiores são as chances de um conflito de bibliotecas ou erros de uma nova versão de código acontecer.

No ecossistema Python isso é resolvido com a abordagem dos ambientes virtuais. No primeiro artigo que escrevi sobre o assunto em https://dev.to/nobrelucas/administrando-ambientes-virtuais-com-conda-54l9 falei mais profundamente sobre esse assunto e introduzi o administrador de ambientes virtuais Conda.

Nesse artigo, busco introduzir um criador de ambientes virtuais muito mais simples que serve para a maioria dos projetos de pequeno e médio porte, o Venv.

Note que diferente do Conda, ele não oferece nenhum suporte para a administração dos ambientes virtuais, somente para a sua criação.

Instalação

Primeira vantagem do Venv: ele já vem instalado com o Python, então nada mais é preciso ser feito para usar ele 🙂.

Criando ambiente virtual

Para criar um ambiente virtual com Venv basta usar um comando muito simples:

python3 -m venv {nome_do_env}

Vamos explorar esse comando por partes:

→ python3 invoca o interpretador Python que será responsável por executar o código do módulo venv

→ -m indica que o código que vai ser executado pelo interpretador Python será um módulo

→ venv é o módulo venv, responsável pela criação do ambiente virtual

→ {nome_do_env}, como auto explicativo, nomeia o diretório onde o ambiente virtual vai ser criado

E assim temos nosso ambiente virtual. Vamos fazer algo prático

Na prática

Vamos criar um ambiente chamado “teste” em um diretório de estudo “criando-venv”

python3 -m venv teste

Se você estiver em um ambiente Linux, digite ls no terminal para ver o diretório com o ambiente criado.

Para ativar o ambiente, basta usar o comando:

source teste/bin/activate

Para sair do ambiente basta escrever o comando deactivate no terminal ou fechar o terminal:

Instalando bibliotecas

Note que as bibliotecas instaladas são somente as básicas para começar a instalar outras, ou seja o seu ambiente está limpo e livre, pronto para começar a ser configurado com novas bibliotecas.

Então agora é só instalar as bibliotecas que você precisa para o seu projeto.

Digamos que vamos fazer uma API com Flask e instalamos ele com pip:

pip install Flask

Após a instalação, nosso ambiente terá as seguintes bibliotecas:

Agora é só programar

Persistindo o ambiente

Para que você possa trabalhar colaborativamente com outros desenvolvedores. Eles vão precisar criar um ambiente virtual e instalar as exatas mesmas bibliotecas que você, na exata mesma versão.

Ao invés de você mandar um print como o que eu mostrei anteriormente para instalar manualmente cada biblioteca, uma de cada vez, você pode criar um arquivo de requerimentos, o requirements.txt. Para isso, basta usar o comando:

pip freeze > requirements.txt

Isso vai criar um arquivo txt com todas as bibliotecas que você está usando no projeto. Lembre de sempre atualizar seu requirements.txt com as novas bibliotecas que você instalar no caminho.

Instalando as bibliotecas do requirements.txt

Caso você seja o outro desenvolvedor que recebeu o requirements.txt. Para instalar essas bibliotecas basta você primeiro criar um ambiente virtual na sua máquina, ativar ele e depois usar o comando:

pip install -r requirements.txt

E você já está pronto para trabalhar também

Conclusão

Com esse artigo você já é capaz de usar o Venv para criar ambientes virtuais para projetos de pequeno e médio porte.

Se você quiser saber mais sobre ambientes virtuais, meu primeiro artigo sobre o assunto tem mais detalhes sobre eles.

Dúvidas, sugestões, correções e críticas são muito bem vindas na sessão de comentários abaixo. Espero poder encontrar você nos meus próximos artigos 😀. Até a próxima!

Concept Drift em Aprendizado de Máquina - Uma Introdução

Lucas Nobre Barbosa — Wed, 01 Nov 2023 13:19:55 +0000

Os dados de um cenário qualquer estão sempre evoluindo, faz parte da natureza de qualquer conjunto de dados. Entretanto, quando essa evolução invalida um modelo de aprendizado de máquina, nós temos o que chamamos de Concept Drift.

A tradução literal de Concept Drift seria “Desvio de Conceito”. Entretanto, por não ser um termo amplamente usado, nesse artigo irei me referir a esse termo somente em inglês.

Esse fenômeno acontece quando as propriedades estatísticas de uma variável alvo, que o modelo está tentando predizer, mudam de uma forma inesperada.

Em modelos tradicionais, isso faz com que as predições se tornem menos acuradas conforme o tempo passa. Sendo assim, a detecção de Concept Drift e a adaptação a esse fenômeno são primordiais em qualquer aplicação com dados e modelos que mudem dinamicamente.

Exemplos de Concept Drift

Existem muitos cenários em que esse fenômeno acontece constantemente. Entre eles podemos citar, por exemplo:

Demanda elétrica de uma cidade ao longo do ano
Mercado de ações
Preferências de compra
Probabilidade de sucesso de filmes

Em qualquer um desses cenários, o valor das predições de um modelo tradicional começa a decair conforme o tempo passa.

Vamos explorar os cenários de demanda elétrica e de preferência de compras.

Quando a pandemia de Covid-19 começou, entre vários outros efeitos, dois cenários mudaram muito rapidamente. Primeiro que o número de pessoas em casa em horários de trabalho aumentou consideravelmente. Também, a busca por máscaras e por álcool em gel aumentaram mais consideravelmente ainda.

Dessa forma, com o advento da pandemia, tanto a demanda energética residencial quanto a busca por produtos específicos aumentou de uma hora para a outra, causando desabastecimento desses produtos (energia elétrica residencial, máscaras e álcool em gel) para muitas pessoas.

Modelos de predição de série histórica para abastecimento energético e modelos de predição de estoque tradicionais sofreram muito com esse Concept Drift, tendo suas predições quase que totalmente invalidadas nesse novo cenário.

Possíveis Soluções

Para resolver o problema de Concept Drift, há duas principais abordagens: soluções reativas e soluções de rastreamento.

Soluções Reativas

A principal solução reativa para lidar com o fenômeno de mudança abrupta de cenário é treinar o modelo novamente, desde o início, com os dados novos, em reação a um mecanismo de acionamento, como um teste de detecção de alterações estatísticas.

Chamam-se de soluções reativas porque só resolvem o problema depois de ele acontecer, o que pode ser tarde demais em alguns cenários.

Soluções de Rastreamento

Soluções, geralmente, mais maduras envolvem rastrear constantemente esse desvio e resolver o problema antes de ele acontecer, com técnicas como, por exemplo:

Atualização constante do modelo
Aprendizado de Máquina Online (minha solução favorita)
Retreinamento constante com as amostras mais recentes
Treinar um classificador com dados novos e substituir o anterior

Conclusão

Nesse artigo introduzi o conceito de Concept Drift no contexto de aprendizado de máquina. Apresentei alguns exemplos e possíveis soluções para lidar com esse comportamento.

Em futuros artigos busco me aprofundar na solução de Concept Drift com Aprendizado de Máquina Online. Para se introduzir no assunto, leia meus outros artigos de aprendizado de máquina online em: https://dev.to/nobrelucas/introducao-ao-aprendizado-de-maquina-online-3ocm.

Se gostou desse artigo, por favor avalie ele de alguma forma. Comentários, críticas, sugestões e correções são muito bem-vindas. Agradeço pelo seu tempo. Até a próxima! 😊

River na Prática: Resolvendo um problema de classificação com Aprendizado de Máquina Online

Lucas Nobre Barbosa — Tue, 24 Oct 2023 14:14:03 +0000

Requisitos

Para seguir esse tutorial espera-se que você tenha conhecimento suficiente da linguagem de programação Python e do uso de ferramentas como Google Colab ou Jupyter-notebook.

Ter lido os dois primeiros artigos da série de artigos sobre River que eu escrevi é desejável.

Instalação

A biblioteca River é feita para funcionar a partir do Python 3.8. A instalação pode ser feita usando o gerenciador de pacotes pip:

# Via notebook
!pip install river

# Via terminal
pip install river

Problema de Classificação

Nesse tutorial vamos explorar um problema de classificação usando o famoso dataset titanic.

💡 O motivo de eu usar um dataset tradicional e em lote para um tutorial de aprendizado em streaming é puramente educacional. Além disso, como dito no artigo anterior, a biblioteca River tem ferramentas para ler conjuntos de dados em lote no formato de streaming para avaliação do modelo e para propósitos de estudo, como o desse tutorial.

💡 Esse dataset poderia ser considerado um dataset proativo, pois temos controle direto sobre os dados. Para saber mais confira o artigo de introdução ao River: https://dev.to/nobrelucas/river-aprendizado-de-maquina-online-com-python-uma-introducao-conceitual-3bb2

Instale os três arquivos do dataset no link: https://www.kaggle.com/competitions/titanic/data

Adicione o dataset no seu workspace e vamos começar a trabalhar.

💡 Recomendo criar uma pasta “data” no seu workspace para adicionar todos os dados

Preparação dos Dados

Com o seu notebook aberto, vamos ao código. Começamos criando um DataFrame pandas com os dados de treino e observando as cinco primeiras linhas.

import pandas as pd

dataframe = pd.read_csv('data/train.csv')
dataframe.head()

Isso deve mostrar o seguinte resultado:

💡 Os detalhes de cada coluna desse dataset podem ser encontrados no link no qual você baixou o conjunto de dados.

Vamos nos concentrar em fazer um modelo simples. Nesse caso, as colunas que mais nos interessam são:

Survived (Alvo): É uma coluna categórica com duas classes (1 para sobreviventes e 0 para não sobreviventes)
Pclass: É uma coluna categórica com três classes (1 para primeira classe, 2 para segunda classe e 3 para terceira classe)
Sex: Coluna categórica indicando o sexo do passageiro

Escolhi as features Pclass e Sex porque, historicamente, mulheres ricas foram as pessoas que mais sobreviveram.

Vamos filtrar essas colunas que são as únicas que nos interessam no momento

dataframe = dataframe[['Survived', 'Pclass', 'Sex']]
dataframe.head()

Mostrando o seguinte resultado:

Agora vamos transformar a coluna Sex em uma coluna numérica (1 para male e 2 para female)

dataframe['Sex'] = dataframe['Sex'].replace({'male': 1, 'female': 2})
dataframe.head()

Obtendo como resultado:

Por fim precisamos separar o dataset em features de treino e alvo (target). No nosso caso, Survived é o alvo e as demais colunas são as features de treino. Também irei transformar a coluna alvo de numérica para booleana para se adaptar ao modelo e a forma que o River trabalha.

features = dataframe[['Pclass', 'Sex']]
target = dataframe['Survived'].replace({0: False, 1: True})

Com todos nossos dados estando no formato desejado e separados em features e target, podemos começar a efetivamente trabalhar com o modelo.

Criação e treinamento do modelo online

O objetivo de um classificador é predizer qual a categoria de uma determinada amostra, predizer um alvo y para um conjunto de características x. Vamos fazer isso usando um modelo de regressão logística.

from river import linear_model

model = linear_model.LogisticRegression()

Com o código acima nós instanciamos o modelo.

💡 Eu irei frequentemente instanciar o modelo do começo para treiná-lo de formas diferentes.

Para treinar o modelo, basta alimentar ele com uma amostra dos dados por vez, mas como fazer isso se nossos dados são um grande lote? O módulo stream do River nos ajuda a lidar com isso e tem uma função chamada iter_pandas, que nos permite iterar um dataframe ou uma série pandas como se os dados estivessem chegando para nós em stream.

Experimente:

from river import stream

for X, y in stream.iter_pandas(features, target):
    print(X, y)

Cada print vai mostrar um dicionário com as features e um valor para cada uma delas e ao lado o valor do target para aquela amostra.

Mas o que queremos não é simplesmente ver as amostras e sim ensinar ao modelo a predizer se dada uma amostra um passageiro sobreviveu ou não.

Para isso, podemos usar o método learn_one(X, y). Entretanto, vamos criar um objeto iterável chamado “stream_dataset” ao invés de chamar a função iter_pandas diretamente no laço de repetição. A motivação para isso vai ficar mais clara futuramente.

from river import stream
stream_dataset = stream.iter_pandas(features, target)

for X, y in stream_dataset:
    model.learn_one(X, y)

Como estamos em um ambiente de aprendizado, vamos usar o mesmo dataframe para testar o modelo. Para um primeiro teste, vamos tentar predizer a primeira amostra do dataframe (homem que estava na terceira classe do navio e que não sobreviveu).

stream_dataset = stream.iter_pandas(features, target)
x, y = next(stream_dataset)
model.predict_one(x)

💡 Notem que eu instancio o objeto stream_dataset novamente para poder iterar ele novamente desde o início. Isso irá se repetir durante o resto do tutorial para experimentar diversas abordagens de treino e de validação.

O resultado do código acima deve ser false pois de fato esse passageiro não sobreviveu.

Verificar o que o modelo prediz uma amostra de cada vez não é uma boa estratégia, então vamos avaliar o modelo de uma forma bem comum para iniciantes em aprendizado de máquina: armazenando a predição do modelo para cada iteração e verificar a classe real para aquela amostra e depois calcular uma certa “acurácia” para essas predições.

💡 Nesse tutorial vou usar como métrica o ROC AUC, uma métrica muito comum para modelos de classificação. Você pode saber mais sobre essa métrica no link: https://mariofilho.com/guia-completo-sobre-roc-auc-em-machine-learning/

from river import metrics

metric = metrics.ROCAUC(n_thresholds=20)

stream_dataset = stream.iter_pandas(features, target)

for X, y in stream_dataset:
    y_pred = model.predict_proba_one(X)
    model.learn_one(X, y)
    metric.update(y, y_pred)

metric

O resultado do código acima deve retornar algo por volta de 81%, o que não é um valor a se jogar fora. Mas vamos experimentar uma outra abordagem, mais próxima do padrão de treinamento e de validação do River.

A biblioteca River permite criar um modelo como uma Pipeline, ou seja, um processo de passos para o treinamento. Isso é feito simplesmente adicionando “|” entre os processos desejados.

Além disso, como dito no artigo de introdução do River, o aprendizado e a inferência acontecem na mesma ordem que acontece no ambiente de produção e para isso a biblioteca usa a função progressive_val_score, que recebe o dataset em formato de stream, o modelo e a métrica usada.

from river import evaluate
from river import optim
from river import preprocessing
from river import compose

stream_dataset = stream.iter_pandas(features, target)

model = (
    preprocessing.StandardScaler() |
    linear_model.LogisticRegression(optimizer=optim.SGD(.1))
)

metric = metrics.ROCAUC(n_thresholds=20)

evaluate.progressive_val_score(stream_dataset, model, metric)

Para otimizar o modelo, antes de os dados alimentarem o modelo, eles são redimensionados com o StandardScaler(). O modelo recebe um otimizador do tipo SGD para descida de gradiente estocástica simples. Por fim avaliamos o modelo com progressive_val_score.

O resultado retornado pela função na última linha deve ser por volta de 82%. Uma melhora não tão considerável em comparação à nossa versão anterior, mas uma melhora é uma melhora.

Por fim, caso você queira identificar com mais facilidade os elementos do seu pipeline do modelo, basta digitar model em uma célula do seu notebook e ver a imagem que define o pipeline. No nosso caso, por exemplo, temos:

Conclusão

Com esse artigo você é capaz de experimentar várias das formas de trabalhar com a biblioteca River para treinar e avaliar modelos de aprendizado de máquina online. Você limpou um conjunto de dados e aprendeu desde como lidar com dados em lote para que funcionem como dados em streaming até como construir e avaliar um modelo de aprendizado online.

Se esse conteúdo foi do seu interesse, não esqueça de avaliá-lo de alguma forma e de me seguir para acompanhar os próximos artigos.

Dúvidas, sugestões ou correções são muito bem-vindas na seção de comentários abaixo. Até a próxima.

River: Aprendizado de Máquina Online com Python, uma Introdução Conceitual

Lucas Nobre Barbosa — Tue, 17 Oct 2023 13:05:29 +0000

No último artigo da série tivemos uma introdução ao aprendizado de máquina online como uma alternativa ao aprendizado de máquina tradicional (também chamado de aprendizado de máquina offline), que funciona com dados em lote.

Hoje, vamos explorar a biblioteca River em nível conceitual, apresentando suas principais características e alguns conceitos básicos que a biblioteca usa ao trabalhar com dados em streaming e modelos de aprendizado de máquina online.

Características do River

As principais características do River são:

A biblioteca funciona de forma incremental, podendo ser usada para processar dados em streaming
O River é adaptável, permitindo trabalhar em um ambiente em constante mudança
É de propósito geral, funcionando para problemas de classificação, de regressão e de clusterização, incluindo aprendizado supervisionado e aprendizado não supervisionado
É eficiente e fácil de aprender, possuindo uma API semelhante ao do scikit-learn
Tem uma comunidade e mantenedores dedicados
Possui conjuntos de dados de fácil acesso que podem ser lidos em forma de streaming para treinamento e avaliação do modelo em um ambiente de estudo. Além de funções para leitura de conjuntos de dados tradicionais em forma de streaming

Entretanto, vale destacar algumas desvantagens que podem ser essenciais para decidir entre essa biblioteca ou outras ferramentas:

A biblioteca não está nem na versão 1.0 ainda
Poucas pessoas fazem praticamente todo o trabalho, “carregando o projeto nas costas”

Isso abre margem para um receio que o projeto fracasse e seja descontinuado. Entretanto, é ainda a melhor alternativa para se trabalhar com aprendizado de máquina online em Python.

Conceitos Básicos

Antes de colocar a mão na massa, é muito importante conhecer um pouco mais sobre os termos que o River usa para entender melhor quais problemas ele resolve.

Data Streams

No geral, esse ainda é um termo muito vago e não consolidado, entretanto seguindo a documentação oficial do River, um data stream é uma sequência individual de elementos. Mais especificamente é um conjunto de características comumente chamada de features no jargão de aprendizado de máquina, ou seja, é como se fosse uma única linha de um CSV. A biblioteca chama essa linha única de características de “amostra”

Vale destacar que toda amostra pode possuir sempre a mesma estrutura e as mesmas features, mas também features novas podem surgir ou sumir, isso depende da aplicação.

Data Streams Reativos e Proativos

Até mesmo dentro do conceito de data streams é possível classificá-lo de duas formas diferentes. Os data streams reativos são aqueles que veem até a gente e que não possuímos muito ou até nenhum controle sobre eles. Note que quando os dados chegam ao modelo vindos da aplicação, como quando um usuário aperta um botão ou quando ele preenche um formulário, não temos controle sobre quando o dado chega e nem qual a velocidade de chegada de novos dados.

Os data streams proativos, por outro lado são o oposto, como quando estamos lendo um arquivo e controlamos o fluxo de dados. Nesse caso, temos controle sobre a velocidade de leitura e até mesmo da ordem que o arquivo é lido.

Processamento Online

Processamento online é o ato de processar os data stream com uma amostra de cada vez, linha a linha. Esse é o maior diferencial do aprendizado online que se opõe ao aprendizado tradicional, no qual se lê um lote inteiro de dados de uma única vez.

Dessa forma, um modelo online é um objeto stateful e dinâmico. Ele continua sempre aprendendo e não precisa revisitar dados antigos.

Propósito Geral

O aprendizado de máquina busca resolver vários problemas, incluindo classificação, regressão, detecção de anomalias, previsão de séries temporais etc. River busca ser uma biblioteca genérica para resolver qualquer tarefa ou problema envolvendo aprendizado de máquina, mas de uma forma online, ou seja, com dados em streaming. Inclusive, muitos algoritmos clássicos que funcionam com dados em lote já possuem suas versões online.

O River também permite realizar tarefas ainda mais simples, como calcular uma média sobre dados em streaming. Ou seja, ele vai além de uma biblioteca de aprendizado de máquina online e se torna uma biblioteca para processamento de dados em streaming.

Dicionários por toda parte

A biblioteca tem como bloco construtor básico o uso de dicionários. Os mantenedores decidiram seguir essa abordagem porque a vetorização não traz nenhum ganho considerável de velocidade no contexto de aprendizado online. Na verdade, bibliotecas de processamento numérico como numpy e PyTorch trazem muito overhead. Usar dicionários nativos do Python é mais rápido.

Datasets

Uma das grandes vantagens do aprendizado de máquina online usando River é a capacidade de fazer o design de modelos que podem fazer predições ao mesmo tempo que aprendem conforme os dados fluem.

Entretanto, durante o desenvolvimento do modelo, você normalmente não vai ter acesso a esses dados em tempo real para avaliar o seu modelo, portanto a biblioteca disponibiliza conjuntos de dados que já podem ser lidos de forma online, ou seja, com uma amostra de cada vez.

A biblioteca também apresenta funções que convertem um conjunto de dados tradicional, um DataFrame pandas por exemplo, em um conjunto de dados processável via streaming.

Avaliação do Modelo

A avaliação do modelo usando River, com aprendizado de máquina online, difere da sua contraparte em lote. Nessa última, você vai geralmente realizar validação cruzada, com seus dados sendo divididos em um conjunto de treino e outro de teste.

O aprendizado online não utiliza esse processo e a avaliação envolve o aprendizado e a inferência na mesma ordem que ela acontece em um ambiente de produção. Isso permite que você simule um cenário de produção e avalie o seu modelo com uma fidelidade maior que na validação cruzada.

Concept Drift

A principal razão para um modelo offline não performar como esperado em produção é por conta do desvio de conceito. Entretanto isso também é verdade para modelos online.

A grande vantagem dos modelos online em relação aos modelos offline é que eles podem lidar com esse desvio. Na verdade, justamente por continuar sempre aprendendo, esses modelos podem se adaptar ao desvio de conceito de uma forma contínua, diferente de modelos tradicionais que precisam ser restringidos desde o começo.

Falaremos mais sobre desvio de conceito em tutoriais futuros.

Conclusão

Nesse artigo pudemos explorar os principais conceitos que a biblioteca River aborda de forma a nos preparar para os conteúdos de cunho mais prático que virão em futuros artigos. Com essa base de conhecimento é possível colocar a mão na massa e implementar nosso primeiro modelo de aprendizado de máquina online usando a biblioteca River.

Introdução ao Aprendizado de Máquina Online

Lucas Nobre Barbosa — Thu, 05 Oct 2023 14:41:27 +0000

A cada dia, a geração de dados no mundo cresce, com a previsão de atingir 163 zettabytes (1 trilhão de gigabytes) até o fim de 2025.

Com a disponibilidade desse vasto volume de dados em um fluxo cada vez maior, negócios em todas as indústrias estão migrando do processamento de dados em lote para o processamento de dados em streaming.

O aprendizado de máquina tradicional é ineficaz nesse cenário, dando origem a uma nova abordagem chamada Aprendizado de Máquina Online (ou Aprendizado de Máquina com Dados em Streaming), que alimenta os modelos de forma incremental.

Neste primeiro artigo, apresentarei uma visão superficial do aprendizado de máquina online, explorando os principais conceitos básicos.

Aprendizado de Máquina Online vs. Aprendizado de Máquina Offline

Aprendizado de Máquina Offline

Quando se fala sobre Aprendizado de Máquina Offline, está-se referindo à abordagem tradicional na qual o modelo aprende com todos os dados de uma vez, carregados na memória. Essa abordagem apresenta algumas desvantagens ao trabalhar com dados em streaming, incluindo:

Modelo não aprende incrementalmente
Usa muitos recursos de processamento e de memória
Leva muito tempo para executar quando o volume de dados é muito grande
É necessário treinar o modelo do zero sempre que novos dados chegam

Aprendizado de Máquina Online

O aprendizado de máquina online, também conhecido como aprendizado de máquina com dados em streaming, pode ser encontrado na Internet com esses dois nomes, e a verdade é que não parece haver um consenso sobre a nomenclatura. No entanto, o segundo nome demonstra claramente sua orientação para trabalhar com dados em streaming, possuindo muitas vantagens em comparação com modelos offline, incluindo:

O modelo é alimentado continuamente sempre que os dados chegam da fonte
Economiza recursos de processamento e memória (pois os dados não são todos carregados de uma única vez)
Sempre que novos dados chegam, não é necessário treinar o modelo do zero
Previne desvios de conceitos (falarei mais sobre isso em outro artigo)

Casos de Uso para Aprendizado de Máquina Online

Como acontece com toda tecnologia, não é suficiente apenas aplicá-la sem analisar criticamente as demandas dos seus problemas de negócio. O aprendizado de máquina online possui muitas vantagens ao abordar problemas em que:

Os dados são sem fim e efetivamente contínuos
Os dados são sensíveis ou privados e não podem ser armazenados
Há uma impossibilidade lógica (requisitos de negócio como os do item anterior) ou física (espaço de armazenamento limitado ou rede indisponível) para armazenar ou transferir os dados
A quantidade de dados é grande demais para caber na memória para o treinamento.

Além disso, deve-se considerar antes de implementar um modelo online:

Como lidar com os altos volumes de dados em tempo real
A velocidade de criação, de distribuição e de coleta dos dados
A variedade dos dados (texto, vídeo, imagem, áudio, etc.)

Conclusão

Se este conteúdo lhe interessou, não esqueça de avaliá-lo de alguma forma e de me seguir para acompanhar os próximos artigos. Dúvidas, sugestões ou correções são muito bem-vindas na seção de comentários abaixo. No próximo artigo, apresentarei uma biblioteca em Python para lidar com modelos de aprendizado de máquina online. Obrigado pela atenção.

Administrando Ambientes Virtuais com Conda

Lucas Nobre Barbosa — Tue, 26 Sep 2023 13:01:35 +0000

Introdução

O dia a dia de um desenvolvedor está interligado ao uso de dezenas de bibliotecas e frameworks para as mais diversas funções. Algumas das bibliotecas mais famosas no ecossistema Python para Ciência de Dados são Pandas, Numpy, Matplotlib, Seaborn, Scikit-Learn, Tensorflow, entre outras. Todavia, conforme o profissional vai trabalhando em diversos projetos e atualizando essas bibliotecas, ele pode acabar caindo no problema de incompatibilidade de pacotes.

Suponhamos que há 10 anos um desenvolvedor chamado Carlos fez um projeto usando Python 2.7, mas hoje em dia já usa o Python 3.9. No entanto, por algum motivo, ele precisa revisitar aquele trabalho antigo. Quando vai tentar rodá-lo, se depara com algum tipo de erro, como um comando de Python 2.7 que não funciona mais em Python 3.9.

Como Carlos poderia resolver esse problema? Talvez nunca mais atualizando as bibliotecas que ele usa? Essa definitivamente não é uma solução satisfatória, então o que fazer? É aí que ambientes virtuais entram. Um ambiente virtual é como um espaço onde você pode guardar as versões de softwares que você quer que rode nele. De forma mais técnica, um ambiente virtual é um diretório com arquivos python executáveis e outros tipos de arquivo que indicam que ele é um ambiente virtual.

Com um desses, Carlos tem mais controle sobre quais pacotes estão sendo usados e em qual versão eles estão, pois sempre que um script for rodado dentro de um ambiente virtual, o script vai rodar com as exatas mesmas versões que foram configuradas na hora de escrevê-lo, a menos que o contrário seja especificado.

Mas como usar isso? Na verdade, existem várias ferramentas para usar as "virtual envs" (ambientes virtuais), tais como o venv, o pyenv e o que será o nosso foco nesse artigo, o conda. Conda é um gerenciador de pacotes das linguagens Python e R, mas também é muito conhecido como um gerenciador de ambientes virtuais. Ele faz parte do Anaconda, um conjunto de ferramentas muito usado por cientistas de dados, como o Jupyter-Notebook, por exemplo.

Nesse artigo, iremos pular a etapa de instalação do Anaconda, pois imagina-se que a maioria dos profissionais e estudantes da área de dados já o use. Esse artigo é feito usando terminal de comandos Linux Fedora, mas funciona na maioria das distribuições Linux.

O ambiente padrão

Se você é um iniciante na área de computação ou veio de um background diferente da tecnologia, suas primeiras experiências com o terminal de comando Linux podem ter sido assustadoras. Ao instalar o Anaconda pela primeira vez em sua distribuição favorita, pode ter se deparado com o marcador "(base)" antes do seu nome de usuário e do nome da sua máquina na linha de comando BASH, como mostrado a seguir.

(base) [user@machine ~]$

Seu primeiro reflexo pode ter sido reiniciar o terminal ou pesquisar como tirar esse (base) estranho dele no Google, mas na verdade, isso já é um ambiente virtual - o ambiente padrão do conda. Nele, estão incluídos todos os pacotes que o conda imagina que você usará como cientista de dados.

“Então, já posso programar à vontade nesse ambiente?”
Calma, por mais que este seja um ambiente virtual, ele é bastante genérico. Experimente rodar o comando.

(base) [user@machine ~]$ conda list

e veja a quantidade de pacotes existentes. Há muitos pacotes que você pode não precisar ou pode precisar em outra versão. Programar nesse ambiente não faz muita diferença em relação a programar sem nenhum ambiente.

Criando um ambiente a partir da linha de comando

Vamos criar nosso próprio ambiente. Vamos supor que você precisa de um ambiente para um projeto que usa Python, Pandas e Numpy, todos em suas últimas versões, nesse caso, digite o comando

(base) [user@machine ~]$ conda create --name teste1 python pandas numpy

Comando grande, mas fácil de entender, conda create é o comando para criar um novo ambiente virtual, a flag --name e o texto que vem em seguida servem para definir qual será o nome desse novo ambiente (o nome do ambiente padrão é base, por exemplo) e todos as palavras a seguir são as bibliotecas, linguagens e frameworks que você quer nesse ambiente, no nosso caso python, pandas e numpy. Após esse comando, uma mensagem semelhante a essa vai aparecer:

Basta você digitar “y” e apertar ENTER que todos os pacotes necessários serão instalados nesse novo ambiente, mas você ainda vai estar no ambiente padrão. Digite o comando

(base) [user@machine ~]$ conda info --envs

Se tudo deu certo, você vai ter como resposta algo semelhante ou idêntico a isso. Para entrar no ambiente novo criado, basta digitar o comando

(base) [user@machine ~]$ source activate teste1

E pronto, você está no ambiente virtual selecionado, com as bibliotecas, linguagens e frameworks que você especificou. Para ter certeza que você está no ambiente correto, você pode ter dois tipos de feedback. Digitando novamente o comando

(teste1) [user@machine ~]$ conda info --envs

# conda environments:
#
base                     /home/user/anaconda3
teste1                *  /home/user/anaconda3/envs/teste1

Note que tem um asterisco (*) ao lado de teste1 ao invés de base, e, se você for atento já pode ter percebido, que (teste1) está escrito no começo da última linha do terminal de comando, enquanto antes era (base). Agora é só desenvolver sua aplicação.

Especificando as versões que você quer

Você pode também deixar explicito quais versões das bibliotecas, linguagens e frameworks você quer. Basta especificar essas versões logo após o nome da biblioteca e de um igual, dessa forma:

(teste1) [user@machine ~]$ conda create -n teste2 python=3.6 pandas numpy=1.16

Note que, como no caso do pandas, quando a versão não é especificada, a última versão é a instalada. Note também que você pode simplificar a flag --name como -n, isso serve para a maioria das flags, fica a seu critério.

Administrando Pacotes

Após criar um ambiente virtual, você pode precisar instalar algum outro pacote ou mesmo atualizar um já instalado (cuidado com o problema de compatibilidade, não jogue fora o potencial dos ambientes virtuais). Nesse caso, você pode procurar se um pacote está disponível com o comando

(teste1) [user@machine ~]$ conda search beautifulsoup4

Com ele, o conda vai listar todos os pacotes disponíveis com esse nome, em todas as versões disponíveis no repositório Anaconda. Assim, sabemos se ele está disponível. Você pode escolher uma das versões que aparecem para você, ou somente instalar a versão mais recente com

(teste1) [user@machine ~]$ conda install beautifulsoup4

Esse pacote vai ser instalado somente no ambiente virtual em que você está, e você pode ver se ele foi instalado corretamente usando

(teste1) [user@machine ~]$ conda list

Conclusão

Pudemos ver que com poucos comandos, que são muito intuitivos, podemos construir um ambiente virtual completo usando conda. Como dito no começo do artigo, existem outros gerenciados de ambientes virtuais para Python e muitos outros para outras linguagens.

O conda e o próprio Anaconda são muito mais completos que os primeiros comandos que ensinei por aqui, mas espero que eles tenham servido de base para futuros aprendizados. Obrigado pela leitura atenciosa, espero vocês no próximo artigo.

Linux PATH: O que é e como usar

Lucas Nobre Barbosa — Tue, 19 Sep 2023 11:31:39 +0000

Introdução

No nosso último artigo nós exploramos de forma bem geral as variáveis de ambiente Linux. Descobrimos como criar variáveis de ambiente temporárias, persistentes para um usuário e variáveis globais. No meio desse processo, citei uma variável de ambiente muito importante e que deve ser conhecida de muitos de vocês, a variável PATH.

A Variável de Ambiente PATH

PATH é uma variável de ambiente que guarda um conjunto ordenado de caminhos (ou paths) onde o Linux vai procurar por executáveis, ou seja, ao executar um comando, não precisamos passar para o terminal um caminho absoluto e somente o nome do comando.

Um exemplo disso seria o comando echo do Linux. Vamos escrever um “Hello World” no BASH:

echo "Hello World"

Esse comando simplesmente mostra na tela o que está entre parênteses. Nós só podemos usá-lo diretamente, assim, porque o caminho para ele está no PATH, mais precisamente, ele está em /usr/bin/. Dessa forma, não precisamos escrever /usr/bin/echo “Hello World” por mais que dessa forma também funcione.

O que está no PATH?

Para saber o que está no seu PATH, basta usar o comando echo dessa forma:

echo $PATH

A lista de caminhos será mostrada no seguinte formato:

/algum/caminho/qualquer:/outro/caminho/qualquer

O caractere “:” simboliza o fim de um caminho e o início de outro. Procure o caminho /usr/bin onde está o nosso comando echo.

Como adicionar um novo caminho ao PATH?

Para adicionar um novo caminho ao PATH, como /algum/novo/caminho, usaremos o comando export como mostrado a seguir (checar tutorial sobre variáveis de ambiente para mais detalhes sobre esse comando).

export PATH=$PATH:/algum/novo/caminho

Da mesma forma que vimos no artigo sobre variáveis de ambiente, o que estamos fazendo é dar um novo valor à variável de ambiente PATH. Esse novo valor nada mais é que seu antigo valor ($PATH) com o seu novo caminho anexado ao final, após o separador “:”.

Não esqueça de depois escrever o comando “echo $PATH” para ver se o seu caminho foi adicionado corretamente ao final do PATH.

Adicionando um novo caminho ao PATH de forma persistente entre sessões de um mesmo usuário

Caso você tenha lido o artigo sobre variáveis de ambiente, você vai lembrar que só usar o export no terminal vai criar ou alterar o valor de uma variável de ambiente de forma efêmera, ou seja, quando você reiniciar a sessão aquela variável vai ter sumido. Para adicionar nosso novo caminho de forma permanente para um usuário, vamos adicionar o export no final do arquivo ~/.bash_profile. Primeiro abra ele no seu editor de texto, no meu caso será o vim.

vim ~/.bash_profile

Depois, adicione o comando export da forma que fizemos anteriormente em algum lugar do arquivo, preferencialmente no final. Após isso, só salve o arquivo e para ativá-lo na sessão atual use o comando a seguir no terminal.

source ~/.bash_profile

Adicionando um novo caminho ao PATH de forma global

Seguindo a mesma lógica de variáveis de ambiente, vamos criar um arquivo.sh em /etc/profile.d

touch /etc/profile.d/exemplo.sh

Com o arquivo criado, vamos editá-lo

vim /etc/profile.d/exemplo.sh

No final do arquivo, adicionamos

export PATH=$PATH:/algum/novo/caminho

E pronto, temos o que queríamos. Um novo caminho que vai funcionar para todos os usuários da máquina.

Removendo um caminho do PATH

Tenha muito cuidado ao fazer isso, mas se você tem certeza que deseja remover, digamos, um/caminho/errado que esteja no final do seu PATH, você pode escrever o seguinte comando no terminal:

PATH=$(echo "$PATH" | sed -e 's|:um/caminho/errado$||')

Novamente, considere que essa alternativa só funciona caso o caminho esteja no final do PATH. Caso não, uma abordagem menos elegante é:

printe o seu PATH na tela usando echo $PATH;
copie e cole o conteúdo printado em algum arquivo em um local seguro
apague o caminho que você deseja remover no arquivo
copie o novo PATH e substitua no seu PATH colando o conteúdo após “PATH=”

Obs: Os passos 1 e 2 podem ser feitos mais facilmente com o comando echo $PATH > caminhos.txt, no terminal.

Conclusão

Nesse artigo aprendemos o que é a variável de ambiente PATH, qual é a sua utilidade e como configurar ela para atender nossas necessidades. Algumas etapas de explicação foram puladas, pois espera-se que você tenha conhecimento de variáveis de ambiente, mas caso não o tenha, você pode checar meu artigo sobre esse assunto nessa mesma plataforma. Obrigado pela leitura.

Uma Introdução a Variáveis de Ambiente em Linux

Lucas Nobre Barbosa — Mon, 11 Sep 2023 12:55:35 +0000

Introdução

Em sua jornada pelo Linux você já deve ter ouvido falar sobre variáveis de ambiente, como uma das mais famosa delas, a variável de ambiente PATH. Mas, o que são essas variáveis? Para o que elas são úteis? São difíceis de aprender? Nesse artigo eu espero te ajudar a responder essas perguntas e talvez até mesmo atiçar sua curiosidade para se aprofundar nesse conteúdo.

Observe que esse artigo é sobre variáveis de ambiente de forma bem genérica, não falaremos de forma aprofundada sobre PATH, todavia escreverei um outro artigo inteiramente sobre essa variável de ambiente tão importante e famosa.

O que são Variáveis de Ambiente?

Nas linguagens de programação existem as variáveis, espaços de memória o qual damos nomes e um valor, como preco = 5.32, em Python. Variáveis de Ambiente são como constantes, que são definidas fora do programa através de alguns comandos ou configurando alguns arquivos.

Elas são muito úteis para esconder informações importantes como senhas, porque colocar essas senhas direto na aplicação é uma péssima ideia (principalmente quando se trata de um repositório público). Definir as senhas em variáveis de ambiente ajuda a esconder elas de pessoas mal intencionadas. Variáveis de Ambiente também são úteis para auxiliar na manutenção do código, pois centralizam algumas configurações em um único lugar e evitam acidentes durante a edição do código. Algumas aplicações são: nomes de domínios, grupo de emails ou URLs/URIs de APIs.

Criando Variáveis de Ambiente

Em linux, para configurar variáveis de ambiente, normalmente é usado o comando export.

export NAME=VALUE

O comando é simples de entender, ao usar ele, você cria uma variável de ambiente com nome NAME e valor VALUE. Por exemplo, podemos criar a variável de ambiente MAX_NUMBER_FILES, que define o número máximo de arquivos que uma aplicação suporta.

export MAX_NUMBER_FILES=3

Para verificar o valor da variável de ambiente, basta usar o comando echo

echo $MAX_NUMBER_FILES

Se a variável não existir, uma linha em braco vai aparecer no terminal.

Outro exemplo seria passar o caminho comumente usado para seus projetos

export CAMINHO_DADOS_VENDAS="~/algum/caminho/valido/dados_vendas"

Apagando Variáveis de Ambiente

Tão simples quanto criar uma variável de ambiente é apagá-la, mas também não se engane, não basta reconfigurá-la com um valor “vazio”, ela vai continuar lá, só que sem valor. A forma correta de apagar uma variável de ambiente é através do comando unset

unset MAX_NUMBER_FILES

Simples assim você apagou sua variável de ambiente. Todavia, cuidado com o que apaga.

Listando as Variáveis de Ambiente

Quer saber quais variáveis de ambiente já existem no seu sistema ou verificar se as que você criou estão configuradas corretamente? O comando para isso é set.

set

O output para isso vai ser gigantesco, então não se assuste, mas com um pouco de paciência você encontra o que quer.

Um outro comando que só mostra as variáveis exportadas é o export

export

Você pode usar a flag -p para mostrar somente as variáveis de ambiente exportadas nessa sessão

export -p

Procurando com atenção você verá as duas variáveis de ambiente que criamos

Variáveis de Ambiente Persistentes entre Sessões de um Usuário

Quando um usuário cria variáveis de ambiente através do terminal de comando linux SHELL, essas variáveis vão existir enquanto a sessão do usuário estiver ativa. Se você quiser que essas variáveis continuem existindo sempre que o sistema for inicializado, você precisa colocar elas em um arquivo de configuração.

O arquivo bash_profile é um excelente candidato para isso, ele armazena diversas configurações do bash shell e também variáveis de ambiente padrão ou que o usuário define. Use o editor de texto de sua preferência, no meu caso será o vim.

vim ~/.bash_profile

No final do arquivo, adicione

export CAMINHO_DADOS_VENDAS="~/algum/caminho/valido/dados_vendas"

Salve o arquivo, no caso do vim isso se faz com :w (e :q para sair do editor), e assim você tem uma variável de ambiente que vai ser inicializada sempre que a sua sessão como usuário iniciar.

Observe que ao fazer isso, a variável de ambiente não vai ser inicializada automaticamente, pois esse arquivo roda quando uma sessão de usuário inicia. Se você quiser já usar essa variável de ambiente, rode também o comando

source ~/.bash_profile

Variáveis de Ambiente Persistentes entre Sessões de todos os Usuários

Por fim, supondo que você precise de uma variável de ambiente que funcione para todo e qualquer usuário que use o mesmo computador ou servidor(chamadas de variáveis de ambiente globais), você precisa criar um arquivo tipo shell no diretório /etc/profile.d. Os passos são simples:

Crie um novo arquivo em /etc/profile.d para armazenar as variáveis de ambiente globais. É recomendado que o nome desse arquivo seja contextualizado com as variáveis de ambiente que ele vai armazenar.

sudo touch /etc/profile.d/http_proxy.sh

Abra o arquivo criado usando um editor de texto

sudo vim /etc/profile.d/http_proxy.sh

Adicione as variáveis de ambientes no arquivo

export HTTP_PROXY=http://my.proxy:8080
export HTTPS_PROXY=https://my.proxy:8080
export NO_PROXY=localhost,::1,.example.com

Salve suas alterações e saia do editor de texto.

Conclusão

Variáveis de ambiente são ferramentas extremamente poderosas e têm o potencial de aprimorar e muito o seu processo de Desenvolvimento, de Ciência de Dados ou de engenharia de Machine Learning. Nesse artigo você aprendeu como criar variáveis de ambiente temporárias, persistentes para um usuário e variáveis de ambiente globais. A partir daqui, continue seus estudos para dominar essa ferramenta. Obrigado pela leitura.