Unidad 3: IA y Analítica

Día 7: Fundamentos de Inteligencia Artificial

La transición de automatización rígida (3.0) a fábricas inteligentes auto-optimizadas (4.0) depende de la capacidad del software para aprender y tomar decisiones autónomas basadas en datos.

Temario de Hoy:

  • **Machine Learning:** Modelos supervisados y no supervisados.
  • **Redes Neuronales:** Estructura de capas, sinapsis y optimización.
  • **Procesamiento de Lenguaje (NLP):** Tokenización y modelos de lenguaje.
  • **Práctica:** Sandbox interactivo de optimización de hiperparámetros.
🧠
El Cerebro de la Fábrica

La IA transforma telemetría de sensores crudos en acciones mecánicas predictivas de alta precisión.

Machine Learning

¿Cómo Aprende una Máquina?

🟢 Aprendizaje Supervisado

El modelo se entrena con pares de entrada-salida etiquetados (datos históricos con fallas registradas).

  • **Clasificación:** Detectar si una pieza es Correcta o Defectuosa.
  • **Regresión:** Predecir el valor numérico exacto de vibración futura.

🔵 Aprendizaje No Supervisado

El modelo analiza datos crudos sin etiquetas e identifica anomalías o agrupaciones naturales por sí mismo.

  • **Clustering (K-Means):** Clasificar patrones de trabajo de motores.
  • **Detección de Anomalías:** Identificar lecturas inusuales en sensores de corriente.
Deep Learning

Anatomía de una Red Neuronal

Las Redes Neuronales Artificiales consisten en capas de nodos (neuronas) interconectados por ponderaciones llamadas **Pesos (Weights)** y **Sesgos (Biases)**.

  • **Capa de Entrada:** Recibe la telemetría (temperatura, vibración, RPM).
  • **Capas Ocultas:** Ejecutan transformaciones no lineales complejas usando funciones de activación (ej: ReLU).
  • **Capa de Salida:** Entrega la probabilidad (ej: 92% de probabilidad de fallo de correa).

Ajuste de Pesos: Backpropagation

Durante el entrenamiento, las predicciones erróneas se retropropagan del final hacia el principio de la red. Usando cálculo diferencial (descenso de gradiente), se reajustan los pesos y sesgos para reducir la pérdida.

Fórmula de Pérdida → Derivadas parciales → Ajuste de Pesos
NLP y Modelos de Lenguaje

Procesamiento del Lenguaje Natural (NLP)

El NLP industrial permite que los operarios interactúen directamente con los sistemas de control utilizando lenguaje humano y que la IA interprete bitácoras y manuales técnicos.

  • **Tokenización:** Dividir textos de fallas (ej: "Error Modbus E-2") en sub-palabras o tokens inteligibles.
  • **Embeddings:** Representar palabras como vectores numéricos. Palabras similares (ej: "motor", "turbina") se agrupan geométricamente.
  • **Modelos Fundacionales (LLMs):** Modelos preentrenados a escala masiva para resumir manuales y diagnosticar fallas de maquinaria.
# Proceso de Vectorización (Embedding)
Texto: "Falla de lubricación en motor"
Tokens: ["Falla", "_de", "_lubri", "cación", "_en", "_motor"]
Vector: [0.12, -0.45, 0.89, ..., 0.34]
/* Permite a modelos semánticos como Gemini razonar y relacionar fallas con soluciones */
Algoritmos de Machine Learning

Algoritmos de Machine Learning Clásicos

Regresión Lineal

Modelado de la relación lineal entre variables independientes y dependientes continuas.

Uso: Estimación del desgaste mecánico lineal de brocas CNC.

Regresión Logística

Modelo probabilístico para predecir la clasificación binaria (Verdadero / Falso).

Uso: Predecir si la soldadura superará el control de calidad (0 o 1).

Árboles de Decisión

Diagrama de flujo lógico de ramificaciones consecutivas que evalúa condiciones.

Uso: Diagnóstico secuencial lógico de averías en compresores.

Entorno de Desarrollo

Desarrollo en Python: Jupyter & Scikit-Learn

El flujo de trabajo en analítica y modelado se facilita mediante herramientas de programación interactivas en Python:

  • **Jupyter Notebooks:** Celdas de código interactivas que facilitan la experimentación, graficado rápido de telemetría y pruebas.
  • **Scikit-Learn:** Librería que contiene algoritmos de regresión, clasificación y clustering listos para entrenarse en 3 líneas de código.
import pandas as pd
from sklearn.linear_model import LinearRegression
# 1. Cargar datos
df = pd.read_csv("datos_sensores.csv")
# 2. Instanciar y entrenar modelo
model = LinearRegression()
model.fit(df[['temperatura']], df['vibracion'])
# 3. Predecir desgaste futuro
model.predict([[82.5]])
Simulación de Entrenamiento

Sandbox: Simulador de Red Neuronal

Error Final: --
Precisión Final: --
Curva de Pérdida (Loss) vs Épocas
Verificación Conceptual

Cuestionario de Validación: Día 7

Pregunta 1 de 3
Puntuación: 0/3
Cargando pregunta...
Gamificación Académica

Minijuego: Optimizador de Hiperparámetros

Línea de Optimización del Modelo IA
1 Niv 1
🔒 Niv 2
🔒 Niv 3
🔒 Niv 4
🔒 Niv 5
Puntuación: 0 Pts
Vidas: ❤️ ❤️ ❤️
Nivel 1: El Gradiente
¿Pregunta del nivel de juego?
Feedback...
Resumen del Día 7

Conclusiones e Integración

La Inteligencia Artificial representa el cerebro analítico que permite procesar telemetría e implementar mantenimiento predictivo.

Conceptos Clave Asimilados:
Redes Neuronales, pesos y sesgos, optimización mediante retropropagación y división de texto semántico en NLP.

Día 7 Completado

Mañana estudiaremos aplicaciones prácticas directas en planta: Mantenimiento Predictivo e Inspección Óptica.

🧠 ⚙️ 🏆
Volver al Portal de Inicio
1 / 10
Notas de Presentador (Teclado: S)
Cargando notas...
Entrenamiento de IA / Machine Learning

Guía Práctica Exacta: Entrenamiento ML en Jupyter

Paso 1: Entorno de Desarrollo (Google Colab)

Google Colab nos permite programar en Python de forma interactiva en la nube, sin necesidad de realizar configuraciones locales complejas en la computadora.

  1. Abre tu navegador e ingresa a **[colab.research.google.com](https://colab.research.google.com)**.
  2. Inicia sesión con tu cuenta de Google.
  3. Haz clic en **"Nuevo cuaderno" (New Notebook)** en la esquina inferior izquierda.
  4. En el nombre del archivo (arriba a la izquierda), escribe **taller_ia_dia7.ipynb**.
Google Colaboratory
📁 Archivo | Editar | Ver | Insertar
[ ] # celda de codigo inicial de Python
Entorno Conectado a Python 3 Google Compute Engine

Paso 2: Cargar y Estructurar Datos Históricos

Importaremos las lecturas históricas de sensores del archivo `datos_sensores_mockaroo.csv`. Contiene telemetría real-simulada de operación del motor.

  1. Crea una celda de código en Colab e introduce el código que se muestra al lado.
  2. Importa la librería **Pandas**, el estándar para analítica de datos en Python.
  3. Carga el archivo mediante pd.read_csv (puedes subir el archivo CSV local a la barra lateral izquierda del navegador).
  4. Imprime el resumen de dimensiones para ver las filas cargadas.
Cargar datos en Colab
# Copia este codigo en Colab:
import pandas as pd
url = "datos_sensores_mockaroo.csv"
df = pd.read_csv(url)
print("Registros cargados:", len(df))
print(df.head(2))

Paso 3: Graficar Relación de Parámetros

Graficaremos la Temperatura contra la Vibración utilizando **Matplotlib** para visualizar y comprobar el comportamiento lineal del desgaste mecánico.

  1. Crea una nueva celda de código en Colab.
  2. Usa plt.scatter asignando la columna **temperatura** al eje X, y la columna **vibracion** al eje Y.
  3. Agrega títulos y cuadrícula para facilitar la lectura visual.
  4. Ejecuta la celda para generar e inspeccionar la gráfica resultante en pantalla.
Visualizacion en Colab
# Graficar telemetria
import matplotlib.pyplot as plt
plt.scatter(df['temperatura'], df['vibracion'], color='purple', alpha=0.5)
plt.xlabel('Temperatura (°C)')
plt.ylabel('Vibracion (mm/s)')
plt.grid(True)
plt.show()

Paso 4: Entrenar el Modelo Scikit-Learn

Entrenaremos un modelo de Regresión Lineal clásico para hallar la recta óptima de predicción matemática en los datos del motor.

  1. Importa la clase LinearRegression del módulo sklearn.linear_model.
  2. Prepara los datos de entrenamiento: la entrada X debe ser un DataFrame bidimensional df[['temperatura']] y la salida y unidimensional.
  3. Instancia el modelo y ejecuta .fit(X, y) para realizar el entrenamiento matemático en milisegundos.
Entrenamiento ML
from sklearn.linear_model import LinearRegression
X = df[['temperatura']]
y = df['vibracion']
# Instanciar y ajustar recta
modelo = LinearRegression()
modelo.fit(X, y)
print("Entrenamiento Completado.")
print("Coeficiente/Pendiente:", modelo.coef_[0])

Paso 5: Predecir Valores y Evaluar Alerta

Ejecutaremos predicciones sobre lecturas críticas no registradas (ej: 85.0°C) y evaluaremos si el nivel de vibración predicho dispara alertas de fallo mecánico.

  1. Llama a modelo.predict([[85.0]]) para estimar la vibración mecánica.
  2. Define un umbral físico tolerable (ej: **4.5 mm/s**).
  3. Escribe una estructura condicional `if/else` en Python para evaluar el resultado.
  4. Si la predicción excede el umbral, imprime una alerta detallada. ¡Listo! Has implementado tu primer modelo predictivo de IA.
Predicciones y Alerta
# Predecir vibración a 85°C
temp_critica = [[85.0]]
vibracion_predicha = modelo.predict(temp_critica)
print(f"Prediccion: {vibracion_predicha[0]:.2f} mm/s")
# Evaluar alerta
limite = 4.5
if vibracion_predicha[0] > limite:
print("⚠️ ALERTA: Programar Mantenimiento")
else:
print("✅ Operacion Normal")
Resultado de Predicción
Temperatura:85.0 °C
Vibración Estimada:4.82 mm/s
⚠️ SUGERIDO: Mantenimiento Predictivo