Einführung
In diesem Lab lernen wir, wie man einen Ishikawa-Diagramm (auch als Fishbone-Diagramm oder Ursache-Wirkungs-Diagramm bekannt) erstellt. Ishikawa-Diagramme werden üblicherweise verwendet, um Probleme in einem System zu identifizieren, indem die Verknüpfungen zwischen Ursachen und Wirkungen gezeigt werden. Wir werden Python und die Matplotlib-Bibliothek verwenden, um das Diagramm zu erstellen.
Tipps für die VM
Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.
Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.
Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback ab, und wir werden das Problem für Sie prompt beheben.
Matplotlib installieren
Bevor wir beginnen, müssen wir sicherstellen, dass Matplotlib installiert ist. Wenn Sie es noch nicht getan haben, können Sie es mit dem folgenden Befehl installieren:
!pip install matplotlib
Bibliotheken importieren
Wir beginnen mit dem Import der erforderlichen Bibliotheken. Wir werden Matplotlib und die Klassen Polygon und Wedge aus dem matplotlib.patches-Modul verwenden.
import matplotlib.pyplot as plt
from matplotlib.patches import Polygon, Wedge
Erstellen des Fishbone-Diagramms
Jetzt werden wir das Fishbone-Diagramm erstellen. Wir beginnen mit dem Erstellen eines Figure- und Axis-Objekts.
fig, ax = plt.subplots(figsize=(10, 6), layout='constrained')
Als nächstes legen wir die x- und y-Bereiche für die Achse fest und deaktivieren die Achse.
ax.set_xlim(-5, 5)
ax.set_ylim(-5, 5)
ax.axis('off')
Funktionen definieren
Wir werden drei Funktionen definieren, die wir verwenden werden, um das Diagramm zu erstellen.
Problems-Funktion
Die erste Funktion ist die Problems-Funktion. Diese Funktion nimmt den Kategorienamen, die x- und y-Positionen der Problem-Pfeils und den Winkel der Problem-Anmerkung entgegen. Sie verwendet die annotate-Methode, um den Problem-Pfeil und die Anmerkung zu erstellen.
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))
Causes-Funktion
Die zweite Funktion ist die Causes-Funktion. Diese Funktion nimmt die Liste der Ursachen, die x- und y-Positionen der Ursachen-Anmerkung und an, ob die Ursache über oder unter dem Problem-Pfeil platziert werden soll. Sie verwendet die annotate-Methode, um die Ursachen-Anmerkung und den Pfeil zu erstellen.
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'))
Draw Body-Funktion
Die dritte Funktion ist die Draw Body-Funktion. Diese Funktion nimmt die Eingabedaten entgegen und verwendet sie, um das Fishbone-Diagramm zu erstellen.
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)
Eingabedaten
Jetzt werden wir die Eingabedaten definieren. Die Daten sollten ein Dictionary sein, wobei die Schlüssel die Kategorien sind und die Werte Listen von Ursachen.
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']
}
Zeichnen des Fishbone-Diagramms
Schließlich werden wir die draw body-Funktion aufrufen und das Diagramm anzeigen.
draw_body(categories)
plt.show()
Zusammenfassung
In diesem Lab haben wir gelernt, wie man ein Ishikawa-Diagramm mit Python und der Matplotlib-Bibliothek erstellt. Wir haben drei Funktionen definiert, um das Diagramm zu erstellen, und ein Dictionary verwendet, um die Eingabedaten zu definieren. Das resultierende Diagramm zeigt, wie Ursachen und Wirkungen in einem System verknüpft sind und kann verwendet werden, um Probleme zu identifizieren.