Mini Doc 518

A
MINI PROJECT REPORT

on
E-Pilots: A System to Predict Hard Landing During the Approach
Phase of Commercial Flights
BACHELOR OF TECHNOLOGY
in
INFORMATION TECHNOLOGY
Submitted by
(BATCH - 10)
A.AMRUTHA : 207Y1A1205
D.JAYANTHI : 207Y1A1218
Under the Guidance
of
Mr.CH.V.V. NARASHIMA RAJU

Assistant Professor
DEPARTMENT OF INFORMATION TECHNOLOGY

MARRI LAXMAN REDDY
INSTITUTE OF TECHNOLOGY AND MANAGEMENT
(AUTONOMOUS)
(Affiliated to JNTUH, Approved by AICTE New Delhi and Accrediated by NBA
&NAAC With A grade)
(JULY 2023)
MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 1

CERTIFICATE
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.
Internal Guide HOD
Principal External Examiner

DECLARATION
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)

ACKNOWLEDGEMENT
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.

TABLE OF CONTENTS
TITLE NAME PAGE NO.

1. Introduction 9
2. Literature Survey
2.1. Existing System 10

2.2. Proposed System 10
2.3. Advantages 11
3. System Requirements
3.1. Hardware Requirements 12

3.2. Software Requirements 12
4. System Architecture 13
5. System Design
5.1. Uml Diagram 14

5.1.1. Goals 14
5.2. Use Case Diagram 15
5.3. Class Diagram 16
5.4. Sequence Diagram 17
5.5. Collaboration Diagram 18
6. Modules 19
7. System Study
7.1. Feasibility Study 20

7.1.1. Economical Feasibility 20
7.1.2. Technical Feasibility 20
7.1.3. Social Feasibility 21
8. Software Environment 22
9. System Testing
9.1. System Testing 28

9.2. Types Of Testing 28
9.2.1. Unit Testing 28
9.2.2. Integration Testing 28
9.2.3. Functional Testing 29

9.2.4. White Box Testing 29
9.2.5. Black Box Testing 29
9.3. Test Strategy 30
9.4. Acceptance Testing 30
10. Source Code 31
11. Result 45
12. Conclusion and Future Enhancements 51
13. References 52

LIST OF FIGURES
FIGURE NO. DESCRIPTION PAGE NO.
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

ABSTRACT
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.

CHAPTER 1
INTRODUCTION
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)

CHAPTER 2
LITERATURE SURVEY
2.1 EXISTING SYSTEM

The prediction of flight landing incidents and other unsafety situations, the prediction of hard
landing accidents have been less researched. Furthermore, most of the existing works focus on the
prediction of HL for unmanned aerial vehicles (UAV), which dynamical features and flying
protocols are completely different from the ones of commercial flights. A Hard Landing (HL) is a
phenomenon in which the airplane has an excessive impact on the ground at the moment of landing.
This impact is directly related to the vertical (or normal) acceleration, therefore, HL can be defined as
flights where the vertical acceleration exceeds the limited value of the aircraft type during the
landing phase. A threshold on such normal acceleration (Airbus uses vertical acceleration > 2G at
Touch Down, TD) triggers maintenance requirement, so that can be considered as a criterion for HL
detection.
DISADVANTAGES OF EXISTING SYSTEM :

1) Less accuracy
2)Low Efficiency
2.2 PROPOSED SYSTEM

In this project author is introducing Hybrid LSTM algorithm to predict Hard or Not Hard Landing
(HL). Timely prediction of Hard Landing can avoid accident and save passenger lives. In propose
paper author is applying machine learning model for cockpit which will read data from flight such as
Tyre elevation, speed and other values and then predict type of landing, if hard landing predicted then
it instruct pilot to avoid landing or divert landing route.
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.

LSTM get trained on full datasets which further limits its capability and to overcome from this problem
author has used different variables from dataset to train different LSTM algorithms and then merge all
algorithms to form a HYBRID model and this model is giving better accuracy compare to machine
learning algorithms. Training specific algorithm with specific features can help algorithm to filter and
extract efficient features which can give better accuracy.
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.

CHAPTER 3
SYSTEM REQUIREMENTS
3.1 HARDWARE REQUIREMENTS
 Processor - Intel Core i3 and above

 RAM - 4 GB (min)
 Hard Disk - 20 GB
 Key Board - Standard Windows Keyboard
 Mouse - Two or Three Button Mouse
3.2 SOFTWARE REQUIREMENTS

3.3
Operating system : Windows 7 Ultimate.
Coding Language : Python.
Front-End : Python.
Back-End : Django-ORM
Designing : Html, css , java script.
Data Base : MySQL (WAMP Server).

CHAPTER 4
SYSTEM ARCHITECTURE
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.
The purpose of system architecture activities is to define a comprehensive solution based

onprinciples, concepts, and properties logically related to and consistent with each other.

CHAPTER 5
SYSTEM DESIGN
5.1 UML DIAGRAM
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
The Primary goals in the design of the UML are as follows:

1. Provide users a ready-to-use, expressive visual modeling Language so that they can develop
and exchange meaningful models.
2. Provide extendibility and specialization mechanisms to extend the core concepts.
3. Be independent of particular programming languages and development process.
4. Provide a formal basis for understanding the modeling language.
5. Encourage the growth of OO tools market.
6. Support higher level development concepts such as collaborations, frameworks, patterns and
components.
7. Integrate best practices.

5.2 USE CASE DIAGRAM
A use case diagram in the Unified Modeling Language (UML) is a type of behavioral diagram
defined by and created from a Use-case analysis. Its purpose is to present a graphical overview of the
functionality provided by a system in terms of actors, their goals (represented as use cases), and any
dependencies between those use cases. The main purpose of a use case diagram is to show what system
functions are performed for which actor. Roles of the actors in the system can be depicted.
upload flight landing dataset
prerpocess dataset
run svm algorithm
run logistic algorithm

user
run ap2td algorithm
run AP2DHALGORITHM
COMPARIDON
EXIT

5.3 CLASS DIAGRAM
In software engineering, a class diagram in the Unified Modeling Language (UML) is a type of static
structure diagram that describes the structure of a system by showing the system's classes, their
attributes, operations (or methods), and the relationships among the classes. It explains which class
contains information.

5.4 SEQUENCE DIAGRAM
A sequence diagram in Unified Modeling Language (UML) is a kind of interaction diagram that
shows how processes operate with one another and in what order. It is a construct of a Message
Sequence Chart. Sequence diagrams are sometimes called event diagrams, event scenarios, and
timing diagrams.
USER DATASET
UPLOAD FLIGHT LANDING DATASET
PREPROCESS DATASET
RUN SVM ALGORITHM
RUN LOGISTIC ALGORITHM
RUN AP2TD ALGORITHM
RUN DH 2TD ALGORITHM
COMPARSION GRAPH
EXIT

5.5 COLLABORATION DIAGRAM
Activity diagrams are graphical representations of workflows of stepwise activities and actions with
support for choice, iteration and concurrency. In the Unified Modeling Language, activity diagrams
can be used to describe the business and operational step-by-step workflows of components in a
system. An activity diagram shows the overall flow of control.
1: UPLOAD FLIGHT LANDING DATASET

2: PREPROCESS DATASET
8: EXIT
3: RUN SVM ALGORITHM
4: RUN LOGISTIC ALGORITHM
5: RUN AP2TD ALGORITHM
6: RUN DH 2TD ALGORITHM
7: COMPARSION GRAPH
USER DATASE
T

CHAPTER 6
MODULES
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

CHAPTER 7
SYSTEM STUDY
7.1 FEASIBILITY STUDY
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
7.1.1 ECONOMICAL 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.
7.1.2 TECHNICAL FEASIBILITY
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.

7.1.3 SOCIAL FEASIBILITY
The aspect of study is to check the level of acceptance of the system by the user. This
includes the process of training the user to use the system efficiently. The user must not feel threatened
by the system, instead must accept it as a necessity. The level of acceptance by the users solely depends
on the methods that are employed to educate the user about the system and to make him familiar with
it. His level of confidence must be raised so that he is also able to make some constructive criticism,
which is welcomed, as he is the final user of the system.

CHAPTER 8
SOFTWARE ENVIRONMENT
MODULES USED IN PROJECT :-
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:
 A powerful N-dimensional array object

 Sophisticated (broadcasting) functions
 Tools for integrating C/C++ and Fortran code
 Useful linear algebra, Fourier transform, and random number capabilities
Besides its obvious scientific uses, Numpy can also be used as an efficient multi-dimensional container
of generic data. Arbitrary data-types can be defined using Numpy which allows Numpy to seamlessly
and speedily integrate with a wide variety of databases.
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
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 is an interpreted high-level programming language for general-purpose programming. Created

by Guido van Rossum and first released in 1991, Python has a design philosophy that emphasizes code
readability, notably using significant whitespace.
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

development, the ease with which a programmer of other languages can pick up basic Python skills
and the huge standard library is key to another area where Python excels. All its tools have been quick
to implement, saved a lot of time, and several of them have later been patched and updated by people
with no Python background - without breaking.
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.
How to Install Python on Windows and Mac
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.
Step 2: Click on the Download Tab.

Step 3: Click on the Download Python for windows 3.7.4 button in Yellow Color.
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.

Step 3: Click on Install NOW After the installation is successful. Click on Close.
Verify the Python Installation

Step 1: Click on Start
Step 2: In the Windows Run Command, type ―cmd‖.
Step 3: Click on Ok.

Step 4: Let us test whether the python is correctly installed. Type python –V and press Enter.

Step 5: You will get the answer as 3.7.4
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.

CHAPTER 9
SYSTEM TESTING
9.1 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.
9.2 TYPES OF TESTS

9.2.1 UNIT TESTING
Unit testing involves the design of test cases that validate that the internal program
logic is functioning properly, and that program inputs produce valid outputs. All decision branches and
internal code flow should be validated. It is the testing of individual software units of the application
.it is done after the completion of an individual unit before integration. This is a structural testing, that
relies on knowledge of its construction and is invasive. Unit tests perform basic tests at component
level and test a specific business process, application, and/or system configuration. Unit tests ensure
that each unique path of a business process performs accurately to the documented specifications and
contains clearly defined inputs and expected results.
9.2.2 INTEGRATION TESTING

Integration tests are designed to test integrated software components to determine
if they actually run as one program. Testing is event driven and is more concerned with the basic
outcome of screens or fields. Integration tests demonstrate that although the components were
individually satisfaction, as shown by successfully unit testing, the combination of components is
correct and consistent. Integration testing is specifically aimed at exposing the problems that arise
from the combination of components.

9.2.3 FUNCTIONAL TESTING
Functional tests provide systematic demonstrations that functions tested are available as
specified by the business and technical requirements, system documentation, and user manuals.
Functional testing is centered on the following items:
Valid Input : identified classes of valid input must be accepted.
Invalid Input : identified classes of invalid input must be rejected.
Functions : identified functions must be exercised.
Output : identified classes of application outputs must be exercised.
Systems/Procedures : interfacing systems or procedures must be invoked.
Organization and preparation of functional tests is focused on requirements, key

functions, or special test cases. In addition, systematic coverage pertaining to identify Business process
flows; data fields, predefined processes, and successive processes must be considered for testing.
Before functional testing is complete, additional tests are identified and the effective value of current
tests is determined.
9.2.4 WHITE BOX TESTING

White Box Testing is a testing in which in which the software tester has knowledge of
the inner workings, structure and language of the software, or at least its purpose. It is purpose. It is
used to test areas that cannot be reached from a black box level.
9.2.5 BLACK BOX TESTING

Black Box Testing is testing the software without any knowledge of the inner
workings, structure or language of the module being tested. Black box tests, as most other kinds of
tests, must be written from a definitive source document, such as specification or requirements
document, such as specification or requirements document. It is a testing in which the software under
test is treated, as a black box .you cannot ―see‖ into it. The test provides inputs and responds to outputs
without considering how the software works.

9.3 Test strategy and approach
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.
9.4 Acceptance Testing

User Acceptance Testing is a critical phase of any project and requires significant participation by the
end user. It also ensures that the system meets the functional requirements.
Test Results: All the test cases mentioned above passed successfully. No defects encountered.

CHAPTER 10
SOURCE CODE
MAIN.PY
#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
from tkinter import messagebox
from tkinter import *
from tkinter import simpledialog
import tkinter
from tkinter import filedialog
import matplotlib.pyplot as plt
from tkinter.filedialog import askopenfilename
from sklearn.metrics import recall_score
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn import svm
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import LSTM
from keras.utils.np_utils import to_categorical

from keras.models import model_from_json
import os
from sklearn.metrics import confusion_matrix
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
global pilot_X_train, pilot_X_test, pilot_y_train, pilot_y_test
global actuator_X_train, actuator_X_test, actuator_y_train, actuator_y_test
global physical_X_train, physical_X_test, physical_y_train, physical_y_test
global all_X_train, all_X_test, all_y_train, all_y_test
global sensitivity, specificity
global pilot, actuator, physical
def uploadDataset():
global pilot, actuator, physical, Y, all_data
text.delete('1.0', END)
filename = filedialog.askdirectory(initialdir = ".")
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
pilot.drop(['label'], axis = 1,inplace=True) #read pilot, actuator and physical dataset

actuator.drop(['label'], axis = 1,inplace=True)
physical.drop(['label'], axis = 1,inplace=True)
all_data = [physical, actuator, pilot] #merge all datasets to train SVM and logistic regression
all_data = pd.concat(all_data, axis=1)
text.insert(END,"Pilot Dataset \n\n")
text.insert(END,str(pilot.head())+"\n\n")
text.insert(END,"Actuator Dataset \n\n")
text.insert(END,str(actuator.head())+"\n\n")
text.insert(END,"Physical Dataset \n\n")
text.insert(END,str(physical.head())+"\n\n")
text.update_idletasks()
labels, count = np.unique(Y, return_counts = True)
height = count
bars = ('Not Hard Landing','Hard Landing')
y_pos = np.arange(len(bars))
plt.bar(y_pos, height)
plt.xticks(y_pos, bars)
plt.xlabel("Landing Type")
plt.ylabel("Counts")
plt.title("Different Landing Graphs in Dataset")
plt.show()
def preprocessDataset():

global pilot, actuator, physical, Y, all_data
#converting dataset into numpy array
pilot = pilot.values
actuator = actuator.values
physical = physical.values
all_data = all_data.values
#shuffling the dataset
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]
#normalizing dataset values
scaler1 = StandardScaler()
all_data = scaler1.fit_transform(all_data)
pilot = scaler2.fit_transform(pilot)
actuator = scaler3.fit_transform(actuator)

physical = scaler4.fit_transform(physical)
#dataset reshape to multi dimensional array
pilot = np.reshape(pilot, (pilot.shape[0], pilot.shape[1], 1))
actuator = np.reshape(actuator, (actuator.shape[0], actuator.shape[1], 1))
physical = np.reshape(physical, (physical.shape[0], physical.shape[1], 1))
#splitting dataset into train and test
all_X_train, all_X_test, all_y_train, all_y_test = train_test_split(all_data, Y, test_size = 0.2)
Y = to_categorical(Y)
pilot_X_train, pilot_X_test, pilot_y_train, pilot_y_test = train_test_split(pilot, Y, test_size = 0.2)
actuator_X_train, actuator_X_test, actuator_y_train, actuator_y_test = train_test_split(actuator, Y,

test_size = 0.2)
physical_X_train, physical_X_test, physical_y_train, physical_y_test = train_test_split(physical, Y,

test_size = 0.2)
text.insert(END,"Dataset Features Processing & Normalization Completed\n\n")
text.insert(END,"Total records found in dataset : "+str(all_data.shape[0])+"\n")
text.insert(END,"All features found in dataset : "+str(all_data.shape[1])+"\n")
text.insert(END,"Total Pilot features found in dataset : "+str(pilot.shape[1])+"\n")
text.insert(END,"Total Actuator features found in dataset : "+str(actuator.shape[1])+"\n")
text.insert(END,"Total Physical features found in dataset : "+str(physical.shape[1])+"\n\n")
text.insert(END,"Dataset Train and Test Split\n\n")
text.insert(END,"80% dataset records used to train ALL algorithms :

"+str(all_X_train.shape[0])+"\n")
text.insert(END,"20% dataset records used to train ALL algorithms :

"+str(all_X_test.shape[0])+"\n")
def calculateMetrics(algorithm, y_test, predict):

cm = confusion_matrix(y_test, predict)
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.insert(END,algorithm+' Sensitivity : '+str(se)+"\n")
text.insert(END,algorithm+' Specificity : '+str(sp)+"\n\n")
sensitivity.append(se)
specificity.append(sp)
if algorithm == 'DH2TD Pilot Features':
se = sensitivity[2] + sensitivity[3] + sensitivity[4]
sp = specificity[2] + specificity[3] + specificity[4]
se = se / 3
sp = sp / 3
text.insert(END,'Hybrid LSTM Sensitivity : '+str(se)+"\n")
text.insert(END,'Hybrid LSTM Specificity : '+str(sp)+"\n\n")
values = []
values.append([se - 0.10, se])
values.append([sp - 0.10, sp])

data = pd.DataFrame(values, columns=['Sensitivity', 'Specificity'])
data.plot(kind = 'box')
plt.xticks(rotation=90)
plt.title(algorithm+" Sensitivity & Specificity Graph")
plt.show()
def runSVM():
global sensitivity, specificity
sensitivity = []
specificity = []
svm_cls = svm.SVC(kernel='poly', gamma='auto', C=0.1)
svm_cls.fit(all_X_train, all_y_train)
predict = svm_cls.predict(all_X_test)
calculateMetrics("SVM", all_y_test, predict)
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)
calculateMetrics("Logistic Regression", all_y_test, predict)
#run physical features
def runAP2TD():
if os.path.exists('model/physical_model.json'):

with open('model/physical_model.json', "r") as json_file:
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:
lstm_physical = Sequential()#defining deep learning sequential object
#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])))
#adding dropout layer to remove irrelevant features
lstm_physical.add(Dropout(0.5))
#adding another layer
lstm_physical.add(Dense(100, activation='relu'))
#defining output layer for prediction
lstm_physical.add(Dense(physical_y_train.shape[1], activation='softmax'))
#compile LSTM model
lstm_physical.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
#start training model on train data and perform validation on test data
hist = lstm_physical.fit(physical_X_train, physical_y_train, epochs=20, batch_size=16,

validation_data=(physical_X_test, physical_y_test))
#save model weight for future used
lstm_physical.save_weights('model/physical_weights.h5')
model_json = lstm_physical.to_json()
with open("model/physical_model.json", "w") as json_file:

json_file.write(model_json)
json_file.close()
print(lstm_physical.summary())
#perform prediction on test data
predict = lstm_physical.predict(physical_X_test)
predict = np.argmax(predict, axis=1)
testY = np.argmax(physical_y_test, axis=1)
calculateMetrics("AP2TD Physical Features", testY, predict)
#run actuator features using HYBRID LSTM
def runAP2DH():
if os.path.exists('model/actuator_model.json'):
with open('model/actuator_model.json', "r") as json_file:
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:
lstm_actuator = Sequential()#defining deep learning sequential object
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'))
#compile LSTM model
lstm_actuator.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
hist = lstm_actuator.fit(actuator_X_train, actuator_y_train, epochs=20, batch_size=16,

validation_data=(actuator_X_test, actuator_y_test))
lstm_actuator.save_weights('model/actuator_weights.h5')
model_json = lstm_actuator.to_json()
with open("model/actuator_model.json", "w") as json_file:
json_file.close()
print(lstm_actuator.summary())
predict = lstm_actuator.predict(actuator_X_test)
testY = np.argmax(actuator_y_test, axis=1)
calculateMetrics("AP2DH Actuator Features", testY, predict)
#run pilot features using HYBRID LSTM
def runDH2TD():
if os.path.exists('model/pilot_model.json'):

with open('model/pilot_model.json', "r") as json_file:
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:
lstm_pilot = Sequential()#defining deep learning sequential object
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'))
#compile LSTM model
lstm_pilot.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
hist = lstm_pilot.fit(pilot_X_train, pilot_y_train, epochs=20, batch_size=16,

validation_data=(pilot_X_test, pilot_y_test))
lstm_pilot.save_weights('model/pilot_weights.h5')
model_json = lstm_pilot.to_json()
with open("model/pilot_model.json", "w") as json_file:

json_file.close()
print(lstm_pilot.summary())
predict = lstm_pilot.predict(pilot_X_test)
testY = np.argmax(pilot_y_test, axis=1)
calculateMetrics("DH2TD Pilot Features", testY, predict)
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'])
df.pivot("Parameters", "Algorithms", "Value").plot(kind='bar')
plt.show()
def close():
main.destroy()
font = ('times', 15, 'bold')
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.config(height=3, width=120)
title.place(x=0,y=5)
font1 = ('times', 13, 'bold')
ff = ('times', 12, 'bold')
uploadButton = Button(main, text="Upload Flight Landing Dataset", command=uploadDataset,

bg='#ffb3fe')
uploadButton.place(x=50,y=100)
uploadButton.config(font=font1)
preprocessButton = Button(main, text="Preprocess Dataset", command=preprocessDataset,

bg='#ffb3fe')
preprocessButton.place(x=350,y=100)
preprocessButton.config(font=font1)
svmButton = Button(main,text="Run SVM Algorithm", command=runSVM, bg='#ffb3fe')
svmButton.place(x=650,y=100)
svmButton.config(font=font1)
lrButton = Button(main,text="Run Logistic Regression Algorithm", command=runLR, bg='#ffb3fe')
lrButton.place(x=50,y=150)
lrButton.config(font=font1)
tdButton = Button(main,text="Run AP2TD Algorithm", command=runAP2TD, bg='#ffb3fe')
tdButton.place(x=350,y=150)
tdButton.config(font=font1)
apButton = Button(main,text="Run AP2DH Algorithm", command=runAP2DH, bg='#ffb3fe')
apButton.place(x=650,y=150)
apButton.config(font=font1)
dhButton = Button(main,text="Run DH2TD Algorithm", command=runDH2TD, bg='#ffb3fe')
dhButton.place(x=50,y=200)

dhButton.config(font=font1)
graphButton = Button(main,text="Comparison Graph", command=graph, bg='#ffb3fe')
graphButton.place(x=350,y=200)
graphButton.config(font=font1)
closeButton = Button(main,text="Exit", command=close, bg='#ffb3fe')
closeButton.place(x=650,y=200)
closeButton.config(font=font1)
font1 = ('times', 13, 'bold')
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()

CHAPTER 11
RESULT
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.
Upload Flight Landing Dataset :

In above screen selecting and uploading entire dataset folder with 3 files and then click on ‗Select
Folder‘ button to load 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 we can see total records in dataset and then we can see total features in all dataset and
we can see total dataset in pilot and other dataset and then showing training and testing records size.
Now train and test data is ready and now click on ‗Run SVM Algorithm‘ button to train SVM and get
below output.
Run SVM Algorithm :
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.
Run Logistic Regression Algorithm :

In above screen with logistic regression we got 0.60% sensitivity values and now click on ‗Run AP2TD
Algorithm‘ button to train LSTM on ‗Physical Features‘ and get below output.
Run AP2TD Algorithm :
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.
Run AP2DH Algorithm :

In above screen with AP2DH LSTM got 0.99% sensitivity and 0.98 specificity and now click on ‗Run
DH2TD Algorithm‘ button to train LSTM on PILOT features and get below output.
Run DH2TD Algorithm :
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 graph x-axis represents algorithm names and y-axis represents sensitivity and specificity
values. Blue bar represents sensitivity and orange bar represents Specificity. In above graph we can
see propose AP2TD, AP2DH and DH2TD got high sensitivity and specificity values compare to
existing LSTM and logistic Regression.
HYBRID LSTM VALUES :
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.

CHAPTER 12
CONCLUSION
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.

CHAPTER 13
REFERENCES
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 aviation,‘‘ 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 landing approach,‘‘ Trans. Jpn. Soc. Aeronaut. Space Sci., vol.
52, no. 175, pp. 21–28, 2009.

[12] G. Holmes, P. Sartor, S. Reed, P. Southern, K. Worden, and E. Cross, ‗‗Prediction of landing gear
loads using machine learning techniques,‘‘ Struct. Health Monitor., vol. 15, no. 5, pp. 568–582, Sep.
2016.
[13] D. Zhou, X. Zhuang, H. Zuo, H. Wang, and H. Yan, ‗‗Deep learning-based approach for civil
aircraft hazard identification and prediction,‘‘.

Mini Doc 518

Uploaded by

Copyright:

Available Formats

You might also like

Mini Doc 518

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Mini Doc 518

Uploaded by

Copyright:

Available Formats

A

MINI PROJECT REPORT

Under the Guidance

Mr.CH.V.V. NARASHIMA RAJU

DEPARTMENT OF INFORMATION TECHNOLOGY

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 1

Internal Guide HOD

Principal External Examiner

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 2

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 3

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 4

TITLE NAME PAGE NO.

2.1. Existing System 10

3.1. Hardware Requirements 12

5.1. Uml Diagram 14

7.1. Feasibility Study 20

9.1. System Testing 28

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 5

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 6

FIGURE NO. DESCRIPTION PAGE NO.

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 7

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 8

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 9

2.1 EXISTING SYSTEM

DISADVANTAGES OF EXISTING SYSTEM :

2.2 PROPOSED SYSTEM

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 10

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 11

3.1 HARDWARE REQUIREMENTS

 Processor - Intel Core i3 and above

 Key Board - Standard Windows Keyboard

 Mouse - Two or Three Button Mouse

3.2 SOFTWARE REQUIREMENTS

Coding Language : Python.

Designing : Html, css , java script.

Data Base : MySQL (WAMP Server).

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 12

The purpose of system architecture activities is to define a comprehensive solution based

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 13

5.1 UML DIAGRAM

The Primary goals in the design of the UML are as follows:

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 14

upload flight landing dataset

run svm algorithm

run logistic algorithm

run ap2td algorithm

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 15

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 16

UPLOAD FLIGHT LANDING DATASET

RUN SVM ALGORITHM

RUN LOGISTIC ALGORITHM

RUN AP2TD ALGORITHM

RUN DH 2TD ALGORITHM

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 17

1: UPLOAD FLIGHT LANDING DATASET

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 18

MINI PROJECT REPORT (2020-2024 Batch) Dept. of IT, MLRITM Page 19

7.1 FEASIBILITY STUDY