""

domingo, 8 de noviembre de 2026

Inmersión en la librería Reliability de Python

Fuente: IA, Gemini Notebook

La librería reliability es una herramienta especializada de Python creada específicamente para la ingeniería de confiabilidad y el análisis de supervivencia. Amplía sustancialmente las capacidades de librerías tradicionales como scipy.stats, ofreciendo funciones especializadas para el modelado probabilístico, el tratamiento de datos censurados y la optimización del mantenimiento.

A continuación se detalla cómo utilizar sus principales módulos y funciones con ejemplos de código listos para Google Colab.


1. Instalación e Importación

Para comenzar en Google Colab, se debe instalar la librería mediante pip:

!pip install reliability -q

Sus módulos principales se organizan en:

  • reliability.Fitters: Ajuste de distribuciones paramétricas a datos de fallas (Weibull, Exponencial, Lognormal, etc.).
  • reliability.Distributions: Creación y evaluación directa de distribuciones probabilísticas.
  • reliability.Other_functions: Herramientas auxiliares como generación y manejo de datos censurados.
  • reliability.Repairable_systems: Modelos para sistemas reparables (ROCOF, tiempo óptimo de reemplazo).

2. Ajuste de Modelos de Falla (Fitters)

El caso de uso más común es ajustar un modelo estadístico a partir de los tiempos hasta la falla observados en campo.

Ejemplo A: Ajuste de Weibull de 2 Parámetros (Fit_Weibull_2P)

Permite calcular los parámetros de escala (\(\alpha\)) y forma (\(\beta\)) a partir de un conjunto de fallas y datos censurados:

from reliability.Fitters import Fit_Weibull_2P
from reliability.Other_functions import make_right_censored_data
import numpy as np

# 1. Tiempos de vida simulados
tiempos_originales = np.random.weibull(a=2, size=100) * 1000

# 2. Aplicar censura a la derecha (equipos que no han fallado al llegar a las 1500 horas)
datos_censurados = make_right_censored_data(tiempos_originales, threshold=1500)

# 3. Ajustar el modelo de Weibull de 2 parámetros
modelo_wb = Fit_Weibull_2P(
    failures=datos_censurados.failures,
    right_censored=datos_censurados.right_censored,
    show_probability_plot=True,
    print_results=True
)

Ejemplo B: Ajustar todas las distribuciones disponibles (Fit_Everything)

Si no sabes qué distribución se adecúa mejor a tus datos, Fit_Everything evalúa múltiples modelos (Weibull, Lognormal, Gamma, Normal, Exponencial) y los ordena según su ajuste estadístico (BIC/AIC):

from reliability.Fitters import Fit_Everything

# Evalúa y compara automáticamente todos los modelos de distribución disponibles
resultados = Fit_Everything(failures=datos_censurados.failures, right_censored=datos_censurados.right_censored)

3. Evaluación de Métricas de Confiabilidad y Tasa de Fallas

Una vez ajustado el modelo (objeto wb), puedes consultar métricas exactas en cualquier horizonte de tiempo \(t\):

  • Función de Supervivencia / Confiabilidad \(R(t)\) (.SF(t)): Mide la probabilidad de operar sin fallas más allá del tiempo \(t\).
  • Función de Riesgo / Tasa de Fallas \(h(t)\) (.HF(t)): Mide la tasa instantánea de ocurrencia de fallas a las \(t\) horas.
  • Función de Densidad de Probabilidad (.PDF(t)) y Acumulada (.CDF(t)).
tiempo_evaluación = 500 # horas

# Probabilidad de sobrevivir a las 500 horas
confiabilidad = modelo_wb.distribution.SF(tiempo_evaluación)

# Tasa instantánea de falla a las 500 horas
tasa_falla = modelo_wb.distribution.HF(tiempo_evaluación)

print(f"Confiabilidad a t={tiempo_evaluación}h: {confiabilidad:.4f}")
print(f"Tasa de fallas a t={tiempo_evaluación}h: {tasa_falla:.6f} fallas/hora")

4. Creación Directa de Distribuciones (Distributions)

Si ya conoces los parámetros del fabricante o de un estudio previo, puedes instanciar directamente el modelo sin necesidad de ajustar datos:

from reliability.Distributions import Weibull_Distribution
import matplotlib.pyplot as plt

# Definir una distribución Weibull conocida (alfa=escala=1200 hrs, beta=forma=2.5)
distribucion_bomba = Weibull_Distribution(alpha=1200, beta=2.5)

# Graficar la curva de densidad y supervivencia
distribucion_bomba.PDF.plot()
distribucion_bomba.SF.plot()
plt.show()

5. Análisis de Sistemas Reparables y Reemplazo Óptimo (Repairable_systems)

Para la gestión estratégica de activos, el módulo Repairable_systems ofrece algoritmos para calcular la frecuencia de reemplazo preventivo que minimice los costos acumulados:

  • optimal_replacement_time: Determina el intervalo óptimo de sustitución equilibrando el costo del mantenimiento preventivo frente al costo de una falla imprevista.
  • ROCOF (Rate of Occurrence of Failures): Evalúa si la tasa de fallas de un sistema reparable está aumentando (degradación) o disminuyendo (aprendizaje/mejora) a lo largo del tiempo.

💡 ¿Te gustaría armar un cuaderno completo en Colab orientado a optimizar el intervalo de mantenimiento preventivo o a analizar diagramas de bloques de confiabilidad (RBD)?

Gráficos de los casos RAM

 Por alguna razón que desconozco en la entrada anterior no se muestran los gráficos de los casos RAM

Grafico del caso 1. R(t) y Mantenibilidad



Grafico del caso 2. CDF weibull 2P


3 Ejemplos de Análisis RAM resueltos con Python

Fuente: IA, Gemini notebook

¡Las fuentes han sido agregadas exitosamente a tu libreta!

A continuación encontrarás 3 ejemplos prácticos y resueltos de análisis RAM explicados paso a paso, listos para copiar y ejecutar en Google Colab.


Caso 1: Cálculo de Métricas Fundamentales RAM (MTBF, MTTR y Disponibilidad)

Este ejemplo analiza el historial de paradas de un equipo para calcular sus indicadores clave:

  • MTBF (Mean Time Between Failures / Tiempo Medio Entre Fallas).
  • MTTR (Mean Time To Repair / Tiempo Medio Para Reparar).
  • Disponibilidad Inherente (\(A\)): \(A = \frac{\text{MTBF}}{\text{MTBF} + \text{MTTR}}\).
  • Confiabilidad \(R(t)\) y Mantenibilidad \(M(t)\) asumiendo tasa de falla constante.
# Instalar e importar librerías necesarias
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 1. Datos simulados de eventos de parada (TBF en horas, TTR en horas)
data = {
    'Evento':[1, 2, 3, 4, 5, 6, 7, 8],
'TBF_horas':, # Tiempos operando hasta la falla 'TTR_horas': [8.5, 12.0, 6.0, 15.5, 9.0, 11.0, 7.5, 13.0] # Tiempos de reparación } df = pd.DataFrame(data)
# 2. Cálculo de indicadores principales mtbf = df['TBF_horas'].mean() mttr = df['TTR_horas'].mean() disponibilidad = mtbf / (mtbf + mttr) tasa_fallas_lambda = 1 / mtbf tasa_reparacion_mu = 1 / mttr print(f"--- INFORME DE MÉTRICAS RAM ---") print(f"MTBF: {mtbf:.2f} horas") print(f"MTTR: {mttr:.2f} horas") print(f"Disponibilidad Operacional (A): {disponibilidad * 100:.2f}%") print(f"Tasa de fallas (lambda): {tasa_fallas_lambda:.6f} fallas/hora") print(f"Tasa de reparación (mu): {tasa_reparacion_mu:.6f} reparaciones/hora\n") # 3. Curvas de Confiabilidad R(t) y Mantenibilidad M(t) para un horizonte de 500 horas tiempo = np.linspace(0, 500, 100) confiabilidad = np.exp(-tasa_fallas_lambda * tiempo) mantenibilidad = 1 - np.exp(-tasa_reparacion_mu * tiempo) # 4. Graficar resultados plt.figure(figsize=(10, 4)) plt.subplot(1, 2, 1) plt.plot(tiempo, confiabilidad, color='blue', lw=2) plt.title('Confiabilidad R(t)') plt.xlabel('Tiempo de operación (horas)') plt.ylabel('Probabilidad de no fallar') plt.grid(True) plt.subplot(1, 2, 2) plt.plot(tiempo, mantenibilidad, color='green', lw=2) plt.title('Mantenibilidad M(t)') plt.xlabel('Tiempo de reparación (horas)') plt.ylabel('Probabilidad de restaurar') plt.grid(True) plt.tight_layout() plt.show()


Implementación del caso 1 en Google Colab

En PPI preferimos introducir los valores de la clave 'Evento' en el
diccionario de datos simulados, como letras para evitar confundirlos con valores de tiempos.


# 1. Datos simulados de eventos de parada (TBF en horas, TTR en horas) data = { 'Evento': ['E1', 'E2', 'E3', 'E4', 'E5', 'E6', 'E7', 'E8'], 'TBF_horas': [120, 340, 560, 670, 1180, 2340, 1500, 1900], # Tiempos operando hasta la falla 'TTR_horas': [8.5, 12.0, 6.0, 15.5, 9.0, 11.0, 7.5, 13.0] # Tiempos de reparación } df = pd.DataFrame(data)

# 2. Cálculo de indicadores principales
--- INFORME DE MÉTRICAS RAM ---
MTBF: 1076.25 horas
MTTR: 10.31 horas
Disponibilidad Operacional (A): 99.05%
Tasa de fallas (lambda): 0.000929 fallas/hora
Tasa de reparación (mu): 0.096970 reparaciones/hora

# 3. Curvas de Confiabilidad R(t) y Mantenibilidad M(t) para un horizonte de 500 horas

# 4. Graficar resultados


Del grafico de confiabilidad R(t), podemos observar que la confiabilidad disminuye a medida
que las horas de operación aumentan. Cuando se tienen 500 horas de operación, la confiabilidad
se reduce a menos del 65%.

Caso contrario ocurre con la mantenibilidad, esta crece a medida que aumentan las horas
de operación, alcanzando su máximo aproximadamente antes de las primeras 50 horas de operación.



Caso 2: Modelado Estadístico de Fallas con Distribución de Weibull

El análisis RAM avanzado utiliza la distribución de Weibull de 2 parámetros para identificar en qué fase de la curva de la tina se encuentra el equipo:

  • Forma (\(\beta\)): Si \(\beta < 1\) (mortalidad infantil), \(\beta \approx 1\) (fallas aleatorias), \(\beta > 1\) (desgaste por envejecimiento).
  • Escala (\(\eta\) o \(\alpha\)): Vida característica del equipo (tiempo al que ha fallado el 63.2% de la población).

En Colab, instalamos e importamos la librería especializada reliability:

# Ejecutar en una celda de Google Colab
!pip install reliability -q

import matplotlib.pyplot as plt
from reliability.Fitters import Fit_Weibull_2P

# Tiempos de falla registrados (en horas de funcionamiento)
tiempos_falla =[120, 240, 350, 480, 590, 710, 850, 990, 1150, 1300, 1500]
# Ajuste de Weibull de 2 parámetros (alpha = escala, beta = forma) modelo_weibull = Fit_Weibull_2P(failures=tiempos_falla, print_results=True) # Evaluación del parámetro beta beta = modelo_weibull.beta alpha = modelo_weibull.alpha print("\n--- DIAGNÓSTICO DE MANTENIMIENTO ---") if beta < 1: print(f"Beta = {beta:.2f} < 1: Dominan fallas prematuras o defectos de instalación.") elif 0.9 <= beta <= 1.1: print(f"Beta = {beta:.2f} ≈ 1: Tasa de fallas constante (fallas aleatorias).") else: print(f"Beta = {beta:.2f} > 1: El equipo está en fase de DESGASTE por uso o envejecimiento.")


Implementación del caso 2 en Google colab

# Ejecutar en una celda de Google Colab 
  Installing build dependencies ... done
  Getting requirements to build wheel ... done
  Preparing metadata (pyproject.toml) ... done
  Building wheel for autograd-gamma (pyproject.toml) ... done

# Tiempos de falla registrados (en horas de funcionamiento)
# Ajuste de Weibull de 2 parámetros (alpha = escala, beta = forma)
Results from Fit_Weibull_2P (95% CI):
Analysis method: Maximum Likelihood Estimation (MLE)
Optimizer: TNC
Failures / Right censored: 11/0 (0% right censored) 

Parameter  Point Estimate  Standard Error  Lower CI  Upper CI
    Alpha         845.516         148.966   598.623   1194.24
     Beta         1.79784        0.445253   1.10648   2.92119 

Goodness of fit    Value
 Log-likelihood -81.6552
           AICc   168.81
            BIC  168.106
             AD  1.26518 





CDF: es la función de densidad de probabilidad acumulada. y la franja de color azul del grafico
corresponde al intervalo de confianza del 95%.

# Evaluación del parámetro beta
--- DIAGNÓSTICO DE MANTENIMIENTO ---
Beta = 1.80 > 1: El equipo está en fase de DESGASTE por uso o envejecimiento.

Caso 3: Simulación Monte Carlo para Disponibilidad de un Sistema

Simular el comportamiento continuo de una planta o equipo durante 1 año (8,760 horas) permite pronosticar la disponibilidad esperada ante la variabilidad real de las fallas y reparaciones.

import numpy as np

# Parámetros del modelo (basados en distribuciones de probabilidad)
# TBF sigue una distribución de Weibull (forma=2.1, escala=800 horas)
# TTR sigue una distribución Lognormal (media logarítmica=2.0, desv logarítmica=0.5 horas)

num_simulaciones = 1000
horas_objetivo_año = 8760
disponibilidades_simuladas = []

for _ in range(num_simulaciones):
    tiempo_acumulado = 0
    tiempo_operativo_total = 0
    tiempo_reparacion_total = 0

    while tiempo_acumulado < horas_objetivo_año:
        # Generar TBF y TTR aleatorios
        tbf = 800 * np.random.weibull(2.1)
        ttr = np.random.lognormal(mean=2.0, sigma=0.5)

        if tiempo_acumulado + tbf + ttr > horas_objetivo_año:
            # Ajustar la última iteración al límite del año
            tiempo_restante = horas_objetivo_año - tiempo_acumulado
            tiempo_operativo_total += min(tbf, tiempo_restante)
            break

        tiempo_operativo_total += tbf
        tiempo_reparacion_total += ttr
        tiempo_acumulado += (tbf + ttr)

    disp = tiempo_operativo_total / horas_objetivo_año
    disponibilidades_simuladas.append(disp)

disp_media = np.mean(disponibilidades_simuladas) * 100
p5 = np.percentile(disponibilidades_simuladas, 5) * 100
p95 = np.percentile(disponibilidades_simuladas, 95) * 100

print(f"--- RESULTADOS DE SIMULACIÓN MONTE CARLO ---")
print(f"Disponibilidad Promedio Esperada: {disp_media:.2f}%")
print(f"Intervalo de Confianza 90%: [{p5:.2f}% - {p95:.2f}%]")

Implementación en Google colab

--- RESULTADOS DE SIMULACIÓN MONTE CARLO ---
Disponibilidad Promedio Esperada: 98.86%
Intervalo de Confianza 90%: [98.42% - 99.22%]

💡 ¿Te gustaría que diseñemos un script en Python para analizar un conjunto de datos real en formato CSV o que elaboremos una guía de estudio paso a paso sobre diagramas de bloques de confiabilidad (RBD)?

lunes, 2 de noviembre de 2026

ThinkCspy / Creación de módulos

 Fuente:ThinkCspy libro interactivo online

5.5. Creando módulos

Has visto cómo usar módulos como , , y , pero ¿cómo crearías un módulo?randommathturtle

¡Cada vez que has escrito un script de Python has creado un módulo!

Un módulo de Python es solo un archivo de código fuente de Python. Consideremos el archivo Python que se muestra a continuación.

cafetería_tienda.py

"""
The coffee shop module contains functions and contains variables
important to implementing a coffee shop.
"""

# Set some variables
shop_name = "Runestone Brew House"
coffee_sizes = ["small", "medium", "large"]
coffee_roasts = ["hot chocolate", "light", "medium", "dark", "espresso"]


Este es un script de Python llamadocoffee_shop.py que contiene tres variables:shop_name ,coffee_sizes , ycoffee_roasts . shop_nameEs una cadenacoffee_sizes, es una lista que contiene cadenas ycoffee_roasts también es una lista que contiene cadenas.

Un módulo es otro nombre para:

Elige uno

Actividad: 5.5.1 Elección múltiple (pregunta4_5_1)


¡eso es genial! Tenemos lo básico de una cafetería. Todo lo que necesitas es un poco de café tostado y tazas. Estás listo para comenzar.

Sin embargo, si intentas ejecutar ese código, no hará mucho que sea visible para un usuario…

¿Cómo podemos utilizar elcoffee_shop módulo? Podemos importarlo y usarlo en otros archivos de código fuente de Python. Consideremos el archivo Python que se muestra a continuación.

café_cliente.py

import coffee_shop

# Output the information we know from the module
print("Welcome to", coffee_shop.shop_name)
print("Available sizes:", coffee_shop.coffee_sizes)
print("Available roasts:", coffee_shop.coffee_roasts


Este es un script de Python llamadocoffee_customer.py que importa nuestrocoffee_shop módulo y luego imprime la información de ese módulo.

Nota

Los archivos del módulo deben estar en el mismo directorio de su computadora para que Python sepa cómo importarlos automáticamente

Crea un módulo mediante:

Elige uno

Actividad: 5.5.2 Elección múltiple (pregunta 4_5_2)


Usamos notación de puntos para tomar las variables , , y del módulo. Luego los imprimimos como parte de mensajes agradables.shop_namecoffee_sizescoffee_roastscoffee_shop

Sin embargo, las variables no son lo único que podemos colocar en los módulos… Podemos poner cualquier código Python válido en ellos.

¡Mejoremos nuestra cafetería!

cafetería_tienda.py

"""
The coffee shop module contains functions and contains variables
important to implementing a coffee shop.
"""

# Set some variables
shop_name = "Runestone Brew House"
coffee_sizes = ["small", "medium", "large"]
coffee_roasts = ["hot chocolate", "light", "medium", "dark", "espresso"]

def order_coffee(size, roast):
    """
    Take an order from a user
    :param size: a string containing one of the coffee_sizes
    :param roast: a string containing one of the coffee_roasts
    :return: a message about the coffee order
    """
    return "Here's your {} coffee roasted {}".format(size, roast)

El contenido del archivo antiguo está presente, pero ahora también hay unaorder_coffee función que toma dos argumentossize yroast .

Además, ¡mira todos los increíbles comentarios que hay allí!

Comentarios del módulo

Es importante incluir comentarios de encabezado en su módulo que expliquen lo que hace el módulo.

Comentarios de la función

Las funciones son el siguiente capítulo, pero los comentarios utilizados aquí demuestran un estilo de documentación común de Python.

Ok, ahora tenemos una función en nuestro módulo, usémosla.

café_cliente.py

# Import the module with coffee_shop functionality
import coffee_shop

# Output the information we know from the module
print("Welcome to", coffee_shop.shop_name)
print("Available sizes:", coffee_shop.coffee_sizes)
print("Available roasts:", coffee_shop.coffee_roasts)

# Get some inputs from the user
order_size = input("What size coffee do you want? ")
order_roast = input("What roast do you want? ")

# Send the order to the coffee shop module
shop_says = coffee_shop.order_coffee(order_size, order_roast)
# Print out whatever it gave back to us
print(shop_says)


¿Qué determina el nombre de nuestra importación?

Elige uno

Actividad: 5.5.3 Elección múltiple (pregunta4_5_3)


Agregamos algunas líneas a nuestrocoffee_customer script… Ahora, después de imprimir bien los datos,coffee_customer le pide al usuario una talla y un asado. ¡Éstos son los parámetros requeridos por nuestraorder_coffee función en elcoffee_shop módulo!

Llame a laorder_coffee función con notación de puntos, como si recuperara valores de variables. La llamada a la función es la línea que dice . La función devuelve algo, por lo que lo guardamos en . La siguiente línea imprime lo que dijo la tienda.shop_says = coffee_shop.order_coffee(order_size, order_roast)shop_says

¡Las cafeterías hacen más que sólo café! Quizás quieras un poco de leche. Necesitamos agregar alguna funcionalidad a nuestra cafetería. Compruébalo a continuación.

cafetería_tienda.py


Se llama a la nueva funciónadd_milk_please y toma un parámetro: elfat_content . Devuelve una cadena que explica lo que sucedió.

Esto es genial. Pero la función no va a hacer nada por sí sola. Tenemos que llamarlo. Consulte la actualización de nuestrocoffee_customer script a continuación.

café_cliente.py


¡eso se puso elegante! ¡Estábamos pidiendo café pero ahora el usuario puede optar por agregar leche! La selección se realiza en un par de capítulos, pero si lees ese código como en inglés verás lo que está pasando.

La llamadaadd_milk_please ocurre justo ahí, se parece a la otra: .shop_says = coffee_shop.add_milk_please(milk_fat)

Terminemos esta visita a la cafetería. Pero será mejor que dejes una propina. Agregaremos otra función a nuestra cafetería para habilitarla.

cafetería_tienda.py


"""
The coffee shop module contains functions and contains variables
important to implementing a coffee shop.
"""

# Set some variables
shop_name = "Runestone Brew House"
coffee_sizes = ["small", "medium", "large"]
coffee_roasts = ["hot chocolate", "light", "medium", "dark", "espresso"]

def order_coffee(size, roast):
    """
    Take an order from a user
    :param size: a string containing one of the coffee_sizes
    :param roast: a string containing one of the coffee_roasts
    :return: a message about the coffee order
    """
    return "Here's your {} coffee roasted {}".format(size, roast)

def add_milk_please(fat_content):
    """
    Pretend like we're adding some milk to a coffee
    :param fat_content: a string or integer containing the milkfat content
    :return: a message about having added the milk
    """
    return "I've added the {}% milk".format(fat_content)

def give_tip(tip_amount):
    """
    Take a tip from the user, then be happy about it
    :param tip_amount: the tip amount
    :return: nothing
    """
    print("Thank you so much!  We don't make a ton of money.")

    # Not having a "return" statement causes our function to return None


Agregamos lagive_tip función que toma un parámetro, eltip_amount . En realidad no hacemos nada con ese parámetro… Pero si nos volviéramos más elegantes con la cafetería, podríamos agregarlo a la factura del cliente, podríamos imprimirlo o podríamos reprender al cliente por ser demasiado tacaño… ¡Aquí simplemente seguimos adelante y expresamos un agradecimiento al usuario! Ser’ amigable es importante.

¿Cómo llamamos a esto desde nuestrocoffee_customer script?

café_cliente.py

# Import the module with coffee_shop functionality
import coffee_shop

# Output the information we know from the module
print("Welcome to", coffee_shop.shop_name)
print("Available sizes:", coffee_shop.coffee_sizes)
print("Available roasts:", coffee_shop.coffee_roasts)

# Get some inputs from the user
order_size = input("What size coffee do you want? ")
order_roast = input("What roast do you want? ")

# Send the order to the coffee shop module
shop_says = coffee_shop.order_coffee(order_size, order_roast)
# Print out whatever it gave back to us
print(shop_says)

# See if the user wants to add milk
add_milk_response = input("Do you want to add milk (y/n)? ")
# Convert the response to lowercase, then check for a "yes" answer
if "y" in add_milk_response.lower():
    milk_fat = input("What percent milk do you want added? ")
    shop_says = coffee_shop.add_milk_please(milk_fat)
    # Print out whatever it gave back to us
    print(shop_says)

# They better give a tip...
print("THAT'S GOOD COFFEE!  Very good.  Your brain is working again.")
print("You better give a tip.")
tip_amount = input("Tip amount? ")
coffee_shop.give_tip(tip_amount)


Nuestra llamada de función está en la última línea.

Entradas recientes

Inmersión en la librería Reliability de Python

Fuente: IA, Gemini Notebook L a librería reliability es una herramienta especializada de Python creada específicamente para la ingeniería ...

Entradas Populares