Código Python: perceptron do zero para decidir se repõe um produto

Código Python: perceptron do zero para decidir se repõe um produto

Toda semana, numa loja de ferragens, numa distribuidora de autopeças ou no depósito de uma padaria pequena, a mesma pergunta volta: peço esse item de novo ou espero? Quase sempre quem responde é uma pessoa, de memória e com uma planilha aberta. O problema não são os dados: as vendas do mês, o estoque disponível e o prazo do fornecedor já estão registrados em algum lugar. O problema é que ninguém tem tempo de olhar os três números ao mesmo tempo, item por item, na hora de montar o pedido.

Este artigo é para o dono do negócio, para o contador que revisa as compras e para o estoquista que monta a lista. Aqui você baixa um programa em Python que se lê do começo ao fim, sem nenhuma biblioteca de inteligência artificial, que pega três colunas do seu estoque e aprende sozinho uma regra simples: quando vale a pena repor. A ideia toda cabe numa frase: um neurônio é uma regra que se ajusta sozinha. Ele começa chutando, erra, se corrige e acaba acertando. Não tem mágica: tem uma fórmula curta repetida trinta vezes sobre os seus dados, e o resultado pode ser conferido linha por linha.

O pacote é um ZIP com quatro arquivos e mais nada. Não traz instalador nem depende da internet: depois de descompactar, tudo roda no seu próprio computador.

O que o programa faz

O programa faz um trabalho limitado e faz o trabalho inteiro. Do começo ao fim:

1. Lê datos/productos.csv: doze produtos de ferragem com as vendas do mês, o estoque, o prazo do fornecedor e uma coluna chamada repor, que vale um quando o comprador repôs aquele produto e zero quando não repôs. Essa coluna é a resposta certa que o neurônio precisa aprender a copiar; o programa não a inventa.
2. Normaliza as três entradas para o intervalo de zero a um. É o passo que quase todo mundo pula e o que decide se o experimento serve ou não.
3. Começa os pesos com valores sorteados, mas com a semente fixa sete, e por isso todo mundo vê exatamente os mesmos números, hoje e daqui a um mês.
4. Treina o neurônio: dá trinta voltas no arquivo, embaralhando a ordem em cada volta, e sempre que a previsão não bate com a resposta certa corrige os pesos na direção que reduz o erro.
5. Mostra os pesos finais com a leitura em palavras, para você acompanhar mesmo sem programar.
6. Prevê produto por produto e compara a previsão com a resposta certa.
7. Grava salida/predicciones.csv, confere que a mesma semente devolve o mesmo resultado e avisa se algo não fecha.

Como executar

Você precisa de Python 3.11 ou superior e absolutamente nada mais. Nem numpy, nem pandas, nem qualquer biblioteca de inteligência artificial: o programa usa só a biblioteca padrão que vem com o Python. Se ainda não tem, baixe do site oficial e aceite as opções padrão.

1. Descompacte o ZIP numa pasta (por exemplo, Documentos/Perceptron).
2. Abra o terminal nessa pasta.
3. Digite o comando e tecle Enter:

   python perceptron_reponer.py

No Windows o interpretador às vezes se chama py: se o comando acima não responder, tente py perceptron_reponer.py. No Mac e no Linux costuma ser python3 perceptron_reponer.py. A única condição é estar dentro da pasta descompactada, porque o programa procura o arquivo de dados em datos/productos.csv e grava o resultado em salida/predicciones.csv.

O código, explicado

O programa inteiro passa um pouco de duzentas linhas e está comentado linha por linha. Seis pedaços bastam para entender a ideia toda.

Os três botões do aprendizado. No começo são declarados três números que governam o treinamento inteiro. A semente fixa o sorteio para o resultado se repetir; a taxa diz quanto cada peso é corrigido em cada erro; as épocas dizem quantas voltas completas o arquivo recebe. Mudar a taxa ou as épocas muda a execução, e por isso o programa imprime esses valores na tela: assim você sabe de onde veio o resultado.

SEMILLA = 7          # # Semente fixa: com o mesmo dado o resultado é sempre o mesmo
TASA = 0.1           # # Taxa de aprendizado: quanto o peso é corrigido em cada erro
EPOCAS = 30          # # Epocas: quantas voltas completas o arquivo recebe

Por que se normaliza. Esta função leva cada coluna para o intervalo de zero a um. Se o neurônio visse o estoque em unidades, que chega a centenas, junto com o prazo em dias, que não passa de trinta, a soma ficaria dominada pela coluna maior e o prazo quase não contaria. Com tudo na mesma escala, cada entrada empurra de verdade e os pesos podem ser comparados entre si.

def normalizar(productos: list[dict], campo: str) -> list[float]:
    """Leva uma coluna ao intervalo 0..1 (min-max): assim o estoque em unidades não esmaga o prazo em dias."""
    valores = [producto[campo] for producto in productos]
    minimo, maximo = min(valores), max(valores)
    rango = maximo - minimo

O neurônio em si. Aqui está o coração, e cabe em duas funções. Multiplica-se cada entrada pelo seu peso, somam-se os três resultados e acrescenta-se o viés. Esse total é comparado com zero: passando de zero a resposta é repor, ficando abaixo a resposta é não repor. Nada além disso; no papel, é uma reta que corta os produtos em dois grupos.

def suma_pesada(pesos: list[float], sesgo: float, entrada: list[float]) -> float:
    """Soma ponderada w*x + b: o valor que o neurônio compara com zero."""
    total = sesgo
    for indice in range(len(ENTRADAS)):
        total += pesos[indice] * entrada[indice]
    return total

def predecir(pesos: list[float], sesgo: float, entrada: list[float]) -> int:
    """Prevê 1 (repor) quando a soma ponderada passa de zero, e 0 quando não passa."""
    return 1 if suma_pesada(pesos, sesgo, entrada) > 0 else 0

O treinamento. Os pesos não nascem certos: nascem sorteados. O que os torna úteis é a regra de correção, aplicada linha após linha dentro de cada época.

def entrenar(entradas: list[list[float]], etiquetas: list[int]) -> tuple:
    """Treina o neurônio com a regra do perceptron e devolve pesos, viés e erros por volta."""
    azar = random.Random(SEMILLA)
    pesos = [azar.uniform(-1.0, 1.0) for _ in ENTRADAS]   # # Cada peso diz o quanto sua entrada empurra para o repor

A correção. Quando a previsão bate com a resposta certa, o erro é zero e nada é tocado: o que já está certo não se mexe. Quando não bate, o erro empurra cada peso na proporção da entrada e do tamanho da taxa de aprendizado. O viés é corrigido igual a um peso, com a diferença de que não multiplica nenhuma entrada.

                for j in range(len(ENTRADAS)):
                    pesos[j] += TASA * error * entradas[indice][j]
                sesgo += TASA * error    # # O viés é corrigido como um peso, mas não multiplica nenhuma entrada

O que você vai ver na tela

Primeiro a tabela de dados exatamente como o arquivo traz e, abaixo, a mesma tabela normalizada: os mesmos produtos vistos na escala de zero a um que o neurônio usa. Repare que a coluna de estoque é a que muda de cara de forma mais brusca; é justamente esse o efeito que buscamos.

DADOS NORMALIZADOS (0 a 1: o que o neurônio vê)
-------------------------------------------------------------------------------------
Produto                         Repor          Vendas 0-1   Estoque 0-1     Prazo 0-1
-------------------------------------------------------------------------------------
Cimento cinza 50 kg             SIM                  0,26          0,10          0,76
Parafuso autoperfurante 1 pol   SIM                  1,00          0,26          0,19
Martelo de bola                 SIM                  0,00          0,00          1,00
Areia grossa (saco)             NÃO                  0,47          1,00          0,00

Depois vem o treinamento. O programa imprime só as voltas em que melhora, que são as que ensinam: na primeira época ele erra sete vezes, na segunda cinco, na terceira quatro, na quarta duas e na sexta não erra mais. Aí está o aprendizado à vista, sem caixa preta.

TREINAMENTO: 30 épocas, taxa 0,10, semente 7
  Época 1/30 · erros 7
  Época 2/30 · erros 5
  Época 3/30 · erros 4
  Época 4/30 · erros 2
  Época 6/30 · erros 0

E no fim, os pesos com a leitura em palavras, o resultado produto por produto e a conferência de que a execução se repete.

PESOS FINAIS E VIÉS (lidos em palavras)
  peso de vendas_mes = 0,25: quanto mais o produto vende, mais vontade de repor
  peso de estoque = -0,74: quanto mais estoque guardado, menos vontade de repor
  peso de prazo_fornecedor = 0,28: quanto mais o fornecedor demora, mais vontade de repor
  viés = -0,06: com as três entradas em zero, o neurônio se inclina a não repor

Esses quatro números são o resultado da execução e merecem uma leitura de negócio:

O que importa não é o valor exato de cada peso, e sim o tamanho relativo entre eles. O estoque pesa mais que as outras duas entradas juntas; o viés é tão pequeno que quase não influi. E, como os dados estão normalizados, esses três números podem ser comparados entre si: se o estoque fosse medido em unidades e o prazo em dias, um peso de menos zero vírgula setenta e quatro não diria nada. Um detalhe que vale ouro: esses pesos são a impressão digital desses doze produtos de exemplo, não uma receita universal. No seu próprio arquivo vão sair outros números, e isso está certo.

Acertos: 12 de 12
Conferência (mesma semente, mesmo resultado): FECHA

A execução de exemplo acerta as doze previsões, isto é, a totalidade dos casos. O programa também grava salida/predicciones.csv com quatro colunas, produto, esperado, previsto e acerto, pronto para abrir no Excel ou em qualquer planilha. É isso que se revisa com o contador: não a promessa de um modelo, mas a lista dos casos em que acertou e daqueles em que errou.

Erros comuns e dicas

• Não encontra o arquivo. Quase sempre você está executando o comando de outra pasta. Entre na pasta descompactada ou escreva o caminho completo até o arquivo.
• Não mova o CSV. O programa procura os dados com o nome exato datos/productos.csv. Se renomear ou tirar da subpasta, deixa de funcionar.
• Mantenha o CSV como CSV. Se editar no Excel, conserve os mesmos cabeçalhos, produto, vendas_mes, estoque, prazo_fornecedor e repor, e o separador por vírgulas. A configuração regional que troca o separador de listas quebra a leitura.
• Nada de símbolos nem ponto de milhar. Os números vão limpos, sem símbolo de moeda e sem separador de milhar.
• A etiqueta é um ou zero. Na coluna repor não escreva palavras como sim ou não: o programa espera números.
• Um dado estranho estraga a tabela. Uma célula vazia ou um texto no meio dos números desalinha as contas; revise o arquivo antes de executar.
• Doze linhas não são um teste. O exemplo é curto de propósito para ficar fácil de acompanhar. Com o seu estoque real, use vários meses e algumas centenas de linhas antes de confiar na regra.
• Anote a semente. Se depois você trocar a semente, vão aparecer outros pesos; a lógica é a mesma, mas o ponto de partida não. Deixe registrado de quais valores cada resultado veio.

Quando isso não basta

Com isto você já repõe com critério, e não com o palpite do mês passado. Ainda assim, os limites merecem uma palavra honesta. O primeiro é técnico: um único neurônio só aprende regras de fronteira reta, do tipo estoque baixo frente às vendas ou prazo longo. Se a sua regra real tiver exceções, por exemplo não repor os produtos que já estão pedidos, é preciso mais de um neurônio. O segundo limite é de operação: este programa é didático, roda na máquina de uma pessoa, sobre um arquivo CSV que alguém precisa manter em dia.

Quando o negócio cresce e a planilha com os scripts já não dá conta, o passo natural é um software de estoque. É aí que entra o Kardex Tauro, a ferramenta para a qual este taller foi escrito: permite levar o estoque e o custo das vendas a sério, com vários usuários e com backup, sem depender de alguém lembrar de atualizar o arquivo. O programa deste artigo é gratuito e serve para entender a mecânica e para organizar o estoque; o software é para quando o estoque já não cabe num arquivo.

Baixe o ZIP, execute do jeito que veio e olhe a tabela de acertos. Depois troque uma linha de datos/productos.csv por um produto seu de verdade e rode de novo: você vai ver a regra se reajustar sozinha, sem tocar em uma linha de código. É esse o truque inteiro, e também a melhor forma de entender por que um estoque organizado vale mais do que um pedido feito às pressas.