Exercise 001_06

Cahier des charges⚓

1
# 001_06 — Analyse statistique avancée sur les données de fiabilité
2
3
## Objectifs
4
- Calculer des statistiques descriptives complètes sur ttf(i)
5
- Calculer le MTBF (Mean Time Between Failures)
6
- Ajouter des colonnes calculées : taux de défaillance λ(i), fiabilité R(i)
7
- Générer plusieurs feuilles Excel avec différentes vues statistiques
8
9
## Structure des feuilles
10
11
### Feuille "do_stats"
12
Statistiques descriptives sur ttf(i) :
13
- Moyenne, médiane, mode
14
- Écart-type, variance
15
- Min, max, étendue
16
- Quartiles (Q1, Q2, Q3)
17
- MTBF (Mean Time Between Failures)
18
19
### Feuille "do_fiabilite"
20
Calculs de fiabilité :
21
- Colonnes : i, ttf(i), N(i), R(i), λ(i), F(i)
22
- R(i) = N(i) / N(0) : Fiabilité
23
- λ(i) = dN(i) / (N(i) × Δt) : Taux de défaillance
24
- F(i) = 1 - R(i) : Fonction de répartition (défaillance cumulée)
25
26
### Feuille "do_summary"
27
Résumé consolidé :
28
- Nombre total d'observations
29
- Durée totale d'observation
30
- Nombre de défaillances
31
- MTBF
32
- Taux de défaillance moyen
33
34
## Formules utilisées
35
36
### MTBF
37
```
38
MTBF = Σ(ttf(i)) / nombre_defaillances
39
```
40
41
### Fiabilité R(i)
42
```
43
R(i) = N(i) / N(0)
44
```
45
Proportion de composants encore fonctionnels
46
47
### Taux de défaillance λ(i)
48
```
49
λ(i) = dN(i) / (N(i-1) × Δt)
50
```
51
où Δt = ttf(i) - ttf(i-1)
52
53
### Fonction de répartition F(i)
54
```
55
F(i) = 1 - R(i)
56
```
57
Probabilité de défaillance avant le temps i
58
Code Python⚓
1
# TD_EDC_01_001_06.py
2
# Résumé : Analyse statistique avancée - MTBF, taux de défaillance, fiabilité
3
# Génère trois feuilles : do_stats, do_fiabilite, do_summary
4
from pathlib import Path
5
import subprocess
6
import pandas as pd
7
import numpy as np
8
import xlsxwriter
9
10
11
def build_paths() -> Path:
12
    """Calcule le chemin du fichier Excel de sortie."""
13
    script = Path(__file__).resolve()
14
    root = script.parent.parent
15
    stem = script.stem
16
    base_dir_name = script.parent.name
17
    xlsx_dir = root / f"{base_dir_name}_do"
18
    xlsx_dir.mkdir(parents=True, exist_ok=True)
19
    
20
    xlsx_path = (xlsx_dir / f"{stem}.xlsx").resolve()
21
    return xlsx_path
22
23
24
def delete_if_exists(file_path: Path) -> None:
25
    """Supprime le fichier s'il existe déjà."""
26
    if file_path.exists():
27
        file_path.unlink()
28
29
30
def prepare_data(n: int = 9, ttf_values: list = None) -> pd.DataFrame:
31
    """Prépare les données de base."""
32
    i_values = list(range(n + 1))
33
    dN_values = [0] + [1] * n
34
    N_values = [n - i for i in range(n + 1)]
35
    
36
    df = pd.DataFrame({
37
        'i': i_values,
38
        'ttf(i)': ttf_values if ttf_values else [0] * (n + 1),
39
        'dN(i)': dN_values,
40
        'N(i)': N_values
41
    })
42
    
43
    return df
44
45
46
def calculate_statistics(df: pd.DataFrame) -> pd.DataFrame:
47
    """Calcule les statistiques descriptives sur ttf(i)."""
48
    ttf = df['ttf(i)']
49
    
50
    stats = {
51
        'Statistique': ['Moyenne', 'Médiane', 'Écart-type', 'Variance', 
52
                        'Min', 'Max', 'Étendue', 'Q1', 'Q2', 'Q3', 'MTBF'],
53
        'Valeur': [
54
            ttf.mean(),
55
            ttf.median(),
56
            ttf.std(),
57
            ttf.var(),
58
            ttf.min(),
59
            ttf.max(),
60
            ttf.max() - ttf.min(),
61
            ttf.quantile(0.25),
62
            ttf.quantile(0.50),
63
            ttf.quantile(0.75),
64
            ttf.sum() / df['dN(i)'].sum()  # MTBF
65
        ]
66
    }
67
    
68
    return pd.DataFrame(stats)
69
70
71
def calculate_reliability(df: pd.DataFrame) -> pd.DataFrame:
72
    """Calcule les indicateurs de fiabilité."""
73
    N_0 = df['N(i)'].iloc[0]
74
    
75
    # Fiabilité R(i) = N(i) / N(0)
76
    R_i = df['N(i)'] / N_0
77
    
78
    # Fonction de répartition F(i) = 1 - R(i)
79
    F_i = 1 - R_i
80
    
81
    # Taux de défaillance λ(i) = dN(i) / (N(i-1) × Δt)
82
    lambda_i = []
83
    for i in range(len(df)):
84
        if i == 0:
85
            lambda_i.append(0)
86
        else:
87
            delta_t = df['ttf(i)'].iloc[i] - df['ttf(i)'].iloc[i-1]
88
            N_prev = df['N(i)'].iloc[i-1]
89
            dN = df['dN(i)'].iloc[i]
90
            if delta_t > 0 and N_prev > 0:
91
                lambda_i.append(dN / (N_prev * delta_t))
92
            else:
93
                lambda_i.append(0)
94
    
95
    df_reliability = pd.DataFrame({
96
        'i': df['i'],
97
        'ttf(i)': df['ttf(i)'],
98
        'N(i)': df['N(i)'],
99
        'R(i)': R_i,
100
        'F(i)': F_i,
101
        'λ(i)': lambda_i
102
    })
103
    
104
    return df_reliability
105
106
107
def create_summary(df: pd.DataFrame) -> pd.DataFrame:
108
    """Crée un résumé consolidé."""
109
    total_obs = len(df) - 1  # Exclure la première ligne
110
    duree_totale = df['ttf(i)'].max()
111
    nb_defaillances = df['dN(i)'].sum()
112
    mtbf = df['ttf(i)'].sum() / nb_defaillances if nb_defaillances > 0 else 0
113
    lambda_moyen = nb_defaillances / duree_totale if duree_totale > 0 else 0
114
    
115
    summary = {
116
        'Indicateur': [
117
            'Nombre d\'observations',
118
            'Durée totale (heures)',
119
            'Nombre de défaillances',
120
            'MTBF (heures)',
121
            'Taux de défaillance moyen (1/h)'
122
        ],
123
        'Valeur': [
124
            total_obs,
125
            duree_totale,
126
            nb_defaillances,
127
            mtbf,
128
            lambda_moyen
129
        ]
130
    }
131
    
132
    return pd.DataFrame(summary)
133
134
135
def write_to_excel(xlsx_path: Path, df_stats: pd.DataFrame, 
136
                   df_reliability: pd.DataFrame, df_summary: pd.DataFrame) -> None:
137
    """Écrit les trois DataFrames dans le fichier Excel."""
138
    workbook = xlsxwriter.Workbook(str(xlsx_path))
139
    
140
    # Feuille 1 : Statistiques descriptives
141
    ws_stats = workbook.add_worksheet("do_stats")
142
    for col_num, col_name in enumerate(df_stats.columns):
143
        ws_stats.write(0, col_num, col_name)
144
    for row_num, row_data in enumerate(df_stats.values, start=1):
145
        for col_num, value in enumerate(row_data):
146
            ws_stats.write(row_num, col_num, value)
147
    print(f"✓ Feuille 'do_stats' créée avec {len(df_stats)} statistiques")
148
    
149
    # Feuille 2 : Fiabilité
150
    ws_reliability = workbook.add_worksheet("do_fiabilite")
151
    for col_num, col_name in enumerate(df_reliability.columns):
152
        ws_reliability.write(0, col_num, col_name)
153
    for row_num, row_data in enumerate(df_reliability.values, start=1):
154
        for col_num, value in enumerate(row_data):
155
            ws_reliability.write(row_num, col_num, value)
156
    print(f"✓ Feuille 'do_fiabilite' créée avec {len(df_reliability)} lignes")
157
    
158
    # Feuille 3 : Résumé
159
    ws_summary = workbook.add_worksheet("do_summary")
160
    for col_num, col_name in enumerate(df_summary.columns):
161
        ws_summary.write(0, col_num, col_name)
162
    for row_num, row_data in enumerate(df_summary.values, start=1):
163
        for col_num, value in enumerate(row_data):
164
            ws_summary.write(row_num, col_num, value)
165
    print(f"✓ Feuille 'do_summary' créée avec {len(df_summary)} indicateurs")
166
    
167
    workbook.close()
168
169
170
def open_in_excel(xlsx_path: Path) -> None:
171
    """Ouvre le classeur généré dans Excel."""
172
    subprocess.Popen(["start", "excel", str(xlsx_path)], shell=True)
173
174
175
def main() -> None:
176
    """Pipeline : calculs statistiques et de fiabilité."""
177
    xlsx_path = build_paths()
178
    
179
    ttf_i = [0, 250, 400, 550, 700, 850, 1000, 1150, 1300, 1450]
180
    
181
    # Préparer les données
182
    df = prepare_data(n=9, ttf_values=ttf_i)
183
    print("Données préparées")
184
    
185
    # Calculer les statistiques
186
    df_stats = calculate_statistics(df)
187
    print("\nStatistiques descriptives :")
188
    print(df_stats)
189
    print()
190
    
191
    # Calculer la fiabilité
192
    df_reliability = calculate_reliability(df)
193
    print("Indicateurs de fiabilité :")
194
    print(df_reliability)
195
    print()
196
    
197
    # Créer le résumé
198
    df_summary = create_summary(df)
199
    print("Résumé consolidé :")
200
    print(df_summary)
201
    print()
202
    
203
    # Écrire dans Excel
204
    delete_if_exists(xlsx_path)
205
    write_to_excel(xlsx_path, df_stats, df_reliability, df_summary)
206
    
207
    print(f"Fichier créé : {xlsx_path}")
208
    open_in_excel(xlsx_path)
209
210
211
if __name__ == "__main__":
212
    main()
213
Documentation⚓
1
# 001_06.py — Analyse statistique avancée
2
3
Ce script Python effectue une analyse statistique avancée incluant le calcul du MTBF (Mean Time Between Failures), du taux de défaillance et de la fiabilité.
4
5
## Objectifs pédagogiques
6
- Comprendre les concepts de fiabilité et de MTBF
7
- Calculer le taux de défaillance (λ) et la fiabilité R(t)
8
- Générer plusieurs feuilles Excel avec des analyses différentes
9
- Utiliser pandas et numpy pour les calculs statistiques
10
11
## Fonctionnement
12
1. **Génération de données TTF (Time To Failure)**
13
   - Création d'un jeu de données de temps avant défaillance
14
   - Calcul du MTBF à partir des données observées
15
16
2. **Calculs de fiabilité**
17
   - Taux de défaillance λ = 1/MTBF
18
   - Fonction de fiabilité R(t) = e^(-λt)
19
   - Calculs sur différentes périodes
20
21
3. **Export multi-feuilles**
22
   - Feuille `do_stats` : statistiques descriptives
23
   - Feuille `do_fiabilite` : calculs de fiabilité
24
   - Feuille `do_summary` : résumé et indicateurs clés
25
26
## Points techniques
27
- Utilisation de `pandas` pour l'analyse de données
28
- Utilisation de `numpy` pour les calculs exponentiels
29
- Export multi-feuilles avec `xlsxwriter`
30
- Structure de données tabulaire pour analyses statistiques
31
32
## Utilisation
33
Ce script sert de modèle pour effectuer des analyses de fiabilité sur des données de défaillance, avec export automatisé dans Excel.
34
35
---
36
*Fichier généré automatiquement par GitHub Copilot (GPT-4.1) — 11/12/2025*
37