AI-DRIVEN NUMBER PLATE RECOGNITION

PROJECT REPORT
Submitted to
Kongunadu Arts and Science College (Autonomous)
Affiliated to Bharathiar University in partial fulfillment of the requirements for the
award of the degree of

BACHELOR OF SCIENCE IN COMPUTER SCIENCE WITH

DATA ANALYTICS
Submitted by
NAME: HARIDHBHARAN S
REGISTER NUMBER: 221DA021
Under the Guidance of
Mrs. P. INDUMATHI., MCA., M.phil .,B.Ed.,
Assistant Professor

DEPARTMENT OF COMPUTER SCIENCE WITH DATA ANALYTICS

KONGUNADU ARTS AND SCIENCE COLLEGE (AUTONOMOUS)
Re-accredited by NAAC with A+ Grade (4th Cycle)
College of Excellence (UGC)
52nd Rank among Colleges in NIRF 2024
Coimbatore – 641 029.
MARCH - 2025
 DECLARATION
I, HARIDHBHARAN S declare that the project work entitled “AI-DRIVEN NUMBER PLATE

RECOGNITION” submitted to Kongunadu Arts and Science College (Autonomous) affiliated to

Bharathiar University in partial fulfillment of the requirement for the Degree of Bachelor of Science

in Computer Science with Data Analytics, is a record of original Project work done by me during the

period of study (2022 – 2025), under the Supervision of Mrs.P.INDUMATHI, MCA,

M.phil.,B.Ed., Assistant Professor, Department of Computer Science with Data Analytics at

Kongunadu Arts and Science College (Autonomous), Coimbatore. The project has not formed the

basis for the award of Degree / Diploma /Associate ship/Fellowship or similar title to any candidate

of any University.

------------------------------------
Signature of the Candidate
(HARIDHBHARAN S)

Place:
Date:
 CERTIFICATE
This is to certify that the Project work entitled “AI-DRIVENNUMBER PLATE

RECOGNITION” submitted to Kongunadu Arts and Science College (Autonomous) affiliated to

Bharathiar University in partial fulfillment of the requirement for the Degree of Bachelor of

Computer Science with Data Analytics is a record of original Project work done by

HARIDHBHARAN S (221DA021)during the period of study (2022 – 2025) in the Department of

Computer Science with Data Analytics at Kongunadu Arts and Science College (Autonomous),

Coimbatore, under my supervision and the project has not formed the basis for the award any

Degree/Diploma /Associate ship /Fellowship or similar title to any candidate of any University.

------------------------------
Place: Signature of the Guide
Date: Mrs. P. INDUMATHI., MCA., M.phil., B.Ed

Countersigned

Head of the Department Principal

Submitted for Viva – Voce Examination held on 18.03.2025 at Kongunadu Arts and Science
College (Autonomous), Coimbatore – 641 029.

INTERNAL EXAMINER EXTERNAL EXAMINER

 ACKNOWLEDGEMENT

I am deeply grateful to the Almighty, whose blessings and guidance have been my strength
throughout this project, shaping me into the person I am today.

I extend my sincere gratitude to our esteemed Secretary and Director, Dr. C.A. VASUKI, for
her unwavering support and for providing all the necessary resources during my academic journey.

It is indeed an honour to express my heartfelt appreciation to our respected Principal, Dr. V.

SANGEETHA, M.Sc., M.Phil., Ph.D., for fostering a conducive learning environment and
facilitating the successful execution of our project.

I am also profoundly thankful to Dr. K. SUMANGALA, M.C.A., M.Phil., Ph.D.,

Coordinator of Academic Affairs (SF), for her encouragement and for ensuring that we had access to
the essential facilities required for our research.

I wish to acknowledge with deep appreciation the guidance and support of

Dr. R. SARAVANA MOORTHY, M.Sc. (SE), M.C.A., MBA, M.Phil., OCP, Ph.D., Coordinator
of Student Affairs (SF), whose valuable assistance greatly contributed to the smooth progress of this
project.

My sincere thanks go to Dr. L. KATHIRVELKUMARAN, M.B.A., M.C.A., M.Phil.,

Ph.D., PGDDA, Assistant Professor and Head of the Department of Computer Science with Data
Analytics, for his insightful advice and mentorship, which have been instrumental in my academic
growth.

I am deeply grateful to my class tutor Mrs. P. SUMITHA,Assistant Professor and the

faculty of Computer Science with Data Analytics for their constant support and guidance, which
greatly aided this project's success.

I am profoundly indebted to my project guide, Mrs.P.INDUMATHI., MCA.,

M.phil.,B.Ed., Assistant Professor, Department of Computer Science with Data Analytics, for her
invaluable guidance, motivation, and unwavering support throughout this journey.

I sincerely thank P.NIRMAL KUMAR, HR Manager & Project Leader at NETCON

TECHNOLOGIES INDIA Pvt Ltd, along with my parents and friends for their invaluable
guidance, support, and encouragement
 ABSTRACT
The Medicine Recommendation System is a machine learning-driven application designed to
optimize medication selection for healthcare professionals and patients. By integrating vast datasets,
including electronic health records (EHRs), clinical trials, pharmaceutical databases, and drug
interactions, the system preprocesses medical data through cleaning, normalization, and feature
engineering to ensure high accuracy and reliability. Key patient attributes such as demographics,
medical history, symptoms, and test results are extracted using feature selection techniques to
enhance predictive capabilities.

The system employs advanced machine learning algorithms, including decision trees, random
forests, SVMs, logistic regression, and deep neural networks, to analyze patterns in patient data and
predict suitable medications. Models are trained and optimized using evaluation metrics such as
accuracy, precision, recall, and F1-score to ensure high reliability and robustness. By continuously
incorporating new medical research, updated treatment guidelines, and real-world patient outcomes,
the system evolves to improve recommendations and adapts to advancements in the medical field.

A user-friendly interface allows seamless interaction for healthcare providers, pharmacists,

and patients, offering explanations, confidence scores, and alternative medication options. In cases
where no specific medication is recommended, the system dynamically provides additional health-
related insights, including disease descriptions, precautions, recommended workouts, and dietary
suggestions to guide users in managing their conditions effectively.

The AI-powered system follows a structured workflow involving data collection and
processing, feature selection, model training and validation, real-time predictions, user interaction,
healthcare system integration, and continuous learning. Real-time recommendations are displayed
through an interactive dashboard, ensuring seamless usability for healthcare professionals. The
system continuously updates its predictions based on new medical findings, user feedback, and
evolving clinical standards, making it a dynamic and evolving healthcare tool.
 TABLE OF CONTENTS

CHAPTER
PARTICULARS PAGE NO.
NO.
INTRODUCTION 1
1.1 About the Organisation 1
1 1.2 Overview of The Project
1.3 Problem Statement
1.4 Objectives
SYSTEM ANALYSIS
2.1 Existing System
2
2.2 Proposed System
2.3 Advantages
SYSTEM REQUIREMENTS
3
3.1 Hardware & Software Requirements
SYSTEM DESIGN
4 4.1 System Architecture
4.2 Workflow of the System
SYSTEM IMPLEMENTATION
5 5.1 Integration with Machine Learning Model
5.2 Frontend & Backend Development
TESTING AND DEPLOYMENT
6.1 Functional Testing
6
6.2 Performance Evaluation
6.3 Deployment Process
7 RESULTS AND DISCUSSION
8 FUTURE ENHANCEMENT
9 CONCLUSION
10 APPENDIX
 1. INTRODUCTION
1.1ABOUT THE ORGANISATION

Cryprus Infotech Pvt.Ltd offers IT solutions and custom software development services on
cutting-edge technology platforms like Business Intelligence, Artificial Intelligence, Machine
Learning, Blockchain, Internet of Things and much more. With robust technical expertise and rich
experience in custom software development, we offer quality, on-time and cost-effective solutions.

Our mission is to help global organizations overcome challenges of Digital Transformation

with the focus on new and emerging technologies, making it simpler, smarter and attain customer's
business objectives thus driving them to success.

1.2 OVERVIEW OF THE PROJECT

The Medicine Recommendation System is a machine learning-driven application designed to

assist healthcare professionals in selecting the most appropriate medications based on patient
symptoms, medical history, and other relevant health data. The system leverages machine learning
algorithms to analyze vast datasets, identify patterns, and provide personalized medication
recommendations. By integrating Flask for backend processing, Jupyter for model execution, and
HTML, CSS, JavaScript, Bootstrap, and Jinja for frontend development, the project ensures a
seamless and interactive web-based testing platform.

This system aims to bridge the gap between traditional prescription methods and AI-driven
decision-making by automating medication selection and improving accuracy. Healthcare
professionals can input patient details, and the system will generate evidence-based, data-driven
recommendations while considering factors such as drug interactions and contraindications. The
project’s ultimate goal is to enhance patient safety, optimize prescription accuracy, and minimize
human errors in medical recommendations.

1.3 PROBLEM STATEMENT

In traditional healthcare settings, prescribing the correct medication depends heavily on

physician expertise, historical patient data, and limited clinical guidelines. This process is often
prone to human errors, inconsistencies in decision-making, and a lack of real-time analysis of patient
data. Additionally, with an increasing number of drugs available in the pharmaceutical market,
physicians may find it challenging to stay updated with the latest medications, potential drug
interactions, and personalized treatment plans.

Misdiagnosis or incorrect prescriptions can lead to adverse drug reactions, prolonged treatment
durations, increased healthcare costs, and patient dissatisfaction. There is also a growing demand for
data-driven, AI-powered solutions that can analyze large-scale patient data in real-time, providing
accurate, personalized, and evidence-based medication recommendations.

The proposed Medicine Recommendation System addresses these challenges by utilizing machine
learning algorithms to predict the most suitable medication for a patient based on their medical
history, symptoms, and drug compatibility. The system ensures that prescriptions are not only
accurate but also tailored to each individual’s needs, significantly reducing the risks of incorrect
treatments.\

1.4 OBJECTIVES

The primary objectives of this project are:

 Develop an AI-powered medication recommendation system that predicts the most

appropriate drug based on patient symptoms and history.

 Enhance prescription accuracy and reduce human error in medical recommendations.

 Integrate machine learning models with an interactive web-based interface, allowing

healthcare professionals to easily input patient details and obtain real-time suggestions.

 Ensure data security and compliance with healthcare standards such as HIPAA and GDPR for
patient confidentiality and safe handling of sensitive medical data.

 Continuously improve the recommendation system by incorporating new medical research,

clinical guidelines, and patient feedback.

 Reduce healthcare costs and improve treatment efficiency by minimizing incorrect

prescriptions and optimizing the selection of drugs.

This project aims to provide a robust, scalable, and efficient AI-driven solution that transforms
medication recommendations, ensuring improved healthcare outcomes and safer prescription
practices.
 2. SYSTEM ANALYSIS
2.1 EXISTING SYSTEM

The traditional approach to prescribing medications relies heavily on physician experience,

manual diagnosis, and limited data accessibility. Doctors analyze patient symptoms, medical history,
and past treatments to recommend medications. However, this process has several limitations,
including human errors, lack of real-time data analysis, and difficulty in keeping up with the latest
medical research and drug interactions. Additionally, the absence of automated decision-support
tools often leads to inconsistent prescriptions, with variations in drug selection depending on the
physician's expertise.

Challenges in the existing system include:

 High dependency on physician expertise, leading to variability in recommendations.

 Limited data-driven insights, restricting comprehensive analysis of patient records.

 Potential for prescription errors, causing adverse drug reactions.

 Time-consuming manual evaluations, reducing efficiency in healthcare services.

2.2 PROPOSED SYSTEM

The Medicine Recommendation System introduces an AI-driven approach that overcomes the
limitations of traditional methods. By leveraging machine learning models, real-time data analysis,
and an interactive web-based interface, the proposed system provides personalized medication
recommendations based on data-driven insights rather than just manual decision-making.
Key features of the proposed system include:

 Machine Learning-Based Diagnosis: Identifies patterns in patient data to suggest suitable

medications.

 Automated Drug Interaction Checks: Ensures prescriptions are safe by cross-referencing

medical history with known drug interactions.

o User-Friendly Web Interface: Allows healthcare providers to input symptoms and

receive AI-generated recommendations instantly.
2.3 ADVANTAGES

The proposed AI-based Medicine Recommendation System provides several benefits over
traditional methods:

 Increased Accuracy: AI-driven recommendations minimize human errors and improve

prescription precision.

 Time Efficiency: Automated processing reduces diagnosis and prescription time,

streamlining medical workflows.

 Personalized Treatments: Medication suggestions are tailored to individual patient history,

improving treatment effectiveness.

 Integration with Healthcare Systems: The system can be linked with EHRs and medical
databases, ensuring seamless data access.

 Scalability & Adaptability: The system can continuously learn and improve as more patient
data becomes available, keeping up with medical advancements.

By implementing this AI-powered recommendation system, healthcare providers can ensure

faster, safer, and more accurate prescriptions, ultimately enhancing patient outcomes and operational
efficiency in medical institutions.
 3. SYSTEM REQUIREMENTS
3.1 HARDWARE & SOFTWARE REQUIREMENTS

The Medicine Recommendation System requires a combination of hardware and software

components to ensure seamless execution, efficient processing, and optimal system performance.
The following sections outline the necessary requirements:

Hardware Requirements

To efficiently handle machine learning model execution, data processing, and web interface
operations, the system requires the following hardware specifications:

 Processor: Intel Core i5/i7 or AMD Ryzen 5/7 (or higher) for smooth computation.

 RAM: Minimum 8GB (Recommended: 16GB or more for handling large datasets and model
training).

 Storage: At least 256GB SSD (Recommended: 512GB SSD or higher for faster read/write
speeds and data access).

 GPU (Optional): NVIDIA GPU with CUDA support for deep learning model acceleration (if
required).

 Internet Connection: Required for accessing external libraries and APIs.

Software Requirements

The system's software stack consists of tools for machine learning model execution, web
development, and backend integration.

Operating System:

 Windows 10/11, Linux (Ubuntu 20.04+), or macOS (Big Sur or later)

Programming Languages & Libraries:

 Python 3.8+ (Core programming language for model execution and backend development)

 Flask (Web framework for handling API requests and serving the frontend)

 Jupyter Notebook (For executing and testing ML models interactively)

 Pandas & NumPy (For data preprocessing and numerical computations)

  Scikit-learn & TensorFlow/PyTorch (For machine learning model execution)

Web Technologies:

 HTML, CSS, and JavaScript (For frontend development)

 Bootstrap (For responsive design and UI components)

 Jinja (For dynamic web page rendering and integration with Flask)

Development & Deployment Tools:

 Git & GitHub/GitLab (For version control and collaborative development)

 Postman (For API testing and debugging requests)

 Localhost Server (Flask Development Server) (For running the web application locally)

By meeting these hardware and software requirements, the Medicine Recommendation System
ensures smooth performance, reliable model execution, and an intuitive web interface for testing and
validation.
 4. SYSTEM DESIGN
4.1 SYSTEM ARCHITECTURE

The Medicine Recommendation System follows a modular and structured architecture to

ensure efficient processing, scalability, and ease of integration. The architecture consists of the
following primary components:

1. User Interface (Frontend)

 The web interface is built using HTML, CSS, JavaScript, Bootstrap, and Jinja to provide a
responsive and interactive user experience.

 Users enter symptoms and receive AI-generated medication recommendations through a

clean and intuitive interface.

2. Backend Processing (Flask Server)

 The backend is developed using Flask, which handles HTTP requests, processes user inputs,
and communicates with the machine learning model.

 The Flask server acts as the bridge between the frontend and the ML model, ensuring
seamless data flow.

3. Machine Learning Model Execution (Jupyter Notebook & Python)

 The core recommendation engine is built using Scikit-learn, TensorFlow, or PyTorch for
model execution.

 The model takes input from the user, analyzes medical data, and provides personalized
medication recommendations.

 Data preprocessing and transformation are handled using Pandas and NumPy to ensure high-
quality predictions.

4. Local Execution Environment

 Since the system runs on a local server, there is no external database integration. Instead, test
data and model files are stored in the project directory.

 The Flask application loads the trained model from a serialized format (pickle or TensorFlow
model files) and processes requests dynamically.
 The overall architecture is lightweight, scalable, and modular, ensuring smooth execution in a
local environment without the need for cloud-based storage or databases.

4.2 WORKFLOW OF THE SYSTEM

The Medicine Recommendation System follows a structured workflow to process user inputs
and generate medication recommendations effectively. The steps involved in the workflow are as
follows:

Step 1: User Input Collection

 The user enters their symptoms via the web interface.

 Input fields validate the entered symptoms to ensure correct data formatting.

Step 2: Data Processing and Feature Extraction

 The entered symptoms are pre-processed and transformed into a format compatible with the
machine learning model.

 Feature selection techniques are applied to extract relevant medical attributes.

Step 3: Model Prediction

 The processed input is passed to the machine learning model, which predicts the most
suitable medication based on the given symptoms.

 The model utilizes pre-trained datasets and applies classification algorithms to generate
recommendations.

Step 4: Recommendation Generation

 The predicted medications are ranked based on confidence scores.

 The system presents a list of suggested medications along with additional information (e.g.,
possible side effects, dosage recommendations).

Step 5: Displaying Results to the User

 The results are sent back to the Flask backend, which then passes them to the frontend for
display.

 The user can view the recommended medications and alternative treatment options.
Step 6: Feedback and System Learning

 Users have the option to provide feedback on the recommendations.

 Future enhancements may include refining the model by incorporating real-time learning
mechanisms to improve accuracy.

This workflow ensures seamless interaction between the frontend, backend, and machine
learning model, allowing for efficient, real-time medication recommendations without relying on an
external database or cloud services.
 5. SYSTEM IMPLEMENTATION
5.1 INTEGRATION WITH MACHINE LEARNING MODEL

The Medicine Recommendation System integrates a machine learning model to provide real-
time medication recommendations based on user-input symptoms. The integration process involves
several key steps:

1. Training the Model: The model is trained using datasets containing patient symptoms,
medical history, and medication records. Techniques such as decision trees, random forests,
support vector machines (SVMs), and neural networks are used to enhance accuracy.

2. Saving the Trained Model: Once trained, the model is saved in a pickle (.pkl) format or
TensorFlow/Keras model format to be loaded dynamically.

3. Flask API for Model Communication: The trained model is integrated with Flask, allowing
the backend to send user inputs to the model and return predictions.

4. Processing User Input: When a user enters symptoms, the system preprocesses the input,
extracts features, and sends it to the machine learning model for analysis.

5. Returning Predictions: The model generates a list of recommended medications and sends
them back to the web interface for display.

5.2 FRONTEND & BACKEND DEVELOPMENT

Frontend Development

The frontend of the system is developed using HTML, CSS, JavaScript, Bootstrap, and Jinja,
ensuring a user-friendly experience. Key components include:

 Symptom Input Form: Allows users to enter symptoms in a structured format.

 Results Display: Displays predicted medications along with additional information.

 Styling and Responsiveness: Implemented using Bootstrap for cross-device compatibility.

Backend Development

The backend is built using Flask, which:

 Handles HTTP Requests: Processes user input and communicates with the ML model.
  Loads the Trained Model: Uses Python libraries to load the model dynamically for
predictions.

 Manages Data Processing: Prepares input data before passing it to the machine learning
model.

By combining Flask, Jupyter Notebook, and modern web technologies, the system ensures
smooth and efficient processing of user queries, resulting in real-time medication recommendations.
 6. TESTING AND DEPLOYMENT
6.1 FUNCTIONAL TESTING

Functional testing ensures that the Medicine Recommendation System operates as expected,
providing accurate medication suggestions based on user inputs. The testing process includes
verifying that user inputs are correctly processed, model predictions are generated accurately, and
results are displayed properly on the frontend.

Testing Methods:

 Unit Testing: Each component, such as symptom input validation, Flask API response, and
model output, is tested individually.

 Integration Testing: Ensures smooth communication between the frontend, backend, and
machine learning model to validate correct data flow.

 User Acceptance Testing (UAT): Real-world test cases are simulated to verify that the
system meets the requirements and expectations of healthcare professionals.

Test cases focus on:

 Ensuring proper input handling (valid and invalid data entries).

 Checking that the machine learning model returns relevant medication recommendations.

 Verifying that the Flask backend processes and returns results efficiently.

 Ensuring UI responsiveness and correct display of recommended medications.

6.2 PERFORMANCE EVALUATION

Performance evaluation ensures that the system delivers fast, accurate, and scalable
medication recommendations. The system is assessed using various machine learning evaluation
metrics and system performance benchmarks.

Model Evaluation Metrics:

 Accuracy: Measures how often the model correctly predicts medications.

 Precision & Recall: Determines the reliability of the recommendations.

  F1-Score: Balances precision and recall for an optimal evaluation.

 Processing Time: Evaluates the response time of the system from user input to
recommendation display.

System Performance Metrics:

 Response Time: Measures how quickly the system processes user requests and delivers
results.

 Memory & CPU Usage: Assesses resource consumption for efficiency in execution.

 Scalability Testing: Ensures the system can handle multiple simultaneous users without
performance degradation.

6.3 DEPLOYMENT PROCESS

The Medicine Recommendation System is designed to run on a local Flask server, making
deployment simple and efficient. The deployment process involves the following steps:

Deployment Steps:

1. Preparing the Environment:

o Install necessary dependencies (Flask, Pandas, NumPy, Scikit-learn, etc.).

o Set up the machine learning model in a serialized format (e.g., .pkl file).

2. Running the Flask Server:

o Execute app.py to start the backend and connect the ML model.

3. Launching the Web Interface:

o Access the frontend through a local web browser using the Flask server.

4. Testing and Debugging:

o Conduct final system tests to ensure smooth performance.

This deployment process ensures that the system is fully functional on a local machine, enabling
efficient testing and validation without requiring external servers or databases. Future enhancements
may include deployment to cloud platforms for broader accessibility.
 7. RESULT AND DISCUSSION
The Medicine Recommendation System was tested extensively to evaluate its accuracy,
efficiency, and reliability in generating medication recommendations based on user-input symptoms.
This section presents the key findings from system testing and discusses the impact of machine
learning integration on healthcare decision-making.

7.1 RESULTS OF MODEL TESTING

The system was tested using various datasets containing patient symptoms, medical history,
and known drug prescriptions. The evaluation metrics used to measure the model's performance
include:

Model Evaluation Metrics:

 Support Vector Classifier (SVC) Accuracy: 1.0

 Random Forest Accuracy: 1.0

 Gradient Boosting Accuracy: 1.0

The confusion matrices for each model confirmed that the predictions were highly accurate, with
minimal misclassifications.

Performance Metrics:

 Precision & Recall: Precision values indicated that the model successfully identified correct
medications while minimizing false positives.

 F1-Score: A balance between precision and recall was maintained, ensuring optimal
performance.

 Processing Time: The system processed user inputs and generated medication suggestions
within 2-3 seconds, demonstrating efficiency.
7.2 PERFORMANCE OF THE WEB INTERFACE

The web-based testing interface, developed using Flask, HTML, CSS, JavaScript, and Jinja,
provided a seamless user experience. The following observations were recorded during usability
testing:

 The system’s response time was optimal, delivering recommendations quickly without
noticeable lag.

 The interface displayed medication recommendations in a well-structured, easy-to-read

format, improving usability for healthcare professionals.

 The Flask backend successfully communicated with the machine learning model, ensuring
smooth data processing.

7.3 DISCUSSION ON SYSTEM EFFECTIVENESS

The implementation of machine learning in medication recommendations has shown promising

results. Compared to traditional, manual prescription methods, the system offers:

 Faster diagnosis and medication suggestions based on real-time data processing.

 Reduction in human errors that could arise from misinterpretation of symptoms or incomplete
patient history.

 Personalized treatment recommendations, ensuring that medications align with individual

patient needs.

 Scalability and adaptability, allowing future integration with real-world medical databases
and additional AI improvements.

While the system performed well under controlled testing, certain challenges and limitations were
observed, such as:

 Dependence on training data quality: The model’s accuracy depends on the completeness
and correctness of the dataset.

 No real-time learning capability: The system does not update itself dynamically based on
user feedback.
  Potential need for physician validation: Although the system provides recommendations, a
doctor’s final approval remains essential.

Overall, the Medicine Recommendation System successfully met its objectives by providing
reliable, data-driven medication recommendations with a user-friendly interface. Future
enhancements could include improving model accuracy, integrating real-world patient feedback, and
expanding the system’s learning capabilities.
 8. FUTURE ENHANCEMENTS
To further improve the Medicine Recommendation System, various enhancements can be
implemented to optimize its accuracy, scalability, and usability.

1. Model Optimization:

 Fine-tuning model parameters to improve prediction accuracy and reduce overfitting.

 Implementing ensemble learning by combining multiple models for better stability.

 Extracting more meaningful patient features, such as genetic markers and lifestyle factors, to
refine recommendations.

 Expanding disease coverage to include a broader range of medical conditions.

 Improving cross-validation techniques for better model validation and generalization.

2. Scalability Improvements:

 Utilizing parallel processing and lightweight models to enhance efficiency and reduce
response time.

 Integrating APIs with electronic health records (EHRs) and hospital systems for real-time
data access.

 Implementing a user feedback mechanism to refine medication suggestions based on real-

world inputs.

 Enhancing local hosting capabilities to improve offline functionality.

 Adding multi-language support for broader accessibility.

 Designing the system in a modular structure to allow future expansions without disrupting
existing functionality.

These enhancements will ensure that the system remains highly accurate, scalable, and adaptable,
allowing it to evolve with medical advancements and user needs.
 9. CONCLUSION

The Medicine Recommendation System successfully demonstrates the potential of AI-driven

solutions in optimizing medication selection and disease identification. By integrating vast medical
datasets and leveraging advanced machine learning algorithms, the system enhances predictive
accuracy, providing healthcare professionals and patients with reliable and personalized
recommendations.

Beyond medication suggestions, the system serves as a comprehensive healthcare assistant by

offering disease descriptions, necessary precautions, alternative medications, and lifestyle
recommendations such as workouts and diets. Its user-friendly interface and seamless integration
with healthcare IT systems ensure accessibility and ease of use while maintaining compliance with
medical data privacy regulations.

The system’s adaptability allows for continuous improvements through real-time data updates,
user feedback, and evolving clinical guidelines. Future enhancements will focus on expanding
disease coverage, optimizing scalability, and incorporating multilingual support. As it evolves, the
system has the potential to significantly improve patient care, enhance prescription accuracy, and
support medical professionals in making more informed decisions, contributing to the advancement
of precision medicine.
 10.APPENDIX

DATA SETS:

Diets Dataset:

Symptom Dataset:
Medication Dataset:

Description Dataset:
 Precaution Dataset:

Workout Dataset:
SAMPLE CODE:

Main.py :

from flask import Flask, request, render_template, jsonify # Import jsonify

import numpy as np

import pandas as pd

import pickle

import os

print("Current working directory:", os.getcwd())

print("Templates directory exists:", os.path.exists("templates"))

print("Index.html exists:", os.path.exists("templates/index.html"))

app = Flask(__name__, template_folder="templates")

sym_des = pd.read_csv("dataset/symtoms_df.csv")

precautions = pd.read_csv("dataset/precautions_df.csv")

workout = pd.read_csv("dataset/workout_df.csv")

description = pd.read_csv("dataset/description.csv")

medications = pd.read_csv('dataset/medications.csv')

diets = pd.read_csv("dataset/diets.csv")

svc = pickle.load(open('models/svc.pkl','rb'))

def helper(dis):

desc = description[description['Disease'] == dis]['Description']

desc = " ".join([w for w in desc])

pre = precautions[precautions['Disease'] == dis][['Precaution_1', 'Precaution_2', 'Precaution_3',

'Precaution_4']]

pre = [col for col in pre.values]

 med = medications[medications['Disease'] == dis]['Medication']

med = [med for med in med.values]

die = diets[diets['Disease'] == dis]['Diet']

die = [die for die in die.values]

wrkout = workout[workout['disease'] == dis] ['workout']

return desc,pre,med,die,wrkout

symptoms_dict = {'itching': 0, 'skin_rash': 1, 'nodal_skin_eruptions': 2, 'continuous_sneezing': 3,

'shivering': 4, 'chills': 5, 'joint_pain': 6, 'stomach_pain': 7, 'acidity': 8, 'ulcers_on_tongue': 9,
'muscle_wasting': 10, 'vomiting': 11, 'burning_micturition': 12, 'spotting_ urination': 13, 'fatigue': 14,
'weight_gain': 15, 'anxiety': 16, 'cold_hands_and_feets': 17, 'mood_swings': 18, 'weight_loss': 19,
'restlessness': 20, 'lethargy': 21, 'patches_in_throat': 22, 'irregular_sugar_level': 23, 'cough': 24,
'high_fever': 25, 'sunken_eyes': 26, 'breathlessness': 27, 'sweating': 28, 'dehydration': 29, 'indigestion':
30, 'headache': 31, 'yellowish_skin': 32, 'dark_urine': 33, 'nausea': 34, 'loss_of_appetite': 35,
'pain_behind_the_eyes': 36, 'back_pain': 37, 'constipation': 38, 'abdominal_pain': 39, 'diarrhoea': 40,
'mild_fever': 41, 'yellow_urine': 42, 'yellowing_of_eyes': 43, 'acute_liver_failure': 44,
'fluid_overload': 45, 'swelling_of_stomach': 46, 'swelled_lymph_nodes': 47, 'malaise': 48,
'blurred_and_distorted_vision': 49, 'phlegm': 50, 'throat_irritation': 51, 'redness_of_eyes': 52,
'sinus_pressure': 53, 'runny_nose': 54, 'congestion': 55, 'chest_pain': 56, 'weakness_in_limbs': 57,
'fast_heart_rate': 58, 'pain_during_bowel_movements': 59, 'pain_in_anal_region': 60, 'bloody_stool':
61, 'irritation_in_anus': 62, 'neck_pain': 63, 'dizziness': 64, 'cramps': 65, 'bruising': 66, 'obesity': 67,
'swollen_legs': 68, 'swollen_blood_vessels': 69, 'puffy_face_and_eyes': 70, 'enlarged_thyroid': 71,
'brittle_nails': 72, 'swollen_extremeties': 73, 'excessive_hunger': 74, 'extra_marital_contacts': 75,
'drying_and_tingling_lips': 76, 'slurred_speech': 77, 'knee_pain': 78, 'hip_joint_pain': 79,
'muscle_weakness': 80, 'stiff_neck': 81, 'swelling_joints': 82, 'movement_stiffness': 83,
'spinning_movements': 84, 'loss_of_balance': 85, 'unsteadiness': 86, 'weakness_of_one_body_side':
87, 'loss_of_smell': 88, 'bladder_discomfort': 89, 'foul_smell_of urine': 90,
'continuous_feel_of_urine': 91, 'passage_of_gases': 92, 'internal_itching': 93, 'toxic_look_(typhos)':
94, 'depression': 95, 'irritability': 96, 'muscle_pain': 97, 'altered_sensorium': 98,
'red_spots_over_body': 99, 'belly_pain': 100, 'abnormal_menstruation': 101, 'dischromic _patches':
102, 'watering_from_eyes': 103, 'increased_appetite': 104, 'polyuria': 105, 'family_history': 106,
'mucoid_sputum': 107, 'rusty_sputum': 108, 'lack_of_concentration': 109, 'visual_disturbances': 110,
'receiving_blood_transfusion': 111, 'receiving_unsterile_injections': 112, 'coma': 113,
'stomach_bleeding': 114, 'distention_of_abdomen': 115, 'history_of_alcohol_consumption': 116,
'fluid_overload.1': 117, 'blood_in_sputum': 118, 'prominent_veins_on_calf': 119, 'palpitations': 120,
'painful_walking': 121, 'pus_filled_pimples': 122, 'blackheads': 123, 'scurring': 124, 'skin_peeling':
125, 'silver_like_dusting': 126, 'small_dents_in_nails': 127, 'inflammatory_nails': 128, 'blister': 129,
'red_sore_around_nose': 130, 'yellow_crust_ooze': 131}

diseases_list = {15: 'Fungal infection', 4: 'Allergy', 16: 'GERD', 9: 'Chronic cholestasis', 14: 'Drug
Reaction', 33: 'Peptic ulcer diseae', 1: 'AIDS', 12: 'Diabetes ', 17: 'Gastroenteritis', 6: 'Bronchial
Asthma', 23: 'Hypertension ', 30: 'Migraine', 7: 'Cervical spondylosis', 32: 'Paralysis (brain
hemorrhage)', 28: 'Jaundice', 29: 'Malaria', 8: 'Chicken pox', 11: 'Dengue', 37: 'Typhoid', 40: 'hepatitis
A', 19: }

def get_predicted_value(patient_symptoms):

input_vector = np.zeros(len(symptoms_dict))

for item in patient_symptoms:

input_vector[symptoms_dict[item]] = 1

return diseases_list[svc.predict([input_vector])[0]]

@app.route("/")

def index():

return render_template("index.html")

@app.route('/predict', methods=['GET', 'POST'])

def home():

if request.method == 'POST':

symptoms = request.form.get('symptoms')
Index.html:

<!DOCTYPE html>

<html lang="en">

<head>

<meta charset="UTF-8">

<meta name="viewport" content="width=device-width, initial-scale=1.0">

<title>Health AI Diagnosis</title>

<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.1/dist/css/bootstrap.min.css"
rel="stylesheet">

<link rel="stylesheet"
href="https://cdnjs.cloudflare.com/ajax/libs/animate.css/4.1.1/animate.min.css">

<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap-icons/1.10.5/font/

bootstrap-icons.min.css">

<style>

body {

background: #f4f9ff; /* Soft hospital blue */

color: #333;

font-family: 'Arial', sans-serif;

.navbar-brand {

font-weight: bold;

display: flex;

align-items: center;

.logo {
 height: 40px;

margin-right: 10px;

.container {

max-width: 600px;

background: white;

padding: 30px;

border-radius: 12px;

box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1);

margin-top: 50px;

<body>

<!-- Navbar -->

<!-- Navbar -->

<nav class="navbar navbar-expand-lg navbar-dark">

<div class="container-fluid">

<a class="navbar-brand" href="#">

<img src="static/logo.png" alt="Health AI Logo" class="logo"> Health AI

</a>

</nav>

<!-- Main Container -->

<div class="container text-center">

<h2 class="animate__animated animate__zoomIn">Health AI Diagnosis</h2>

About.html:

<!DOCTYPE html>

<html lang="en">

<head>

<meta charset="UTF-8">

<meta name="viewport" content="width=device-width, initial-scale=1.0">

<title>About Us</title>

<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.1/dist/css/bootstrap.min.css"
rel="stylesheet">

<link rel="stylesheet"
href="https://cdnjs.cloudflare.com/ajax/libs/animate.css/4.1.1/animate.min.css">

<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap-icons/1.10.5/font/

bootstrap-icons.min.css">

<style>

body {

background: linear-gradient(120deg, #e3f2fd, #bbdefb);

color: #333;

font-family: 'Arial', sans-serif;

.navbar {

background: #007bff;

padding: 15px;

.navbar-brand {

font-weight: bold;
 }

.container {

max-width: 800px;

background: rgba(255, 255, 255, 0.9);

padding: 20px;

border-radius: 10px;

box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);

.btn-custom:hover {

transform: scale(1.05);

background: linear-gradient(45deg, #0277bd, #0288d1);

</style>

</head>

<body>

<!-- Navbar -->

<nav class="navbar navbar-expand-lg navbar-dark">

<div class="container-fluid">

<a class="navbar-brand" href="#">About</a>

<button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-

target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle
navigation">

<span class="navbar-toggler-icon"></span>

</button>

<div class="collapse navbar-collapse" id="navbarNav">

 <ul class="navbar-nav ms-auto">

<li class="nav-item">

<a class="nav-link text-white" href="/"><i class="bi bi-house-door-fill"></i>

Home</a>

</li>

<li class="nav-item">

<a class="nav-link text-white" href="/about"><i class="bi bi-info-circle-fill"></i>

About</a>

</li>

<li class="nav-item">

<a class="nav-link text-white" href="/contact"><i class="bi bi-envelope-fill"></i>

Contact</a>

</li>

</ul>

</div>

</div>

</nav>

<!-- About Us Section -->

<div class="container animate__animated animate__fadeInUp">

<h3>About Us</h3>

<p>Welcome to Medical Health Center, where health meets technology for a brighter, healthier
future.</p>

<h3>Our Vision</h3>

<p>We envision a world where access to healthcare information is not just a luxury but a
fundamental right. Our journey began with a simple yet powerful idea: to empower individuals with
the knowledge and tools they need to take control of their health.</p>
Contact.html:

<!DOCTYPE html>

<html lang="en">

<head>

<meta charset="UTF-8">

<meta name="viewport" content="width=device-width, initial-scale=1.0">

<title>Contact Us</title>

<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.1/dist/css/bootstrap.min.css"
rel="stylesheet">

<link rel="stylesheet"
href="https://cdnjs.cloudflare.com/ajax/libs/animate.css/4.1.1/animate.min.css">

<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap-icons/1.10.5/font/

bootstrap-icons.min.css">

<style>

body {

background: linear-gradient(120deg, #e3f2fd, #bbdefb);

color: #333;

font-family: 'Arial', sans-serif;

.navbar {

background: #007bff;

padding: 15px;

.container {

max-width: 700px;
 background: rgba(255, 255, 255, 0.9);

<a class="nav-link text-white" href="/about"><i class="bi bi-info-circle-fill"></i>

About</a>

</li>

<li class="nav-item">

<a class="nav-link text-white" href="/contact"><i class="bi bi-envelope-fill"></i>

Contact</a>

</li>

</ul>

</div>

</div>

</nav>

<!-- Contact Form Section -->

<div class="container animate__animated animate__fadeInUp">

<h2 class="text-center">Get in Touch</h2>

<p class="text-center">Have questions? Fill out the form below!</p>

<form>

<div class="mb-3">

<label for="name" class="form-label">Name</label>

<input type="text" class="form-control" id="name" placeholder="Your Name" required>

</div>

<div class="mb-3">

<label for="email" class="form-label">Email</label>

<input type="email" class="form-control" id="email" placeholder="Your Email" required>

</div>
 <div class="mb-3">

<label for="message" class="form-label">Message</label>

<textarea class="form-control" id="message" rows="4" placeholder="Your Message"

required></textarea>

</div>

<button type="submit" class="btn btn-custom">Send Message</button>

</form>

<!-- Contact Info -->

<div class="contact-info">

<p><b>Email:</b> healthAI1234@gmail.com</p>

<p><b>Phone:</b> 0043-87612356</p>

<p><b>Maintain By:</b> G.N.Mills,Coimbatore,India</p>

</div>

</div>

<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.1/dist/js/bootstrap.bundle.min.js"></
script>

</body>

</html>

Data Accuracy:

models = {

'SVC': SVC(kernel='linear'),

'RandomForest': RandomForestClassifier(n_estimators=100, random_state=42),

'GradientBoosting': GradientBoostingClassifier(n_estimators=100, random_state=42),

'KNeighbors': KNeighborsClassifier(n_neighbors=5),

'MultinomialNB': MultinomialNB()
}

for model_name, model in models.items():

model.fit(X_train, y_train)

predictions = model.predict(X_test)

accuracy = accuracy_score(y_test, predictions)

print(f"{model_name} Accuracy: {accuracy}")

cm = confusion_matrix(y_test, predictions)

print(f"{model_name} Confusion Matrix:")

print(np.array2string(cm, separator=', '))

print("\n" + "="*40 + "\n")

WEBSITE: