Mini Project Report On

AI Based Academic Advisor

Submitted to fulfillment of the requirements for the award of the degree of
BACHELOR OF TECHNOLOGY
in
COMPUTER SCIENCE AND ENGINEERING
By
Bellamkonda Sricharan (22911A05L8)
Goswami Prem (22911A05M4)
Goundla Sankeerth Goud (22911A05M5)
Mingari Vinay (22911A05P0)

Under the Guidance of

Dr.P.Sandhya
Assistant Professor

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

VIDYA JYOTHI INSTITUTE OF TECHNOLOGY

(An Autonomous Institution)
(Approved by AICTE, Accredited by NAAC, NBA & permanently Affiliated to JNTUH, Hyderabad)

Aziz Nagar Gate, C. B. Post, Hyderabad – 500075

2024-2025

1
 DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

CERTIFICATE

This is to certify that the project report titled “AI Based Academic Advisor” is being submitted by
Bellamkonda Sricharan(22911A05L8), Goswami Prem(22911A05M4), Goundla Sankeerth
Goud(22911A05M5), Mingari Vinay(22911A05P0) in partial fulfillment for Mini Project in
Computer Science and Engineering, is a record of bonafide work carried out by them under my
guidance and supervision.

Internal Guide Head of Department

Dr.P.Sandhya Dr. D. Aruna Kumari
Assistant Professor Professor

2
 DECLARATION

We, Bellamkonda Sricharan, Goswami Prem, Goundla Sankeerth Goud, Mingari Vinay
hereby declare that the Mini Project entitled, “AI Based Academic Advisor” submitted for the degree
of Bachelor of Technology in Computer Science and Engineering is original and has been done by
us and this work is not copied and submitted anywhere for the award of any degree.

Date:
Place: Hyderabad

Bellamkonda Sricharan (22911A05L8)

Goswami Prem (22911A05M4)

GoundlaSankeerthGoud(22911A0LM5)

Mingari Vinay (22911A05P0)

3
 ACKNOWLEDGEMENT

We wish to express our sincere gratitude to the project guide, Dr. P. Sandhya Assistant Professor,
Vidya Jyothi Institute of Technology, Hyderabad for her timely cooperation and valuable suggestions
while carrying out this work. It is her kindness that made us learn more from her.

We are grateful to Dr. D. Aruna Kumari, Professor, and HoD, Department of CSE, for her help and
support during our academic year.

We wholeheartedly convey our gratitude to Principal Dr. A. Srujana for providing the necessary
infrastructure to complete this project.

We would thank my parents and the faculty members who have contributed to our progress through
the course to come to this stage.

Bellamkonda Sricharan (22911A05L8)

Goswami Prem (22911A05M4)

GoundlaSankeerthGoud(22911A0LM5)

Mingari Vinay (22911A05P0)

4
 ABSTRACT
AI Based Academic Advisor

The AI-based Academic Advisor project aims to revolutionize educational and career
guidance by combining artificial intelligence with intuitive web-based interaction. Traditional
academic advising systems often rely on static content or rule-based logic, offering generic
recommendations that fail to address the unique strengths and aspirations of individual students. In
contrast, this project integrates machine learning to offer tailored suggestions, making academic
planning more data-driven and personalized.

The recommendation engine in AI-based Academic Advisor is inspired by systems like

Coursera’s skill-based course recommendation and LinkedIn Learning’s personalized learning paths,
which utilize classification algorithms and user profiling to suggest optimal learning journeys.
Similar to these platforms, this project uses a Random Forest Classifier trained on labeled user data
to predict suitable career paths based on a student’s education level, interests, and personal strengths.

Unlike generic career websites or static counseling tools, the AI-based Academic Advisor
bridges the gap between data and decision-making by providing contextual YouTube playlists
alongside recommendations, helping users explore fields more interactively. While tools like
MyNextMove and CareerExplorer offer static mappings of interests to careers, they lack the dynamic
learning and personalization capabilities of AI-driven systems.

Furthermore, the platform design takes cues from the growing adoption of intelligent
dashboards and real-time user data processing in edtech solutions, ensuring that students are
continuously engaged with relevant academic insights. By blending the capabilities of machine
learning, intuitive user experience, and real-time content linkage, the AI-based Academic Advisor
offers a future-ready solution that addresses key shortcomings in existing academic guidance
platforms.

5
 INDEX
Contents Page No
1. Introduction 8
2. Literature Survey 9
3. Feasibility Study 10
3.1 Technical Feasibility 10
3.2 Operational and Economic Feasibility 10
4. System Analysis 11
4.1 Existing System 11
4.2 Proposed System 11
4.3 System Requirements 11
4.3.1 Software Requirements 11
4.3.2 Hardware Requirements 12
4.4 Requirements Definition 12
4.4.1 Functional Requirements 12
4.4.2 Non Functional Requirements 12
5. System Design 13
5.1 Class Diagram 14
5.2 Data Flow Diagram 15
6. Software Implementation 21
6.1 Web Technologies 21
6.1.1 Technologies used in the application 21
6.2 Sample Code 23
7. System Testing 29
8. Results and Output Screens 34
9. Conclusion and Future Enhancement 41
10. References 42

6
 LIST OF SCREENSHOTS

S.NO TITLE PAGENO

8.1 HOME PAGE 34

8.2 RECOMMENDATION PAGE 37
8.3 DASHBOARD PAGE 38
8.4 COURCES PAGE 39
8.5 ABOUT US PAPGE 40

7
 CHAPTER 1
INTRODUCTION
The AI-Based Academic Advisor is a smart web application that aims to
support students in making informed decisions about their academic and career paths
using data-driven recommendations. Built using Python, Flask, and machine learning
libraries such as scikit-learn, the system processes user input—such as education
level, interests, and personal strengths—to predict suitable career options. At the core
of the system is a Random Forest Classifier model trained on historical user data,
enabling the application to classify inputs and generate meaningful career
suggestions with high accuracy.
The system features a modular architecture, separating concerns across training,
inference, and presentation layers. The backend handles model prediction and data
encoding, while the frontend provides a clean, intuitive user interface built with
HTML, CSS, and JavaScript. After submitting a form, users receive a tailored
recommendation, along with a curated YouTube playlist aligned with the suggested
career path. These multimedia resources serve as a gateway for users to explore
potential professions in more depth.
This advisor not only simplifies the process of career planning for students but also
provides a scalable foundation for educational institutions and counselors seeking to
integrate AI into their advising systems. With its extensible design, the project allows
for easy integration of additional data features, user profiles, or even real-time
feedback loops, making it a forward-thinking solution for personalized academic
guidance.

8
 CHAPTER 2
LITERATURE SURVEY

The AI-based Academic Advisor aims to modernize academic guidance by offering

personalized recommendations using machine learning. Unlike conventional advising
tools that rely on static rules, this system adapts to each student’s unique background
and interests.
Inspired by platforms like Coursera and LinkedIn Learning, the project uses
classification techniques to suggest relevant career paths and educational content. This
mirrors how Netflix personalizes content using behavior-based models.
Traditional systems such as career portals provide generic suggestions but lack the
dynamic feedback and intelligence found in AI-driven models. AI-based Academic
Advisor addresses this gap by integrating predictive modeling with interactive learning
resources.
Additionally, the rise of intelligent dashboards in education platforms highlights the
importance of real-time, user-focused interfaces. This project follows that trend by
offering an adaptive and engaging academic planning experience.

9
 CHAPTER 3
FEASIBILITY STUDY
3.1 Technical Feasibility
• The project uses mature and accessible technologies such as Python and
Flask.
• Machine learning is implemented using the scikit-learn library.
• A Random Forest Classifier is used for robust multi-class classification.
• LabelEncoder is applied to preprocess categorical user input.
• The architecture is modular, separating training, serving, and front-end
layers.
• Components like the model and encoders are serialized using Python's
pickle module.
• This enables efficient loading and prediction at runtime.
3.2 Operational and Economic Feasibility
• The system is user-centric, offering a simple and intuitive interface.
• Built with HTML, CSS, and JavaScript for ease of use.
• Can run on standard web servers with no need for high-performance
hardware.
• Utilizes open-source libraries, reducing licensing and development costs.
• Easily deployable on local machines or low-cost cloud services.
• Suitable for educational institutions like schools, colleges, and NGOs.
• Integrates free educational multimedia (e.g., YouTube playlists) to
enhance value.

10
 CHAPTER 4

SYSTEM ANALYSIS

4.1 Existing System

Current academic guidance platforms primarily offer static content or predefined pathways based on
broad categories like education level or stream. While they serve the basic purpose of providing information,
they lack intelligent recommendation systems and do not adapt to individual user profiles. These tools are
often designed for general usability but fall short in delivering personalized insights or interactive engagement.
As a result, students receive generic suggestions without deeper support for personalized discovery or adaptive
academic planning.

4.2 Proposed System

AI-based Academic Advisor is a smart web-based solution built to offer personalized and interactive
academic guidance. Unlike traditional advisory systems, it integrates machine learning to recommend careers
based on a student’s background, interests, and strengths. The platform provides curated learning resources,
intuitive navigation, and a user-friendly dashboard for seamless exploration. With real-time prediction,
responsive design, and data-driven insights, it ensures students receive tailored suggestions with clarity and
ease. This unified system combines intelligent guidance, personalized content, and smooth user experience in
a single platform.

4.3 System Requirements

4.3.1 Software Requirements

• Operating System: Windows 10 or higher, Linux (for deployment)

• Frontend: HTML5, CSS3, JavaScript (for web-based UI)

• Backend: Flask (Python), Jinja2 templating engine

• AI/ML: Python libraries including Pandas, Scikit-learn, Pickle

• Data Storage: CSV files (for user data and model training)

• Recommendation Logic: Pretrained Random Forest Classifier with LabelEncoders

11
 4.3.2 Hardware Requirements
● RAM: Minimum 4GB (Recommended 8GB for development)
● Processor: Intel i3 or above
● Storage: At least 4GB of free disk space

4.4 Requirements Definition

After evaluating the limitations of existing academic guidance platforms, the AI-based
Academic Advisor system is designed to address current needs through clearly defined functional
and non-functional specifications. These requirements are detailed below:

4.4.1 Functional Requirements

The core functionalities of the system include a secure user registration and data collection process.
Users can input their educational background, interests, and strengths through an intuitive web form. The
backend processes this data using a machine learning model to generate real-time career recommendations.
Each suggested career is linked to curated YouTube playlists for further exploration. Additional features
include a user dashboard to track recommendations and visited resources, along with smooth navigation
between multiple sections like Home, Courses, Dashboard, and About Us.

4.4.2 Non Functional Requirements

The non-functional attributes ensure that AI-based Academic Advisor is efficient, scalable, and user-
friendly. The system delivers fast prediction responses with minimal latency and supports consistent
performance under increased usage. Its clean and intuitive web interface is accessible to users across
academic levels. Data is processed securely using local file handling, and the modular architecture allows
for easy maintenance and future enhancements. The lightweight design ensures smooth navigation, making
the platform reliable and adaptable for evolving academic needs.

12
 CHAPTER 5
SYSTEM DESIGN

5.1 UML Diagrams

UML diagrams help visualize the architecture, behavior, and interactions within the AI-based
Academic Advisor system. These models assist developers, stakeholders, and testers by providing
structured views of the system’s functionality and design. At its core, a use case in this context
describes how a student interacts with the platform—for example, by submitting academic details,
receiving career recommendations, or accessing course playlists.

● A sequence of interactions between the student (actor) and the system.

● A functional behavior the advisor system performs in response to user inputs.

Use cases support clear communication, help define system functionality, and serve as a guide
during development and testing. Multiple use cases are created to capture the full functionality of the
system.

UML diagrams typically represent five key views of the system:

User Model View:

● Represents the system from the user’s perspective.

In AI-based Academic Advisor, actors include Student, Admin, and ML Engine, with interactions like
submitting user data, receiving recommendations, or managing datasets.

Structural Model view:

● Captures the static elements such as entities and their relationships.

For example, relationships between User, Input Data, Recommendation Engine, and Career

13
Paths entities in the system.

Environmental Model View:

Illustrates the operational context in which the system runs.

This includes deployment on local or cloud servers, interaction with CSV data files, and
optional integration with video platforms like YouTube for course recommendations.

UML design in AI-based Academic Advisor is categorized into two modeling domains:

UML Analysis Modeling: Focuses on the user and structural views, including actor
interactions and data flow.

UML Design Modeling: Highlights behavior-driven flows and the implementation

architecture behind predictive recommendation generation.

The following section presents a visual representation of AI-based Academic Advisor’s

design through various UML diagrams. Each provides a focused view of system
interactions, logic, and structure. These include use case, class, activity, sequence,
component, and deployment diagrams.

Use Case Diagram:

Illustrates how users (Students, Admin) interact with the system.

Includes use cases like Login, Submit User Data, Get Career Recommendations, View
Learning Resources, Navigate Dashboard.

14
1. Class Diagram:

15
2. Activity Diagram:

16
3. Sequence Diagram:

17
4. Use case diagram:

18
5. Component Diagram:

19
6.object Diagram:

20
 CHAPTER 6
SOFTWARE IMPLEMENTATION
6.1 Web Technologies
The AI-Based Academic Advisor system integrates essential web and AI technologies to
provide an intelligent, user-friendly career guidance platform. The system is built with a focus on
accessibility, responsiveness, and data-driven decision-making, using both backend and frontend
technologies for streamlined implementation.

6.1.1 Technologies used in the application

● Flask (Backend Web Framework)

Flask is a lightweight Python-based web framework used to handle server-side logic

and routing. It manages form submissions, processes input data, and communicates with the
AI model to generate predictions. Flask also supports API endpoints for integration with
frontend pages.

● Python (AI Prediction Engine)

Python powers the core recommendation logic of the system. Using libraries such as
Pandas, NumPy, and Scikit-learn, it processes student input and predicts suitable academic or
career paths. The model is trained on labeled data and returns personalized suggestions.

● HTML & CSS (Frontend Interface)

The user interface is built using HTML for content structure and CSS for styling. Input
fields, buttons, and result display sections are designed to be clean and responsive, ensuring
a smooth experience for users accessing the platform on web browsers.

● JavaScript (Client-Side Behavior)

JavaScript is used to enhance interactivity and validation in the frontend. It helps

21
manage user inputs, form behavior, and output rendering. It may also handle dynamic content
updates without requiring full page reloads.

● Bootstrap (Responsive Design)

Bootstrap is employed for creating a responsive and mobile-friendly layout. Its

predefined components and grid system allow the application to adapt to different screen
sizes, improving usability across devices.

● Jinja2 (Templating Engine)

Flask integrates with Jinja2 templates to dynamically render HTML pages. Based on
user inputs, the server populates the prediction results, YouTube recommendations, and
guidance content on the output page using this templating system.

22
 6.2 Sample Code

app.py (Flask main file)

from flask import Flask, render_template, request, redirect, url_for, session
import pickle, csv

app = Flask(_name_)
app.secret_key = 'your_secret_key'

# Load the model and encoders

model = pickle.load(open('model.pkl', 'rb'))
le_education, le_interest, le_strength = pickle.load(open('encoders.pkl', 'rb'))

@app.route('/')
def index():
return render_template('index.html')

@app.route('/predict', methods=['POST'])
def predict():
name = request.form['name']
age = request.form['age']
education = request.form['education']
interest = request.form['interest']
strength = request.form['strength']

encoded_input = [
le_education.transform([education])[0],
le_interest.transform([interest])[0],
le_strength.transform([strength])[0]
]

recommendation = model.predict([encoded_input])[0]

session['user'] = {
'name': name,
'age': age,
'education': education,
'interest': interest,
'strength': strength,
'recommendation': recommendation,
'visited_courses': []
}

with open('user_data.csv', 'a', newline='') as f:

writer = csv.writer(f)
writer.writerow([name, age, education, interest, strength, recommendation])

return redirect(url_for('recommendation'))

23
@app.route('/recommendation')
def recommendation():
recommendation = session['user']['recommendation']
return render_template('recommendation.html', recommendation=recommendation)

@app.route('/courses')
def courses():
recommendation = session['user']['recommendation']
session['user']['visited_courses'].append(recommendation)

youtube_links = {
'Archaeology': [
'https://youtube.com/playlist?list=PLnl4bzqH5QqKVoafPg1adHUxPurKvfyxr',
'https://youtube.com/playlist?list=PLAiwjOgpXvubzuVsbfRI0L4mJoFvQHNWv',
'https://youtube.com/playlist?list=PL1mr9ZTZb3TUqxi2svB3PUHvj-9io2RL5',
'https://youtube.com/playlist?list=PLhMDlPcDRBKQHBoEHIsEvMbnUFMb7tbLB'
],
'Agricultural Scientist': [
'https://youtube.com/playlist?list=PLsXBJ1D_rGFLKeEdOQq87c0GJaFNn83uO',
'https://youtube.com/playlist?list=PL5QqUn7E35CDFpwC1lTzCI7d5u5rsppsn',
'https://youtube.com/playlist?list=PLCT8-CYagFjM1CMAMw1G0adkzx9z06V9i',
'https://youtube.com/playlist?list=PLnI1zSpX4B-BFYqiaIvz71du2Yqc86nCh'
],
'Banker': [
'https://youtube.com/playlist?list=PLRYBXdFrXO9WpeTKOj2xZiEhP1qSo8WYd',
'https://youtube.com/playlist?list=PLfoo1YHNBGvZNMCVdNJDnUeiIMqSjCCBR',
'https://youtube.com/playlist?list=PLhli2lbMRVRl6rSiJz0kBFVLM3Ilt-t9n'
],
'Business Management': [
'https://youtube.com/playlist?list=PLsh2FvSr3n7eHjE7vVU0xM52gm5gWgroz',
'https://youtube.com/playlist?list=PLoJHkGmgd2_kaxMmAgUNnYD5VM8ZGHGy6',
'https://youtube.com/playlist?list=PL3XU4dkmwc1c1X8od8AYYxQjwFD-F_nb4',
'https://youtube.com/playlist?list=PLsOlZpO_j74qGy8gIBdtuKdDcluqlHP7T'
],
'Chartered Accountant': [
'https://youtube.com/playlist?list=PL0w5G7FOKzzp_pLOzk4vDPUV489ATfoRu',
'https://youtube.com/playlist?list=PLuPsXhXyb-c-QZiHznBcsBlgErWLwJj8V',
'https://youtube.com/playlist?list=PLxSsE7nAS4Izc1SpkCtnBSpMhSwEDaIEn',
'https://youtube.com/playlist?list=PLrHodlkr-ygGe1JD29JimDAI-EqVPsqRA'
],
'Computer Science': [
'https://youtube.com/playlist?list=PLPIwNooIb9vhxM2K0KpKMtRxrG0pYS00c',
'https://youtube.com/playlist?list=PL1fd5kIddTjm-IDk-LlP2yM2PjTVlNZJ4',
'https://youtube.com/playlist?list=PL1fd5kIddjnMJaC8BRrDa5R8m-IxxZ39',
'https://youtube.com/playlist?list=PL8dPuuaLjXtNlUrzyH5r6jN9ulIgZBpdo'
],
}

playlist_links = youtube_links.get(recommendation, [])

return render_template('courses.html', recommendation=recommendation, playlists=playlist_links)
24
@app.route('/dashboard')
def dashboard():
user = session.get('user', {})
return render_template('dashboard.html', user=user)

@app.route('/about_us')
def about_us():
return render_template('about_us.html')

if _name_ == '_main_':
app.run(debug=True)

train_model.py

import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.ensemble import RandomForestClassifier
import pickle

# Define data
education_levels = ["Science", "Commerce", "Arts"]
interests = ["Technology", "Biology", "Business", "Design", "Physics", "Finance", "Media",
"Chemistry", "Mathematics", "Medicine", "Accounting", "Performing Arts",
"Environmental Science", "Economics", "Psychology", "Law", "Agriculture",
"Political Science", "Marketing", "Information Technology", "Film Studies",
"History", "Banking"]
strengths = ["Logical Thinking", "Analytical Thinking", "Communication", "Creativity",
"Problem Solving", "Numerical Skills", "Storytelling", "Research", "Empathy",
"Attention to Detail", "Scientific Curiosity", "Critical Thinking", "Leadership",
"Precision", "Curiosity", "Public Speaking", "Persuasion", "Environmental Awareness",
"Debating Skills", "Quantitative Skills", "Detail-Oriented"]

# Sample recommendation logic with randomness to train model

import random
recommendation_options = ["Computer Science", "Finance & Accounting", "Medical Sciences",
"Graphic Design", "Environmental Research", "Political Studies",
"Business Management", "Performing Arts", "Law", "Agriculture Studies"]

data = []
recommendations = []

for _ in range(500): # 500 random samples

edu = random.choice(education_levels)
interest = random.choice(interests)
strength = random.choice(strengths)

# Create more intelligent mapping (simplified, for demo)

if "Tech" in interest or "IT" in interest:
25
 rec = "Computer Science"
elif "Finance" in interest or "Accounting" in interest:
rec = "Finance & Accounting"
elif "Medicine" in interest or "Biology" in interest:
rec = "Medical Sciences"
elif "Design" in interest or "Arts" in edu:
rec = "Graphic Design"
elif "Political" in interest or "Law" in interest:
rec = "Political Studies"
else:
rec = random.choice(recommendation_options)

data.append([edu, interest, strength])

recommendations.append(rec)

# Create DataFrame
df = pd.DataFrame(data, columns=["Education", "Interest", "Strength"])
df["Recommendation"] = recommendations

# Encode
le_edu = LabelEncoder()
le_interest = LabelEncoder()
le_strength = LabelEncoder()

df["Education"] = le_edu.fit_transform(df["Education"])
df["Interest"] = le_interest.fit_transform(df["Interest"])
df["Strength"] = le_strength.fit_transform(df["Strength"])

X = df[["Education", "Interest", "Strength"]]

y = df["Recommendation"] # No encoding needed

# Train model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X, y)

# Save model and encoders

with open("model.pkl", "wb") as f:
pickle.dump(model, f)

with open("encoders.pkl", "wb") as f:

pickle.dump((le_edu, le_interest, le_strength), f)

print(" Model and encoders trained and saved.")

script.js

document.addEventListener('DOMContentLoaded', function() {
// Form validation for login form (index.html)
const indexForm = document.querySelector('form');

26
// Input fields
const nameInput = document.getElementById('name');
const ageInput = document.getElementById('age');
const phoneInput = document.getElementById('phone');
const emailInput = document.getElementById('email');
const educationInput = document.getElementById('education');
const interestInput = document.getElementById('interest');
const strengthInput = document.getElementById('strength');

// Validation function
function validateForm(event) {
// Reset previous error messages
const errorElements = document.querySelectorAll('.error-message');
errorElements.forEach(e => e.remove());

let isValid = true;

// Name validation: must not be empty

if (nameInput.value.trim() === '') {
showError(nameInput, 'Name cannot be empty');
isValid = false;
}

// Age validation: must be a number and greater than 0

if (!/^\d+$/.test(ageInput.value) || ageInput.value <= 0) {
showError(ageInput, 'Please enter a valid age');
isValid = false;
}

// Phone validation: must be a valid phone number format

if (!/^\d{10}$/.test(phoneInput.value)) {
showError(phoneInput, 'Phone number must be 10 digits');
isValid = false;
}

// Email validation: must be a valid email format

if (!/\S+@\S+\.\S+/.test(emailInput.value)) {
showError(emailInput, 'Please enter a valid email address');
isValid = false;
}

// Education, Interest, and Strength validation: must not be empty

if (educationInput.value === '') {
showError(educationInput, 'Please select your education');
isValid = false;
}

if (interestInput.value === '') {

showError(interestInput, 'Please select your area of interest');
isValid = false;
27
 }

if (strengthInput.value === '') {

showError(strengthInput, 'Please select your strength');
isValid = false;
}

// If invalid, prevent form submission

if (!isValid) {
event.preventDefault();
}
}

// Function to display error message next to the invalid field

function showError(inputElement, message) {
const errorMessage = document.createElement('div');
errorMessage.classList.add('error-message');
errorMessage.style.color = 'red';
errorMessage.style.fontSize = '0.9rem';
errorMessage.style.marginTop = '5px';
errorMessage.textContent = message;

inputElement.parentElement.appendChild(errorMessage);
}

// Attach validation to form submit

if (indexForm) {
indexForm.addEventListener('submit', validateForm);
}
});’

28
 CHAPTER 7
SYSTEM TESTING
Software testing is a crucial phase in the development of the AI-based Academic Advisor
system. It ensures the application works as intended, delivers accurate recommendations, and
provides a smooth, error-free experience to users. The testing process focused on validating
functionalities like career prediction, data entry, recommendation generation, and integration with
supporting components such as the Flask backend and dataset processing modules.

7.1 Types of Testing

7.1.1 Unit testing

Unit testing targeted individual modules, including:

• Career prediction algorithm logic

• Form input validation (e.g., academic percentage, stream selection)

• Flask API routes for processing requests

Each unit was tested in isolation to confirm that it handles valid input correctly and returns
the expected output. For instance, when a specific academic stream and percentage are entered, the
prediction function should accurately return a suitable career suggestion.

7.1.2 Integration testing

Integration testing ensures that all components of the AI-Based Academic Advisor work
together smoothly. It verifies:

Communication between the frontend (HTML/CSS/JS) and backend (Flask).

Proper data flow from user inputs to the LabelEncoder and machine learning model.

Correct responses from the Random Forest Classifier back to the user interface.

This testing phase helps identify any issues in the interaction between modules and ensures accurate
academic recommendations.

7.1.3 Functional testing

29
 Functional testing ensured that all user-facing features performed as expected. This
included:

• Form submissions capturing correct user inputs

• Career suggestions displayed accurately based on inputs

• Recommendation of external resources such as YouTube playlists

System responses were tested for various user profiles to confirm consistency and accuracy.

7.2 System Testing

System testing evaluated the entire application in a production-like environment using web
browsers on different devices. This tested end-to-end behavior including:

• Form navigation and data validation

• Execution of the career prediction engine

• Display of output recommendations and links

Real-time testing confirmed usability and correctness under typical conditions.

7.2.1 White Box Testing

White box testing was used to examine the internal structure of functions and APIs.

Developers analyzed the logic used in the prediction module and tested multiple input paths to

ensure code coverage and performance.

7.2.2 Black Box Testing

Black box testing focused on verifying application outputs without looking into internal code.
Testers checked if:

• Valid user inputs produced correct career predictions

30
 • Navigation links worked

• Errors were handled properly on incorrect or missing inputs

7.3 Unit Testing:

The smallest units of the system were individually tested for correctness, including:
• Form field input validation logic
• Career prediction decision logic
• Recommendation retrieval based on prediction

Tests were performed using dummy inputs to verify accuracy.

Test Strategy and Approach

• Both manual testing and automated testing with Python’s unittest framework were applied
• Mock datasets were used to simulate user inputs and validate output behavior
• Emphasis was placed on code stability and user data flow integrity

7.4 Integration Testing

Integration testing ensured seamless communication between key modules. Scenarios
included:

• Receiving inputs from form pages and passing them to the Flask API

• Correct functioning of prediction algorithm with backend data

• Generation of YouTube playlist links based on prediction output

7.5 User Acceptance Testing (UAT)

UAT was conducted by having real students use the application and provide feedback. The tests
involved:

• Inputting academic data

• Interpreting suggested career options

31
 • Following external learning resources

Feedback was used to enhance clarity of recommendations, input prompts, and output formatting.

7.6 Testing Methodologies

The following methodologies were applied during Ai Based Academic advisor testing:

➢ Unit Testing
➢ Integration Testing
➢ User Acceptance Testing
➢ Output Testing

7.6.1 Unit Testing

Modules tested individually included:

• Academic input validators
• Prediction logic based on trained dataset
• Output formatting

Python’s unittest module was used to automate logical checks.

7.6.2 Integration Testing

After units were validated, integration testing ensured:

• Backend and frontend interactions worked as expected

• Recommendations linked to appropriate YouTube content

7.6.2.1 Top-Down Integration

Started with high-level user interface and incrementally connected:

• Backend logic
• Career suggestions

32
 • Recommendation links

7.6.2.2 Bottom-up Integration

Began with testing prediction logic and dataset handling before integrating the user
interface and routing.

7.6.3 User Acceptance Testing

Beta testing with students led to refinements such as:

• Better error messages
• Improved recommendation accuracy
• Streamlined form design

7.6.4 Output Testing

Outputs were tested for clarity and correctness:

• Displayed career suggestion

• Correct loading of video links

• Validation of input/output sequences

33
 CHAPTER 8
RESULTS AND OUTPUT SCREENS

8.1 Home page

34
35
36
8.2 RECOMMENDATION PAGE

37
8.3 DASHBOARD PAGE:

38
8.4 COURCES PAGE:

39
8.5 ABOUT US PAPGE:

40
 CHAPTER 9
CONCLUSION & FUTURE ENHANCEMENT

The AI-based Academic Advisor project offers a smart, efficient solution to the
challenges students face when making academic and career decisions. By leveraging
machine learning algorithms, the system analyzes a student's educational background
and interests to provide personalized career recommendations. This approach ensures
guidance that is both relevant and adaptive to individual profiles.
The platform is designed with user accessibility and simplicity in mind. Its web-
based interface allows students to easily enter their information and receive instant
suggestions, along with curated learning resources such as YouTube playlists. The use
of technologies like Python, Flask, and scikit-learn ensures that the system delivers fast
and accurate predictions in a lightweight environment.
Overall, the AI-based Academic Advisor stands as a practical tool for modern
academic guidance. It bridges the gap between students and informed decision-making
by combining data-driven insights with a user-friendly experience. With potential for
future integration of NLP chatbots, cloud storage, and more advanced analytics, the
system can evolve into a comprehensive academic support platform.

41
 CHAPTER 10
REFERENCES
1. Scikit-learn: Machine Learning in Python – Pedregosa et al., Journal of Machine Learning
Research, 2011.
2. Python Official Documentation – Python Software Foundation. https://docs.python.org
3. Flask Web Framework – Pallets Projects. https://flask.palletsprojects.com
4. Machine Learning Career Prediction Dataset – Kaggle. https://www.kaggle.com
5. LabelEncoder – scikit-learn preprocessing tools.
6. "Designing User Interfaces for Web Applications" – Alan Cooper, About Face: The Essentials
of Interaction Design.

42