Creación del diagrama de Ishikawa

PythonPythonBeginner
Practicar Ahora

This tutorial is from open-source community. Access the source code

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprenderemos a crear un diagrama de Ishikawa, también conocido como diagrama de hueso de pez o diagrama de causa y efecto. Los diagramas de Ishikawa se utilizan comúnmente para identificar problemas en un sistema al mostrar cómo se relacionan las causas y los efectos. Utilizaremos Python y la biblioteca Matplotlib para crear el diagrama.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Instalar Matplotlib

Antes de comenzar, debemos asegurarnos de tener Matplotlib instalado. Si aún no lo has hecho, puedes instalarlo con el siguiente comando:

!pip install matplotlib

Importar bibliotecas

Comenzaremos importando las bibliotecas necesarias. Utilizaremos Matplotlib y las clases Polygon y Wedge del módulo matplotlib.patches.

import matplotlib.pyplot as plt
from matplotlib.patches import Polygon, Wedge

Crear el diagrama de hueso de pez

Ahora crearemos el diagrama de hueso de pez. Comenzaremos creando un objeto de figura y eje.

fig, ax = plt.subplots(figsize=(10, 6), layout='constrained')

Luego, estableceremos los límites x e y del eje y desactivaremos el eje.

ax.set_xlim(-5, 5)
ax.set_ylim(-5, 5)
ax.axis('off')

Definir las funciones

Definiremos tres funciones que usaremos para crear el diagrama.

Función de problemas

La primera función es la función de problemas. Esta función toma el nombre de la categoría, las posiciones x e y de la flecha del problema y el ángulo de la anotación del problema. Utiliza el método annotate para crear la flecha del problema y la anotación.

def problems(data: str,
             problem_x: float, problem_y: float,
             prob_angle_x: float, prob_angle_y: float):
    ax.annotate(str.upper(data), xy=(problem_x, problem_y),
                xytext=(prob_angle_x, prob_angle_y),
                fontsize='10',
                color='white',
                weight='bold',
                xycoords='data',
                verticalalignment='center',
                horizontalalignment='center',
                textcoords='offset fontsize',
                arrowprops=dict(arrowstyle="->", facecolor='black'),
                bbox=dict(boxstyle='square',
                          facecolor='tab:blue',
                          pad=0.8))
Función de causas

La segunda función es la función de causas. Esta función toma la lista de causas, las posiciones x e y de la anotación de la causa y si la causa debe colocarse encima o debajo de la flecha del problema. Utiliza el método annotate para crear la anotación de la causa y la flecha.

def causes(data: list, cause_x: float, cause_y: float,
           cause_xytext=(-9, -0.3), top: bool = True):
    for index, cause in enumerate(data):
        coords = [[0, [0, 0]],
                  [0.23, [0.5, -0.5]],
                  [-0.46, [-1, 1]],
                  [0.69, [1.5, -1.5]],
                  [-0.92, [-2, 2]],
                  [1.15, [2.5, -2.5]]]
        if top:
            cause_y += coords[index][1][0]
        else:
            cause_y += coords[index][1][1]
        cause_x -= coords[index][0]
        ax.annotate(cause, xy=(cause_x, cause_y),
                    horizontalalignment='center',
                    xytext=cause_xytext,
                    fontsize='9',
                    xycoords='data',
                    textcoords='offset fontsize',
                    arrowprops=dict(arrowstyle="->",
                                    facecolor='black'))
Función de dibujar el cuerpo

La tercera función es la función de dibujar el cuerpo. Esta función toma los datos de entrada y los utiliza para crear el diagrama de hueso de pez.

def draw_body(data: dict):
    second_sections = []
    third_sections = []
    if len(data) == 1 or len(data) == 2:
        spine_length = (-2.1, 2)
        head_pos = (2, 0)
        tail_pos = ((-2.8, 0.8), (-2.8, -0.8), (-2.0, -0.01))
        first_section = [1.6, 0.8]
    elif len(data) == 3 or len(data) == 4:
        spine_length = (-3.1, 3)
        head_pos = (3, 0)
        tail_pos = ((-3.8, 0.8), (-3.8, -0.8), (-3.0, -0.01))
        first_section = [2.6, 1.8]
        second_sections = [-0.4, -1.2]
    else:  ## len(data) == 5 or 6
        spine_length = (-4.1, 4)
        head_pos = (4, 0)
        tail_pos = ((-4.8, 0.8), (-4.8, -0.8), (-4.0, -0.01))
        first_section = [3.5, 2.7]
        second_sections = [1, 0.2]
        third_sections = [-1.5, -2.3]

    for index, problem in enumerate(data.values()):
        top_row = True
        cause_arrow_y = 1.7
        if index % 2!= 0:
            top_row = False
            y_prob_angle = -16
            cause_arrow_y = -1.7
        else:
            y_prob_angle = 16
        if index in (0, 1):
            prob_arrow_x = first_section[0]
            cause_arrow_x = first_section[1]
        elif index in (2, 3):
            prob_arrow_x = second_sections[0]
            cause_arrow_x = second_sections[1]
        else:
            prob_arrow_x = third_sections[0]
            cause_arrow_x = third_sections[1]
        if index > 5:
            raise ValueError(f'Maximum number of problems is 6, you have entered '
                             f'{len(data)}')
        ax.plot(spine_length, [0, 0], color='tab:blue', linewidth=2)
        ax.text(head_pos[0] + 0.1, head_pos[1] - 0.05, 'PROBLEM', fontsize=10,
                weight='bold', color='white')
        semicircle = Wedge(head_pos, 1, 270, 90, fc='tab:blue')
        ax.add_patch(semicircle)
        triangle = Polygon(tail_pos, fc='tab:blue')
        ax.add_patch(triangle)
        problems(list(data.keys())[index], prob_arrow_x, 0, -12, y_prob_angle)
        causes(problem, cause_arrow_x, cause_arrow_y, top=top_row)

Datos de entrada

Ahora definiremos los datos de entrada. Los datos deben ser un diccionario donde las claves son las categorías y los valores son listas de causas.

categories = {
    'Method': ['Time consumption', 'Cost', 'Procedures', 'Inefficient process', 'Sampling'],
    'Machine': ['Faulty equipment', 'Compatibility'],
    'Material': ['Poor-quality input', 'Raw materials', 'Supplier', 'Shortage'],
    'Measurement': ['Calibration', 'Performance', 'Wrong measurements'],
    'Environment': ['Bad conditions'],
    'People': ['Lack of training', 'Managers', 'Labor shortage', 'Procedures', 'Sales strategy']
}

Dibujar el diagrama de hueso de pez

Finalmente, llamaremos a la función de dibujar el cuerpo y mostraremos el diagrama.

draw_body(categories)
plt.show()

Resumen

En este laboratorio, aprendimos cómo crear un diagrama de Ishikawa utilizando Python y la biblioteca Matplotlib. Definimos tres funciones para crear el diagrama y utilizamos un diccionario para definir los datos de entrada. El diagrama resultante muestra cómo las causas y los efectos están vinculados en un sistema y se puede utilizar para identificar problemas.