Mini Doc 518
Mini Doc 518
Mini Doc 518
BACHELOR OF TECHNOLOGY
in
INFORMATION TECHNOLOGY
Submitted by
(BATCH - 10)
A.AMRUTHA : 207Y1A1205
D.JAYANTHI : 207Y1A1218
of
This is to certify that the project titled “E-Pilots: A System to Predict Hard Landing During the
Approach Phase of Commercial Flights” is being submitted by A.AMRUTHA (207Y1A1205) and
D.JAYANTHI (207Y1A1218) in IV B.tech I semester in INFORMATION TECHNOLOGY is a
record bonafide work carried out by them. The results embodied in this report have not been
submitted to anyother university for the award of any degree.
This is to certify that the project titled “E-Pilots: A System to Predict Hard Landing During the
Approach Phase of Commercial Flights” is being submitted by A.AMRUTHA (207Y1A1205)
and D.JAYANTHI (207Y1A1218) in IV B.tech I semester in INFORMATION
TECHNOLOGY is a record bonafide work carried out by them. The results embodied in this report
have not been submitted to any other university for the award of any degree.
Date:
A.AMRUTHA D.JAYANTHI
(207Y1A1205) (207Y1A1218)
We are happy to express my deep sense of gratitude to the principal of the college Dr.K.
VENKATESWARA REDDY, Professor, Department of Computer Science and Engineering, Marri
Laxman Reddy Institute of Technology & Management, for having provided me with adequate facilities
to pursue my project.
We would like to thank Dr. M. NAGALAKSHMI, Assoc Professor and Head of The Department of
Information Technology (IT), Marri Laxman Reddy Institute of Technology & Management, for
having provided the freedom to use all the facilities available in the department, especially the
laboratories and the library.
We are very grateful to my project guide Mr.CH.V.V. NARASHIMA RAJU, Ass. Prof.,
Department of Information Technology (IT), Marri Laxman Reddy Institute of Technology
&Management, for her extensive patience and guidance throughout my project work.
We sincerely thank my seniors and all the teaching and non-teaching staff of the Department of
Computer Science for their timely suggestions, healthy criticism and motivation during the course of
this work.
We would also like to thank my classmates for always being there whenever I needed help or moral
support. With great respect and obedience, I thank my parents and brother who werethe backbone
behind my deeds.
Finally, We express my immense gratitude with pleasure to the other individuals who have either
directly or indirectly contributed to my need at right time for the development and success of this
work.
1. Architecture Diagram 13
2. Use Case Diagram 15
3. Class Diagram 16
4. Sequence Diagram 17
5. Collaboration Diagram 18
6. Python Download 25
7. Python Installation 26
8. Command Prompt 27
9. Python Version 27
10. E-Pilots Page 45
11. Upload Flights Landing Dataset 45
12. Pilot & Actuator 46
13. Preprocess Dataset 46
14. SVM Algorithm 47
15. Logistic Regression Algorithm 47
16. AP2TD Algorithm 48
17. AP2DH Algorithm 48
18. DH2TD Algorithm 49
19. Comparison Graph 49
20. Values For Hybrid LSTM 50
More than half of all commercial aircraft operation accidents could have been prevented by
executing a go around. Making timely decision to execute a go-around manoeuvre can potentially
reduce overall aviation industry accident rate. In this paper, we describe a cockpit-deployable
machine learning system to support flight crew go-around decision-making based on the prediction
of a hard landing event.
This work presents a hybrid approach for hard landing prediction that uses features modelling
temporal dependencies of aircraft variables as inputs to a neural network. Based on a large dataset of
58177 commercial flights, the results show that our approach has 85% of average sensitivity with
74% of average specificity at the go-around point. It follows that our approach is a cockpit-
deployable recommendation system that outperforms existing approaches.
In this paper, we describe a cockpit-deployable machine learning system to support flight crew go-
around decision-making based on the prediction of a hard landing event. Based on a large dataset of
58177 commercial flights, the results show that our approach has 85% of average sensitivity with
74% of average specificity at the go-around point. Making timely decision to execute a go-around
manoeuvre can potentially reduce overall aviation industry accident rate.
These include unstable approach, hard landing, abnormal attitude or bounce at landing, aircraft
lateral deviations at high speed on the ground, and short rolling distance at landing. Some precursors
can occur in isolation, but they can also cause the other precursors, with unstable approach being the
predominant one.
A study conducted by Blajev and Curtis [5] found that 83% of runway excursion accidents in their
16-year analysis period could have been avoided by a go-around decision. A go-around occurs when
the flight crew makes the decision not to continue an approach or a landing, and follows procedures
to conduct another approach or to divert to another airport.
1. INTRODUCTION:
Between 2008-2017, 49% of fatal accidents involving commercial jet worldwide occurred during
final approach and landing, and this statistic has not changed in several decades . A considerable
proportion of approach and landing accidents/incidents involved runway excursions, which has been
identified as one of the top safety concerns shared by European Union Aviation Safety Agency
(EASA) member states , as well as US National Transportation Safety Board and US Federal
Aviation Administration. According to EASA , there are several known precursors to runway
excursions during landing.
These include unstable approach, hard landing, abnormal attitude or bounce at landing, aircraft
lateral deviations at high speed on the ground, and short rolling distance at landing. Some
precursors can occur in isolation, but they can also cause the other precursors, with unstable
approach being the predominant one. Boeing reported that whilst only 3% of approaches in The
associate editor coordinating the review of this manuscript and approving it for publication was
Massimo Cafaro .
Commercial aircraft operation met the criteria of an unstable approach, 97% of them continued to
landing rather than executing a go-around . A study conducted by Blajev and Curtis found
that 83% of runway excursion accidents in their 16-year analysis period could have been avoided
by a go-around decision. Therefore, making timely decision to execute a go-around manoeuvre
could therefore potentially reduce the overall aviation industry accident rate . A go- around occurs
when the flight crew makes the decision not to continue an approach or a landing, and follows
procedures to conduct another approach or to divert to another airport.
Go-around decision can be made by either flight crew members, and can be executed at any point
from the final approach fix point to wheels touching down on the runway (but prior to activation of
brakes, spoilers, or thrust reversers)
Many existing machine learning (SVM, logistic regression and many more) and deep learning LSTM
algorithm already implemented and LSTM give better landing prediction accuracy compare to other
machine learning algorithms but LSTM is not trained to predict the vertical acceleration at TD at the
next time interval after the current observation. In fact, a recurrent network can only predict
acceleration at the immediate time interval from the current observation and its capability for long
term predictions is not clear. Since HL depends on the values of such vertical acceleration in a tight
temporal window at the time of TD, this limits the deployability of system in a cockpit.
In propose paper author has trained LSTM with different features such as Pilot (DH2TD), Actuator
(AP2DH) and Physical (AP2TD). 3 different LSTM algorithms trained on above 3 different features
and then merge all algorithms to form a hybrid model.
2.3 ADVANTAGES
1) The machine learning approach can also be improved in several aspects. Although results appear
superior to existing methods, our models would benefit from a more complex analysis of temporal
dependencies using a convolutional neural network to extract deep dependencies.
2) In the proposed system, for a cockpit-deployable machine learning system to support flight crew
goaround decision, some results regarding the hardware and software requirements, especially for the
speed of network should be investigated.
Hard Disk - 20 GB
Front-End : Python.
Back-End : Django-ORM
4.SYSTEM ARCHITECTURE
System architecture is the design and structure of a software system, including its components,
interactions, interfaces, and behaviors. It is a crucial aspect of software development, as it affects the
quality, performance, scalability, security, and maintainability of the system.
UML stands for Unified Modeling Language. UML is a standardized general-purpose modeling
language in the field of object-oriented software engineering. The standard is managed, and was
created by, the Object Management Group.
The goal is for UML to become a common language for creating models of object oriented computer
software. In its current form UML is comprised of two major components: a Meta-model and a
notation. In the future, some form of method or process may also be added to; or associated with,
UML.
The Unified Modeling Language is a standard language for specifying, Visualization, Constructing
and documenting the artifacts of software system, as well as for business modeling and other non-
software systems.
The UML represents a collection of best engineering practices that have proven successful in the
modeling of large and complex systems.
The UML is a very important part of developing objects oriented software and the software
development process. The UML uses mostly graphical notations to express the design of software
projects.
5.1.1 GOALS
prerpocess dataset
run AP2DHALGORITHM
COMPARIDON
EXIT
USER DATASET
PREPROCESS DATASET
COMPARSION GRAPH
EXIT
6. MODULES
To implement this project we have designed following modules
1) Upload Flight Landing Dataset: using this module we will upload dataset folder with 3 files
and then application read all 3 files and then find and plot graph with number of HARD and
NOT Hard Landing graph
2) Preprocess Dataset: using this module we will normalize and shuffle dataset and then split
dataset into train and test where application used 80% dataset for training and 20% for testing.
3) Run SVM Algorithm: using this module we will train SVM with all features using 80% dataset
and then perform prediction on 20% test data and then calculate SVM sensitivity and
specificity score and then plot graph. Graph closer to 1 will reflect good performance of the
algorithm
4) Run Logistic Regression Algorithm: using this module we will train SVM with all features
using 80% dataset and then perform prediction on 20% test data and then calculate SVM
sensitivity and specificity score and then plot graph. Graph closer to 1 will reflect good
performance of the algorithm
5) Run AP2TD Algorithm: this module train LSTM on PHYSICAL features and then perform
prediction on test data and calculate sensitivity and specificity
6) Run AP2DH Algorithm: this module train LSTM on ACTUATOR features and then perform
prediction on test data and calculate sensitivity and specificity
7) Run DH2TD Algorithm: this module train LSTM on PILOT features and then perform
prediction on test data and calculate sensitivity and specificity. This module merge all modules
to get HYBRID LSTM sensitivity and specificity values
8) Comparison Graph: using this module we will plot sensitivity and specificity graph
The feasibility of the project is analyzed in this phase and business proposal is put forth with a very
general plan for the project and some cost estimates. During system analysis the feasibility study of
the proposed system is to be carried out. This is to ensure that the proposed system is not a burden to
the company. For feasibility analysis, some understanding of the major requirements for the system
is essential.
Three key considerations involved in the feasibility analysis are
ECONOMICAL FEASIBILITY
TECHNICAL FEASIBILITY
SOCIAL FEASIBILITY
This study is carried out to check the economic impact that the system will have on the
organization. The amount of fund that the company can pour into the research and development of
the system is limited. The expenditures must be justified. Thus the developed system as well within
the budget and this was achieved because most of the technologies used are freely available. Only
the customized products had to be purchased.
This study is carried out to check the technical feasibility, that is, the technical requirements
of the system. Any system developed must not have a high demand on the available technical
resources. This will lead to high demands on the available technical resources. This will lead to high
demands being placed on the client. The developed system must have a modest requirement, as only
minimal or null changes are required for implementing this system.
SOFTWARE ENVIRONMENT
Tensorflow
TensorFlow is a free and open-source software library for dataflow and differentiable programming
across a range of tasks. It is a symbolic math library, and is also used for machine learning applications
such as neural networks. It is used for both research and production at Google.
TensorFlow was developed by the Google Brain team for internal Google use. It was released under
the Apache 2.0 open-source license on November 9, 2015.
Numpy
Numpy is a general-purpose array-processing package. It provides a high-performance
multidimensional array object, and tools for working with these arrays.
It is the fundamental package for scientific computing with Python. It contains various features
including these important ones:
Pandas
Pandas is an open-source Python Library providing high-performance data manipulation and analysis
tool using its powerful data structures. Python was majorly used for data munging and preparation. It
had very little contribution towards data analysis. Pandas solved this problem. Using Pandas, we can
accomplish five typical steps in the processing and analysis of data, regardless of the origin of data
load, prepare, manipulate, model, and analyze. Python with Pandas is used in a wide range of fields
including academic and commercial domains including finance, economics, Statistics, analytics, etc.
Matplotlib is a Python 2D plotting library which produces publication quality figures in a variety of
hardcopy formats and interactive environments across platforms. Matplotlib can be used in Python
scripts, the Python and IPython shells, the Jupyter Notebook, web application servers, and four
graphical user interface toolkits. Matplotlib tries to make easy things easy and hard things possible.
You can generate plots, histograms, power spectra, bar charts, error charts, scatter plots, etc., with just
a few lines of code. For examples, see the sample plots and thumbnail gallery.
For simple plotting the pyplot module provides a MATLAB-like interface, particularly when
combined with IPython. For the power user, you have full control of line styles, font properties, axes
properties, etc, via an object oriented interface or via a set of functions familiar to MATLAB users.
Scikit – learn
Scikit-learn provides a range of supervised and unsupervised learning algorithms via a consistent
interface in Python. It is licensed under a permissive simplified BSD license and is distributed under
many Linux distributions, encouraging academic and commercial use.
Python
Python features a dynamic type system and automatic memory management. It supports multiple
programming paradigms, including object-oriented, imperative, functional and procedural, and has a
large and comprehensive standard library.
Python is Interpreted − Python is processed at runtime by the interpreter. You do not need to compile
your program before executing it. This is similar to PERL and PHP.
Python is Interactive − you can actually sit at a Python prompt and interact with the interpreter directly
to write your programs.
Python also acknowledges that speed of development is important. Readable and terse code is part of
this, and so is access to powerful constructs that avoid tedious repetition of code. Maintainability also
ties into this may be an all but useless metric, but it does say something about how much code you
have to scan, read and/or understand to troubleshoot problems or tweak behaviors. This speed of
Machine Learning
Employ Machine Learning Or Deep Learning Techniques To Build Predictive Models For Hard Landing
Detection.You May Use Libraries Like Tensorflow,Pytorch, Or Scikit-Learn In Python. Train The Models
Using Historical Flight Data,Considering Features Such As Altitude,Airspeed,Pitch,Roll,Yaw,Weather
Conditions,And Previous Landing Outcomes.
Implement And Fine-Tune Algorithms That Can Classify Landings As Hard Or Safe Based On The
Predictive Models Output.
Downloading Steps
Step 1: Go to the official site to download and install python using Google Chrome or any other web
browser. OR Click on the following link: https://www.python.org
Now, check for the latest and the correct version for your operating system.
Installation of Python
Step 1: Go to Download and Open the downloaded python version to carry out the installation
process.
Step 2: Before you click on Install Now, Make sure to put a tick on Add Python 3.7 to PATH.
Note: If you have any of the earlier versions of Python already installed. You must first uninstall the
earlier version and then install the new one.
SYSTEM TESTING
The purpose of testing is to discover errors. Testing is the process of trying to discover every
conceivable fault or weakness in a work product. It provides a way to check the functionality of
components, sub assemblies, assemblies and/or a finished product It is the process of exercising
software with the intent of ensuring that the Software system meets its requirements and user
expectations and does not fail in an unacceptable manner. There are various types of test. Each test
type addresses a specific testing requirement.
Field testing will be performed manually and functional tests will be written in detail.
Test objectives
All field entries must work properly.
Pages must be activated from the identified link.
The entry screen, messages and responses must not be delayed.
Features to be tested
Verify that the entries are of the correct format
No duplicate entries should be allowed
All links should take the user to the correct page.
Test Results: All the test cases mentioned above passed successfully. No defects encountered.
MAIN.PY
#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import tkinter
import pandas as pd
import numpy as np
import os
main = Tk()
main.title("E-Pilots: A System to Predict Hard Landing During the Approach Phase of Commercial
Flights")
main.geometry("1300x1200")
global filename
global dataset
global Y, all_data
def uploadDataset():
text.delete('1.0', END)
pilot = pd.read_csv("Dataset/Pilot.csv")
actuator = pd.read_csv("Dataset/Actuators.csv")
physical = pd.read_csv("Dataset/Physical.csv")
Y = physical['label'].values
all_data = [physical, actuator, pilot] #merge all datasets to train SVM and logistic regression
text.insert(END,str(pilot.head())+"\n\n")
text.insert(END,str(actuator.head())+"\n\n")
text.insert(END,str(physical.head())+"\n\n")
text.update_idletasks()
height = count
y_pos = np.arange(len(bars))
plt.bar(y_pos, height)
plt.xticks(y_pos, bars)
plt.xlabel("Landing Type")
plt.ylabel("Counts")
plt.show()
def preprocessDataset():
text.delete('1.0', END)
pilot = pilot.values
actuator = actuator.values
physical = physical.values
all_data = all_data.values
indices = np.arange(all_data.shape[0])
np.random.shuffle(indices)
all_data = all_data[indices]
Y = Y[indices]
pilot = pilot[indices]
actuator = actuator[indices]
physical = physical[indices]
scaler1 = StandardScaler()
all_data = scaler1.fit_transform(all_data)
scaler2 = StandardScaler()
pilot = scaler2.fit_transform(pilot)
scaler3 = StandardScaler()
actuator = scaler3.fit_transform(actuator)
scaler4 = StandardScaler()
Y = to_categorical(Y)
total = sum(sum(cm))
se = cm[0,0]/(cm[0,0]+cm[0,1])
sp = cm[1,1]/(cm[1,0]+cm[1,1])
se = accuracy_score(y_test, predict)
sp = recall_score(y_test, predict)
if sp == 0:
sp = accuracy_score(y_test, predict)
text.update_idletasks()
sensitivity.append(se)
specificity.append(sp)
se = se / 3
sp = sp / 3
text.update_idletasks()
values = []
data.plot(kind = 'box')
plt.xticks(rotation=90)
plt.show()
def runSVM():
text.delete('1.0', END)
sensitivity = []
specificity = []
svm_cls.fit(all_X_train, all_y_train)
predict = svm_cls.predict(all_X_test)
def runLR():
lr_cls = LogisticRegression(max_iter=1,tol=300)
lr_cls.fit(all_X_train, all_y_train)
predict = lr_cls.predict(all_X_test)
def runAP2TD():
if os.path.exists('model/physical_model.json'):
loaded_model_json = json_file.read()
lstm_physical = model_from_json(loaded_model_json)
json_file.close()
lstm_physical.load_weights("model/physical_weights.h5")
lstm_physical._make_predict_function()
else:
#adding LSTM layer with 100 filters to filter given input X train data to select relevant features
lstm_physical.add(LSTM(100,input_shape=(physical_X_train.shape[1],
physical_X_train.shape[2])))
lstm_physical.add(Dropout(0.5))
lstm_physical.add(Dense(100, activation='relu'))
lstm_physical.add(Dense(physical_y_train.shape[1], activation='softmax'))
#start training model on train data and perform validation on test data
lstm_physical.save_weights('model/physical_weights.h5')
model_json = lstm_physical.to_json()
json_file.close()
print(lstm_physical.summary())
predict = lstm_physical.predict(physical_X_test)
def runAP2DH():
if os.path.exists('model/actuator_model.json'):
loaded_model_json = json_file.read()
lstm_actuator = model_from_json(loaded_model_json)
json_file.close()
lstm_actuator.load_weights("model/actuator_weights.h5")
lstm_actuator._make_predict_function()
else:
#adding LSTM layer with 100 filters to filter given input X train data to select relevant features
lstm_actuator.add(LSTM(100,input_shape=(actuator_X_train.shape[1],
actuator_X_train.shape[2])))
lstm_actuator.add(Dropout(0.5))
lstm_actuator.add(Dense(100, activation='relu'))
lstm_actuator.add(Dense(actuator_y_train.shape[1], activation='softmax'))
#start training model on train data and perform validation on test data
lstm_actuator.save_weights('model/actuator_weights.h5')
model_json = lstm_actuator.to_json()
json_file.write(model_json)
json_file.close()
print(lstm_actuator.summary())
predict = lstm_actuator.predict(actuator_X_test)
def runDH2TD():
if os.path.exists('model/pilot_model.json'):
loaded_model_json = json_file.read()
lstm_pilot = model_from_json(loaded_model_json)
json_file.close()
lstm_pilot.load_weights("model/pilot_weights.h5")
lstm_pilot._make_predict_function()
else:
#adding LSTM layer with 100 filters to filter given input X train data to select relevant features
lstm_pilot.add(LSTM(100,input_shape=(pilot_X_train.shape[1], pilot_X_train.shape[2])))
lstm_pilot.add(Dropout(0.5))
lstm_pilot.add(Dense(100, activation='relu'))
lstm_pilot.add(Dense(pilot_y_train.shape[1], activation='softmax'))
#start training model on train data and perform validation on test data
lstm_pilot.save_weights('model/pilot_weights.h5')
model_json = lstm_pilot.to_json()
json_file.write(model_json)
print(lstm_pilot.summary())
predict = lstm_pilot.predict(pilot_X_test)
def graph():
df = pd.DataFrame([['SVM','Sensitivity',sensitivity[0]],['SVM','Specificity',specificity[0]],
['Logistic Regression','Sensitivity',sensitivity[1]],['Logistic
Regression','Specificity',specificity[1]],
['AP2TD','Sensitivity',sensitivity[2]],['AP2TD','Specificity',specificity[2]],
['AP2DH','Sensitivity',sensitivity[3]],['AP2DH','Specificity',specificity[3]],
['DH2TD','Sensitivity',sensitivity[4]],['DH2TD','Specificity',specificity[4]],
],columns=['Parameters','Algorithms','Value'])
plt.show()
def close():
main.destroy()
title = Label(main, text='E-Pilots: A System to Predict Hard Landing During the Approach Phase of
Commercial Flights')
title.config(bg='HotPink4', fg='yellow2')
title.config(font=font)
title.place(x=0,y=5)
uploadButton.place(x=50,y=100)
uploadButton.config(font=font1)
preprocessButton.place(x=350,y=100)
preprocessButton.config(font=font1)
svmButton.place(x=650,y=100)
svmButton.config(font=font1)
lrButton.place(x=50,y=150)
lrButton.config(font=font1)
tdButton.place(x=350,y=150)
tdButton.config(font=font1)
apButton.place(x=650,y=150)
apButton.config(font=font1)
dhButton.place(x=50,y=200)
graphButton.place(x=350,y=200)
graphButton.config(font=font1)
closeButton.place(x=650,y=200)
closeButton.config(font=font1)
text=Text(main,height=20,width=130)
scroll=Scrollbar(text)
text.configure(yscrollcommand=scroll.set)
text.place(x=10,y=300)
text.config(font=font1)
main.config(bg='plum2')
main.mainloop()
OUTPUT
To run project double click on ‗run.bat‘ file to get below output.
Run.bat :
In above screen click on ‗Upload Flight Landing Dataset‘ button to upload dataset and get below
output.
Select Folder :
In above screen dataset loaded and we can see some records from PILOT and ACTUATOR dataset
and you can scroll down above screen text area to view Physical dataset values and in graph x-axis
represents type of landing and y-axis represents counts of landing found in dataset. Now close above
graph and then click on ‗Preprocess Dataset‘ button to normalize, shuffle and split dataset into train
and test and get below output.
Preprocess Dataset :
In above screen with SVM we got sensitivity as 0.82 and Specificity as 0.55 and in box plot x-axis
represents metric names and y-axis represents values. Now close above graph and then click on ‗Run
Logistic Regression Algorithm‘ button to train logistic regression and get below output.
In above screen with AP2TD physical features we got LSTM sensitivity as 0.92 and specificity as 0.95
and now click on ‗Run AP2DH Algorithm‘ to train LSTM on Actuator features and get below output.
In above screen with DH2TD we got LSTM sensitivity as 0.93 and specificity as 0.92 and now click
on ‗Comparison Graph‘ button to get below comparison graph.
Comparison Graph :
In above screen in last we can see sensitivity and specificity values for HYBRID LSTM by combining
all 3 models. For hybrid LSTM we got sensitivity as 0.95 and specificity as 0.96%. This values are
closer to value given in base paper.
The following conclusions can be extracted from the analysis carried out in this paper. The analysis of
automation factors (autopilot, flight direc- tor and auto-thrust) suggests that these factors do not have
any influence on the probability of a HL event and, thus, it might not be necessary to incorporate them
into models. Experiments for the optimization of architectures show that the configurations that
achieve higher sensitivity are the ones with the lowest number of neurons. As reported in the literature
increasing the number of layers and neurons does not improve the performance of neither classifiers
nor regressors. Models using only Physical variables achieve an average recall of 94% with a
specificity of 86% and outperform state- of-the-art LSTM methods. This brings confidence into the
model for early prediction of HL in a cockpit deployable system. Regarding capability for go-around
recommendation before DH, even if we perform better than existing methods, there is a significant
drop in recall and specificity due to the dynamic nature of a landing approach and factors influencing
HL close to TD.
Future Enhacements
Future scopes aim to enhance the system's capabilities, improve flight safety, and provide more
comprehensive support to pilots, air traffic controllers, and other stakeholders involved in the landing
phase of commercial flights.
Based on a large dataset of 58177 commercial flights, the results show that our approach has 85% of
average sensitivity with 74% of average specificity at the go-around point. It follows that our approach
is a cockpit-deployable recommendation system that outperforms existing approaches.
Finally, there are some issues that have not been covered in this work, that remain as future work, and
should be further developed. Among such cases, stand out the robustness of the classifier (regressor)
to unseen cases and its behavior under a drifting data environment. In a safety demanding environment
as aviation, it surely be needed to investigate such issues and we expect to do in further works. In the
future, such a system could be expanded to also include Air Traffic Management in which the
information is shared with the Air Traffic Controller in order to anticipate the likely scenario and
optimize runway use.
References
[1] Statistical Summary of Commercial Jet Airplane Accidents–Worldwide Operations| 1959–2017,
Boeing Commercial Airplanes, Aviation Saf., Seattle, WA, USA, 2018.
[2] ‗‗Developing standardised FDM-based indicators,‘‘ Eur. Aviation Saf. Plan 2012-2015, Cologne,
Germany, 2016.
[3] ‗‗Advisory circular ac no: 91-79a mitigating the risks of a runway overrun upon landing,‘‘ Federal
Aviation Admin., Washington, DC, USA, 2016.
[4] M. Coker and L. S. Pilot, ‗‗Why and when to perform a go-around maneu- ver,‘‘ Boeing Edge, vol.
2014, pp. 5–11, 2014.
[5] T. Blajev and W. Curtis, ‗‗Go-around decision making and execution project: Final report to flight
safety foundation,‘‘ Flight Saf. Found., Alexandria, VA, USA, Mar. 2017.
[6] ‗‗European action plan for the prevention of runway excursions,‘‘ Eurocon- trol, Brussels, Belgium,
2013.
[7] ‗‗Artificial intelligence roadmap—A human-centric approach to ai in avi- ation,‘‘ Eur. Union
Aviation Saf. Agency, Cologne, Germany, 2020.
[8] ‗‗The European plan for aviation safety (EPAS 2020–2024),‘‘ Eur. Union Aviation Saf. Agency,
Cologne, Germany, 2019.
[9] L. Wang, C. Wu, and R. Sun, ‗‗Pilot operating characteristics analysis of long landing based on
flight QAR data,‘‘ in Proc. Int. Conf. Eng. Psychol. Cognit. Ergonom. Berlin, Germany: Springer,
2013, pp. 157–166.
[10] L. Li, J. Hansman, R. Palacios, and R. Welsch, ‗‗Anomaly detection via a Gaussian mixture model
for flight operation and safety monitoring,‘‘ Transp. Res. C, Emerg. Technol., vol. 64, pp. 45–57, Mar.
2016.
[11] M. Miwa, T. Tsuchiya, S. Yonezawa, N. Yokoyama, and A. Suzuki, ‗‗Real-time flight trajectory
generation applicable to emergency land- ing approach,‘‘ Trans. Jpn. Soc. Aeronaut. Space Sci., vol.
52, no. 175, pp. 21–28, 2009.
[13] D. Zhou, X. Zhuang, H. Zuo, H. Wang, and H. Yan, ‗‗Deep learning-based approach for civil
aircraft hazard identification and prediction,‘‘.