Pular para conteúdo

SLTINTA - Ementa - Plano de Aula - Slide da aula

🎯 Objetivo

  • Introdução ao Aprendizado de Máquina (Machine Learning);
  • Visão Geral de um Projeto de IA:
    • estabelecendo a fase de Definição do Escopo e mapeamento requisitos na Indústria 4.0 (Manutenção Preditiva).

🔴 Situação-Problema Contextualizada

Você foi contratado como Engenheiro de IA para compor a equipe de desenvolvimento de uma grande planta siderúrgica que opera 24 horas por dia. O principal ativo da fábrica é uma estação de usinagem CNC de alto desempenho. Recentemente, a quebra inesperada do cabeçote de corte dessa máquina causou uma parada na linha de produção que durou 36 horas, gerando um prejuízo estimado em R$ 150.000,00 entre peças de reposição urgentes, ociosidade da equipe e multas por atraso na entrega dos produtos aos clientes.

A gerência de manutenção possui sensores que medem variáveis físicas da máquina a cada segundo, mas atualmente esses dados são apenas visualizados em telas isoladas e descartados. O seu desafio no semestre é interligar essa telemetria e criar um sistema inteligente capaz de prever uma falha mecânica com antecedência, permitindo que a equipe agende o reparo durante uma pausa planejada de produção.

🏁 Descritivo de Metas da Atividade Prática

Para dar o primeiro passo na resolução do problema da siderúrgica, sua equipe deverá atingir as seguintes metas nesta primeira sessão de laboratório:

  • Meta 1: Validar a integridade do histórico de telemetria fornecido pela fábrica (dataset), mapeando os tipos de dados de cada sensor e identificando se há registros nulos ou corrompidos.

  • Meta 2: Quantificar estatisticamente a distribuição das classes de falha para entender a frequência real das quebras e a severidade do desbalanceamento dos dados.

  • Meta 3: Descobrir, por meio de matrizes de correlação inicial, quais sensores (ex: temperatura ou vibração) demonstram maior vínculo linear imediato com o comportamento de quebra da máquina.

🛠️ Ferramentas

🧠 Conhecimento Teórico

  • Conceitos de IA na Indústria: Diferença conceitual, operacional e financeira entre as estratégias de manutenção corretiva, preventiva e preditiva.

  • Taxonomia do Aprendizado de Máquina: O papel do Aprendizado Supervisionado (focado em Classificação Binária para o rótulo de falha) e do Aprendizado Não Supervisionado.

  • Ciclo de Vida de Projetos de Dados: Introdução à metodologia CRISP-DM, com ênfase nas fases de Entendimento do Negócio e Entendimento dos Dados.

💻 Atividade Prática

Análise Exploratória de Dados (EDA) do Ativo Industrial

  1. Carregar o arquivo CSV contendo os dados dos sensores usando pd.read_csv().

  2. Inspecionar a estrutura volumétrica e os tipos de dados das colunas (df.info() e df.describe()).

  3. Isolar as variáveis preditoras (Features: temperatura ambiente, velocidade de rotação, torque, desgaste) da variável alvo (Target: falha da máquina).

  4. Plotar um gráfico de barras volumétrico da variável alvo para evidenciar visualmente a raridade do evento de quebra.

  5. Gerar um mapa de calor (Heatmap) de correlação de Pearson para identificar dependências numéricas entre as temperaturas do processo e o desgaste da ferramenta.

Ambiente Virtual - Virtual Environment

Um Virtual Environment (Ambiente Virtual) é uma ferramenta que permite a criação de um espaço isolado para o desenvolvimento de projetos em Python, sendo uma prática fortemente recomendada na área de desenvolvimento de software e ciência de dados.

Propósito Principal

O objetivo central é permitir que você trabalhe em diferentes projetos na mesma máquina sem que as versões das bibliotecas entrem em conflito. Por exemplo, um projeto industrial pode exigir uma versão específica do TensorFlow que é incompatível com a versão necessária para outro estudo; o ambiente virtual resolve isso isolando as dependências de cada um.

Funcionamento

  • Isolamento: Quando um ambiente virtual está ativo, qualquer pacote instalado via pip será instalado apenas dentro daquela pasta específica.
  • Acesso Restrito: O interpretador Python passará a ter acesso apenas às bibliotecas contidas naquele ambiente, ignorando os pacotes instalados globalmente no sistema (a menos que seja configurado de outra forma).
  • Ciclo de Uso: Geralmente, o usuário cria o ambiente, ativa-o (usando comandos como source env/bin/activate no Linux/macOS ou .\env\Scripts\activate no Windows) para trabalhar e, ao terminar, utiliza o comando deactivate para sair.

Ferramentas Comuns

  • virtualenv: Uma das ferramentas mais tradicionais para criar esses ambientes isolados.
  • Anaconda (Conda): Outra alternativa popular que permite criar ambientes com versões específicas do Python (ex: conda create -n meu_projeto python=3.5) e gerenciar dependências de forma robusta.

Alternativas em Nuvem

Plataformas como o Google Colab funcionam como ambientes virtuais baseados na nuvem. Elas eliminam a necessidade de instalação e configuração local, já vindo com as principais bibliotecas de aprendizado de máquina (como Pandas, NumPy e TensorFlow) pré-instaladas, garantindo que diferentes usuários obtenham os mesmos resultados ao executar o código.

Usando um ambiente virtual

1) Criando o ambiente virtual

python3 -m venv venv_sltinta

2) Carregando o ambiente virtual

source venv_sltinta/bin/activate

3.0) Instalando bibliotecas básicas

pip install pandas numpy matplotlib seaborn

3.1) Listando bibliotecas (requisitos) instaladas

pip freeze

3.1.1) Listando e salvando bibliotecas (requisitos) instaladas 

pip freeze > requirements.txt
Obs: Executar após todos os requisitos do projeto estarem instalados ou sempre que um novo requisito for instalado.

3.1.2) Instalando requisitos de arquivo

pip install -r requirements.txt

3.2) Instalando kernel para Jupyter 

pip install ipykernel

4) Adicionando o ambiente virtual à lista de kernels

python3 -m ipykernel install --user --name=venv_sltinta

4.1) Excluindo o ambiente virtual da lista de kernels

jupyter-kernelspec uninstall venv_sltinta

5) Executando Jupyter notebook

Apenas se estiver instalado no computador. 

jupyter-lab
# ou
jupyter-notebook

Notebook

import pandas as pd

df = pd.read_csv('dataset/ai4i2020.csv')

Meta 1: Validação dos dados

Validar a integridade do histórico de telemetria fornecido pela fábrica (dataset), mapeando os tipos de dados de cada sensor e identificando se há registros nulos ou corrompidos.

1. Mapeamento dos Tipos de Dados (dtypes)

O primeiro passo é garantir que o Python interpretou os dados corretamente (ex: se um sensor de temperatura está como número e a timestamp como data, e não como texto/string).

# Validação do tipo de dado
df.columns

df.info()

import pandera.pandas as pa

schema = pa.DataFrameSchema(
    columns={
                'UDI':                      pa.Column('int64'),
                'Product ID':               pa.Column('str'),
                'Type':                     pa.Column('str'),
                'Air temperature [K]':      pa.Column('float64'),
                'Process temperature [K]':  pa.Column('float64'), 
                'Rotational speed [rpm]':   pa.Column('int64'), 
                'Torque [Nm]':              pa.Column('float64'),
                'Tool wear [min]':          pa.Column('int64'), 
                'Machine failure':          pa.Column('int64'), 
                'TWF':                      pa.Column('int64'), 
                'HDF':                      pa.Column('int64'), 
                'PWF':                      pa.Column('int64'), 
                'OSF':                      pa.Column('int64'),
                'RNF':                      pa.Column('int64')
    }
)

schema.validate(df)

2. Identificando Registros Nulos (Missing Values)

Sensores falham e deixam buracos. Para mapear quantos nulos existem por sensor, tanto em números absolutos quanto em porcentagem:

# Identificando registros nulos

# Contagem absoluta de nulos
nulos_por_sensor = df.isnull().sum()

# Porcentagem de nulos
porcentagem_nulos = (df.isnull().sum() / len(df)) * 100

# Criando uma tabela de diagnóstico
diagnostico_nulos = pd.DataFrame({
    'Total Nulos': nulos_por_sensor,
    'Porcentagem (%)': porcentagem_nulos
}).sort_values(by='Porcentagem (%)', ascending=False)

print("\n--- Relatório de Dados Ausentes ---")
print(diagnostico_nulos)

3. Identificando Dados Corrompidos (Outliers e Anomalias)

Dados corrompidos nem sempre são nulos. Às vezes, um sensor travou em um valor impossível (ex: temperatura de \(-999°C\) ou \(9999°C\)) ou enviou uma string corrompida.Para pegar esses "falsos dados", use o método .describe() para olhar os valores mínimos, máximos e quartis:

Como identificar os corrompidos aqui: - Mínimos/Máximos absurdos: Um sensor de pressão que bateu \(0\) ou um valor absurdamente alto do nada. - Desvio Padrão (std) igual a zero: Significa que o sensor travou no mesmo valor para sempre.Se você quiser criar uma regra customizada para marcar dados corrompidos (ex: temperatura fora da faixa de \(-10°C\) a \(120°C\)):

# Criando uma máscara de dados corrompidos
limite_min, limite_max = 295.3, 304.5
dados_corrompidos = df[(df['Air temperature [K]'] < limite_min) | (df['Air temperature [K]'] > limite_max)]

print(f"Quantidade de registros corrompidos no sensor de temperatura: {len(dados_corrompidos)}")

def validar_integridade(dataframe):
    validacao = pd.DataFrame({
        'Tipo de Dado': dataframe.dtypes,
        'Qtd Nulos': dataframe.isnull().sum(),
        '% Nulos': (dataframe.isnull().sum() / len(dataframe)) * 100,
        'Valores Únicos': dataframe.nunique()
    })
    return validacao

print(validar_integridade(df))

Meta 2: Quantificar a distribuição das classes de falhas

Quantificar estatisticamente a distribuição das classes de falha para entender a frequência real das quebras e a severidade do desbalanceamento dos dados.

df[(df['Machine failure'] > 0)]

df['Machine failure'].loc[df['Machine failure'] > 0].count()

df['Machine failure'].eq(1).sum()

len(df['Machine failure'])

TWF (Tool Wear Failure): 120 casos (A ferramenta desgasta e falha/é trocada de forma crítica).

HDF (Heat Dissipation Failure): 115 casos (Superaquecimento por falta de dissipação térmica).

OSF (Overstrain Failure): 98 casos (A tensão gerada pelo produto entre torque e desgaste passa do limite).

PWF (Power Failure): 95 casos (A potência consumida cai abaixo de 3500W ou passa de 9000W).

RNF (Random Failure): 5 casos (Falhas puramente aleatórias de 0,1% de chance ocorridas no processo).

mf = df['Machine failure'].eq(1).sum()/len(df['Machine failure'])
print("Falha de máquina: ", mf*100, "%")

mf = df['TWF'].eq(1).sum()/len(df['TWF'])
print("TWF: ", mf*100, "%")

mf = df['HDF'].eq(1).sum()/len(df['HDF'])
print("HDF: ", mf*100, "%")

mf = df['PWF'].eq(1).sum()/len(df['PWF'])
print("PWF: ", mf*100, "%")

mf = df['OSF'].eq(1).sum()/len(df['OSF'])
print("OSF: ", mf*100, "%")

mf = df['RNF'].eq(1).sum()/len(df['RNF'])
print("RNF: ", mf*100, "%")

Meta 3: Quais Sensores possuem vínvulo imediado com a quebra da máquina

Descobrir, por meio de matrizes de correlação inicial, quais sensores (ex: temperatura ou vibração) demonstram maior vínculo linear imediato com o comportamento de quebra da máquina.

#sensores=['Air temperature [K]','Process temperature [K]', 'Rotational speed [rpm]', 'Torque [Nm]','Tool wear [min]', 'Machine failure', 'TWF', 'HDF', 'PWF', 'OSF','RNF']
sensores = {
    'Air temperature [K]': 'Temp_Ambiente_K',
    'Process temperature [K]': 'Temp_Processo_K',
    'Rotational speed [rpm]': 'Velocidade_Rotacao_RPM',
    'Torque [Nm]': 'Torque_Nm',
    'Tool wear [min]': 'Desgaste_Ferramenta_min',
    'Machine failure': 'Falha_Maquina'
}
df_analise = df[list(sensores.keys())].rename(columns=sensores)

# Calcular a Matriz de Correlação de Pearson
matriz_corr = df_analise.corr()
matriz_corr

# Isolar a correlação estritamente com o alvo (ordenada do maior para o menor)
corr_com_alvo = matriz_corr[['Falha_Maquina']].drop('Falha_Maquina').sort_values(by='Falha_Maquina', ascending=False)
corr_com_alvo

print("--- Correlação Linear de Pearson com a Falha da Máquina ---")
print(corr_com_alvo)

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

# 5. Plotar o Heatmap da Matriz Completa
plt.figure(figsize=(8, 6))
sns.heatmap(matriz_corr, annot=True, cmap='RdBu_r', fmt=".3f", vmin=-1, vmax=1, linewidths=0.5)
plt.title('Matriz de Correlação Linear dos Sensores')
plt.tight_layout()
plt.show()

def matriz_correlacao_linear_sensores( failure, falha ):
    sensores = {
        'Air temperature [K]': 'Temp_Ambiente_K',
        'Process temperature [K]': 'Temp_Processo_K',
        'Rotational speed [rpm]': 'Velocidade_Rotacao_RPM',
        'Torque [Nm]': 'Torque_Nm',
        'Tool wear [min]': 'Desgaste_Ferramenta_min',
        failure: falha
    }
    df_analise = df[list(sensores.keys())].rename(columns=sensores)
    matriz_corr = df_analise.corr()
    corr_com_alvo = matriz_corr[[falha]].drop(falha).sort_values(by=falha, ascending=False)

    plt.figure(figsize=(8, 6))
    sns.heatmap(matriz_corr, annot=True, cmap='RdBu_r', fmt=".3f", vmin=-1, vmax=1, linewidths=0.5)
    plt.title('Matriz de Correlação Linear dos Sensores')
    plt.tight_layout()
    plt.show()

matriz_correlacao_linear_sensores('TWF', 'Falha de Desgaste de Ferramenta')

# heat dissipation failure (HDF) - Falha de dissipação de calor
matriz_correlacao_linear_sensores('HDF', 'Falha de dissipação de calor')

# power failure (PWF) - falha de energia
matriz_correlacao_linear_sensores('PWF', 'Falha de Energia')

# overstrain failure (OSF) - falha de tensão excessiva
matriz_correlacao_linear_sensores('OSF', 'Falha de tensão excessiva')

# random failures (RNF) - Falha aleatória
matriz_correlacao_linear_sensores('RNF', 'Falhas aleatorias')