| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067 |
- import pandas as pd
- import numpy as np
- import seaborn as sns
- import matplotlib.pyplot as plt
- from scipy import stats
- import statsmodels.api as sm
- from statsmodels.formula.api import ols
- from scipy.stats import chi2_contingency
- import requests
- import pandas as pd
- from datetime import datetime, timedelta, date
- import json
- import os
- import statsmodels.api as sm
- from statsmodels.formula.api import ols
- from statsmodels.stats.multicomp import pairwise_tukeyhsd
- import statsmodels.formula.api as smf
- import matplotlib.patheffects as path_effects
- import matplotlib.dates as mdates
- from sklearn.ensemble import RandomForestRegressor
- from sklearn.model_selection import train_test_split
- from sklearn.metrics import mean_absolute_error, mean_squared_error
- pd.set_option('display.max_columns', None)
- dataset = 'export_des_missions_2025-06-13_100933-8546-653608357.csv'
- df = pd.read_csv(dataset, sep=';')
- df
- df.describe(include='all')
- df1=df.copy()
- df1
- airports = 'airports.csv'
- airports = pd.read_csv(airports)
- airports
- df_iata_pays = airports[['iata_code', 'iso_country']]
- # Supprimer les lignes sans code IATA
- df_iata_pays = df_iata_pays.dropna(subset=['iata_code'])
- df_iata_pays
- # Renommer les colonnes avant la jointure pour éviter conflits
- df_iata_pays_origin = df_iata_pays.rename(columns={'iata_code': 'Origine', 'iso_country': 'pays_origine'})
- df_iata_pays_dest = df_iata_pays.rename(columns={'iata_code': 'Destination', 'iso_country': 'pays_destination'})
- # Merge origine
- df1 = df1.merge(df_iata_pays_origin, on='Origine', how='left')
- # Merge destination
- df1 = df1.merge(df_iata_pays_dest, on='Destination', how='left')
- df1
- !pip install pycountry
- import pycountry
- def iso_to_country_name(code):
- try:
- return pycountry.countries.get(alpha_2=code).name
- except:
- return code
- df1['Origine'] = df1['pays_origine'].apply(iso_to_country_name)
- df1['Destination'] = df1['pays_destination'].apply(iso_to_country_name)
- df1['code_pays_origine'] = df1['pays_origine']
- df1['code_pays_Destination'] = df1['pays_destination']
- df1 = df1.drop(columns=['pays_origine', 'pays_destination'])
- df1.head(40)
- API_KEY = 'NNPh5mZBBbBTNm6qnvvzI56gY1P339NZ'
- BASE_URL = 'https://calendarific.com/api/v2/holidays'
- CACHE_FILE = 'cache_feries.json'
- df1['date_arrivee'] = pd.to_datetime(df1['ST arrivée'], format='%d/%m/%Y %H:%M', errors='coerce').dt.date
- df1['date_depart'] = pd.to_datetime(df1['ST départ'], format='%d/%m/%Y %H:%M', errors='coerce').dt.date
- # Extraction des couples (pays, année) uniques dans origine et destination
- def extract_pays_annee(df1, col_pays, col_date):
- subset = df1[[col_pays, col_date]].dropna()
- subset['annee'] = subset[col_date].apply(lambda x: x.year)
- return set(zip(subset[col_pays], subset['annee']))
- pays_annees_origine = extract_pays_annee(df1, 'code_pays_origine', 'date_arrivee')
- pays_annees_destination = extract_pays_annee(df1, 'code_pays_Destination', 'date_depart')
- pays_annees = pays_annees_origine.union(pays_annees_destination)
- # Charger le cache depuis fichier JSON
- if os.path.exists(CACHE_FILE):
- with open(CACHE_FILE, 'r') as f:
- cache_feries = json.load(f)
- # Conversion des clés de string à tuple
- cache_feries = {tuple(k.split(',')): v for k, v in cache_feries.items()}
- print(f"Cache chargé, {len(cache_feries)} entrées")
- else:
- cache_feries = {}
- print("Pas de cache trouvé, nouvelle création")
- def save_cache():
- with open(CACHE_FILE, 'w') as f:
- json.dump({','.join(k): v for k, v in cache_feries.items()}, f, indent=2)
- def fetch_holidays(country_code, year):
- key = (country_code, str(year))
- if key in cache_feries:
- return cache_feries[key]
-
- print(f"Appel API pour {country_code} {year}...")
- params = {
- 'api_key': API_KEY,
- 'country': country_code,
- 'year': year,
- 'type': 'national,religious'
- }
- try:
- response = requests.get(BASE_URL, params=params)
- response.raise_for_status()
- holidays = response.json()['response']['holidays']
- data = [
- {
- 'date': h['date']['iso'],
- 'name': h['name'],
- 'type': ','.join(h.get('type', []))
- } for h in holidays
- ]
- cache_feries[key] = data
- save_cache()
- return data
- except Exception as e:
- print(f"Erreur API pour {country_code} {year} : {e}")
- return []
- # Remplissage complet du cache (pour les pays/années manquants)
- for (pays, annee) in pays_annees:
- fetch_holidays(pays, annee)
- def check_holiday(date, country_code):
- if pd.isna(date) or pd.isna(country_code):
- return False, None, None
- key = (country_code, str(date.year))
- holidays = cache_feries.get(key, [])
- for h in holidays:
- if h['date'] == date.isoformat():
- return True, h['name'], h['type']
- return False, None, None
- df1[['ferie_origine', 'fete_origine', 'type_fete_origine']] = df1.apply(
- lambda row: pd.Series(check_holiday(row['date_arrivee'], row['code_pays_origine'])),
- axis=1
- )
- df1[['ferie_destination', 'fete_destination', 'type_fete_destination']] = df1.apply(
- lambda row: pd.Series(check_holiday(row['date_depart'], row['code_pays_Destination'])),
- axis=1
- )
- df1.head(30)
- # Fonction d'alerte popup dans Jupyter
- def notify_jupyter(message):
- from IPython.display import display, Javascript
- js_code = f'alert("{message}");'
- display(Javascript(js_code))
- def check_tomorrow_feries(df):
- demain = datetime.now().date() + timedelta(days=1)
-
- # Extraire tous les codes pays à vérifier (origine + destination)
- pays_origine = df['code_pays_origine'].dropna().unique()
- pays_destination = df['code_pays_Destination'].dropna().unique()
- pays_a_verifier = set(pays_origine).union(pays_destination)
- alerts = []
- for pays in pays_a_verifier:
- is_ferie, nom, type_fete = check_holiday(demain, pays)
- if is_ferie:
- alerts.append(f"{demain.isoformat()} - {pays} : {nom} ({type_fete})")
- if alerts:
- message = "Jour(s) férié(s) demain :\n" + "\n".join(alerts)
- print(message)
- notify_jupyter(message)
- else:
- print(f"Aucun jour férié demain ({demain.isoformat()}) pour les pays dans le dataframe.")
- check_tomorrow_feries(df1)
- #planifier tache : cron job(linux) / task scheduler(windows)
- def check_holiday_for_date(check_date, country_code):
- if not check_date or not country_code:
- return False, None, None
- key = (country_code, str(check_date.year))
- holidays = cache_feries.get(key, [])
- if not holidays:
- holidays = fetch_holidays(country_code, check_date.year)
- for h in holidays:
- if h['date'] == check_date.isoformat():
- return True, h['name'], h['type']
- return False, None, None
- date_test = date(2025, 6, 6)
- pays_origine = 'DE'
- pays_destination = 'TN'
- ferie_origine, nom_origine, type_origine = check_holiday_for_date(date_test, pays_origine)
- ferie_destination, nom_destination, type_destination = check_holiday_for_date(date_test, pays_destination)
- print(f"Date : {date_test}")
- print(f"Pays origine ({pays_origine}) : {'Férié' if ferie_origine else 'Non férié'} - {nom_origine} ({type_origine})")
- print(f"Pays destination ({pays_destination}) : {'Férié' if ferie_destination else 'Non férié'} - {nom_destination} ({type_destination})")
- # Nombre de PMR par Origine
- pmr_par_origine = df1.groupby('Origine').size().reset_index(name='Nombre_PMR')
- print(pmr_par_origine)
- pmr_par_origine_sorted = pmr_par_origine.sort_values(by='Nombre_PMR', ascending=False)
- data_to_plot = pmr_par_origine_sorted.copy()
- # barplot
- plt.figure(figsize=(max(20, len(data_to_plot) * 0.25), 10)) # ajuster automatiquement la largeur
- sns.barplot(data=data_to_plot, x='Origine', y='Nombre_PMR', palette='Blues_d')
- plt.title("Nombre de PMR par origine", fontsize=18)
- plt.xlabel("origine", fontsize=14)
- plt.ylabel("Nombre de PMR", fontsize=14)
- plt.xticks(rotation=90, fontsize=9)
- plt.yticks(fontsize=12)
- plt.grid(axis='y', linestyle='--', alpha=0.7)
- plt.tight_layout()
- plt.show()
- # Nombre de PMR par Origine
- pmr_par_destination = df1.groupby('Destination').size().reset_index(name='Nombre_PMR')
- print(pmr_par_destination)
- pmr_par_destination_sorted = pmr_par_destination.sort_values(by='Nombre_PMR', ascending=False)
- data_to_plot = pmr_par_destination_sorted.copy()
- # barplot
- plt.figure(figsize=(max(20, len(data_to_plot) * 0.25), 10))
- sns.barplot(data=data_to_plot, x='Destination', y='Nombre_PMR', palette='Blues_d')
- plt.title("Nombre de PMR par Destination", fontsize=18)
- plt.xlabel("Destination", fontsize=14)
- plt.ylabel("Nombre de PMR", fontsize=14)
- plt.xticks(rotation=90, fontsize=9)
- plt.yticks(fontsize=12)
- plt.grid(axis='y', linestyle='--', alpha=0.7)
- plt.tight_layout()
- plt.show()
- # test ANOVA (Analyse de la Variance)
- # une ligne = un pmr
- df1['PMR'] = 1
- # Tester si l'Origine est significative
- model_origine = ols('PMR ~ C(Origine)', data=df1).fit()
- anova_origine = sm.stats.anova_lm(model_origine, typ=2)
- print("ANOVA pour Origine :")
- print(anova_origine)
- # Tester si la Destination est significative
- model_destination = ols('PMR ~ C(Destination)', data=df1).fit()
- anova_destination = sm.stats.anova_lm(model_destination, typ=2)
- print("\nANOVA pour Destination :")
- print(anova_destination)
- # tester la dépendance entre Origine et Destination
- contingency_table = pd.crosstab(df1['Origine'], df1['Destination'])
- # Test du Chi²
- chi2, p, dof, expected = chi2_contingency(contingency_table)
- print("Chi² :", chi2)
- print("Degrés de liberté :", dof)
- print("P-value :", p)
- import seaborn as sns
- import matplotlib.pyplot as plt
- plt.figure(figsize=(20, 10))
- sns.heatmap(contingency_table, cmap='Blues')
- plt.title('Heatmap Origine vs Destination')
- plt.xlabel('Destination')
- plt.ylabel('Origine')
- plt.show()
- df1['Origine'] = df1['Origine'].fillna('').str.strip()
- df1['Destination'] = df1['Destination'].fillna('').str.strip()
- # Détection des cas
- entree_et_reste = df1[(df1['Origine'] != '') & (df1['Destination'] == '')]
- sortie_seulement = df1[(df1['Origine'] == '') & (df1['Destination'] != '')]
- escale = df1[(df1['Origine'] != '') & (df1['Destination'] != '')]
- # Labels et valeurs
- labels = ['Entrée et restée en France', 'Sortie uniquement de France', 'Escale']
- counts = [len(entree_et_reste), len(sortie_seulement), len(escale)]
- total = len(df1)
- percentages = [round(c / total * 100, 2) for c in counts]
- # graphe
- plt.figure(figsize=(9, 6))
- bars = plt.bar(labels, counts, color=['#b0e0e6', '#add8e6', '#aec6cf'])
- plt.title('Répartition des passagers via la France')
- plt.ylabel('Nombre de passagers')
- plt.xticks(rotation=15)
- plt.grid(axis='y', linestyle='', alpha=0.7)
- # Ajout des valeurs + %
- for bar, count, perc in zip(bars, counts, percentages):
- plt.text(bar.get_x() + bar.get_width()/2,
- bar.get_height() + total*0.001, # un peu au-dessus
- f'{count} ({perc}%)',
- ha='center', va='bottom', fontsize=10, fontweight='bold')
- plt.tight_layout()
- plt.show()
- # Création de la variable 'org_dest'
- def type_passage(row):
- if row['Origine'] != '' and row['Destination'] == '':
- return '0' # entrée en France
- elif row['Origine'] == '' and row['Destination'] != '':
- return '1' # sortie de France
- elif row['Origine'].upper() != 'FRANCE' and row['Destination'].upper() != 'FRANCE':
- return '2' #escaleF
-
- df1['org_dest'] = df1.apply(type_passage, axis=1)
- df1 = df1.drop(columns=['PMR'])
- df1.head(40)
- contingency_table = df1['org_dest'].value_counts().sort_index()
- print(contingency_table)
- table = pd.DataFrame({'PMR_count': contingency_table})
- chi2, p, dof, expected = chi2_contingency([table['PMR_count'], expected := [table['PMR_count'].sum() / 3] * 3])
- print(f"\nChi2 = {chi2:.2f}, p-value = {p:.4f}")
- # Conversion en datetime avec dayfirst=True (car format jour/mois/année)
- df1['ST arrivée'] = pd.to_datetime(df1['ST arrivée'], dayfirst=True)
- df1['ST départ'] = pd.to_datetime(df1['ST départ'], dayfirst=True)
- # Extraction jour de la semaine (0=lundi, 6=dimanche)
- df1['jour_semaine_entree'] = df1['ST arrivée'].dt.dayofweek
- df1['jour_semaine_depart'] = df1['ST départ'].dt.dayofweek
- # Format HH:MM
- df1['heure_entree'] = df1['ST arrivée'].dt.strftime('%H:%M')
- df1['heure_depart'] = df1['ST départ'].dt.strftime('%H:%M')
- # Mois : Janvier, Février, etc.
- df1['mois_entree'] = df1['ST arrivée'].dt.month_name()
- df1['mois_depart'] = df1['ST départ'].dt.month_name()
- df1.head()
- # Mapper les numéros de jours (0 à 6) en noms
- jours = ['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche']
- df1['jour_nom_entree'] = df1['jour_semaine_entree'].map(dict(enumerate(jours)))
- df1['jour_nom_depart'] = df1['jour_semaine_depart'].map(dict(enumerate(jours)))
- def countplot_avec_valeurs(data, colonne, ordre, titre, xlabel, ylabel):
- plt.figure(figsize=(10, 4))
- ax = sns.countplot(data=data, x=colonne, order=ordre)
- plt.title(titre)
- plt.xlabel(xlabel)
- plt.ylabel(ylabel)
- plt.xticks(rotation=45)
-
- # Ajouter les valeurs au-dessus des barres
- for p in ax.patches:
- hauteur = p.get_height()
- ax.text(p.get_x() + p.get_width() / 2., hauteur + 3, # +3 pour décoller un peu du sommet
- int(hauteur), ha='center', fontsize=10)
-
- plt.tight_layout()
- plt.show()
- countplot_avec_valeurs(df1, 'jour_nom_entree', jours,
- 'Répartition des entrées par jour de la semaine',
- 'Jour de la semaine', 'Nombre d\'entrées')
- countplot_avec_valeurs(df1, 'jour_nom_depart', jours,
- 'Répartition des départs par jour de la semaine',
- 'Jour de la semaine', 'Nombre de départs')
- mois_ordre = ['January', 'February', 'March', 'April', 'May', 'June',
- 'July', 'August', 'September', 'October', 'November', 'December']
- # Filtrer les mois présents dans la colonne 'mois_entree' et 'mois_depart'
- mois_ordre_entree = [m for m in mois_ordre if m in df1['mois_entree'].unique()]
- mois_ordre_depart = [m for m in mois_ordre if m in df1['mois_depart'].unique()]
- def countplot_avec_valeurs(data, colonne, ordre, titre, xlabel, ylabel):
- plt.figure(figsize=(10, 4))
- ax = sns.countplot(data=data, x=colonne, order=ordre)
- plt.title(titre)
- plt.xlabel(xlabel)
- plt.ylabel(ylabel)
- plt.xticks(rotation=45)
- for p in ax.patches:
- hauteur = p.get_height()
- ax.text(p.get_x() + p.get_width() / 2., hauteur + 3,
- int(hauteur), ha='center', fontsize=10)
- plt.tight_layout()
- plt.show()
- # Répartition par mois d'entrée
- countplot_avec_valeurs(df1, 'mois_entree', mois_ordre_entree,
- 'Répartition des entrées par mois',
- 'Mois', 'Nombre d\'entrées')
- # Répartition par mois de départ
- countplot_avec_valeurs(df1, 'mois_depart', mois_ordre_depart,
- 'Répartition des départs par mois',
- 'Mois', 'Nombre de départs')
- API_URL = "https://iata-and-icao-codes.p.rapidapi.com/airlines"
- HEADERS = {
- "x-rapidapi-key": "9bd1fe1013mshfef01143800e2cbp18a39ejsnfa4b363d6392",
- "x-rapidapi-host": "iata-and-icao-codes.p.rapidapi.com"
- }
- response = requests.get(API_URL, headers=HEADERS)
- if response.status_code == 200:
- data = response.json()
- airlines_df = pd.DataFrame(data)
- # Renommer les colonnes pour faciliter la fusion
- airlines_arr = airlines_df.rename(columns={'iata_code': 'Code Cie arrivée', 'name': 'nom_compagnie_arr'})
- airlines_dest = airlines_df.rename(columns={'iata_code': 'Code Cie départ', 'name': 'nom_compagnie_dest'})
- df1 = df1.merge(airlines_arr[['Code Cie arrivée', 'nom_compagnie_arr']], on='Code Cie arrivée', how='left')
- df1 = df1.merge(airlines_dest[['Code Cie départ', 'nom_compagnie_dest']], on='Code Cie départ', how='left')
- # Dictionnaire de corrections manuelles si certaines compagnies manquent dans l'API
- corrections = {
- 'EZY': 'easyJet',
- 'EJU': 'easyJet Europe',
- 'VF': 'Volotea',
- 'ENT': 'Enter Air',
- 'N0': 'Norwegian Air Sweden'
- }
- for code, name in corrections.items():
- df1.loc[df1['Code Cie arrivée'] == code, 'nom_compagnie_arr'] = name
- df1.loc[df1['Code Cie départ'] == code, 'nom_compagnie_dest'] = name
- # Formatage final : Nom (Code)
- df1['nom_compagnie_arr'] = df1.apply(
- lambda row: f"{row['nom_compagnie_arr']} ({row['Code Cie arrivée']})"
- if pd.notna(row['nom_compagnie_arr']) else row['Code Cie arrivée'],
- axis=1
- )
- df1['nom_compagnie_dest'] = df1.apply(
- lambda row: f"{row['nom_compagnie_dest']} ({row['Code Cie départ']})"
- if pd.notna(row['nom_compagnie_dest']) else row['Code Cie départ'],
- axis=1
- )
- df1[['Code Cie arrivée', 'nom_compagnie_arr', 'Code Cie départ', 'nom_compagnie_dest']].head(40)
- else:
- print(f"Erreur API: code {response.status_code}")
- # Associer chaque vol à sa compagnie
- compagnie_par_vol_arr = df1.groupby(['Num Vol arrivée'])['nom_compagnie_arr'].first()
- compagnie_par_vol_dep = df1.groupby(['Num Vol départ'])['nom_compagnie_dest'].first()
- # Compter le nombre de vols uniques par compagnie (arrivée et départ)
- nb_vols_uniques_arr = compagnie_par_vol_arr.value_counts().sort_values(ascending=False)
- nb_vols_uniques_dep = compagnie_par_vol_dep.value_counts().sort_values(ascending=False)
- fig, axes = plt.subplots(1, 2, figsize=(18, 6))
- # ARRIVÉE
- sns.barplot(x=nb_vols_uniques_arr.index, y=nb_vols_uniques_arr.values,
- palette="Blues_d", ax=axes[0])
- axes[0].set_title("Vols uniques par compagnie (arrivée)")
- axes[0].set_xlabel("Compagnie")
- axes[0].set_ylabel("Nombre de vols uniques")
- axes[0].tick_params(axis='x', rotation=90)
- for i, v in enumerate(nb_vols_uniques_arr.values):
- axes[0].text(i, v + 0.5, str(v), ha='center', fontsize=8)
- # DÉPART
- sns.barplot(x=nb_vols_uniques_dep.index, y=nb_vols_uniques_dep.values,
- palette="Greens_d", ax=axes[1])
- axes[1].set_title("Vols uniques par compagnie (départ)")
- axes[1].set_xlabel("Compagnie")
- axes[1].set_ylabel("Nombre de vols uniques")
- axes[1].tick_params(axis='x', rotation=90)
- for i, v in enumerate(nb_vols_uniques_dep.values):
- axes[1].text(i, v + 0.5, str(v), ha='center', fontsize=8)
- plt.tight_layout()
- plt.show()
- # Comptage des compagnies à l’arrivée
- compte_arr = df1['nom_compagnie_arr'].value_counts()
- # Comptage des compagnies au départ
- compte_dep = df1['nom_compagnie_dest'].value_counts()
- def ajouter_valeurs_barres(ax, valeurs):
- for i, v in enumerate(valeurs):
- ax.text(i, v + max(valeurs)*0.01, str(v), ha='center', va='bottom', fontsize=9)
- # ARRIVÉE
- plt.figure(figsize=(15, 6))
- ax1 = sns.barplot(x=compte_arr.index, y=compte_arr.values, palette='Blues_d')
- plt.title("Nombre de PMR par compagnie aérienne à l’arrivée")
- plt.xlabel("Compagnie")
- plt.ylabel("Nombre total PMR par compagnie")
- plt.xticks(rotation=90)
- ajouter_valeurs_barres(ax1, compte_arr.values)
- plt.tight_layout()
- plt.show()
- # DÉPART
- plt.figure(figsize=(15, 6))
- ax2 = sns.barplot(x=compte_dep.index, y=compte_dep.values, palette='Greens_d')
- plt.title("Nombre de PMR par compagnie aérienne départ")
- plt.xlabel("Compagnie")
- plt.ylabel("Nombre Total PMR")
- plt.xticks(rotation=90)
- ajouter_valeurs_barres(ax2, compte_dep.values)
- plt.tight_layout()
- plt.show()
- # Nombre de PMR par vol arrivée
- pmr_par_vol_arrivee = df1.groupby('Num Vol arrivée').size().sort_values(ascending=False)
- # Compagnie associée à chaque vol arrivée
- compagnie_par_vol_arrivee = df1.groupby('Num Vol arrivée')['nom_compagnie_arr'].first()
- df_vols_arrivee = pd.DataFrame({
- 'nombre_pmr': pmr_par_vol_arrivee,
- 'compagnie': compagnie_par_vol_arrivee
- }).dropna() # <-- Important pour éviter NaN
- # Moyenne PMR par vol par compagnie arrivée
- moyenne_pmr_par_compagnie_arrivee = (
- df_vols_arrivee.groupby('compagnie')['nombre_pmr']
- .mean()
- .sort_values(ascending=False)
- )
- # Nombre de PMR par vol arrivée
- plt.figure(figsize=(18, 6))
- sns.barplot(x=pmr_par_vol_arrivee.index.astype(str), y=pmr_par_vol_arrivee.values, palette='Blues_d')
- plt.title("Nombre de PMR par vol arrivée")
- plt.xlabel("Vol arrivée (CodeCie_NumVol)")
- plt.ylabel("Nombre de PMR")
- plt.xticks(rotation=90)
- for i, v in enumerate(pmr_par_vol_arrivee.values):
- if pd.notna(v) and pd.notnull(v): # Vérification
- plt.text(i, v + 0.5, str(int(v)), ha='center', fontsize=8)
- plt.tight_layout()
- plt.show()
- # Moyenne PMR par vol par compagnie arrivée
- plt.figure(figsize=(15, 6))
- sns.barplot(x=moyenne_pmr_par_compagnie_arrivee.index, y=moyenne_pmr_par_compagnie_arrivee.values, palette='coolwarm')
- plt.title("Moyenne de PMR par vol par compagnie (arrivée)")
- plt.xlabel("Compagnie")
- plt.ylabel("Moyenne PMR par vol")
- plt.xticks(rotation=90)
- for i, v in enumerate(moyenne_pmr_par_compagnie_arrivee.values):
- if pd.notna(v) and pd.notnull(v): # Vérification
- plt.text(i, v + 0.05, f"{v:.2f}", ha='center', fontsize=10)
- plt.tight_layout()
- plt.show()
- # Nombre de PMR par vol départ
- pmr_par_vol_depart = df1.groupby([ 'Num Vol départ']).size().sort_values(ascending=False)
- compagnie_par_vol_depart = df1.groupby([ 'Num Vol départ'])['nom_compagnie_dest'].first()
- df_vols_depart = pd.DataFrame({
- 'nombre_pmr': pmr_par_vol_depart,
- 'compagnie': compagnie_par_vol_depart
- })
- # Calcul moyenne PMR par vol par compagnie départ
- moyenne_pmr_par_compagnie_depart = df_vols_depart.groupby('compagnie')['nombre_pmr'].mean().sort_values(ascending=False)
- # Nombre PMR par vol départ
- plt.figure(figsize=(18, 6))
- sns.barplot(x=pmr_par_vol_depart.index, y=pmr_par_vol_depart.values, palette='Greens_d')
- plt.title("Nombre de PMR par vol départ")
- plt.xlabel("Vol départ (CodeCie_NumVol)")
- plt.ylabel("Nombre de PMR")
- plt.xticks(rotation=90)
- for i, v in enumerate(pmr_par_vol_depart.values):
- plt.text(i, v + 0.5, str(v), ha='center', fontsize=8)
- plt.tight_layout()
- plt.show()
- # Moyenne PMR par vol par compagnie départ
- plt.figure(figsize=(15, 6))
- sns.barplot(x=moyenne_pmr_par_compagnie_depart.index, y=moyenne_pmr_par_compagnie_depart.values, palette='coolwarm')
- plt.title("Moyenne de PMR par vol par compagnie (départ)")
- plt.xlabel("Compagnie")
- plt.ylabel("Moyenne PMR par vol")
- plt.xticks(rotation=90)
- for i, v in enumerate(moyenne_pmr_par_compagnie_depart.values):
- plt.text(i, v + 0.05, f"{v:.2f}", ha='center', fontsize=10)
- plt.tight_layout()
- plt.show()
- # Calcul PMR par vol arrivée
- pmr_par_vol_arrivee = df1.groupby('Num Vol arrivée').size().reset_index(name='nombre_pmr')
- compagnie_arr = df1.groupby('Num Vol arrivée')['nom_compagnie_arr'].first().reset_index()
- df_vols_arrivee = pmr_par_vol_arrivee.merge(compagnie_arr, on='Num Vol arrivée')
- # Calcul PMR par vol départ
- pmr_par_vol_depart = df1.groupby('Num Vol départ').size().reset_index(name='nombre_pmr')
- compagnie_dep = df1.groupby('Num Vol départ')['nom_compagnie_dest'].first().reset_index()
- df_vols_depart = pmr_par_vol_depart.merge(compagnie_dep, on='Num Vol départ')
- # ANOVA arrivée
- modele_arr = ols('nombre_pmr ~ C(nom_compagnie_arr)', data=df_vols_arrivee).fit()
- anova_arr = sm.stats.anova_lm(modele_arr, typ=2)
- print("ANOVA - nombre PMR par compagnie (arrivée) :")
- print(anova_arr)
- # Tukey HSD arrivée
- tukey_arr = pairwise_tukeyhsd(endog=df_vols_arrivee['nombre_pmr'],
- groups=df_vols_arrivee['nom_compagnie_arr'],
- alpha=0.05)
- print(tukey_arr.summary())
- tukey_arr.plot_simultaneous()
- plt.title('Tukey HSD - PMR par compagnie (arrivée)')
- plt.show()
- # --- ANOVA départ ---
- modele_dep = ols('nombre_pmr ~ C(nom_compagnie_dest)', data=df_vols_depart).fit()
- anova_dep = sm.stats.anova_lm(modele_dep, typ=2)
- print("ANOVA - nombre PMR par compagnie (départ) :")
- print(anova_dep)
- # Tukey HSD départ
- tukey_dep = pairwise_tukeyhsd(endog=df_vols_depart['nombre_pmr'],
- groups=df_vols_depart['nom_compagnie_dest'],
- alpha=0.05)
- print(tukey_dep.summary())
- tukey_dep.plot_simultaneous()
- plt.title('Tukey HSD - PMR par compagnie (départ)')
- plt.show()
- # Calcul du nombre de PMR par compagnie à l'arrivée
- pmr_arr = df1['nom_compagnie_arr'].value_counts(dropna=False).reset_index()
- pmr_arr.columns = ['compagnie', 'total_pmr']
- # Calcul de la distribution cumulée (en excluant NaN dans le calcul)
- pmr_arr_nonan = pmr_arr[pmr_arr['compagnie'].notna()].copy()
- pmr_arr_nonan['cumsum'] = pmr_arr_nonan['total_pmr'].cumsum() / pmr_arr_nonan['total_pmr'].sum()
- # Identifier les compagnies représentant 80% des PMR
- top_80_arr = pmr_arr_nonan[pmr_arr_nonan['cumsum'] <= 0.8]['compagnie'].tolist()
- # Créer une nouvelle colonne dans df1 avec regroupement
- def simplify_compagnie(x):
- if pd.isna(x):
- return x # garder NaN tel quel
- elif x in top_80_arr:
- return x
- else:
- return 'Other'
- df1['compagnie_arr_simplifiée'] = df1['nom_compagnie_arr'].apply(simplify_compagnie)
- # Recompter les PMR par compagnie simplifiée (y compris NaN)
- pmr_arr_grouped = df1['compagnie_arr_simplifiée'].value_counts(dropna=False).reset_index()
- pmr_arr_grouped.columns = ['compagnie', 'total_pmr']
- # Nettoyer pour le graphique : enlever NaN
- pmr_arr_grouped_clean = pmr_arr_grouped[pmr_arr_grouped['compagnie'].notna()]
- # Garder seulement le top 80, exclure 'Other'
- pmr_arr_top = pmr_arr_grouped_clean[pmr_arr_grouped_clean['compagnie'] != 'Other']
- # Tracer la courbe avec uniquement le top 80, sans 'Other'
- plt.figure(figsize=(12, 6))
- plt.bar(pmr_arr_top['compagnie'], pmr_arr_top['total_pmr'], color='steelblue')
- plt.title("Top compagnies représentant 80% des PMR à l'arrivée")
- plt.xlabel("Compagnie aérienne")
- plt.ylabel("Nombre de PMR")
- plt.xticks(rotation=90)
- plt.tight_layout()
- plt.show()
- # Calcul du nombre de PMR par compagnie à la destination (en comptant aussi les NaN)
- pmr_dest = df1['nom_compagnie_dest'].value_counts(dropna=False).reset_index()
- pmr_dest.columns = ['compagnie', 'total_pmr']
- # Calcul de la distribution cumulée (sur les compagnies non NaN)
- pmr_dest_nonan = pmr_dest[pmr_dest['compagnie'].notna()]
- pmr_dest_nonan.loc[:, 'cumsum'] = pmr_dest_nonan['total_pmr'].cumsum() / pmr_dest_nonan['total_pmr'].sum()
- # Identifier les compagnies représentant 80% des PMR à la destination
- top_80_dest = pmr_dest_nonan[pmr_dest_nonan['cumsum'] <= 0.8]['compagnie'].tolist()
- # Fonction pour simplifier la colonne des compagnies à la destination
- def simplify_compagnie_dest(x):
- if pd.isna(x):
- return x # garder NaN tel quel
- elif x in top_80_dest:
- return x
- else:
- return 'Other'
- df1['compagnie_dest_simplifiée'] = df1['nom_compagnie_dest'].apply(simplify_compagnie_dest)
- # Recompter les PMR par compagnie simplifiée à la destination (avec NaN)
- pmr_dest_grouped = df1['compagnie_dest_simplifiée'].value_counts(dropna=False).reset_index()
- pmr_dest_grouped.columns = ['compagnie', 'total_pmr']
- # Filtrer pour le graphique : garder seulement le top 80, exclure 'Other' et NaN
- pmr_dest_top = pmr_dest_grouped[
- (pmr_dest_grouped['compagnie'] != 'Other') &
- (pmr_dest_grouped['compagnie'].notna())
- ]
- # Tracer la courbe avec uniquement le top 80, sans 'Other'
- plt.figure(figsize=(12, 6))
- plt.bar(pmr_dest_top['compagnie'], pmr_dest_top['total_pmr'], color='steelblue')
- plt.title("Top compagnies représentant 80% des PMR à la destination")
- plt.xlabel("Compagnie aérienne")
- plt.ylabel("Nombre de PMR")
- plt.xticks(rotation=90)
- plt.tight_layout()
- plt.show()
- df1
- def time_to_minutes(t):
- try:
- if pd.isna(t):
- return np.nan
- h, m = map(int, t.split(':'))
- return h * 60 + m
- except Exception:
- return np.nan
- # encodage cyclique (sin/cos)
- def encode_cyclic_period(period_idx, total_periods=58):
- if np.isnan(period_idx):
- return np.nan, np.nan
- angle = 2 * np.pi * period_idx / total_periods
- return np.sin(angle), np.cos(angle)
- # Conversion heures vers minutes
- df1['minutes_entree'] = df1['heure_entree'].apply(time_to_minutes)
- df1['minutes_depart'] = df1['heure_depart'].apply(time_to_minutes)
- # Calcul des périodes entières (58 périodes de 24.83 minutes environ)
- periode_duration = 1440 / 58 # ≈ 24.8276 min
- df1['periode_entree'] = df1['minutes_entree'].apply(
- lambda x: int(x // periode_duration) if not np.isnan(x) else np.nan)
- df1['periode_depart'] = df1['minutes_depart'].apply(
- lambda x: int(x // periode_duration) if not np.isnan(x) else np.nan)
- # Encodage cyclique
- df1[['periode_entree_sin', 'periode_entree_cos']] = df1['periode_entree'].apply(
- lambda x: pd.Series(encode_cyclic_period(x)))
- df1[['periode_depart_sin', 'periode_depart_cos']] = df1['periode_depart'].apply(
- lambda x: pd.Series(encode_cyclic_period(x)))
- df1
- plt.figure(figsize=(8, 8))
- plt.title("Visualisation encodage cyclique des heures (arrivée et départ)")
- # Scatter points
- plt.scatter(df1['periode_entree_cos'], df1['periode_entree_sin'], color='blue', label='Heure Arrivée', alpha=0.6)
- plt.scatter(df1['periode_depart_cos'], df1['periode_depart_sin'], color='red', label='Heure Départ', alpha=0.6)
- # Circle
- circle = plt.Circle((0, 0), 1, color='grey', fill=False, linestyle='--')
- plt.gca().add_artist(circle)
- def annotated_text(x, y, text, color):
- txt = plt.text(x, y, text, fontsize=10, color=color, fontweight='bold')
- txt.set_path_effects([path_effects.Stroke(linewidth=2, foreground='white'), path_effects.Normal()])
- # periodes Unique entrée
- unique_entree_periods = df1['periode_entree'].dropna().unique()
- for periode in unique_entree_periods:
- periode = int(periode)
- minutes = periode * 25
- h = minutes // 60
- m = minutes % 60
- # Calculate cos and sin for the label position (radius a bit > 1 for visibility)
- angle = 2 * np.pi * (periode / 58)
- x = 1.1 * np.cos(angle)
- y = 1.1 * np.sin(angle)
- annotated_text(x, y, f"{h:02d}h{m:02d}", 'blue')
- # periodes Unique départ
- unique_depart_periods = df1['periode_depart'].dropna().unique()
- for periode in unique_depart_periods:
- periode = int(periode)
- minutes = periode * 25
- h = minutes // 60
- m = minutes % 60
- angle = 2 * np.pi * (periode / 58)
- x = 1.2 * np.cos(angle) # Slightly farther out to not overlap entrée labels
- y = 1.2 * np.sin(angle)
- annotated_text(x, y, f"{h:02d}h{m:02d}", 'red')
- plt.xlabel('Cosinus')
- plt.ylabel('Sinus')
- plt.legend()
- plt.grid(True)
- plt.axis('equal')
- plt.tight_layout()
- plt.show()
- entree_counts = df1['periode_entree'].dropna().astype(int).value_counts().sort_index()
- depart_counts = df1['periode_depart'].dropna().astype(int).value_counts().sort_index()
- # Fusionner dans un même index
- all_indices = sorted(set(entree_counts.index).union(depart_counts.index))
- entree = [entree_counts.get(i, 0) for i in all_indices]
- depart = [depart_counts.get(i, 0) for i in all_indices]
- # Créer les labels combinés (indice + heure)
- def indice_to_hour_str(indice):
- total_minutes = indice * 25
- h = total_minutes // 60
- m = total_minutes % 60
- return f"{indice:02d} ({h:02d}h{m:02d})"
- horaire_labels = [indice_to_hour_str(i) for i in all_indices]
- # Positions des barres
- x = np.arange(len(all_indices))
- width = 0.4
- # Barplot
- plt.figure(figsize=(14, 6))
- plt.bar(x - width/2, entree, width=width, label='Arrivée', color='blue')
- plt.bar(x + width/2, depart, width=width, label='Départ', color='red')
- plt.xlabel("Indice de période (tranche de 25 minutes)")
- plt.ylabel("Nombre de PMR")
- plt.title("Nombre d'arrivées et de départs par tranche horaire")
- plt.xticks(x, horaire_labels, rotation=90)
- plt.legend()
- plt.grid(True, axis='y', linestyle='--', alpha=0.7)
- plt.tight_layout()
- plt.show()
- # Extraire le jour de la semaine pour arrivée et départ
- df1['jour_semaine_arrivee'] = df1['ST arrivée'].dt.day_name()
- df1['jour_semaine_depart'] = df1['ST départ'].dt.day_name()
- # Compter le nombre de PMR par jour de la semaine (arrivée)
- pmr_arrivee_sem = df1.groupby('jour_semaine_arrivee').size().reindex(
- ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
- )
- # Compter le nombre de PMR par jour de la semaine (départ)
- pmr_depart_sem = df1.groupby('jour_semaine_depart').size().reindex(
- ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
- )
- # Créer un DataFrame pour faciliter le tracé
- df_sem = pd.DataFrame({
- 'Arrivées': pmr_arrivee_sem,
- 'Départs': pmr_depart_sem
- })
- df_sem.plot(kind='bar', figsize=(10,5), color=['skyblue', 'salmon'])
- plt.title("Nombre total de PMR par jour de la semaine (Arrivées vs Départs)")
- plt.ylabel("Nombre de PMR")
- plt.xlabel("Jour de la semaine")
- plt.xticks(rotation=45)
- plt.grid(axis='y')
- plt.tight_layout()
- plt.show()
- # Grouper par date uniquement
- pmr_par_jour_arrivee = df1.groupby(df1['ST arrivée'].dt.date).size()
- pmr_par_jour_depart = df1.groupby(df1['ST départ'].dt.date).size()
- # Tracer les courbes
- plt.figure(figsize=(12, 6))
- plt.plot(pmr_par_jour_arrivee.index, pmr_par_jour_arrivee.values, marker='o', linestyle='-', color='blue', label='Arrivées')
- plt.plot(pmr_par_jour_depart.index, pmr_par_jour_depart.values, marker='o', linestyle='-', color='red', label='Départs')
- plt.title("Évolution du nombre de PMR par jour (Arrivées vs Départs)")
- plt.xlabel("Date")
- plt.ylabel("Nombre de PMR")
- plt.legend()
- plt.grid(True)
- # Rendre l'axe X plus clair avec format date
- ax = plt.gca()
- ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
- plt.xticks(rotation=45)
- plt.tight_layout()
- plt.show()
- df1['ST arrivée arrondie'] = df1['ST arrivée'].dt.floor('25min')
- df1['ST départ arrondie'] = df1['ST départ'].dt.floor('25min')
- pmr_par_25min_arrivee = df1.groupby('ST arrivée arrondie').size()
- pmr_par_25min_depart = df1.groupby('ST départ arrondie').size()
- plt.figure(figsize=(14, 6))
- plt.plot(pmr_par_25min_arrivee.index, pmr_par_25min_arrivee.values, label='Arrivées', marker='o')
- plt.plot(pmr_par_25min_depart.index, pmr_par_25min_depart.values, label='Départs', marker='o')
- plt.title("Nombre de PMR par tranche de 25 minutes")
- plt.xlabel("Date et heure")
- plt.ylabel("Nombre de PMR")
- ax = plt.gca()
- ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M'))
- ax.xaxis.set_major_locator(mdates.HourLocator(interval=1)) # tick every 1 hour
- plt.xticks(rotation=45)
- plt.grid(True)
- plt.legend()
- plt.tight_layout()
- plt.show()
- df1 = df1.drop(columns=['jour_nom_entree', 'jour_nom_depart', 'minutes_entree' ,'minutes_depart' ,'periode_entree', 'periode_depart','jour_semaine_arrivee','ST arrivée arrondie', 'ST départ arrondie'])
- df1
- colonnes_details = [
- 'Detail SORTI', 'Detail MEET-RPI', 'Detail ELB', 'Detail MEETR-A',
- 'Detail MEETL-A', 'Detail MEET-LIEU', 'Detail MEET-BNQ', 'Detail MEET-ACC',
- 'Detail PEMB', 'Detail MEET-EMB', 'Detail MEETR-D', 'Detail MEETL-D', 'Detail MEET-COR'
- ]
- for col in colonnes_details:
- print(f"\n--- {col} ---")
- print(df1[col].value_counts(dropna=False)) # dropna=False pour aussi voir les NaN
- print(df1[col].value_counts(dropna=False, normalize=True).round(3) * 100) # pourcentage
- # nouvelle colonne binaire : 1 si "NO SHOW", 0 sinon
- df1['no_show'] = df1[['Detail SORTI', 'Detail MEETR-A', 'Detail MEETL-A','Detail MEET-ACC']].apply(
- lambda row: 'NO SHOW' in row.values, axis=1).astype(int)
- # compagnie à l'arrivée
- no_show_by_company = df1.groupby('nom_compagnie_arr')['no_show'].agg(['count', 'sum'])
- no_show_by_company['taux_no_show'] = no_show_by_company['sum'] / no_show_by_company['count']
- no_show_by_company = no_show_by_company.sort_values('taux_no_show', ascending=False)
- plt.figure(figsize=(12, 6))
- plt.bar(no_show_by_company.index[:20], no_show_by_company['taux_no_show'][:20], color='tomato')
- plt.xticks(rotation=90)
- plt.title("Taux de NO SHOW par compagnie (Top 20)")
- plt.ylabel("Taux de NO SHOW")
- plt.xlabel("Compagnie aérienne")
- plt.tight_layout()
- plt.show()
- # Table de contingence entre compagnie et no_show
- contingency_table = pd.crosstab(df1['nom_compagnie_arr'], df1['no_show'])
- chi2, p, dof, expected = chi2_contingency(contingency_table)
- print(f"Chi² statistic : {chi2:.2f}")
- print(f"Degrees of freedom : {dof}")
- print(f"P-value : {p:.5f}")
- if p < 0.05:
- print("✅ Il existe une relation significative entre la compagnie aérienne et le NO SHOW (on rejette H0).")
- else:
- print("❌ Aucune relation significative détectée (on ne peut pas rejeter H0).")
- # nouvelle colonne binaire : 1 si "NO SHOW" dans l'une des colonnes sélectionnées, 0 sinon
- df1['no_show'] = df1[['Detail SORTI', 'Detail MEETR-A', 'Detail MEETL-A', 'Detail MEET-ACC']].apply(
- lambda row: 'NO SHOW' in row.values, axis=1).astype(int)
- # compagnie à la destination
- no_show_by_company_dest = df1.groupby('nom_compagnie_dest')['no_show'].agg(['count', 'sum'])
- no_show_by_company_dest['taux_no_show'] = no_show_by_company_dest['sum'] / no_show_by_company_dest['count']
- no_show_by_company_dest = no_show_by_company_dest.sort_values('taux_no_show', ascending=False)
- plt.figure(figsize=(12, 6))
- plt.bar(no_show_by_company_dest.index[:20], no_show_by_company_dest['taux_no_show'][:20], color='tomato')
- plt.xticks(rotation=90)
- plt.title("Taux de NO SHOW par compagnie à la destination (Top 20)")
- plt.ylabel("Taux de NO SHOW")
- plt.xlabel("Compagnie aérienne")
- plt.tight_layout()
- plt.show()
- signal_counts = df['Statut signalement arrivée'].value_counts()
- plt.figure(figsize=(10,6))
- ax = signal_counts.plot(kind='bar', color='skyblue')
- plt.title("Répartition des demandes d'assistance par délai de signalement")
- plt.ylabel("Nombre de demandes")
- plt.xlabel("Statut signalement arrivée")
- plt.xticks(rotation=45, ha='right')
- # Ajouter les nombres au-dessus des barres
- for p in ax.patches:
- height = p.get_height()
- ax.text(p.get_x() + p.get_width() / 2, height + 5, # 5 = décalage vertical au-dessus
- f'{int(height)}', ha='center')
- plt.tight_layout()
- plt.show()
- df1['Statut signalement arrivée'] = df['Statut signalement arrivée'].fillna('Non précisé')
- # Grouper par signalement et calculer le taux moyen de no-show
- no_show_by_signal = df1.groupby('Statut signalement arrivée')['no_show'].mean().sort_values()
- plt.figure(figsize=(10, 6))
- no_show_by_signal.plot(kind='bar', color='salmon')
- plt.ylabel("Taux de no-show")
- plt.title("Taux de no-show selon le moment du signalement de l’assistance")
- plt.xticks(rotation=45)
- plt.grid(axis='y')
- plt.tight_layout()
- plt.show()
- print(df1['Statut signalement arrivée'].unique())
- # Nettoyage des valeurs
- df1['Statut signalement arrivée'] = df1['Statut signalement arrivée'].replace({
- '<1h': '<6h',
- '<2h': '<6h',
- '<6h': '<6h',
- 'N.A': 'Non précisé',
- np.nan: 'Non précisé'
- })
- from pandas.api.types import CategoricalDtype
- ordre = CategoricalDtype(
- categories=['<6h', '<12h', '<24h', '<36h', '>36h'],
- ordered=True
- )
- df1['Statut signalement arrivée'] = df1['Statut signalement arrivée'].astype(ordre)
- df1['Signalement_encoded'] = df1['Statut signalement arrivée'].cat.codes
- df1
- # Trier par nombre de passagers
- passagers_par_vol_date = df1.groupby(['Code Cie arrivée', 'ST arrivée']).size().reset_index(name='nb_passagers')
- top_vols = passagers_par_vol_date.sort_values(by='nb_passagers', ascending=False).head(10)
- plt.figure(figsize=(12, 6))
- bars = plt.barh(
- top_vols['Code Cie arrivée'] + ' - ' + top_vols['ST arrivée'].astype(str),
- top_vols['nb_passagers'],
- color='skyblue'
- )
- plt.xlabel("Nombre de passagers")
- plt.title("Top 10 des vols avec le plus de passagers")
- for bar in bars:
- width = bar.get_width()
- plt.text(width + 1, bar.get_y() + bar.get_height()/2, str(int(width)), va='center')
- plt.gca().invert_yaxis()
- plt.tight_layout()
- plt.show()
- df1['ST arrivée'] = pd.to_datetime(df1['ST arrivée'], errors='coerce')
- df1['tranche_25min_arr'] = df1['ST arrivée'].dt.floor('25min')
- pmr_arrivee_25min = df1.groupby(['tranche_25min_arr']).size().reset_index(name='pmr_total')
- df1['ST départ'] = pd.to_datetime(df1['ST départ'], errors='coerce')
- # Arrondir à la tranche de 25 minutes
- df1['tranche_25min_depart'] = df1['ST départ'].dt.floor('25min')
- # Grouper par tranche et compter les PMR
- pmr_depart_25min = df1.groupby(['tranche_25min_depart']).size().reset_index(name='pmr_total')
- pmr_arrivee_25min = pmr_arrivee_25min.rename(columns={'tranche_25min_arr': 'tranche_25min'})
- pmr_depart_25min = pmr_depart_25min.rename(columns={'tranche_25min_depart': 'tranche_25min'})
- pmr_merged = pd.merge(
- pmr_arrivee_25min,
- pmr_depart_25min,
- on='tranche_25min',
- how='outer',
- suffixes=('_arrivee', '_depart')
- )
- # Remplacer les NaN par 0
- pmr_merged['pmr_total_arrivee'] = pmr_merged['pmr_total_arrivee'].fillna(0).astype(int)
- pmr_merged['pmr_total_depart'] = pmr_merged['pmr_total_depart'].fillna(0).astype(int)
- pmr_merged['total'] = pmr_merged['pmr_total_arrivee'] + pmr_merged['pmr_total_depart']
- pmr_merged = pmr_merged.sort_values('tranche_25min').reset_index(drop=True)
- pmr_merged[['tranche_25min', 'pmr_total_arrivee', 'pmr_total_depart', 'total']]
- pmr_merged = pmr_merged.rename(columns={'total': 'pmr_total'})
- pmr_merged
- #df1=df1[['org_dest', 'ST arrivée', 'ST départ','mois_entree' ,'mois_depart','periode_entree_sin', 'periode_entree_cos' ,'periode_depart_sin', 'periode_depart_cos','no_show','compagnie_arr_encoded','compagnie_dest_encoded']]
- df1
- df1['jour_semaine_entree'] = df1['ST arrivée'].dt.weekday
- df1['jour_semaine_entree_sin'] = np.sin(2 * np.pi * df1['jour_semaine_entree'] / 7)
- df1['jour_semaine_entree_cos'] = np.cos(2 * np.pi * df1['jour_semaine_entree'] / 7)
- df1['jour_semaine_depart'] = df1['ST départ'].dt.weekday
- df1['jour_semaine_depart_sin'] = np.sin(2 * np.pi * df1['jour_semaine_depart'] / 7)
- df1['jour_semaine_depart_cos'] = np.cos(2 * np.pi * df1['jour_semaine_depart'] / 7)
- print(df1[pd.to_numeric(df1['mois_entree'], errors='coerce').isna()]['mois_entree'].unique())
- print(df1[pd.to_numeric(df1['mois_depart'], errors='coerce').isna()]['mois_depart'].unique())
- mois_map = {
- 'janvier': 1, 'février': 2, 'mars': 3, 'avril': 4,
- 'mai': 5, 'juin': 6, 'juillet': 7, 'août': 8,
- 'septembre': 9, 'octobre': 10, 'novembre': 11, 'décembre': 12
- }
- df1['mois_entree'] = df1['mois_entree'].str.lower().str.strip().map(mois_map)
- df1['mois_depart'] = df1['mois_depart'].str.lower().str.strip().map(mois_map)
- df1
- df1['mois_entree_sin'] = np.sin(2 * np.pi * df1['mois_entree'] / 12)
- df1['mois_entree_cos'] = np.cos(2 * np.pi * df1['mois_entree'] / 12)
- df1['mois_depart_sin'] = np.sin(2 * np.pi * df1['mois_depart'] / 12)
- df1['mois_depart_cos'] = np.cos(2 * np.pi * df1['mois_depart'] / 12)
- #df1 = df1.drop(columns=['mois_entree', 'mois_depart' ,'ST arrivée','ST départ','mois_entree','mois_depart','jour_semaine_entree', 'jour_semaine_depart','mois_entree_sin', 'mois_entree_cos' ,'mois_depart_sin' ,'mois_depart_cos'], errors='ignore')
- df1
- df1['tranche_arrivee'] = df1['ST arrivée'].dt.floor('25T')
- df1['tranche_depart'] = df1['ST départ'].dt.floor('25T')
- # Nombre de vols uniques par compagnie à l’arrivée par tranche
- arrivee_grouped = (
- df1.groupby(['tranche_arrivee', 'compagnie_arr_simplifiée'])['Code Cie arrivée']
- .nunique()
- .unstack(fill_value=0)
- .reset_index()
- )
- arrivee_grouped.rename(columns={'tranche_arrivee': 'tranche_25min'}, inplace=True)
- arrivee_grouped.columns = ['tranche_25min'] + [f"arrivee_{col}" for col in arrivee_grouped.columns[1:]]
- # Nombre de vols uniques par compagnie au départ par tranche
- depart_grouped = (
- df1.groupby(['tranche_depart', 'compagnie_dest_simplifiée'])['Code Cie départ']
- .nunique()
- .unstack(fill_value=0)
- .reset_index()
- )
- depart_grouped.rename(columns={'tranche_depart': 'tranche_25min'}, inplace=True)
- depart_grouped.columns = ['tranche_25min'] + [f"depart_{col}" for col in depart_grouped.columns[1:]]
- pmr_merged['tranche_25min'] = pd.to_datetime(pmr_merged['tranche_25min'])
- # Fusion avec les données arrivées et départs
- df_final = pmr_merged.merge(arrivee_grouped, on='tranche_25min', how='left')
- df_final = df_final.merge(depart_grouped, on='tranche_25min', how='left')
- df_final.fillna(0, inplace=True)
- # Nombre total de vols uniques (arrivée + départ) par tranche
- arrivee_total = (
- df1.groupby('tranche_arrivee')['Code Cie arrivée']
- .nunique()
- .reset_index(name='nb_vols_arrivee')
- .rename(columns={'tranche_arrivee': 'tranche_25min'})
- )
- depart_total = (
- df1.groupby('tranche_depart')['Code Cie départ']
- .nunique()
- .reset_index(name='nb_vols_depart')
- .rename(columns={'tranche_depart': 'tranche_25min'})
- )
- vols_total = pd.merge(arrivee_total, depart_total, on='tranche_25min', how='outer').fillna(0)
- vols_total['nb_vols_total'] = vols_total['nb_vols_arrivee'] + vols_total['nb_vols_depart']
- # Fusion avec le total des vols
- df_final = df_final.merge(vols_total[['tranche_25min', 'nb_vols_total']], on='tranche_25min', how='left')
- df_final['nb_vols_total'] = df_final['nb_vols_total'].fillna(0).astype(int)
- df_final['jourSemaine'] = df_final['tranche_25min'].dt.dayofweek
- df_final['is_weekend'] = df_final['jourSemaine'].isin([5,6]).astype(int)
- df_final = df_final.drop(columns=['pmr_total_arrivee', 'pmr_total_depart'], errors='ignore')
- cols = df_final.columns.tolist()
- for col in ['tranche_25min', 'nb_vols_total', 'pmr_total', 'jourSemaine', 'is_weekend']:
- if col in cols:
- cols.remove(col)
- new_cols_order = ['tranche_25min', 'jourSemaine', 'is_weekend', 'nb_vols_total'] + cols + ['pmr_total']
- df_final = df_final[new_cols_order]
- df_final.head(10)
- df1['tranche_arrivee'] = df1['ST arrivée'].dt.floor('25T')
- df1['tranche_depart'] = df1['ST départ'].dt.floor('25T')
- # Nombre de vols uniques par compagnie à l’arrivée par tranche
- arrivee_grouped = (
- df1.groupby(['tranche_arrivee', 'compagnie_arr_simplifiée'])['Num Vol arrivée']
- .nunique()
- .unstack(fill_value=0)
- .reset_index()
- )
- arrivee_grouped.rename(columns={'tranche_arrivee': 'tranche_25min'}, inplace=True)
- arrivee_grouped.columns = ['tranche_25min'] + [f"arrivee_{col}" for col in arrivee_grouped.columns[1:]]
- # Nombre de vols uniques par compagnie au départ par tranche
- depart_grouped = (
- df1.groupby(['tranche_depart', 'compagnie_dest_simplifiée'])['Num Vol départ']
- .nunique()
- .unstack(fill_value=0)
- .reset_index()
- )
- depart_grouped.rename(columns={'tranche_depart': 'tranche_25min'}, inplace=True)
- depart_grouped.columns = ['tranche_25min'] + [f"depart_{col}" for col in depart_grouped.columns[1:]]
- # PMR à l’arrivée par tranche et compagnie (nombre d'occurrences)
- pmr_arrivee = (
- df1.groupby(['tranche_arrivee', 'compagnie_arr_simplifiée'])
- .size()
- .unstack(fill_value=0)
- .reset_index()
- )
- pmr_arrivee.rename(columns={'tranche_arrivee': 'tranche_25min'}, inplace=True)
- pmr_arrivee.columns = ['tranche_25min'] + [f"pmr_arrivee_{col}" for col in pmr_arrivee.columns[1:]]
- # PMR au départ par tranche et compagnie
- pmr_depart = (
- df1.groupby(['tranche_depart', 'compagnie_dest_simplifiée'])
- .size()
- .unstack(fill_value=0)
- .reset_index()
- )
- pmr_depart.rename(columns={'tranche_depart': 'tranche_25min'}, inplace=True)
- pmr_depart.columns = ['tranche_25min'] + [f"pmr_depart_{col}" for col in pmr_depart.columns[1:]]
- pmr_merged = pd.merge(pmr_arrivee, pmr_depart, on='tranche_25min', how='outer').fillna(0)
- pmr_merged['tranche_25min'] = pd.to_datetime(pmr_merged['tranche_25min'])
- df_final = pmr_merged.merge(arrivee_grouped, on='tranche_25min', how='left')
- df_final = df_final.merge(depart_grouped, on='tranche_25min', how='left')
- df_final.fillna(0, inplace=True)
- arrivee_total = (
- df1.groupby('tranche_arrivee')['Num Vol arrivée']
- .nunique()
- .reset_index(name='nb_vols_arrivee')
- .rename(columns={'tranche_arrivee': 'tranche_25min'})
- )
- depart_total = (
- df1.groupby('tranche_depart')['Num Vol départ']
- .nunique()
- .reset_index(name='nb_vols_depart')
- .rename(columns={'tranche_depart': 'tranche_25min'})
- )
- vols_total = pd.merge(arrivee_total, depart_total, on='tranche_25min', how='outer').fillna(0)
- vols_total['nb_vols_total'] = vols_total['nb_vols_arrivee'] + vols_total['nb_vols_depart']
- df_final = df_final.merge(vols_total[['tranche_25min', 'nb_vols_total']], on='tranche_25min', how='left')
- df_final['nb_vols_total'] = df_final['nb_vols_total'].fillna(0).astype(int)
- pmr_cols = [col for col in df_final.columns if col.startswith('pmr_arrivee_') or col.startswith('pmr_depart_')]
- df_final['pmr_total'] = df_final[pmr_cols].sum(axis=1)
- df_final['jourSemaine'] = df_final['tranche_25min'].dt.dayofweek
- df_final = df_final.drop(columns=['pmr_total_arrivee', 'pmr_total_depart'], errors='ignore')
- cols = df_final.columns.tolist()
- for col in ['tranche_25min', 'nb_vols_total', 'pmr_total', 'jourSemaine']:
- if col in cols:
- cols.remove(col)
- new_cols_order = ['tranche_25min', 'jourSemaine', 'nb_vols_total'] + cols + ['pmr_total']
- df_final = df_final[new_cols_order]
- df_final.head(10)
- import requests
- import pandas as pd
- API_KEY = 'NNPh5mZBBbBTNm6qnvvzI56gY1P339NZ'
- BASE_URL = 'https://calendarific.com/api/v2/holidays'
- def get_holidays_for_year_with_names(year, country='FR'):
- params = {
- 'api_key': API_KEY,
- 'country': country,
- 'year': year
- }
- response = requests.get(BASE_URL, params=params)
- data = response.json()
- holidays = {}
- if data['meta']['code'] == 200:
- for holiday in data['response']['holidays']:
- date_iso = holiday['date']['iso'] # format yyyy-mm-dd
- name = holiday['name']
- holidays[date_iso] = name
- else:
- print(f"Erreur API pour l'année {year}:", data['meta'].get('error_detail', 'Erreur inconnue'))
- return holidays
- # Préparation des tranches 25 minutes dans df1 (exemple avec tes colonnes)
- df1['tranche_arrivee'] = df1['ST arrivée'].dt.floor('25T')
- df1['tranche_depart'] = df1['ST départ'].dt.floor('25T')
- # Nombre de vols uniques par compagnie à l’arrivée par tranche
- arrivee_grouped = (
- df1.groupby(['tranche_arrivee', 'compagnie_arr_simplifiée'])['Num Vol arrivée']
- .nunique()
- .unstack(fill_value=0)
- .reset_index()
- )
- arrivee_grouped.rename(columns={'tranche_arrivee': 'tranche_25min'}, inplace=True)
- arrivee_grouped.columns = ['tranche_25min'] + [f"arrivee_{col}" for col in arrivee_grouped.columns[1:]]
- # Nombre de vols uniques par compagnie au départ par tranche
- depart_grouped = (
- df1.groupby(['tranche_depart', 'compagnie_dest_simplifiée'])['Num Vol départ']
- .nunique()
- .unstack(fill_value=0)
- .reset_index()
- )
- depart_grouped.rename(columns={'tranche_depart': 'tranche_25min'}, inplace=True)
- depart_grouped.columns = ['tranche_25min'] + [f"depart_{col}" for col in depart_grouped.columns[1:]]
- # PMR à l’arrivée par tranche et compagnie
- pmr_arrivee = (
- df1.groupby(['tranche_arrivee', 'compagnie_arr_simplifiée'])
- .size()
- .unstack(fill_value=0)
- .reset_index()
- )
- pmr_arrivee.rename(columns={'tranche_arrivee': 'tranche_25min'}, inplace=True)
- pmr_arrivee.columns = ['tranche_25min'] + [f"pmr_arrivee_{col}" for col in pmr_arrivee.columns[1:]]
- # PMR au départ par tranche et compagnie
- pmr_depart = (
- df1.groupby(['tranche_depart', 'compagnie_dest_simplifiée'])
- .size()
- .unstack(fill_value=0)
- .reset_index()
- )
- pmr_depart.rename(columns={'tranche_depart': 'tranche_25min'}, inplace=True)
- pmr_depart.columns = ['tranche_25min'] + [f"pmr_depart_{col}" for col in pmr_depart.columns[1:]]
- # Fusion des PMR arrivee et depart
- pmr_merged = pd.merge(pmr_arrivee, pmr_depart, on='tranche_25min', how='outer').fillna(0)
- pmr_merged['tranche_25min'] = pd.to_datetime(pmr_merged['tranche_25min'])
- # Fusion des données vols et pmr
- df_final = pmr_merged.merge(arrivee_grouped, on='tranche_25min', how='left')
- df_final = df_final.merge(depart_grouped, on='tranche_25min', how='left')
- df_final.fillna(0, inplace=True)
- # Calcul du nombre total de vols par tranche
- arrivee_total = (
- df1.groupby('tranche_arrivee')['Num Vol arrivée']
- .nunique()
- .reset_index(name='nb_vols_arrivee')
- .rename(columns={'tranche_arrivee': 'tranche_25min'})
- )
- depart_total = (
- df1.groupby('tranche_depart')['Num Vol départ']
- .nunique()
- .reset_index(name='nb_vols_depart')
- .rename(columns={'tranche_depart': 'tranche_25min'})
- )
- vols_total = pd.merge(arrivee_total, depart_total, on='tranche_25min', how='outer').fillna(0)
- vols_total['nb_vols_total'] = vols_total['nb_vols_arrivee'] + vols_total['nb_vols_depart']
- df_final = df_final.merge(vols_total[['tranche_25min', 'nb_vols_total']], on='tranche_25min', how='left')
- df_final['nb_vols_total'] = df_final['nb_vols_total'].fillna(0).astype(int)
- pmr_cols = [col for col in df_final.columns if col.startswith('pmr_arrivee_') or col.startswith('pmr_depart_')]
- df_final['pmr_total'] = df_final[pmr_cols].sum(axis=1)
- df_final['jourSemaine'] = df_final['tranche_25min'].dt.dayofweek
- cols = df_final.columns.tolist()
- for col in ['tranche_25min', 'nb_vols_total', 'pmr_total', 'jourSemaine']:
- if col in cols:
- cols.remove(col)
- new_cols_order = ['tranche_25min', 'jourSemaine', 'nb_vols_total'] + cols + ['pmr_total']
- df_final = df_final[new_cols_order]
- # holiday_name
- years = df_final['tranche_25min'].dt.year.unique()
- all_holidays = {}
- for year in years:
- holidays_for_year = get_holidays_for_year_with_names(year, country='FR')
- all_holidays.update(holidays_for_year)
- df_final['date_str'] = df_final['tranche_25min'].dt.strftime('%Y-%m-%d')
- df_final['holiday_name'] = df_final['date_str'].map(all_holidays).fillna('')
- df_final.drop(columns=['date_str'], inplace=True)
- df_final.head(10)
- df_final
- df_final['minutes'] = df_final['tranche_25min'].dt.hour * 60 + df_final['tranche_25min'].dt.minute
- df_final['tranche_num'] = df_final['minutes'] // 25
- max_tranche = 24 * 60 // 25
- df_final['tranche_sin'] = np.sin(2 * np.pi * df_final['tranche_num'] / max_tranche)
- df_final['tranche_cos'] = np.cos(2 * np.pi * df_final['tranche_num'] / max_tranche)
- max_jour = 7
- df_final['jour_sin'] = np.sin(2 * np.pi * df_final['jourSemaine'] / max_jour)
- df_final['jour_cos'] = np.cos(2 * np.pi * df_final['jourSemaine'] / max_jour)
- # Supprime les colonnes originales si nécessaire
- df_final = df_final.drop(columns=['tranche_25min', 'jourSemaine'])
- df_final
- X = df_final.drop(columns=['pmr_total'])
- y = df_final['pmr_total']
- X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
- rf = RandomForestRegressor(n_estimators=100, random_state=42)
- rf.fit(X_train, y_train)
- y_pred = rf.predict(X_test)
- mae = mean_absolute_error(y_test, y_pred)
- rmse = mean_squared_error(y_test, y_pred, squared=False)
- print(f"MAE: {mae:.2f}")
- print(f"RMSE: {rmse:.2f}")
- ordered_columns = [
- "nb_vols_total",
- "pmr_arrivee_Aer Lingus (EI)",
- "pmr_arrivee_Air Algerie (AH)",
- "pmr_arrivee_Air Canada (AC)",
- "pmr_arrivee_Air China (CA)",
- "pmr_arrivee_Air France (AF)",
- "pmr_arrivee_Air India (AI)",
- "pmr_arrivee_Air Senegal (HC)",
- "pmr_arrivee_Air Tahiti Nui (TN)",
- "pmr_arrivee_American Airlines (AA)",
- "pmr_arrivee_Asiana Airlines (OZ)",
- "pmr_arrivee_Avianca (AV)",
- "pmr_arrivee_Brussels Airlines (SN)",
- "pmr_arrivee_Cathay Pacific (CX)",
- "pmr_arrivee_EL AL (LY)",
- "pmr_arrivee_Emirates (EK)",
- "pmr_arrivee_Etihad Airways (EY)",
- "pmr_arrivee_LATAM Chile (LA)",
- "pmr_arrivee_Lufthansa (LH)",
- "pmr_arrivee_Norwegian Air Sweden (N0)",
- "pmr_arrivee_Nouvelair (BJ)",
- "pmr_arrivee_Other",
- "pmr_arrivee_PIA (PK)",
- "pmr_arrivee_Qatar Airways (QR)",
- "pmr_arrivee_SAS Scandinavian (SK)",
- "pmr_arrivee_Singapore Airlines (SQ)",
- "pmr_arrivee_SunExpress (XQ)",
- "pmr_arrivee_Turkish Airlines (TK)",
- "pmr_arrivee_United Airlines (UA)",
- "pmr_arrivee_Volotea (VF)",
- "pmr_arrivee_easyJet (EZY)",
- "pmr_arrivee_easyJet Europe (EJU)",
- "pmr_depart_Air Algerie (AH)",
- "pmr_depart_Air Canada (AC)",
- "pmr_depart_Air France (AF)",
- "pmr_depart_Air India (AI)",
- "pmr_depart_Air Senegal (HC)",
- "pmr_depart_Alitalia (AZ)",
- "pmr_depart_American Airlines (AA)",
- "pmr_depart_Avianca (AV)",
- "pmr_depart_British Airways (BA)",
- "pmr_depart_Brussels Airlines (SN)",
- "pmr_depart_EL AL (LY)",
- "pmr_depart_Emirates (EK)",
- "pmr_depart_Ethiopian Airlines (ET)",
- "pmr_depart_Jet2.com (LS)",
- "pmr_depart_Lufthansa (LH)",
- "pmr_depart_Nouvelair (BJ)",
- "pmr_depart_Other",
- "pmr_depart_Qatar Airways (QR)",
- "pmr_depart_Royal Air Maroc (AT)",
- "pmr_depart_SunExpress (XQ)",
- "pmr_depart_Turkish Airlines (TK)",
- "pmr_depart_United Airlines (UA)",
- "pmr_depart_Volotea (VF)",
- "pmr_depart_easyJet (EZY)",
- "pmr_depart_easyJet Europe (EJU)",
- "arrivee_Aer Lingus (EI)",
- "arrivee_Air Algerie (AH)",
- "arrivee_Air Canada (AC)",
- "arrivee_Air China (CA)",
- "arrivee_Air France (AF)",
- "arrivee_Air India (AI)",
- "arrivee_Air Senegal (HC)",
- "arrivee_Air Tahiti Nui (TN)",
- "arrivee_American Airlines (AA)",
- "arrivee_Asiana Airlines (OZ)",
- "arrivee_Avianca (AV)",
- "arrivee_Brussels Airlines (SN)",
- "arrivee_Cathay Pacific (CX)",
- "arrivee_EL AL (LY)",
- "arrivee_Emirates (EK)",
- "arrivee_Etihad Airways (EY)",
- "arrivee_LATAM Chile (LA)",
- "arrivee_Lufthansa (LH)",
- "arrivee_Norwegian Air Sweden (N0)",
- "arrivee_Nouvelair (BJ)",
- "arrivee_Other",
- "arrivee_PIA (PK)",
- "arrivee_Qatar Airways (QR)",
- "arrivee_SAS Scandinavian (SK)",
- "arrivee_Singapore Airlines (SQ)",
- "arrivee_SunExpress (XQ)",
- "arrivee_Turkish Airlines (TK)",
- "arrivee_United Airlines (UA)",
- "arrivee_Volotea (VF)",
- "arrivee_easyJet (EZY)",
- "arrivee_easyJet Europe (EJU)",
- "depart_Air Algerie (AH)",
- "depart_Air Canada (AC)",
- "depart_Air France (AF)",
- "depart_Air India (AI)",
- "depart_Air Senegal (HC)",
- "depart_Alitalia (AZ)",
- "depart_American Airlines (AA)",
- "depart_Avianca (AV)",
- "depart_British Airways (BA)",
- "depart_Brussels Airlines (SN)",
- "depart_EL AL (LY)",
- "depart_Emirates (EK)",
- "depart_Ethiopian Airlines (ET)",
- "depart_Jet2.com (LS)",
- "depart_Lufthansa (LH)",
- "depart_Nouvelair (BJ)",
- "depart_Other",
- "depart_Qatar Airways (QR)",
- "depart_Royal Air Maroc (AT)",
- "depart_SunExpress (XQ)",
- "depart_Turkish Airlines (TK)",
- "depart_United Airlines (UA)",
- "depart_Volotea (VF)",
- "depart_easyJet (EZY)",
- "depart_easyJet Europe (EJU)",
- "minutes",
- "tranche_num",
- "tranche_sin",
- "tranche_cos",
- "jour_sin",
- "jour_cos"
- ]
- def generate_pmr(size):
- return np.random.poisson(lam=2, size=size)
- n_samples = 1000
- pmr_arrivee_cols = [c for c in ordered_columns if c.startswith("pmr_arrivee_")]
- pmr_depart_cols = [c for c in ordered_columns if c.startswith("pmr_depart_")]
- arrivee_cols = [c for c in ordered_columns if c.startswith("arrivee_")]
- depart_cols = [c for c in ordered_columns if c.startswith("depart_")]
- data = {}
- data["nb_vols_total"] = np.random.randint(0, 50, size=n_samples)
- for col in pmr_arrivee_cols:
- data[col] = generate_pmr(n_samples)
- for col in pmr_depart_cols:
- data[col] = generate_pmr(n_samples)
- for col in arrivee_cols + depart_cols:
- # Binary 0/1 for arrival/departure presence flags
- data[col] = np.random.choice([0, 1], size=n_samples)
- data["minutes"] = np.random.randint(0, 1440, size=n_samples)
- data["tranche_num"] = data["minutes"] // 25
- data["tranche_sin"] = np.sin(2 * np.pi * data["tranche_num"] / 96)
- data["tranche_cos"] = np.cos(2 * np.pi * data["tranche_num"] / 96)
- jour_num = np.random.randint(0, 7, size=n_samples)
- data["jour_sin"] = np.sin(2 * np.pi * jour_num / 7)
- data["jour_cos"] = np.cos(2 * np.pi * jour_num / 7)
- import pandas as pd
- df = pd.DataFrame(data)
- df = df[ordered_columns]
- pmr_pred = rf.predict(df)
- for tranche, pred in zip(data['tranche_num'], pmr_pred):
- start_minute = tranche * 25
- end_minute = (tranche + 1) * 25 - 1
- start_hour, start_min = divmod(start_minute, 60)
- end_hour, end_min = divmod(end_minute, 60)
- print(f"Tranche {tranche} ({start_hour:02d}:{start_min:02d} - {end_hour:02d}:{end_min:02d}): Prédiction PMR = {pred:.2f}")
- import requests
- import pandas as pd
- import numpy as np
- API_KEY = "OaVTBoRzf6lvHiOkYr8UFhNg06CGGdB6"
- # Fonction qui récupère la liste des jours fériés d'une année pour un pays
- def get_holidays_for_year_country(year, country_code):
- url = "https://calendarific.com/api/v2/holidays"
- params = {
- 'api_key': API_KEY,
- 'country': country_code,
- 'year': year,
- 'type': 'national,religious' # tu peux ajuster le type si besoin
- }
- response = requests.get(url, params=params)
- if response.status_code != 200:
- print(f"Erreur API pour {year} - {country_code}: {response.status_code}")
- return set()
- holidays = response.json().get('response', {}).get('holidays', [])
- # Extraire les dates ISO (YYYY-MM-DD) dans un set pour accès rapide
- holiday_dates = set(hol['date']['iso'] for hol in holidays)
- return holiday_dates
- df['ST arrivée'] = pd.to_datetime(df['ST arrivée'], errors='coerce')
- df['year_arrivee'] = df['ST arrivée'].dt.year
- unique_year_country = df[['year_arrivee', 'code_pays_origine']].dropna().drop_duplicates()
- # Dictionnaire pour stocker les jours fériés par (année, pays)
- holidays_map = {}
- for idx, row in unique_year_country.iterrows():
- year = int(row['year_arrivee'])
- country = row['code_pays_origine']
- holidays_map[(year, country)] = get_holidays_for_year_country(year, country)
- # Fonction pour vérifier si la date est un jour férié via le mapping
- def is_holiday_mapped(row):
- if pd.isnull(row['ST arrivée']) or pd.isnull(row['code_pays_origine']):
- return False
- key = (row['ST arrivée'].year, row['code_pays_origine'])
- date_str = row['ST arrivée'].strftime('%Y-%m-%d')
- return date_str in holidays_map.get(key, set())
- df['jour_ferie_arrivee'] = df.apply(is_holiday_mapped, axis=1)
- df.drop(columns=['year_arrivee'], inplace=True)
- def encode_cyclique_time(dt_series):
- minutes = dt_series.dt.hour.fillna(0) * 60 + dt_series.dt.minute.fillna(0)
- minutes_in_day = 24 * 60
- sin_time = np.sin(2 * np.pi * minutes / minutes_in_day)
- cos_time = np.cos(2 * np.pi * minutes / minutes_in_day)
- return sin_time, cos_time
- df['sin_ST_arrivee'], df['cos_ST_arrivee'] = encode_cyclique_time(df['ST arrivée'])
- df['jour_sem_arrivee'] = df['ST arrivée'].dt.dayofweek
- features_pmr = [
- 'Num Vol arrivée',
- 'Code Cie arrivée',
- 'code_pays_origine',
- 'Origine',
- 'jour_sem_arrivee',
- 'sin_ST_arrivee', 'cos_ST_arrivee',
- 'jour_ferie_arrivee'
- ]
- df_volArr = df[features_pmr].dropna().copy()
- df_volArr.head(30)
- !pip install lightgbm
- pip install catboost
- import pandas as pd
- import numpy as np
- import requests
- from sklearn.model_selection import train_test_split
- from sklearn.metrics import mean_squared_error, r2_score
- from lightgbm import LGBMRegressor
- from catboost import CatBoostRegressor, Pool
- from sklearn.metrics import confusion_matrix, accuracy_score, ConfusionMatrixDisplay
- import matplotlib.pyplot as plt
- API_KEY = "OaVTBoRzf6lvHiOkYr8UFhNg06CGGdB6"
- def get_holidays_for_year_country(year, country_code):
- url = "https://calendarific.com/api/v2/holidays"
- params = {
- 'api_key': API_KEY,
- 'country': country_code,
- 'year': year,
- 'type': 'national,religious'
- }
- try:
- response = requests.get(url, params=params, timeout=10)
- response.raise_for_status()
- except requests.RequestException as e:
- print(f"Erreur API pour {year} - {country_code}: {e}")
- return set()
-
- holidays = response.json().get('response', {}).get('holidays', [])
- return set(hol['date']['iso'] for hol in holidays if 'date' in hol and 'iso' in hol['date'])
- def encode_cyclique_time(dt_series):
- hours = dt_series.dt.hour.fillna(0)
- minutes = dt_series.dt.minute.fillna(0)
- total_minutes = hours * 60 + minutes
- minutes_in_day = 24 * 60
- sin_time = np.sin(2 * np.pi * total_minutes / minutes_in_day)
- cos_time = np.cos(2 * np.pi * total_minutes / minutes_in_day)
- return sin_time, cos_time
- def prepare_data():
- local_csv_path = "export_des_missions_2025-06-13_100933-8546-653608357.csv"
- cols_to_keep = ['Num Vol arrivée', 'Num Vol départ', 'Code Cie arrivée', 'Code Cie départ',
- 'Origine', 'Destination', 'ST départ', 'ST arrivée']
- df = pd.read_csv(local_csv_path, sep=';')
- df = df[cols_to_keep].copy()
- df['ST arrivée'] = pd.to_datetime(df['ST arrivée'], errors='coerce')
- df['ST départ'] = pd.to_datetime(df['ST départ'], errors='coerce')
- airports = pd.read_csv('airports.csv')
- df_iata_pays = airports[['iata_code', 'iso_country']].dropna(subset=['iata_code'])
- df_iata_pays_origin = df_iata_pays.rename(columns={'iata_code': 'Origine', 'iso_country': 'code_pays_origine'})
- df_iata_pays_dest = df_iata_pays.rename(columns={'iata_code': 'Destination', 'iso_country': 'code_pays_destination'})
- df = df.merge(df_iata_pays_origin, on='Origine', how='left')
- df = df.merge(df_iata_pays_dest, on='Destination', how='left')
- pmr_depart = df.groupby('Num Vol départ').size().reset_index(name='pmr_total_depart')
- pmr_arrivee = df.groupby('Num Vol arrivée').size().reset_index(name='pmr_total_arrivee')
- df_depart = df[['Num Vol départ', 'Code Cie départ', 'Origine', 'Destination', 'ST départ', 'code_pays_destination']].copy()
- df_arrivee = df[['Num Vol arrivée', 'Code Cie arrivée', 'Origine', 'Destination', 'ST arrivée', 'code_pays_origine']].copy()
- df_depart = df_depart.merge(pmr_depart, on='Num Vol départ', how='left')
- df_arrivee = df_arrivee.merge(pmr_arrivee, on='Num Vol arrivée', how='left')
- df_depart.rename(columns={
- 'Num Vol départ': 'Num Vol',
- 'Code Cie départ': 'Code Cie',
- 'ST départ': 'ST',
- 'code_pays_destination': 'code_pays',
- 'pmr_total_depart': 'pmr total'
- }, inplace=True)
- df_arrivee.rename(columns={
- 'Num Vol arrivée': 'Num Vol',
- 'Code Cie arrivée': 'Code Cie',
- 'ST arrivée': 'ST',
- 'code_pays_origine': 'code_pays',
- 'pmr_total_arrivee': 'pmr total'
- }, inplace=True)
- df_depart['type_vol'] = 'depart'
- df_arrivee['type_vol'] = 'arrivee'
- df_depart = df_depart[df_depart['Num Vol'].notna() & (df_depart['Num Vol'] != '')]
- df_arrivee = df_arrivee[df_arrivee['Num Vol'].notna() & (df_arrivee['Num Vol'] != '')]
- df_vols = pd.concat([df_depart, df_arrivee], ignore_index=True)
- df_vols = df_vols.drop_duplicates(subset=['Num Vol'])
- df_vols['Trajet'] = df_vols.apply(
- lambda row: row['Destination'] if row['type_vol'] == 'depart' else row['Origine'],
- axis=1
- )
- df_vols['ST'] = pd.to_datetime(df_vols['ST'], errors='coerce')
- df_vols['Origine'] = df_vols['Origine'].fillna('')
- df_vols['Destination'] = df_vols['Destination'].fillna('')
- df_vols['code_pays'] = df_vols['code_pays'].fillna('')
-
- # Compter le nombre de vols par jour
- frequence_vol_par_jour = df_vols.groupby(['Num Vol']).size().rename('frequence_vol_par_jour')
- df_vols = df_vols.merge(frequence_vol_par_jour, on='Num Vol', how='left')
- unique_year_country = df_vols[['ST', 'code_pays']].dropna()
- unique_year_country['year'] = unique_year_country['ST'].dt.year
- unique_year_country = unique_year_country[['year', 'code_pays']].drop_duplicates()
- holidays_map = {}
- for _, row in unique_year_country.iterrows():
- key = (int(row['year']), row['code_pays'])
- if key not in holidays_map:
- holidays_map[key] = get_holidays_for_year_country(*key)
- def is_holiday(row):
- if pd.isnull(row['ST']) or pd.isnull(row['code_pays']):
- return False
- key = (row['ST'].year, row['code_pays'])
- date_str = row['ST'].strftime('%Y-%m-%d')
- return date_str in holidays_map.get(key, set())
- df_vols['jour_ferie'] = df_vols.apply(is_holiday, axis=1)
- df_vols['sin_ST'], df_vols['cos_ST'] = encode_cyclique_time(df_vols['ST'])
- df_vols['jour_sem'] = df_vols['ST'].dt.dayofweek.fillna(-1).astype(int)
- final_cols = [
- 'Num Vol',
- 'Code Cie',
- 'Trajet',
- 'jour_sem',
- 'sin_ST',
- 'cos_ST',
- 'jour_ferie',
- 'frequence_vol_par_jour',
- 'pmr total'
- ]
- df_vols_final = df_vols[final_cols].copy()
- df_vols_final.to_csv('vols.csv', index=False)
- print("Données enrichies sauvegardées dans vols.csv")
- def train_and_evaluate():
- df = pd.read_csv('vols.csv')
- X = df.drop(columns=["pmr total", "Num Vol"])
- y = df["pmr total"]
- categorical_cols = X.select_dtypes(include='object').columns.tolist()
- X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
- train_pool = Pool(X_train, y_train, cat_features=categorical_cols)
- test_pool = Pool(X_test, y_test, cat_features=categorical_cols)
- model = CatBoostRegressor(
- iterations=1000,
- learning_rate=0.05,
- depth=6,
- loss_function='RMSE',
- eval_metric='RMSE',
- random_seed=42,
- verbose=100,
- early_stopping_rounds=50
- )
- model.fit(train_pool, eval_set=test_pool, use_best_model=True)
- y_pred = model.predict(X_test)
- mse = mean_squared_error(y_test, y_pred)
- r2 = r2_score(y_test, y_pred)
- print(f"Mean Squared Error (MSE): {mse:.2f}")
- print(f"R^2 Score: {r2:.2f}")
- df_result = X_test.copy()
- df_result['y_true'] = y_test
- df_result['y_pred'] = y_pred
- print(df_result.head(10))
-
- total_y_true = y_test.sum()
- print(f"Somme totale de y_true : {total_y_true}")
- total_y_pred = y_pred.sum()
- print(f"Somme totale de y_pred : {total_y_pred}")
-
- y_test_class = y_test.round().astype(int)
- y_pred_class = np.round(y_pred).astype(int)
- cm = confusion_matrix(y_test_class, y_pred_class)
- acc = accuracy_score(y_test_class, y_pred_class)
- print(f"\nAccuracy (rounded predictions): {acc:.2f}")
- disp = ConfusionMatrixDisplay(confusion_matrix=cm)
- disp.plot(cmap='Blues')
- plt.title('Confusion Matrix (rounded values)')
- plt.show()
- if __name__ == "__main__":
- prepare_data()
- train_and_evaluate()
- import pandas as pd
- from sklearn.linear_model import Ridge
- from sklearn.metrics import mean_squared_error, r2_score
- from sklearn.model_selection import train_test_split
- # Charger les données
- df = pd.read_csv("vols.csv")
- y = df["pmr total"]
- X = df.drop(columns=["pmr total"])
- X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
- # Encodage par la moyenne cible (Target Encoding)
- X_train_enc = X_train.copy()
- X_test_enc = X_test.copy()
- for col in X.select_dtypes(include=["object", "category"]).columns:
- means = X_train_enc.join(y_train)[[col, "pmr total"]].groupby(col)["pmr total"].mean()
- X_train_enc[col] = X_train_enc[col].map(means)
- X_test_enc[col] = X_test_enc[col].map(means)
-
- # Remplacer les valeurs inconnues (non vues dans le train) par la moyenne globale
- global_mean = y_train.mean()
- X_test_enc[col] = X_test_enc[col].fillna(global_mean)
- # Modèle Ridge
- model = Ridge(alpha=1.0)
- model.fit(X_train_enc, y_train)
- # Prédictions
- y_pred = model.predict(X_test_enc)
- # Évaluation
- mse = mean_squared_error(y_test, y_pred)
- r2 = r2_score(y_test, y_pred)
- print(f"Mean Squared Error (MSE): {mse:.2f}")
- print(f"R² Score: {r2:.2f}")
- with open("AE.ipynb", "r", encoding="utf-8") as f:
- notebook = json.load(f)
- with open("code.py", "w", encoding="utf-8") as f:
- for cell in notebook["cells"]:
- if cell["cell_type"] == "code":
- f.write("".join(cell["source"]))
- f.write("\n\n")
|