A PROJECT REPORT

on

“MODULAR AUTOML SYSTEM FOR REAL

DATA”

Submitted to
KIIT Deemed to be University

In Partial Fulfilment of the Requirement for the Award of

BACHELOR’S DEGREE IN
INFORMATION TECHNOLOGY

BY

CHIRANJIB PARIDA 22053423

SUDIPTA SAHU 22053473
ANAND AYUSHMAN DAS 22053575
PRATEEK PARIJA 22053614
SOUBHAGYA SWAIN 22054199

UNDER THE GUIDANCE OF

[Link] KUMAR
SUBHASIS BEHERA

SCHOOL OF COMPUTER ENGINEERING

KALINGA INSTITUTE OF INDUSTRIAL TECHNOLOGY
BHUBANESWAR, ODISHA - 751024
March 2026
A PROJECT REPORT
 KIIT Deemed to be University
School of Computer Engineering
Bhubaneswar, ODISHA 751024

CERTIFICATE
This is to certify that the project entitled
“CLAUSIFY“
submitted by

CHIRANJIB PARIDA 22053423

SUDIPTA SAHU 22053473
ANAND AYUSHMAN DAS 22053575
PRATEEK PARIJA 22053614
SOUBHAGYA SWAIN 22054199

is a record of bonafide work carried out by them, in the partial fulfilment of the
requirement for the award of Degree of Bachelor of Engineering (Computer Science
& Engineering at KIIT Deemed to be university, Bhubaneswar. This work is done
during year 2025-2026, under our guidance.

Date: / /

Prof. Nayan Kumar Subhasis Behera

Project Guide
 Acknowledgements

We are profoundly grateful to Prof. Nayan Kumar Subhasis Behera of School

of Computer Engineering for his expert guidance and continuous
encouragement throughout to see that this project rights its target since its
commencement to its completion. .....................

Chiranjib Parida
Sudipta Sahu
Anand Ayushman Das
Prateek Parija
Soubhagya Swain
dscdfgregerger

ABSTRACT

The rapid growth of data-driven applications has increased the demand for efficient and
accessible machine learning solutions. However, the traditional process of building
machine learning models involves multiple complex steps, including data
preprocessing, exploratory data analysis, model selection, and evaluation. These tasks
require significant expertise and time, making them challenging for beginners and non-
specialists. To address this limitation, this project presents an Automated Machine
Learning (AutoML) Application that simplifies and automates the end-to-end machine
learning workflow.
The proposed system provides an interactive web-based interface developed using
Streamlit, allowing users to upload datasets, analyze data, train models, and download
results with minimal effort. The backend of the application is powered by PyCaret, a
low-code machine learning library that automates data preprocessing, model training,
and evaluation. Additionally, YData Profiling is used to generate comprehensive
exploratory data analysis reports, enabling users to understand their datasets effectively
before model training.
The system incorporates several practical enhancements to improve reliability and
usability in real-world scenarios. These include handling encoding issues during data
ingestion, replacing deprecated libraries with updated alternatives, and optimizing
performance for faster report generation. The modular architecture separates data
analysis and model training components, ensuring flexibility and maintainability.
The application is evaluated using multiple datasets to verify its functionality,
robustness, and performance. Results demonstrate that the system can efficiently train
and compare multiple machine learning models, automatically selecting the best-
performing model based on standard evaluation metrics. By reducing manual effort and
technical complexity, the system serves as a valuable tool for students, researchers, and
practitioners, enabling faster experimentation and improved productivity in machine
learning tasks.
Keywords: Automated Machine Learning, PyCaret, Streamlit, Data Analysis, Model
Selection, Machine Learning Automation
dscdfgregerger

1 Introduction & Architecture 1

2 Basic Concepts/ Literature Review 2

2.1- 2.5 Legal Q/A, RAG, Embedding and Vector databases, LLM with 2
constraints

3 Problem Statement / Requirement Specifications 3

3.1-3.4 Stakeholders & Users, Use cases, FR, NFR 3
3.5 Constraints & Assumptions 4

4 System Design & Methodology 5

4.1 Architecture Overview 5
4.2 Data Ingestion and Chunking 5
4.3 Embeddings and Vector Store 5
4.4-4.7 Retrieval, Answer Generation, Frontend, Design Diagrams 5

5 Implementation 6
5.1-5.3 Project Layout, Setup & Commands, Module Descriptions 6
5.4 Error Handling 6

6 Testing and Evaluation 7

6.1 What was Tested 7
6.2 Test Cases 7
6.3 Metrics & Evaluation Procedure 7

7 Results and Discussion 8

7.1-7.4 Findings, Illustrative ex., Error analysis, Short Ablation Studies 8

8 Standards, Ethics, Compliance 9

8.1- 8.4 Coding standards, Testing standards, Data &Legal compliance, 9
Responsible Use

9 Conclusion & Future Work 10

9.1-9.2 Conclusion, Future Work 10

References 11

Individual Contribution 12

Plagiarism Report 13
List of Figures

1.1 Local System (ON-PREMISES CPU) 1

Chapter 1

Introduction
In recent years, machine learning has become an essential tool across industries for
data-driven decision making. However, building effective machine learning models
requires expertise in data preprocessing, feature engineering, model selection, and
evaluation. These steps are often time-consuming and complex, especially for beginners
or non-technical users. To address this challenge, the concept of Automated Machine
Learning (AutoML) has emerged, aiming to simplify and automate the entire machine
learning workflow.
The proposed system, an Automated Machine Learning Application, is designed to
provide a user-friendly platform that enables users to build, analyze, and deploy
machine learning models with minimal effort. The application allows users to upload
datasets, perform automated exploratory data analysis (EDA), train multiple machine
learning models, compare their performance, and download the best-performing model.
This significantly reduces the manual effort involved in traditional machine learning
pipelines.
The system is developed using Streamlit for the frontend interface and PyCaret for
backend machine learning automation. The integration of these technologies enables the
creation of a powerful yet simple application that can be used for educational purposes,
research, and rapid prototyping of machine learning solutions.

Architecture
The architecture of the system follows a modular and sequential pipeline approach. The
process begins with the data ingestion module, where users upload their dataset in CSV
format. The uploaded data is then processed and validated to ensure compatibility with
the system.
Once the data is successfully loaded, the system performs automated exploratory data
analysis using a profiling engine. This step provides detailed insights into the dataset,
including missing values, data distributions, correlations, and potential anomalies. After
understanding the data, the system proceeds to the model training phase, where multiple
machine learning algorithms are automatically trained and evaluated using PyCaret.
The system then compares the performance of all trained models based on evaluation
metrics such as accuracy, precision, recall, and F1-score. The best-performing model is
selected and finalized. Finally, the trained model is made available for download in a
serialized format, allowing users to reuse it in other applications.
This modular architecture ensures that each component of the system operates
independently while contributing to the overall workflow. It also enhances
maintainability, scalability, and ease of future improvements.

School of Computer Engineering, KIIT, BBSR

Chapter 2

Basic Concepts/ Literature Review

2.1 Automated Machine Learning (AutoML)
Automated Machine Learning refers to the process of automating the various stages of
the machine learning pipeline, including data preprocessing, feature selection, model
training, and hyperparameter tuning. Traditional machine learning workflows require
significant human intervention and domain expertise, which can be a barrier for many
users. AutoML addresses this limitation by providing automated solutions that reduce
complexity and improve efficiency.
In this project, AutoML is implemented using the PyCaret library, which offers a low-
code interface for performing complex machine learning tasks. It enables users to train
and compare multiple models with minimal configuration, thereby accelerating the
model development process.

2.2 Exploratory Data Analysis (EDA)

Exploratory Data Analysis is a critical step in understanding the structure and
characteristics of a dataset before applying machine learning algorithms. It involves
summarizing the main features of the data, identifying patterns, detecting anomalies,
and checking assumptions.
The system uses YData Profiling, a modern profiling tool, to generate comprehensive
EDA reports. These reports include information about missing values, correlations
between variables, statistical summaries, and visualizations. This helps users gain
insights into their data without requiring manual analysis.

2.3 Machine Learning Models

Machine learning models are mathematical algorithms used to identify patterns in data
and make predictions. In this system, multiple models are trained automatically,
including classification and regression algorithms such as Logistic Regression, Decision
Trees, Random Forest, and Gradient Boosting.
Each model is evaluated using standard performance metrics, and the best model is
selected based on its accuracy and overall performance. This automated approach
eliminates the need for manual model selection and tuning.

2.4 PyCaret Framework

PyCaret is an open-source machine learning library that simplifies the process of
building and deploying machine learning models. It provides a unified interface for data
preprocessing, model training, evaluation, and deployment.
In this project, PyCaret is used to handle the entire machine learning pipeline. It
automatically performs tasks such as handling missing values, encoding categorical
variables, normalizing data, and training multiple models. This significantly reduces
development time and complexity.

2.5 Streamlit Framework

Streamlit is a Python-based framework used for building interactive web applications
for data science and machine learning projects. It allows developers to create user
interfaces with minimal code.
The application uses Streamlit to provide an intuitive interface where users can upload
datasets, view analysis reports, train models, and download results. Its simplicity and
responsiveness make it ideal for rapid application development.

School of Computer Engineering, KIIT, BBSR 2

Chapter 3

Problem Statement / Requirement

Specifications

3.1 Problem Statement

The process of developing machine learning models involves multiple complex steps
that require technical expertise and significant time investment. Beginners often find it
difficult to understand and implement these steps effectively. Additionally, manual
model selection and tuning can lead to inefficiencies and suboptimal results.
The objective of this project is to develop an automated system that simplifies the
machine learning workflow, making it accessible to users with minimal technical
knowledge while maintaining high performance and reliability.

3.2 Stakeholders and Users

The system is designed for a wide range of users, including students, data analysts,
researchers, and developers. Students can use the system to learn machine learning
concepts, while analysts and researchers can use it for quick data analysis and model
building. Developers can leverage the system for rapid prototyping of machine
learning applications.

3.3 Functional Requirements

The system must allow users to upload datasets in CSV format and perform automated
data analysis. It should be capable of training multiple machine learning models and
displaying their performance metrics. Additionally, it must provide an option to
download the trained model for future use.

3.4 Non-Functional Requirements

The system should be user-friendly, efficient, and reliable. It must provide quick
responses, handle errors gracefully, and ensure compatibility across different
environments. The application should also be scalable and maintainable for future
enhancements.
3.5 Constraints and Assumptions
The system assumes that the input data is structured and provided in CSV format. It
Chapter 3
operates primarily on CPU and does not require GPU acceleration. The performance of
the system depends on the quality and size of the dataset. Additionally, compatibility
with specific library versions is necessary for smooth operation.

School of Computer Engineering, KIIT, BBSR 4

Chapter 4
System Design and Methodology
4.1 Architecture Overview
The system follows a sequential workflow starting from data ingestion to model
deployment. Each stage of the process is designed to operate independently while
contributing to the overall pipeline.

4.2 Data Ingestion and Processing

The system reads input data using the Pandas library. To handle real-world datasets
with varying encodings, a fallback mechanism is implemented that attempts to read the
file in multiple encoding formats such as UTF-8, Latin-1, and CP1252. This ensures
that the system can handle diverse datasets without crashing.

4.3 Automated Exploratory Data Analysis

After loading the data, the system generates an automated profiling report using YData
Profiling. To improve performance, a minimal mode is enabled, which reduces
computation time while still providing essential insights.

4.4 Model Training and Selection

The core functionality of the system is powered by PyCaret, which automates the
process of training multiple machine learning models. It performs preprocessing,
feature transformation, and model evaluation automatically. The system compares
different models and selects the best one based on performance metrics.

4.5 Model Evaluation

The trained models are evaluated using metrics such as accuracy, precision, recall, and
F1-score. These metrics help in determining the effectiveness of each model. The
system displays a leaderboard of models, making it easy for users to understand their
performance.

4.6 Frontend Design

The frontend is developed using Streamlit, providing an interactive interface for users.
It includes features such as file upload, data preview, report visualization, model
training, and model download. The interface is designed to be simple and intuitive.

4.7 System Improvements

Several improvements have been made to the original project to ensure compatibility
and performance. Deprecated libraries were replaced with updated alternatives, and a
new method was implemented to render profiling reports directly using HTML.
Additionally, encoding issues were resolved, making the system robust for real-world
usage.

School of Computer Engineering, KIIT, BBSR 5

Chapter 5
Implementation
5.1 Implementation Overview
The implementation of the Automated Machine Learning Application was carried out
using a modular and scalable approach to ensure maintainability, robustness, and ease of
deployment. The system is developed entirely in Python and integrates multiple
libraries, each responsible for a specific stage of the machine learning pipeline. The
primary objective during implementation was to transform a basic AutoML prototype
into a stable and production-ready application capable of handling real-world datasets.
The application is built around a Streamlit-based interface that serves as the interaction
layer between the user and the backend processing modules. The backend logic is
powered by PyCaret for machine learning automation and YData Profiling for
exploratory data analysis. Pandas is used extensively for data manipulation and
preprocessing tasks.
A key focus during implementation was ensuring compatibility with modern
development environments. Since many machine learning libraries have strict version
dependencies, the system was configured to run on Python 3.11.9, which provides
stability while maintaining compatibility with PyCaret and its underlying dependencies.

5.2 System Environment and Dependency Management

One of the major challenges encountered during implementation was managing
dependency conflicts across different libraries. The original project was designed for
older Python versions (3.9/3.10), whereas modern systems default to Python 3.12,
which is not fully supported by PyCaret and its dependency Numba.
To address this issue, a dedicated virtual environment was created using Python 3.11.9.
This ensured that all libraries functioned correctly without runtime conflicts.
Additionally, a critical compatibility issue with NumPy 2.0 was resolved by
downgrading to a stable 1.x version, preventing runtime errors such as deprecated
attribute access.
Furthermore, deprecated libraries such as pandas-profiling were replaced with ydata-
profiling, which is actively maintained and compatible with modern systems. All
dependencies were explicitly defined in the [Link] file to ensure
reproducibility across different environments.

5.3 Data Ingestion and Validation Pipeline

The data ingestion module is responsible for handling user-uploaded datasets in CSV
format. In real-world scenarios, datasets often come with inconsistent encoding formats,
leading to frequent runtime errors during file reading.
To make the system robust, a multi-stage encoding fallback mechanism was
implemented. Initially, the system attempts to read the dataset using UTF-8 encoding. If
this fails due to a UnicodeDecodeError, it automatically retries using alternative
encodings such as Latin-1 and CP1252. Additionally, an error-tolerant mode
(errors='ignore') is applied to prevent application crashes.
Once the dataset is successfully loaded, basic validation checks are performed to ensure
data integrity. These include verifying the presence of rows and columns, detecting
empty datasets, and ensuring that the file follows a structured tabular format. This
preprocessing step ensures that only valid data is passed to subsequent stages of the
pipeline.

5.4 Automated Exploratory Data Analysis (EDA)

The system integrates YData Profiling to generate automated exploratory data analysis
reports. Instead of relying on traditional manual plotting methods, the system produces
a comprehensive report containing statistical summaries, missing value analysis,
correlation matrices, and feature distributions.
A significant modification was made to improve performance and compatibility. The
original implementation relied on an external library (streamlit-ydata-profiling) to
embed reports directly into the interface. However, this library is deprecated and
incompatible with newer Python versions.
To overcome this limitation, the profiling report is generated as a raw HTML object
using YData Profiling and rendered using Streamlit’s native [Link]()
function. This approach eliminates dependency issues and improves rendering
performance.
Additionally, the profiling process is executed in minimal mode, which skips
computationally expensive operations such as complex correlation analysis. This
ensures that reports are generated quickly, making the system suitable for live
demonstrations and real-time usage.

5.5 Automated Machine Learning Pipeline

The core functionality of the system is implemented using the PyCaret library, which
automates the end-to-end machine learning workflow. Once the dataset is loaded, the
user selects a target variable, and the system initializes a supervised learning
environment.
PyCaret automatically performs several preprocessing steps, including handling missing
values, encoding categorical variables, normalizing data, and splitting the dataset into
training and testing sets. This eliminates the need for manual preprocessing and reduces
the chances of human error.
The system then executes a model comparison process, where multiple machine
learning algorithms are trained and evaluated simultaneously. These include models
such as Logistic Regression, Decision Trees, Random Forest, and Gradient Boosting.
Each model is evaluated using cross-validation techniques to ensure reliable
performance metrics.
The results are displayed in the form of a leaderboard, allowing users to compare
models based on metrics such as accuracy, precision, recall, and F1-score. The best-
performing model is automatically selected and finalized.

5.6 Model Serialization and Export

After identifying the best-performing model, the system provides an option to export the
trained model for future use. The model is serialized using a binary format (Pickle),
which preserves its structure and learned parameters.
This feature allows users to integrate the trained model into other applications without
retraining. It also supports reproducibility, as the same model can be reused for
predictions on new data.

5.7 Frontend Implementation (Streamlit Interface)

The frontend of the application is implemented using Streamlit, which provides a clean
and interactive user interface. The UI is designed to follow a simple workflow:
1. Upload dataset
2. Preview data
3. Generate EDA report
4. Train models
5. Download best model
The interface dynamically updates based on user actions, providing real-time feedback
and status messages. Error handling is integrated into the UI to guide users in case of
issues such as missing files or incorrect inputs.
The use of Streamlit ensures that the application remains lightweight, responsive, and
easy to deploy.

5.8 Error Handling and System Robustness

To ensure reliability, several error-handling mechanisms were implemented throughout
the system. Common issues such as missing datasets, invalid file formats, and absent
dependencies are detected early and communicated to the user through clear messages.
The system also handles edge cases such as empty datasets and unsupported encodings
without crashing. These safeguards make the application stable and suitable for real-
world usage.

5.9 Performance Optimization

Performance optimization was a key consideration during implementation. Several
improvements were introduced to reduce execution time and enhance responsiveness.
The use of minimal mode in profiling significantly reduces report generation time.
Removing deprecated libraries and replacing them with lightweight alternatives also
improves efficiency.
Additionally, the modular design of the system ensures that each component operates
independently, allowing for faster debugging and easier scalability.

School of Computer Engineering, KIIT, BBSR 6

 Chapter 6

Testing and Evaluation

6.1 Testing Overview
The Automated Machine Learning Application was subjected to comprehensive testing
to ensure its correctness, robustness, and reliability across different stages of the
workflow. Since the system integrates multiple components such as data ingestion,
exploratory data analysis, and automated model training, it was essential to validate
each module individually as well as the system as a whole.
Testing was carried out using multiple datasets of varying sizes and structures to
simulate real-world scenarios. These datasets included clean datasets, datasets with
missing values, and datasets with mixed data types. The objective was to verify whether
the system could handle diverse inputs without failure while maintaining accurate
outputs.
Special attention was given to validating the integration between modules. For instance,
ensuring that the output of the data ingestion module is correctly passed to the EDA
component, and subsequently to the machine learning pipeline. The testing process also
included verifying that the user interface responds correctly to different user actions and
provides meaningful feedback in case of errors.

6.2 Functional Testing

Functional testing was performed to ensure that all features of the application operate as
intended. The file upload functionality was tested with valid CSV files to confirm
successful ingestion and preview of the dataset. Additionally, invalid inputs such as
unsupported file formats and empty files were tested to ensure that the system provides
appropriate error messages.
The automated exploratory data analysis module was tested by generating reports for
different datasets and verifying the correctness of statistical summaries, missing value
detection, and correlation analysis. The rendering of the EDA report using HTML
within the Streamlit interface was also validated to ensure compatibility and smooth
visualization.
The machine learning pipeline was tested by selecting different target variables and
running the model training process. The system was verified to correctly train multiple
models, generate performance metrics, and display a comparative leaderboard. The
model export functionality was also tested to ensure that the trained model is correctly
serialized and can be reused.

6.3 Non-Functional Testing

Non-functional testing focused on evaluating the performance, usability, and stability of
the system. Performance testing was conducted by measuring the time taken for key
operations such as data loading, EDA report generation, and model training. The results
showed that the system performs efficiently for small to medium-sized datasets, with
acceptable latency for real-time usage.
Usability testing was carried out by interacting with the application from a user’s
perspective. The interface was found to be intuitive, with a clear workflow guiding
users through each step. Error messages and status indicators were tested to ensure that
they are informative and user-friendly.
Stability testing involved running the application multiple times under different
conditions to ensure consistent behavior. The system successfully handled repeated
executions without crashes, demonstrating its reliability.

6.4 Test Cases

A series of test cases were designed to validate the functionality of different
components. In the first test case, a valid dataset was uploaded, and the system
successfully processed the file, generated an EDA report, and trained machine learning
models. This confirmed the correct functioning of the complete pipeline.
In another test case, an invalid file format was provided, and the system correctly
displayed an error message without crashing. A dataset with missing values was also
tested to verify whether the system could handle incomplete data. The application
successfully processed the dataset and performed model training, demonstrating the
effectiveness of automatic preprocessing.
Additionally, a test case was conducted using a dataset with encoding issues. The
fallback mechanism successfully loaded the dataset using alternative encodings,
validating the robustness of the data ingestion module.

6.5 Evaluation Metrics

The performance of the machine learning models generated by the system was
evaluated using standard evaluation metrics. These include accuracy, precision, recall,
and F1-score, which provide a comprehensive measure of model performance.
Accuracy was used to measure the overall correctness of predictions, while precision
and recall were used to evaluate the model’s performance on specific classes. The F1-
score provided a balanced measure by combining precision and recall. These metrics
were automatically computed and displayed in the model comparison leaderboard
generated by PyCaret.
In addition to model performance, system-level metrics such as execution time and
responsiveness were also considered. These metrics helped in evaluating the efficiency
of the application in real-time scenarios.

6.6 Results Analysis

The results obtained from testing indicate that the system is capable of efficiently
automating the machine learning pipeline. The automated model comparison process
consistently identified high-performing models, reducing the need for manual
intervention.
The system demonstrated strong performance in handling structured datasets and
provided reliable outputs across different test cases. The integration of automated
preprocessing ensured that datasets with missing values or mixed data types were
handled effectively.
However, it was observed that the performance of the system depends on the quality of
the input data. Noisy or poorly structured datasets may lead to reduced model accuracy.
Additionally, the absence of advanced feature engineering may limit performance in
complex scenarios.

6.7 Limitations Observed During Testing

During testing, certain limitations of the system were identified. The system currently
supports only structured CSV datasets and does not handle unstructured data formats
such as text or images. Additionally, the reliance on default preprocessing techniques
may not be sufficient for highly complex datasets.
Another limitation is the dependency on specific library versions, which may affect
compatibility with future updates. The system also operates on CPU, which may
increase processing time for very large datasets.

School of Computer Engineering, KIIT, BBSR 7

Chapter 7

Results and Discussions

7.1 Results
The Automated Machine Learning Application was successfully implemented and
tested across multiple datasets to evaluate its performance, usability, and reliability. The
system demonstrated its ability to automate the complete machine learning pipeline,
starting from data ingestion and exploratory analysis to model training and final model
selection.
Upon uploading a dataset, the system efficiently generated a comprehensive exploratory
data analysis report, providing insights into missing values, feature distributions, and
correlations. The use of optimized profiling ensured that the reports were generated
within a reasonable time frame, even for moderately sized datasets.
During the model training phase, the application utilized the PyCaret framework to train
and evaluate multiple machine learning models simultaneously. The system
successfully generated a comparison table (leaderboard) that ranked models based on
evaluation metrics such as accuracy, precision, recall, and F1-score. In most test cases,
ensemble-based models such as Random Forest and Gradient Boosting performed better
compared to simpler models, indicating the system’s capability to identify optimal
algorithms automatically.
The model export functionality also worked as expected, allowing users to download
the best-performing model in a serialized format. This feature enhances the practical
usability of the system, enabling deployment in external applications without retraining.

7.2 Discussion
The results demonstrate that the system effectively reduces the complexity involved in
building machine learning models. By automating repetitive and technical tasks such as
preprocessing, model selection, and evaluation, the application enables users to focus on
interpreting results rather than implementing algorithms.
One of the key strengths of the system is its ability to handle real-world datasets with
minimal user intervention. The implementation of an encoding fallback mechanism
ensured that datasets with non-standard formats were processed successfully without
errors. This significantly improves the robustness of the system compared to traditional
implementations that often fail when encountering encoding issues.
Another important observation is the efficiency of the automated model comparison
process. Instead of manually training and tuning individual models, the system
evaluates multiple algorithms in parallel and presents a clear performance comparison.
This not only saves time but also ensures that the selected model is based on objective
evaluation metrics.
The integration of automated exploratory data analysis also adds significant value to the
system. Users can gain a clear understanding of their data before proceeding to model
training, which helps in identifying potential issues such as missing values or
imbalanced distributions.
7.3 Error Analysis
Despite the overall effectiveness of the system, certain limitations and errors were
observed during testing. In some cases, the performance of the models was affected by
poor data quality, such as highly imbalanced datasets or noisy features. Since the system
relies on automated preprocessing, it may not always apply advanced feature
engineering techniques required for complex datasets.
Another issue observed was the increased processing time for larger datasets,
particularly during the EDA generation phase. Although the use of minimal mode
improved performance, there is still scope for further optimization.
Additionally, while the system successfully selects the best model based on predefined
metrics, it does not provide deep insights into why a particular model performs better
than others. This limits interpretability, especially for users who want a deeper
understanding of model behavior.

7.4 Comparative Analysis and Observations

A comparative analysis of different models revealed that ensemble-based algorithms
generally outperformed simpler models in terms of accuracy and robustness. Models
such as Random Forest and Gradient Boosting consistently ranked higher in the
leaderboard due to their ability to handle complex relationships within the data.
On the other hand, simpler models such as Logistic Regression performed adequately
on linearly separable datasets but showed reduced performance on more complex
datasets. This highlights the importance of automated model selection in identifying the
most suitable algorithm for a given problem.
The system also demonstrated consistent performance across multiple runs, indicating
good reproducibility. The use of fixed configurations and controlled preprocessing
ensured that results remained stable under similar conditions.

7.5 Improvements and Future Scope Identified from Results

Based on the observations, several potential improvements were identified. The system
can be enhanced by incorporating advanced feature engineering techniques to improve
model performance on complex datasets. Additionally, integrating explainable AI (XAI)
tools could provide better insights into model predictions and improve interpretability.
Performance optimization for large datasets is another area for improvement.
Techniques such as sampling or parallel processing can be explored to reduce execution
time. Furthermore, extending support for additional data formats and integrating deep
learning models can broaden the scope of the system.

School of Computer Engineering, KIIT, BBSR 8

Chapter 8
Standards, Ethics, and Compliance
8.1 Coding and Documentation Standards
The development of the Automated Machine Learning Application follows standard
software engineering practices to ensure code quality, readability, and maintainability.
The implementation adheres to widely accepted Python coding conventions, particularly
those outlined in PEP 8 guidelines. Proper indentation, meaningful variable names,
modular function design, and consistent formatting have been maintained throughout
the codebase.
The application is structured in a modular manner, where each component of the system
—such as data ingestion, exploratory data analysis, and model training—is separated
into logical sections. This modular design enhances code clarity and simplifies
debugging and future enhancements. Functions are designed to perform specific tasks,
reducing redundancy and improving efficiency.
Documentation plays a critical role in ensuring reproducibility and ease of
understanding. The project includes a well-defined [Link] file that lists all
dependencies along with their compatible versions. This ensures that the system can be
replicated across different environments without compatibility issues. Additionally,
inline comments and descriptive code blocks are used to explain key functionalities,
making the codebase accessible even to new developers.

8.2 Testing Standards

To ensure reliability and consistency, the system was tested using a structured approach.
Testing was conducted on multiple datasets to validate each stage of the pipeline,
including data ingestion, exploratory analysis, model training, and result generation.
Both functional and non-functional testing methods were applied to verify correctness,
performance, and usability.
A fixed set of datasets was used during testing to maintain reproducibility of results.
Key performance metrics such as accuracy, precision, recall, and F1-score were
recorded to evaluate model effectiveness. Additionally, system-level metrics such as
execution time and responsiveness were monitored to assess performance.
Error scenarios, such as invalid file formats, missing data, and encoding issues, were
also tested to ensure that the system handles such cases gracefully. The application
provides clear and actionable error messages, helping users identify and resolve issues
efficiently.

8.3 Data Privacy and Compliance

The system is designed with a strong emphasis on data privacy and security. All
datasets uploaded by users are processed locally within the application environment,
ensuring that sensitive data is not transmitted to external servers. This approach
minimizes the risk of data leakage and maintains user confidentiality.
The application does not store user data permanently, and all processing is performed in
a temporary session. Users have full control over their data, including uploading and
deleting datasets as needed. This ensures compliance with basic data protection
principles.
Additionally, the system is intended to work with publicly available or user-provided
datasets. It does not include any proprietary or restricted data. Users are responsible for
ensuring that the data they upload complies with relevant legal and ethical standards.

8.4 Responsible Use and Ethical Considerations

The Automated Machine Learning Application is developed primarily for educational
and research purposes. While it provides automated model generation and evaluation, it
should not be used as a sole decision-making tool in critical applications such as
healthcare, finance, or legal systems without proper validation and expert review.
One of the key ethical considerations in machine learning is the potential for bias in data
and models. Since the system relies on user-provided datasets, any inherent bias in the
data may be reflected in the model’s predictions. Users are encouraged to analyze their
data carefully and interpret results responsibly.
The system does not make autonomous decisions but provides insights based on data. It
is the responsibility of the user to validate and verify the results before applying them in
real-world scenarios. A disclaimer can be included in the application stating that the tool
is intended for learning and experimentation purposes only.

8.5 Reproducibility and Maintainability

Reproducibility is a key aspect of any machine learning system. To ensure consistent
results, the application uses fixed configurations and controlled environments. The use
of a virtual environment and specified library versions ensures that the system behaves
consistently across different setups.
The modular design of the system also contributes to maintainability. Individual
components can be updated or replaced without affecting the overall functionality. This
makes the system adaptable to future technological advancements and library updates.
School of Computer Engineering, KIIT, BBSR 9

Chapter 9

Conclusion and Future Work

9.1 Conclusion
The Automated Machine Learning Application developed in this project successfully
demonstrates how complex machine learning workflows can be simplified through
automation. The system integrates data ingestion, exploratory data analysis, model
training, evaluation, and model export into a unified and user-friendly platform. By
leveraging powerful libraries such as PyCaret and YData Profiling, the application
eliminates the need for manual intervention in several stages of the machine learning
pipeline.
One of the major achievements of the project is the transformation of an initial
prototype into a stable and robust application capable of handling real-world datasets.
The implementation addresses practical challenges such as dependency conflicts,
compatibility issues with modern Python versions, and data encoding errors. These
improvements ensure that the system operates reliably across different environments
and does not fail when exposed to imperfect or messy datasets.
The system also emphasizes usability by providing an intuitive interface through
Streamlit. Users can upload data, analyze it, train models, and download results
without requiring advanced programming knowledge. This makes the application
particularly useful for students, beginners, and professionals who want to quickly
experiment with machine learning models.
From a performance perspective, the system effectively trains and compares multiple
models, selecting the best-performing one based on standard evaluation metrics. This
automated model selection process reduces development time and improves efficiency.
Additionally, the modular design of the system ensures maintainability and provides a
strong foundation for future enhancements.
Overall, the project achieves its objective of creating an accessible, efficient, and
reliable Automated Machine Learning system. It highlights the potential of automation
in reducing complexity and enabling wider adoption of machine learning technologies.

9.2 Future Work

Although the system performs effectively in its current form, several enhancements
can be made to extend its capabilities and improve its performance. One potential area
of improvement is the integration of advanced feature engineering techniques.
Currently, the system relies on automated preprocessing provided by PyCaret, but
incorporating custom feature selection and transformation methods could further
enhance model accuracy.
Another important direction for future work is the inclusion of deep learning models.
Extending the system to support neural networks and frameworks such as TensorFlow
or PyTorch would allow it to handle more complex datasets and problem domains,
including image and text data.
Performance optimization for large datasets is also an area that can be explored.
Techniques such as data sampling, parallel processing, and GPU acceleration can be
implemented to reduce execution time and improve scalability. Additionally,
optimizing the exploratory data analysis module can further enhance responsiveness.
The system can also be extended to support real-time predictions by integrating a
prediction API. This would allow users to deploy trained models as web services and
use them for live data inference. Deployment on cloud platforms such as AWS or
Azure can further improve accessibility and scalability.
Another valuable enhancement would be the integration of explainable AI (XAI)
techniques. Providing insights into model decisions can improve transparency and help
users understand why a particular model performs better. This is especially important
in domains where interpretability is critical.
Finally, improvements in the user interface and user experience can make the
application more interactive and visually appealing. Features such as progress
indicators, customizable reports, and dashboard visualizations can enhance usability.

9.3 Final Remarks

In conclusion, the project demonstrates a practical and effective approach to
simplifying machine learning workflows through automation. While the current system
provides a solid foundation, the identified improvements offer significant opportunities
for further development. With continued enhancements, the application has the
potential to evolve into a comprehensive platform for machine learning
experimentation and deployment.

School of Computer Engineering, KIIT, BBSR 10

 References
[1 ]S. M. Metev and V. P. Veiko, Laser Assisted Microtechnology, 2nd ed., R. M. Osgood, Jr., Ed. Berlin,
Germany: Springer-Verlag, 1998.

[2] Breckling, Ed., The Analysis of Directional Time Series: Applications to Wind Speed and Direction, ser.
Lecture Notes in Statistics. Berlin, Germany: Springer, 1989, vol. 61.
[3] S. Zhang, C. Zhu, J. K. O. Sin, and P. K. T. Mok, “A novel ultrathin elevated channel low-temperature poly-Si
TFT,” IEEE Electron Device Lett., vol. 20, pp. 569–571, Nov. 1999.
[4] M. Wegmuller, J. P. von der Weid, P. Oberson, and N. Gisin, “High resolution fiber distributed measurements
with coherent OFDR,” in Proc. ECOC’00, 2000, paper 11.3.4, p. 109.
[5] R. E. Sorace, V. S. Reinhardt, and S. A. Vaughn, “High-speed digital-to-RF converter,” U.S. Patent 5 668 842,
Sept. 16, 1997.

[6] (2002) The IEEE website. [Online]. Available: [Link]

[7] M. Shell. (2002) IEEEtran homepage on CTAN. [Online]. Available: [Link]
archive/macros/latex/contrib/supported/IEEEtran/

School of Computer Engineering, KIIT, BBSR 11

SAMPLE INDIVIDUAL CONTRIBUTION REPORT:

<TITLE OF THE PROJECT IN FONT SIZE 14, FONT STYLE TIMES

NEW ROMAN, BOLD AND CENTERED>

<Student Name (in capital letters in font size 12, Times New Roman and
centered>
<Student Roll number (font size 12, Times New Roman and centered>

Abstract: A short description of the aim and objective of the project work carried out in 3-4
lines. This part should be common to all students in the group. The font size and style will
remain same from this point onwards. The font size will be 12 and font style will be Times
New Roman. The line spacing will be 1.5.
This report should be prepared in A4 page format with ‘default’ option under ‘Margin’ of the
‘Page Layout’ tab in Microsoft Word. Word limit for this section is 80.

Individual contribution and findings: The student should clearly indicate his/her role
in the project group and the contribution in implementing the project work. The student should
also outline his /her planning involved in implementing his/her part in the work. This
contribution report should be different for every student in the group. The student would also
write his./her technical findings and experience while implementing the corresponding part of
the project. The overall contribution report should not be less than 1 page for each student.
The Student should provide both the soft copy and signed hard copy to the project supervisor.

Individual contribution to project report preparation: Student should mention

his/her role in preparing the group project report indicating which chapter and portions
contributed.

Individual contribution for project presentation and demonstration: Student

should mention his/her role in preparing presentations and part of the project demonstrated.

Full Signature of Supervisor: Full signature of the

student:
…………………………….
……………………………..
 TURNITIN PLAGIARISM REPORT
(This report is mandatory for all the projects and plagiarism
must be below 25%)