Construindo Modelos de Machine Learning com Python no Contexto Industrial

Introdução: Como o Machine Learning Está Transformando a Indústria com Python

Hoje em dia o termo “Machine Learning” está super em alta porque permite prever tendências, identificar padrões e automatizar decisões em várias áreas, desde finanças até saúde e indústria.

Mas o que é Machine Learnig?

De uma forma bem simples, podemos dizer que Machine Learning nada mais é do que uma maneira de ensinar os computadores aprenderem e a tomarem decisões sozinhos, a partir de dados fornecidos, sobre uma situação real, sem que haja a participação de alguém em sua programação.

Imagina que você é dono de uma fábrica e quer saber se está investindo seu dinheiro da melhor forma. Será que aumentar o investimento sempre traz mais lucro? Será que reduzir custos ajuda ou pode atrapalhar?

Diante desse cenário, no contexto industrial, este artigo tem como objetivo apresentar um script simples em Python, demonstrando como essa linguagem pode ajudar o computador a “aprender” com os dados da empresa e, a partir disso, conseguir prever o que pode acontecer no futuro.

O script analisará algumas variáveis, tais como investimentos, custos, eficiência e vendas de várias fábricas e, a partir delas, tentar entender como essas variáveis influenciam o desempenho financeiro.

Como o Machine Learning Transforma a Indústria e Otimiza Decisões

O modelo Machine Learning (Scikit-learn, 2024) com Python basicamente ensina o computador a analisar dados de uma indústria e prever se a empresa está indo bem financeiramente ou não. O que acontece é que, em vez de tomar decisões no achismo, o Machine Learning ajuda a entender padrões e sugerir ações mais certeiras.

No nosso exemplo, criamos um modelo que pega informações como investimento, custos, eficiência e vendas de várias fábricas fictícias. Com isso, ele aprende o que funciona e o que não funciona e depois consegue prever qual será o desempenho financeiro de uma empresa com base nesses números.

Ou seja, é como se o computador estudasse a situação e falasse: ‘Ei, se você continuar gastando assim, pode acabar tendo prejuízo!’ ou ‘Se você aumentar a eficiência, pode lucrar mais sem precisar investir tanto!’.

No fim das contas, a ideia é usar Machine Learning e Python para ajudar empresas a tomar decisões mais inteligentes, evitando desperdício e aumentando o lucro.

A Mágica do Funcionamento do Script em Python

Aqui entra a mágica do Machine Learning! No nosso exemplo, criamos um programa em Python que simula a realidade de várias empresas, como se fossem pequenas fábricas fictícias. Ele analisa quatro coisas principais:

1. Quanto dinheiro foi investido na produção.
2. Quais foram os custos (como matéria-prima e funcionários).
3. Quão eficiente a empresa foi (se produziu rápido e sem desperdício).
4. Quanto vendeu no final.

Com base nesses números, o programa tenta prever se a empresa teve um bom desempenho financeiro ou não.

Para que serve isso?

O objetivo é ajudar empresários e gestores a entenderem como suas decisões financeiras afetam os lucros. Se o modelo percebe que altos investimentos nem sempre significam mais lucro, ou que certos custos afetam o resultado, os empresários podem ajustar suas estratégias antes de tomar decisões arriscadas.

Por que usar o Python num Modelo de Machine Learning?

Porque é uma linguagem poderosa e eficiente no contexto do Machine Learnig.

Por Que Python?

• Eficiência e Facilidade de Uso:
• Python é uma linguagem poderosa para cálculos financeiros, graças a bibliotecas como NumPy.
• Interface Gráfica Simples:
• Tkinter permite a criação de interfaces de forma rápida e intuitiva, ideal para protótipos e aplicações internas.
• Geração de Relatórios:
• Com ReportLab, é possível gerar relatórios em PDF de alta qualidade, facilitando a apresentação dos resultados.
• Versatilidade:
• Python é amplamente utilizado em diversas áreas, e esse simulador pode servir de base para outros projetos de análise financeira.

Como funciona o fluxo do projeto

1. Simulação dos Dados (simulacao.py):

O módulo gera um conjunto de dados para um número especificado de empresas. Cada registro contém valores para investimento, custo, eficiência e vendas, e o “desempenho” é calculado por uma fórmula linear (com um toque de ruído aleatório).

2. Interface Gráfica (interface_gráfica.py):

A interface construída com Tkinter permite ao usuário definir quantas empresas serão simuladas, acionar a simulação e visualizar os resultados em uma tabela (Treeview).

3. Geração do Relatório (gerar_relatorio.py):

Ao solicitar a geração do relatório, o módulo usa ReportLab para criar um PDF que inclui uma tabela formatada com os dados simulados. O módulo também utiliza o locale para formatação e a biblioteca tabulate para exibir a tabela formatada no console.

4. Execução Principal (main.py):

O arquivo principal integra a interface gráfica e adiciona um botão para gerar o relatório PDF, coordenando a interação entre os módulos.

Esse exemplo prático pode servir como base para o desenvolvimento do artigo técnico, demonstrando como Python pode ser utilizado para criar modelos de Machine Learning (aqui, simulados) aplicados à análise financeira no setor industrial, integrando diversas bibliotecas para visualização, formatação e geração de relatórios.

Como os dados fictícios são gerados:

1. Definição dos Intervalos de Valores:

Para cada variável (como investimento, custo, eficiência e vendas), definimos um intervalo plausível. Por exemplo:

o   Investimento: Valores entre 50 e 200 (poderia representar milhares de reais).

o   Custo: Valores entre 30 e 150.

o   Eficiência: Percentuais entre 60 e 100.

o   Vendas: Valores entre 100 e 500.

2. Geração Aleatória:

Utilizamos a função random.uniform(min, max) para obter um valor decimal aleatório dentro do intervalo definido. Isso simula a variação natural dos dados financeiros no setor industrial.

3. Cálculo do Indicador de Performance:

Após gerar as variáveis, calculamos a performance utilizando um modelo linear simples (com coeficientes pré-definidos e um intercepto) e adicionamos um ruído aleatório para simular variações reais. Essa fórmula serve como uma “simulação” de um modelo de Machine Learning.

Como podemos observar pela imagem, pelo trecho de código, esses coeficientes são os valores fixos que definimos manualmente para simular um modelo de regressão linear. Cada coeficiente indica o peso que a respectiva variável (investimento, custo, eficiência, vendas) tem na determinação do índice de performance. Por exemplo:

1. Investimento (0.3): Um valor maior de investimento aumenta a performance.
2.   Custo (-0.2): Custos maiores reduzem a performance.
3.   Eficiência (0.5): A eficiência tem um impacto forte e positivo.
4.   Vendas (0.1): As vendas contribuem positivamente, mas com um peso menor.

Esses valores não foram obtidos por meio de um algoritmo de Machine Learning real (como os que a biblioteca Scikit-learn oferece), mas sim escolhidos para exemplificar como um modelo pode combinar diferentes variáveis para calcular um resultado final. Em um cenário real, utilizaráamos a Scikit-learn para treinar um modelo de regressão linear, que encontraria esses coeficientes a partir dos dados históricos.

4. Criação de um Registro para Cada Empresa:

Para cada empresa, montamos um dicionário com os campos:

o   Empresa: Nome fictício (por exemplo, "Empresa 1", "Empresa 2", etc.)

o   Investimento

o   Custo

o   Eficiência

o   Vendas

o   Performance

5. Agrupamento dos Dados:

Esses registros são armazenados em uma lista, que é utilizada posteriormente pela interface gráfica para exibição e pelo módulo de geração de relatórios para criação do PDF.

Com esse método, ao executar a interface gráfica ou chamar a função de simulação diretamente, você gera um conjunto de dados fictícios que pode ser utilizado para demonstrar os conceitos de Machine Learning com Python, análise financeira e a criação de relatórios.

Possíveis Ajustes:

• Personalização dos Intervalos:
• Se desejar, você pode ajustar os intervalos para refletir cenários mais realistas para o setor industrial ou para um segmento específico dentro da indústria.
• Distribuição dos Dados:
• Em vez de usar uma distribuição uniforme, você pode utilizar distribuições estatísticas mais sofisticadas (como a distribuição normal) com a ajuda do módulo numpy.random para simular cenários com variabilidade mais acentuada.
• Dados Adicionais:
• Se o modelo exigir mais variáveis (por exemplo, taxa de crescimento, margem de lucro, etc.), basta adicionar mais campos na função de geração de dados, definindo intervalos e regras para sua criação.

Conclusão

Concluímos, o que vimos aqui é que Machine Learning não é um bicho de sete cabeças, e Python é uma das melhores ferramentas para colocá-lo em prática. Com alguns dados e um modelo bem treinado, conseguimos ensinar o computador a reconhecer padrões e prever cenários que ajudam na tomada de decisões, especialmente no setor industrial.

Se antes as empresas tomavam decisões com base no feeling ou na experiência dos gestores, hoje elas podem contar com a tecnologia para analisar milhões de informações e indicar os melhores caminhos. Isso significa menos erros, mais eficiência e um controle muito maior sobre os negócios.

O diferencial é que esse tipo de tecnologia não está restrita a grandes corporações. Com um pouco de aprendizado e prática, qualquer pessoa pode começar a aplicar Machine Learning para resolver problemas do dia a dia, seja em uma fábrica, no comércio ou até para organizar melhor as finanças pessoais.

Embora o script use coeficientes manuais, ele simula o fluxo de um processo de Machine Learning. Ou seja, ele demonstra como um modelo (como uma regressão linear) combinaria variáveis – investimento, custo, eficiência e vendas – para calcular um índice de performance. Em um cenário real, você usaria a biblioteca Scikit-learn com métodos como o Ordinary Least Squares (OLS) para "treinar" o modelo e determinar esses coeficientes a partir de dados históricos. Essa simulação serve como uma prova de conceito para mostrar como o aprendizado de máquina pode ser aplicado na prática.

Então, se você nunca pensou em aprender Python e Machine Learning, fica o convite! Com as ferramentas certas e um pouco de curiosidade, dá para fazer coisas incríveis e transformar dados em decisões mais inteligentes!

Apêndice: Código-Fonte Completo

A seguir, apresentamos os scripts Python utilizados no projeto.

a) simulacao.py

# src/simulacao.py
import random


def treinar_modelo():
  """
  Simula o treinamento de um modelo de Machine Learning,
  retornando coeficientes fixos e um intercepto.
  """
  coefficients = {
      'investimento': 0.3,
      'custo': -0.2,
      'eficiencia': 0.5,
      'vendas': 0.1
  }
  intercept = 5.0
  return coefficients, intercept


def prever_performance(investimento, custo, eficiencia, vendas, coefficients, intercept):
  """
  Aplica uma fórmula linear com ruído para simular a predição do desempenho financeiro.
  """
  noise = random.uniform(-1, 1)
  score = (coefficients['investimento'] * investimento +
           coefficients['custo'] * custo +
           coefficients['eficiencia'] * eficiencia +
           coefficients['vendas'] * vendas +
           intercept + noise)
  return score


def gerar_dados_simulados(n=10):
  """
  Gera dados fictícios para n empresas, simulando variáveis financeiras e
  calculando o desempenho predito.
  """
  coefficients, intercept = treinar_modelo()
  dados = []
  for i in range(1, n + 1):
      # Gerando valores aleatórios para cada variável
      investimento = round(random.uniform(50, 200), 2)    # Ex: em milhares
      custo = round(random.uniform(30, 150), 2)
      eficiencia = round(random.uniform(60, 100), 2)       # Em porcentagem
      vendas = round(random.uniform(100, 500), 2)
      performance = round(prever_performance(investimento, custo, eficiencia, vendas, coefficients, intercept), 2)
      dados.append({
          'Empresa': f'Empresa {i}',
          'Investimento': investimento,
          'Custo': custo,
          'Eficiência': eficiencia,
          'Vendas': vendas,
          'Performance': performance
      })
  return dados

b) interface_grafica.py

# src/interface_gráfica.py
import tkinter as tk
from tkinter import ttk


# Importações diretas das funções necessárias
from .gerar_relatorio import gerar_relatorio_pdf
from .simulacao import gerar_dados_simulados


class InterfaceGrafica:
  def __init__(self, master):
      self.master = master
      self.master.title("Simulação de Performance Financeira Industrial")
      
      # Frame para entrada de dados
      frame_input = tk.Frame(master)
      frame_input.pack(pady=10)
      
      tk.Label(frame_input, text="Número de Empresas:").grid(row=0, column=0, padx=5)
      self.entrada_n = tk.Entry(frame_input, width=5)
      self.entrada_n.insert(0, "10")
      self.entrada_n.grid(row=0, column=1, padx=5)
      
      self.btn_simular = tk.Button(frame_input, text="Simular Dados", command=self.simular)
      self.btn_simular.grid(row=0, column=2, padx=5)
      
      # Treeview para exibir a tabela dos dados simulados
      self.tree = ttk.Treeview(master, columns=("Investimento", "Custo", "Eficiência", "Vendas", "Performance"), show='headings')
      self.tree.heading("Investimento", text="Investimento")
      self.tree.heading("Custo", text="Custo")
      self.tree.heading("Eficiência", text="Eficiência")
      self.tree.heading("Vendas", text="Vendas")
      self.tree.heading("Performance", text="Performance")
      self.tree.pack(pady=10, fill=tk.BOTH, expand=True)
      
      self.dados_simulados = []  # Armazena os dados simulados


  def simular(self):
      """
      Obtém o número de empresas desejado, gera os dados simulados e os exibe na tabela.
      """
      try:
          n = int(self.entrada_n.get())
      except ValueError:
          n = 10  # Valor padrão se a conversão falhar
      
      self.dados_simulados = gerar_dados_simulados(n)
      # Limpa os dados antigos na Treeview
      for i in self.tree.get_children():
          self.tree.delete(i)
      # Insere os novos dados
      for registro in self.dados_simulados:
          self.tree.insert("", "end", values=(
              registro['Investimento'],
              registro['Custo'],
              registro['Eficiência'],
              registro['Vendas'],
              registro['Performance']
          ))

c) gerar_relatorio.py

# src/gerar_relatorio.py


import locale
import tabulate


from reportlab.lib.pagesizes import letter
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
from reportlab.lib import colors
from reportlab.lib.styles import getSampleStyleSheet


def gerar_relatorio_pdf(dados, nome_arquivo="relatorio_simulacao.pdf"):
  """
  Gera um relatório em PDF com os dados simulados.
  Utiliza o locale para formatação e ReportLab para criação do PDF.
  """
  # Define a localidade para formatação (exemplo para pt_BR)
  try:
      locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')
  except locale.Error:
      locale.setlocale(locale.LC_ALL, '')
  
  # Cria o documento PDF com o tamanho de página "letter"
  doc = SimpleDocTemplate(nome_arquivo, pagesize=letter)
  elementos = []
  styles = getSampleStyleSheet()
  
  # Título do relatório
  titulo = Paragraph("Relatório de Simulação de Performance Financeira Industrial", styles['Title'])
  elementos.append(titulo)
  elementos.append(Spacer(1, 12))
  
  # Monta os dados para a tabela (com cabeçalho)
  tabela_dados = [["Empresa", "Investimento", "Custo", "Eficiência", "Vendas", "Performance"]]
  for registro in dados:
      investimento = locale.currency(registro['Investimento'], grouping=True)
      custo = locale.currency(registro['Custo'], grouping=True)
      eficiencia = f"{registro['Eficiência']}%"
      vendas = locale.currency(registro['Vendas'], grouping=True)
      performance = f"{registro['Performance']:.2f}"
      tabela_dados.append([registro['Empresa'], investimento, custo, eficiencia, vendas, performance])
  
  # Cria a tabela no PDF e aplica estilos
  tabela = Table(tabela_dados)
  tabela.setStyle(TableStyle([
      ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
      ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
      ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
      ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
      ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
      ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
      ('GRID', (0, 0), (-1, -1), 1, colors.black)
  ]))
  elementos.append(tabela)
  
  # Gera o PDF
  doc.build(elementos)
  
  # Exibe a tabela formatada no console usando tabulate para conferência
  print("Relatório Gerado:")
  print(tabulate.tabulate(tabela_dados, headers="firstrow", tablefmt="grid"))


# Bloco de teste: Executa a função se este módulo for o principal
if __name__ == '__main__':
  dados_exemplo = [
      {'Empresa': 'Empresa 1', 'Investimento': 100.0, 'Custo': 50.0, 'Eficiência': 90, 'Vendas': 200.0, 'Performance': 80.0},
      {'Empresa': 'Empresa 2', 'Investimento': 150.0, 'Custo': 70.0, 'Eficiência': 85, 'Vendas': 250.0, 'Performance': 90.0},
  ]
  gerar_relatorio_pdf(dados_exemplo)

d) main.py

# main.py


import tkinter as tk
import tkinter.messagebox as messagebox
from src.interface_grafica import InterfaceGrafica
from src.gerar_relatorio import gerar_relatorio_pdf


def gerar_relatorio_callback(interface):
  """
  Verifica se há dados simulados e, se houver, chama a função
  de geração do relatório PDF.
  """
  if not interface.dados_simulados:
      messagebox.showwarning("Aviso", "Nenhum dado simulado disponível. Por favor, simule os dados primeiro.")
      return
  gerar_relatorio_pdf(interface.dados_simulados)
  messagebox.showinfo("Relatório", "Relatório PDF gerado com sucesso!")


if __name__ == "__main__":
  root = tk.Tk()
  app = InterfaceGrafica(root)
  
  # Botão para gerar o relatório PDF
  btn_relatorio = tk.Button(root, text="Gerar Relatório PDF", command=lambda: gerar_relatorio_callback(app))
  btn_relatorio.pack(pady=10)
  
  root.mainloop()

Siga-me no LinkedIn: www.linkedin.com/comm/mynetwork/discovery-see-all?usecase=PEOPLE_FOLLOWS&followMember=izairton-oliveira-de-vasconcelos-a1916351

Minha Newsletter, o link para assinar:https://www.linkedin.com/build-relation/newsletter-follow?entityUrn=7287106727202742273

https://lnkd.in/d4a_8ySV

https://github.com/IOVASCON/simulador_ml_industria.git