Introduction
Dans ce laboratoire, nous allons apprendre à créer un diagramme d'Ishikawa, également connu sous le nom de diagramme en forme d'arête de poisson ou de diagramme cause-effet. Les diagrammes d'Ishikawa sont couramment utilisés pour identifier les problèmes dans un système en montrant comment les causes et les effets sont liés. Nous utiliserons Python et la bibliothèque Matplotlib pour créer le diagramme.
Conseils sur la machine virtuelle
Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter pour pratiquer.
Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limites du carnet Jupyter.
Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous réglerons rapidement le problème pour vous.
Installer Matplotlib
Avant de commencer, nous devons nous assurer d'avoir Matplotlib installé. Si vous ne l'avez pas déjà fait, vous pouvez l'installer à l'aide de la commande suivante :
!pip install matplotlib
Importer les bibliothèques
Nous allons commencer par importer les bibliothèques nécessaires. Nous utiliserons Matplotlib et les classes Polygon et Wedge du module matplotlib.patches.
import matplotlib.pyplot as plt
from matplotlib.patches import Polygon, Wedge
Créer le diagramme en forme d'arête de poisson
Maintenant, nous allons créer le diagramme en forme d'arête de poisson. Nous commencerons par créer un objet figure et un objet axe.
fig, ax = plt.subplots(figsize=(10, 6), layout='constrained')
Ensuite, nous définirons les limites x et y de l'axe et désactiverons l'axe.
ax.set_xlim(-5, 5)
ax.set_ylim(-5, 5)
ax.axis('off')
Définir les fonctions
Nous allons définir trois fonctions que nous utiliserons pour créer le diagramme.
Fonction problèmes
La première fonction est la fonction problèmes. Cette fonction prend en entrée le nom de la catégorie, les positions x et y de la flèche du problème et l'angle de l'annotation du problème. Elle utilise la méthode annotate pour créer la flèche du problème et l'annotation.
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))
Fonction causes
La deuxième fonction est la fonction causes. Cette fonction prend en entrée la liste des causes, les positions x et y de l'annotation de la cause et si la cause doit être placée au-dessus ou en-dessous de la flèche du problème. Elle utilise la méthode annotate pour créer l'annotation de la cause et la flèche.
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'))
Fonction draw_body
La troisième fonction est la fonction draw_body. Cette fonction prend en entrée les données d'entrée et les utilise pour créer le diagramme en forme d'arête de poisson.
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)
Données d'entrée
Maintenant, nous allons définir les données d'entrée. Les données devraient être un dictionnaire où les clés sont les catégories et les valeurs sont des listes de causes.
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']
}
Dessiner le diagramme en forme d'arête de poisson
Enfin, nous appellerons la fonction draw_body et afficherons le diagramme.
draw_body(categories)
plt.show()
Sommaire
Dans ce laboratoire, nous avons appris à créer un diagramme d'Ishikawa à l'aide de Python et de la bibliothèque Matplotlib. Nous avons défini trois fonctions pour créer le diagramme et utilisé un dictionnaire pour définir les données d'entrée. Le diagramme obtenu montre comment les causes et les effets sont liés dans un système et peut être utilisé pour identifier les problèmes.