Python Plane Classifier

Project Overview

The Python Plane Classifier is a machine learning project designed to classify aircraft type using radar-style dimensional input data. The application takes user-provided aircraft measurements, processes them through a trained model, and returns a predicted aircraft category.

The project was built as a practical demonstration of supervised machine learning, data preprocessing, user input handling, and automated classification. Instead of manually sorting aircraft based on values, the program uses a trained decision tree workflow to make predictions from structured input data.

This project helped connect software development with robotics and embedded systems concepts by showing how sensor-like input data can be processed into useful decisions.

Project Specs

This project included dataset handling, model training, feature selection, prediction logic, console-based user interaction, output formatting, and documentation through screenshots and source code.

Engineering Challenges

One of the main challenges was turning raw input values into a clear classification workflow that a user could understand. The program needed to guide the user through entering values, process those values correctly, and return a prediction in a readable way.

Another challenge was making the project more than a basic script. The classifier needed to demonstrate a complete machine learning flow, including data loading, training, prediction, and output, while still being simple enough for a user to run from the command line.

• Preparing numeric input data for machine learning predictions
• Training a decision tree model for aircraft classification
• Handling user input clearly through a console-based interface
• Formatting prediction results in a way that is easy to understand
• Connecting classification logic to a practical radar-style use case
• Documenting the project with screenshots and source code evidence

System Design

The classifier was designed around a supervised learning workflow. The program loads aircraft-related data, separates the input features from the target classification, trains a decision tree model, and then uses that model to predict aircraft type based on new user input.

The user-facing side of the project runs through a command-line interface. The user enters radar-style aircraft measurements, and the program passes those values into the trained model to produce a classification result.

This structure keeps the system simple while still demonstrating a full machine learning pipeline from data to prediction.

• Python used as the main programming language
• scikit-learn used for machine learning model development
• Decision tree classifier used for prediction logic
• Input features used to represent aircraft measurement data
• Console interface used for user-driven predictions
• Prediction output used to classify the aircraft category

Testing & Iteration

Testing focused on confirming that the program could accept user input, process values without crashing, and return classification results. The output screenshot documents the classifier running and producing predictions from entered values.

During development, the program was refined to make the user flow clearer and the output easier to read. This included improving the instructions shown to the user, checking that values were passed into the model correctly, and making sure the final classification result was displayed cleanly.

• Tested model predictions using sample input values
• Verified that the program accepted user-entered numeric data
• Checked that prediction output displayed correctly
• Improved console instructions for first-time users
• Used screenshots to document working classification behavior

Results & Findings

The Python Plane Classifier successfully demonstrated a working machine learning classification workflow. The program can take structured input data, run it through a trained model, and return an automated aircraft classification result.

The project showed how machine learning can be used to support decision-making systems, especially when input data resembles what a sensor or radar system might provide. This connects directly to robotics and embedded systems, where software often needs to interpret data and decide what action or classification makes sense.

The strongest takeaway from this project was learning how to build a complete prediction pipeline instead of only training a model. The final program includes data handling, model logic, user interaction, and result output.

Future Improvements

Future versions of this project could improve accuracy, usability, and realism by expanding the dataset and adding stronger validation around user input.

• Add a larger and more realistic aircraft dataset
• Compare multiple models such as KNN, random forest, and logistic regression
• Add input validation to catch missing or invalid user values
• Display prediction confidence or probability scores
• Create a simple GUI or web interface for easier use
• Add charts to show model performance and feature importance
• Export predictions to a log file for later review

Technologies Used

Project Links

GitHub Repository: View Source Code

Demo Evidence: The screenshots above show the Python classifier interface, source code, and output behavior. The demo output documents the classifier processing input values and generating automated aircraft classification results.

Key Contributions

• Built the Python-based machine learning classifier
• Implemented a decision tree prediction workflow
• Created a console-based user input and prediction system
• Tested the classifier with sample input values
• Documented the system using screenshots and GitHub source code
• Connected classification logic to a radar-style aircraft use case