S.

NO CONTENTS PAGE NO

1 SYNOPSIS

2 INTRODUCTION

3 SYSTEM ANALYSIS
3.1 Existing System
3.2 Proposed System
4 SYSTEM DESIGN
4.1 Data Flow Diagram
4.2 Database
4.3 Module Description
4.4 Screen
5 HARDWARE AND SOFTWARE
SPECIFICATION

6 IMPLEMENTATION

7 TESTING
7.1 Software Testing
7.2 Functional Testing
7.3 Non-Functional Testing
8 CONCLUSION AND FUTURE
ENHANCEMENT

9 BIBLIOGRAPHY

10 APPENDIX
10.1 Source Code
10.2 Screen Shots
 1. SYNOPSIS

As a result of the rapid technological development and the development

of the chatbot concept and the time and effort it can save. Many specialized
frameworks have emerged to undertake chatbot creation and development. By
relying on artificial intelligence, the chatbot has integrated machine learning
within it, and it has become more comprehensive and wider for various
technological fields. Therefore, we will create a chatbot for the University's
Admission and Registration, the project aims to build a chatbot to facilitate the
process of accessing information related to students' inquiries towards
admissions, Registration and the university itself. The motivation for the work
of this project is that there is no university-level equivalent from previous
graduation projects, as this project mainly targets all palestinian tawjihi
students and other palestinians, non palestinian students . As a conclusion, it
lies in answering frequent and common questions by people and providing the
answer to these questions at any time the person wants.
 2. INTRODUCTION

Chatbot is a computer program that humans will interact with in natural

spoken language and including artificial intelligence techniques such as NLP
(Natural language processing) that makes the chatbot more interactive and
more reliable.

Based on the recent epidemiological situation, the increasing demand and

reliance on electronic education has become very difficult to access to the
university due to the curfew imposed, and this has led to limited access to
information for academics at the university.

This project aims to build a chatbot for Admission and Registration to

answer every person who asks about the university, colleges, majors and
admission policy.
 3. SYSTEM ANALYSIS

3.1 EXISTING SYSTEM

In the current scenario, accessing information about university admissions and

registration can be challenging, especially with limitations on physical access due to factors
like the recent epidemiological situation and curfews. Traditional methods of accessing
information may not be sufficient to meet the increasing demand for electronic education.
This creates a gap between potential students and the information they need to make
informed decisions about their education.

DISADVANTAGES OF EXISITNG SYSTEM

- Limited Accessibility: With restrictions on physical access to the university premises due
to factors like curfews or the recent epidemiological situation, accessing information through
traditional methods may be challenging for students.

- Time Constraints: Traditional methods of accessing information, such as visiting the

university in person or making phone calls during operating hours, may not be feasible for
students who have other commitments or are in different time zones.

- Dependency on Human Resources: Providing information through traditional methods

often relies on the availability of university staff, which may result in delays or limited
access to information, especially during busy periods.

- Lack of Personalization: Traditional methods may lack the ability to provide personalized
responses to individual inquiries, leading to a less engaging and efficient interaction for
users.
3.2 PROPOSED SYSTEM

To bridge this gap, we propose the development of a chatbot for Admission and
Registration purposes. This chatbot will leverage artificial intelligence techniques such as
Natural Language Processing (NLP) to interact with users in natural language. By
integrating machine learning, the chatbot will become more comprehensive and reliable,
capable of answering a wide range of inquiries related to the university, colleges, majors,
and admission policies. This project targets Palestinian Tawjihi students as well as other
Palestinian and non-Palestinian students, aiming to provide them with easy access to
information anytime they need it. By addressing common questions and providing timely
responses, the chatbot will enhance the accessibility and efficiency of the university
admission and registration process.

ADVANTAGES OF PROPOSED SYSTEM

- Accessibility: The chatbot will provide easy access to information about university
admissions and registration, allowing users to inquire anytime and from anywhere.

- Efficiency: By leveraging artificial intelligence and machine learning, the chatbot will be
able to handle a wide range of inquiries quickly and accurately, saving time for both users
and university staff.

- 24/7 Availability: Unlike traditional methods that may have limited operating hours, the
chatbot will be available round-the-clock, ensuring that users can get the information they
need whenever they need it.
- Personalized Interaction: Through Natural Language Processing (NLP), the chatbot will
engage users in natural language conversations, providing a personalized and user-friendly
experience.

4. SYSTEM DESIGN

4.1 DATA FLOW DIAGRAM

A Data Flow Diagram (DFD) is a diagram that describes the flow of data and
the processes that change data throughout a system. It’s a structured analysis and design
tool that can be used for flowcharting in place of or in association with information.
Oriented and process oriented system flowcharts. When analysts prepare the Data Flow
Diagram, they specify the user needs at a level of detail that virtually determines the
information flow into and out of the system and the required data resources. This
network is constructed by using a set of symbols that do not imply physical
implementations. The Data Flow Diagram reviews the current physical system, prepares
input and output specification, specifies the implementation plan etc.

Four basic symbols are used to construct data flow diagrams. They are symbols
that represent data source, data flows, and data transformations and data storage. The
points at which data are transformed are represented by enclosed Figures, usually
circles, which are called nodes.

DATA FLOW DIAGRAM SYMBOLS

- Source or Destination of data

- Data Flow

- Process
 - Storage

User Interface

|
Chatbot Processing
v

| Database & Knowledge

v Repository

University

Admission&

Registration
4.2 DATABASE

For the proposed chatbot system for University Admission and Registration, you would need
a database that stores various information related to the university, admissions, registration,
majors, policies, and other relevant data. Here's a simplified outline of the database schema:

1. Users Table:
- UserID (Primary Key)
- Username
- Password (encrypted)
- Email

2. Questions Table:
- QuestionID (Primary Key)
- QuestionText
- UserID (Foreign Key referencing Users Table)
- Timestamp

3. Answers Table:
- AnswerID (Primary Key)
- QuestionID (Foreign Key referencing Questions Table)
- AnswerText
- Timestamp

4. Majors Table:
- MajorID (Primary Key)
- MajorName
- Description
 - AdmissionRequirements

5. Admissions Table:
- AdmissionID (Primary Key)
- MajorID (Foreign Key referencing Majors Table)
- AdmissionDeadline
- AdmissionProcessDescription

6. Registration Table:
- RegistrationID (Primary Key)
- RegistrationDeadline
- RegistrationProcessDescription

7. Policies Table:
- PolicyID (Primary Key)
- PolicyTitle
- PolicyDescription
- EffectiveDate
- ExpiryDate

8. FAQs (Frequently Asked Questions) Table:

- FAQID (Primary Key)
- Question
- Answer

9. Logs Table:
- LogID (Primary Key)
- UserID (Foreign Key referencing Users Table)
- Action (e.g., question asked, answer provided)
- Timestamp
4.3 MODULE DESCRPTION

USER MANAGEMENT MODULE

- Responsible for managing user accounts, including registration, login, and profile
management.
- Allows users to create accounts, login securely, and update their profile information.

QUESTION SUBMISSION MODULE

- Allows users to submit questions to the chatbot regarding university admissions,

registration, majors, policies, etc.
- Captures user queries and stores them in the database for processing.

ANSWER RETRIEVAL MODULE

- Retrieves relevant answers from the database based on user queries.

- Utilizes Natural Language Processing (NLP) techniques to understand and match user
queries with appropriate responses.

MAJORS INFORMATION MODULE

- Provides information about available majors, including descriptions, admission

requirements, and related details.
- Allows users to inquire about specific majors and their prerequisites.

ADMISSIONS INFORMATION MODULE

 - Presents information about admission deadlines, processes, and requirements for various
majors.
- Keeps users informed about important dates and procedures for applying to the university.

REGISTRATION INFORMATION MODULE

- Offers details about registration deadlines, procedures, and requirements for enrolling in
courses.
- Assists users in understanding the registration process and fulfilling necessary steps.

LOGGING MODULE

- Records user interactions with the chatbot, including questions asked, answers provided,
and timestamps.
- Helps in analyzing user behavior, improving system performance, and tracking user
engagement.

ADMINISTRATIVE MODULE

- Provides administrative functionalities for managing system settings, database content,

and user access.
- Allows administrators to add/update/delete information in the database, monitor system
activity, and perform maintenance tasks.
4.4 SCREEN
 5. HARDWARE AND SOFTWARE SPECIFICATION

 Language : Python

 IDE : Anaconda, Notebook

 Processor : i3 or above

 Ram : 4 GB or above

3.1 HARDWARE REQUIREMENT

The hardware used for the development of the project is:

 PROCESSOR : i3

 RAM : 8 GB RAM

 MONITOR : 15” COLOR

 HARD DISK : 500 GB

 KEYBOARD : Keys enhanced

 MOUSE : Logitech

3.2 SOFTWARE REQUIREMENTS

The software used for the development of the project is:

 ENVIRONMENT : ANACONDA TOOL

 TOOLS : JUPYTER
 LANGUAGE : PYTHON
SOFTWARE DESCRIPTION

Anaconda Tool

Anaconda is a popular open-source distribution of the Python and R programming

languages for data science and machine learning tasks. It aims to simplify package
management and deployment by providing a comprehensive ecosystem of tools, libraries, and
packages commonly used in data science and scientific computing.

Here are some key features and components of Anaconda:

1. Package Management :
Anaconda comes with its package manager called conda, which allows users to
install, update, and manage software packages and dependencies. Conda provides a unified
interface for managing packages across different programming languages and environments.

2. Data Science Libraries :

Anaconda includes a wide range of pre-installed data science libraries and tools, such
as NumPy, pandas, SciPy, Matplotlib, scikit-learn, TensorFlow, PyTorch, and many others.
These libraries are essential for data manipulation, analysis, visualization, and machine
learning tasks.

3. Integrated Development Environment (IDE) :

Anaconda provides an optional integrated development environment called Anaconda
Navigator, which offers a graphical user interface (GUI) for managing environments,
installing packages, and launching applications. Additionally, users can also use other popular
IDEs such as Jupyter Notebook, JupyterLab, Spyder, or VSCode with Anaconda.

4. Environment Management :
Anaconda allows users to create isolated environments with specific sets of packages
and dependencies, making it easy to manage different project requirements and avoid
 conflicts between packages. Users can create, clone, export, and share environments using
conda commands or Anaconda Navigator

5. Cross-Platform Compatibility :

Anaconda is available for Windows, macOS, and Linux operating systems, making it
suitable for users across different platforms.

6. Community Support :

Anaconda has a large and active community of users and contributors who provide
support, tutorials, and resources for beginners and experienced users alike. The community
forums, documentation, and online resources are valuable sources of information for
troubleshooting issues and learning new skills.

7. Data Visualization Tools :

In addition to data science libraries, Anaconda includes several data visualization

tools like Matplotlib, Seaborn, Plotly, and Bokeh, which enable users to create interactive and
informative visualizations for data exploration and presentation.

8. Education and Training :

Anaconda provides resources and support for educational institutions, including

Anaconda Education Program, which offers free access to Anaconda products and services
for educational purposes. It also offers training courses and certifications for individuals
looking to enhance their skills in data science and machine learning.

Overall, Anaconda is a powerful and versatile tool for data scientists, researchers,
educators, and developers working on data-intensive projects. Its extensive library of
packages, robust package management system, and user-friendly interface make it a popular
choice for data science and scientific computing tasks.
Languages Supported By Anaconda

Anaconda primarily supports the Python and R programming languages, which are
widely used in the field of data science, scientific computing, and machine learning.

1. Python :
Python is the primary language supported by Anaconda. It comes with a
comprehensive collection of Python packages and libraries commonly used in data analysis,
machine learning, scientific computing, and visualization. Anaconda provides tools like
conda for package management and environments to simplify Python development
workflows.

2. R:

Anaconda also supports the R programming language, which is popular among

statisticians and data analysts for its robust ecosystem of packages for statistical analysis, data
visualization, and machine learning. Anaconda includes the R language interpreter and
provides tools for managing R packages and environments.

Additionally, while Anaconda primarily focuses on Python and R, it also supports

other programming languages and tools through its package management system (conda) and
environments. Users can install packages and libraries for languages like Julia, Java, C/C++,
and others using conda or other package managers compatible with Anaconda.

In summary, while Python and R are the main languages supported by Anaconda,
users have the flexibility to work with other languages and tools within the Anaconda
ecosystem.
Features of Anaconda

Anaconda is a powerful tool for data science and machine learning tasks, offering a
range of features that streamline development, analysis, and deployment processes. Some key
features of Anaconda include:

1. Package Management :
Anaconda comes with a package manager called conda, which simplifies the
installation, updating, and management of software packages and dependencies. Conda
provides a unified interface for managing packages across different programming languages
and environments.

2. Data Science Libraries :

Anaconda includes a vast array of pre-installed data science libraries and tools such
as NumPy, pandas, SciPy, Matplotlib, scikit-learn, TensorFlow, PyTorch, and others. These
libraries are essential for data manipulation, analysis, visualization, and machine learning
tasks.

3. Integrated Development Environment (IDE) :

Anaconda offers an optional integrated development environment called Anaconda

Navigator, which provides a graphical user interface (GUI) for managing environments,
installing packages, and launching applications. Additionally, users can also use other popular
IDEs such as Jupyter Notebook, JupyterLab, Spyder, or VSCode with Anaconda.

4. Environment Management :

Anaconda enables users to create isolated environments with specific sets of packages
and dependencies, facilitating the management of different project requirements and avoiding
conflicts between packages. Users can create, clone, export, and share environments using
conda commands or Anaconda Navigator.
5. Cross-Platform Compatibility :

Anaconda is available for Windows, macOS, and Linux operating systems, making it
suitable for users across different platforms.

6. Community Support :

Anaconda has a large and active community of users and contributors who provide
support, tutorials, and resources for beginners and experienced users alike. The community
forums, documentation, and online resources are valuable sources of information for
troubleshooting issues and learning new skills.

7. Data Visualization Tools :

In addition to data science libraries, Anaconda includes several data visualization

tools like Matplotlib, Seaborn, Plotly, and Bokeh, enabling users to create interactive and
informative visualizations for data exploration and presentation.

8. Education and Training :

Anaconda provides resources and support for educational institutions, including the
Anaconda Education Program, which offers free access to Anaconda products and services
for educational purposes. It also offers training courses and certifications for individuals
looking to enhance their skills in data science and machine learning.

9. Integration with Cloud Services :

Anaconda integrates with cloud services such as Amazon Web Services (AWS),
Microsoft Azure, and Google Cloud Platform (GCP), allowing users to deploy and scale their
data science projects in cloud environments seamlessly.

10. Version Control and Collaboration :

Anaconda supports version control systems like Git and provides tools for
collaboration, enabling teams to work together on data science projects efficiently.

These features make Anaconda a comprehensive and versatile tool for data scientists,
researchers, educators, and developers working on data-intensive projects. Its extensive
library of packages, robust package management system, and user-friendly interface make it a
popular choice for data science and scientific computing tasks.

About Jupyter Notebook

Jupyter Notebook is an open-source web application that allows you to create and share
documents that contain live code, equations, visualizations, and narrative text. It supports
various programming languages, including Python, R, Julia, and others.

Features of Jupyter Notebook

Key features of Jupyter Notebook include:

1. Interactive Computing :
You can write and execute code in cells, which allows for an interactive computing
experience. Each cell can contain code, markdown text, or raw text.

2. Rich Output :
Jupyter Notebooks support the display of rich media output, including images, videos,
HTML, LaTeX equations, and more. This makes it suitable for data analysis, visualization,
and report generation.

3. Kernel Support :
Jupyter Notebook works with different programming languages through the concept
of kernels. Each notebook is associated with a kernel, which allows it to execute code written
in that language.

4. Notebook Sharing :
 Notebooks can be shared easily with others, either by sharing the notebook file or
using online platforms like GitHub, JupyterHub, or Jupyter Notebooks hosted on cloud
services like Google Colab or Microsoft Azure Notebooks.

5. Version Control :
Since Jupyter Notebooks are plain text files, they can be version controlled using Git
or other version control systems, enabling collaboration and tracking changes over time.

6. Integration with Libraries :

Jupyter Notebooks integrate well with various libraries and tools commonly used in
data science and scientific computing, such as NumPy, Pandas, Matplotlib, scikit-learn,
TensorFlow, and PyTorch.

7. Customization :
Jupyter Notebooks offer customization options, allowing users to configure the
appearance, behavior, and extensions according to their preferences.

Jupyter Notebook has become an essential tool in data science, machine learning, research,
education, and other fields where interactive computing and documentation are required. It
provides a flexible and intuitive environment for experimentation, analysis, and
communication of results.

About Python
 Python is a dynamically typed, high-level programming language known for its
simplicity, readability, and versatility. It was created by Guido van Rossum and first released
in 1991. Since then, Python has grown into one of the most popular programming languages
worldwide, with a large and active community of developers.

One of Python's distinguishing characteristics is its philosophy of emphasizing code

readability and simplicity, often expressed in the Zen of Python, a set of guiding principles
for writing Python code. This philosophy promotes clear, concise, and elegant code, which
contributes to Python's popularity among developers of all skill levels.

Python's design is influenced by several programming paradigms, including

procedural, object-oriented, and functional programming. It supports a wide range of
programming styles and techniques, allowing developers to choose the most appropriate
approach for their projects.

The language's syntax is designed to be intuitive and easy to learn, making it

accessible to beginners while still powerful enough for experienced programmers. Python
uses indentation to define code blocks, which enhances readability and enforces a consistent
coding style across projects.

Python's standard library is extensive and provides support for various tasks such as
file I/O, networking, database access, GUI development, and more. This rich collection of
modules and packages reduces the need for external dependencies and accelerates
development by providing ready-to-use solutions for common problems.

In addition to its standard library, Python has a vast ecosystem of third-party libraries
and frameworks contributed by the community. These libraries cover a wide range of
domains, including web development, data science, machine learning, artificial intelligence,
scientific computing, game development, and more. Popular libraries and frameworks like
NumPy, Pandas, TensorFlow, Django, Flask, and Pygame have cemented Python's position as
a leading language in these fields.

Python's versatility extends beyond traditional software development to areas such as

system administration, automation, scripting, and education. Its simplicity and readability
make it an ideal choice for writing scripts and automating repetitive tasks, while its powerful
features enable the development of complex applications and systems.
 Python's community is one of its greatest strengths, with millions of developers
contributing to its development, documentation, and ecosystem. The Python Software
Foundation (PSF) oversees the language's development and promotes its use through
conferences, workshops, and educational initiatives.

Python's open-source nature and permissive licensing make it accessible to everyone,

encouraging collaboration, innovation, and the sharing of knowledge. Its inclusivity and
welcoming community have contributed to Python's continued growth and success as a
programming language.

Overall, Python's combination of simplicity, readability, versatility, and community

support has made it a favorite among developers worldwide. Whether you're a beginner
learning to code or an experienced programmer building complex applications, Python offers
the tools and resources you need to bring your ideas to life.

Features of Python

The features of Python are summarized:

1. Simple and Readable Syntax :

Python's syntax is designed to be simple, clean, and easy to understand, which makes
it accessible to beginners and promotes code readability.

2. High-Level Language :
Python is a high-level programming language, which means it abstracts low-level
details like memory management and hardware interactions, allowing developers to focus on
solving problems at a higher level.

3. Interpreted and Interactive :

Python is an interpreted language, meaning that code is executed line by line by an
interpreter, which allows for rapid development and testing. It also supports an interactive
 mode, where commands can be entered directly into the interpreter and executed
immediately.

4. Dynamic Typing :
Python is dynamically typed, which means that variables don't have a fixed data type
and can dynamically change types during runtime. This flexibility simplifies coding but
requires careful attention to data types.

5. Multi-Paradigm :
Python supports multiple programming paradigms, including procedural, object-
oriented, and functional programming. This flexibility allows developers to choose the most
appropriate programming style for their projects.

6. Cross-Platform :
Python is platform-independent, which means that code written in Python can run on
different operating systems without modification. This makes it a versatile choice for cross-
platform development.

7. Extensive Standard Library :

Python comes with a large standard library that provides support for various tasks
such as file I/O, networking, database access, GUI development, and more. This rich
collection of modules and packages reduces the need for external dependencies and
accelerates development by providing ready-to-use solutions for common problems.

8. Third-Party Libraries and Ecosystem :

 Python has a vast ecosystem of third-party libraries and frameworks contributed by
the community. These libraries cover a wide range of domains, including web development,
data science, machine learning, artificial intelligence, scientific computing, game
development, and more.

9. Object-Oriented Programming (OOP) :

Python supports object-oriented programming (OOP) principles, allowing developers
to create classes, objects, and methods to encapsulate data and behavior. OOP concepts such
as inheritance, polymorphism, and encapsulation are supported.

10. Community and Support :

Python has a large and active community of developers who contribute to its
development, documentation, and ecosystem. The Python Software Foundation (PSF)
oversees the language's development and promotes its use through conferences, workshops,
and educational initiatives.

These features make Python a popular choice for a wide range of applications,
including web development, data analysis, machine learning, automation, scripting, scientific
computing, and more. Its simplicity, versatility, and strong community support have
contributed to its widespread adoption and continued success as a programming language.

Advantages of Python

1.Ease of Learning and Readability:

Python's syntax is designed to be simple and easy to understand, making it an
excellent choice for beginners and experienced programmers alike. Its readability resembles
plain English, which facilitates code comprehension and collaboration among developers.

2.Wide Range of Libraries and Frameworks:

 Python boasts a rich ecosystem of libraries and frameworks for diverse purposes,
including data analysis (e.g., NumPy, Pandas), machine learning (e.g., TensorFlow, scikit-
learn), web development (e.g., Django, Flask), and more. These libraries enable developers to
accomplish complex tasks efficiently without reinventing the wheel.

3.Cross-Platform Compatibility:
Python is a cross-platform language, meaning that code written in Python can run
seamlessly on various operating systems such as Windows, macOS, and Linux. This
portability makes Python an ideal choice for developing applications that need to be deployed
across different platforms.

3.Strong Community Support:

Python has a vibrant and active community of developers worldwide. This community
contributes to the continuous improvement of the language by creating open-source libraries,
sharing knowledge through forums and tutorials, and providing assistance through online
communities such as Stack Overflow and Python-related conferences.

4.High-Level Language:
Python is a high-level language, which means that it abstracts away low-level details,
such as memory management and hardware interactions, allowing developers to focus on
solving problems and writing clean, concise code. This abstraction makes Python particularly
suitable for rapid development and prototyping.

5.Scalability:
Python is scalable, enabling developers to build small scripts or large-scale
applications with ease. Its scalability is evident in its usage by companies ranging from
startups to tech giants like Google, Facebook, and Netflix, which rely on Python for
developing robust and scalable systems.

6.Integration Capabilities:
 Python seamlessly integrates with other languages and platforms, allowing developers
to leverage existing code written in languages such as C/C++ or Java. This interoperability
makes Python an attractive choice for building systems that require interfacing with legacy
code or integrating with external systems.

7.Support for Multiple Paradigms:

Python supports multiple programming paradigms, including procedural, object-
oriented, and functional programming. This versatility enables developers to choose the most
suitable approach for their projects and encourages code reuse, modularity, and
maintainability

8.Extensibility and Customization:

Python is highly extensible, allowing developers to extend its functionality through
custom modules and packages. Additionally, Python's dynamic nature enables runtime
modifications and introspection, facilitating interactive development and experimentation.

9.Deployment Flexibility:
Python offers various deployment options, including standalone executables, web
applications, microservices, and cloud-based solutions. Its versatility in deployment allows
developers to choose the most appropriate deployment strategy for their applications.
 6. IMPLEMENTATION

Implementation is used here to mean the process of converting a new or

revised system design into operational one; conversion is one aspect of
implementation. the other aspect is post implementation review and software and
maintenance.
There are three type of implementation:

 Implementation of a computer system

 Implementation of new computer system
 Implementation of a modified application

IMPLEMENTATION OF THE COMPUTER SYSTEM

It’s should be replace a manual system the problems encountered are
converting files, training users creating accurate files, and verifying printouts for
integrity.

IMPLEMENTATION OF NEW COMPUTER SYSTEM

 It’s should be replace an existing one this is usually a difficult conversion. if
not properly planned there can be many problems. Some large computer system have
taken even years to convert.

IMPLEMENTATION OF A MODIFIED APPLICATION

It’s should be replace an existing one using the same computer. This type of
conversion is relativity easy to handle, provided there are no major changes to the
file.

7. TESTING

7.1 SOFTWARE TESTING

Software testing is an important element of software quality assurance and

represents the ultimate review of specification, design and coding. It increasing
visibility of software as a system element and the costs associates with a software
failure are motivating forces for all well planned through testing. The system is
tested with giving wrong information. Cascade deletion and, the software developer
checks updating. Testing and debugging are different activities, but debugging must
be accommodated in any testing strategy.

7.2 FUNCTIONAL TESTING

Unit testing
 The first step in testing is Unit testing. Individual testing are tested to ensure
that they operate correctly. Each component is tested independently, without other
system components. The module interface is tested to ensure that information
properly flow into and out of the program.These are tested that the module operates
at boundary established to limit or restrict processing. Unit testing is normally
considered as an adjunct to the coding step. After the coding has been developed,
received and verified for correct syntax, unit testing begins. Here each module is
tested to provide its correctness, validity and determine any missing operations and
to verify whether the objectives have been met, errors are noted down and corrected
immediately.

Unit testing is the important and major part of the project. So errors can be
rectified easily in each module and program clarity can be increased. In this project,
the entire system is divided into several modules and is developed individually.
Hence, unit testing is conducted to individual modules.

Integration testing

The second step in the testing process is the Integration testing. Integration
testing is the systematic technique for constructing the program structure while
conducting tests to uncover errors associated with integrating. After the unit test,
each module is gradually integrated to form one final system.
All the modules when unit tested will work properly but after integrating the
data can cause error one module can have an inadvertent, adverse effect on another;
sub functions when combined may not produce the desired major function; global
data structures can cause problems, etc.
Hence, the objective of integration testing is to take unit tested modules and
build a final program structure. In this project, modules are combined to find the
overall performance of the system.

Acceptance testing
The types of acceptance testing are:
 The User Acceptance test: focuses mainly on the functionality thereby
validating the fitness-for-use of the system by the business user. The user
acceptance test is performed by the users and application managers.

 The Operational Acceptance test: also known as Production acceptance test

validates whether the system meets the requirements for operation. In most of
the organization the operational acceptance test is performed by the system
administration before the system is released. The operational acceptance test
may include testing of backup/restore, disaster recovery, maintenance tasks
and periodic check of security vulnerabilities.

 Contract Acceptance testing: It is performed against the contract’s

acceptance criteria for producing custom developed software. Acceptance
should be formally defined when the contract is agreed.
 Compliance acceptance testing: It is also known as regulation acceptance
testing is performed against the regulations which must be adhered to, such
as governmental, legal or safety regulations.

7.3 NON-FUNCTIONAL TESTING

Non-functional testing evaluates aspects of the system beyond specific

behaviors or functions. It focuses on how the system performs. Based on the content
you provided, the following section falls under non-functional testing

Performance testing

A type of Physical test covering a wide range of engineering or functional

evaluations where a material, product, or system is not specified by detailed material
or component specifications: rather, emphasis is on the final measurable performance
characteristics. Testing can be a qualitative or quantitative procedure.
VERIFICATION & VALIDATION

CLIENT SIDE VALIDATION

Various client side validations are used to ensure on the client side that only valid data is
entered. Client side validation saves server time and load to handle invalid data. Some checks
imposed are:

 VBScript in used to ensure those required fields are filled with suitable data only.
Maximum lengths of the fields of the forms are appropriately defined.

 Forms cannot be submitted without filling up the mandatory data so that manual mistakes
of submitting empty fields that are mandatory can be sorted out at the client side to save
the server time and load.

 Tab-indexes are set according to the need and taking into account the ease of user while
working with the system.
SERVER SIDE VALIDATION

Some checks cannot be applied at client side. Server side checks are necessary to save the
system from failing and intimating the user that some invalid operation has been performed
or the performed operation is restricted. Some of the server side checks imposed is:

 Server side constraint has been imposed to check for the validity of primary key and
foreign key. A primary key value cannot be duplicated. Any attempt to duplicate the
primary value results into a message intimating the user about those values through the
forms using foreign key can be updated only of the existing foreign key values.

 User is intimating through appropriate messages about the successful operations or

exceptions occurring at server side.

 Various Access Control Mechanisms have been built so that one user may not agitate
upon another. Access permissions to various types of users are controlled according to the
organizational structure. Only permitted users can log on to the system and can have
access according to their category. User- name, passwords and permissions are controlled
o the server side.

 Using server side validation, constraints on several restricted operations are imposed.
8. CONCLUSION AND FUTURE ENHANCEMENT

CONCLUSION

This bot was built to respond to the inquiries of the students regarding each of the university's
faculties and their specializations, with extracted information for each specialization,
familiarizing students with the level exams that students submit about their enrollment in the
university, introducing the educational qualification diploma program and the mechanism for
joining it. Giving students notes on the electronic enrollment application package, the
locations of approved banks, and how to fill out the application. Introduce students to the
conditions and notes that must be taken into account in the event of joining Palestine
Polytechnic University and the mechanism for calculating grades. Introduce students to the
procedures followed to reserve a seat and what documents are required after the student is
accepted. Introducing students to the system of transferring to Palestine Polytechnic
University from another university on the undergraduate system. Informing students of the
university’s teaching system and language. Introducing students to the student exchange
system with other universities. Introducing students to the system of grants, exemptions, and
financial aid provided to students. Informing students of cases in which the student loses his
university seat. Introducing students to the installment refund system for new students and its
conditions.

FUTURE ENHANCEMENT

Multilingual Support
- Implement support for multiple languages to cater to a diverse user base.

Voice Interaction
- Introduce voice recognition capabilities for users to interact with the chatbot through
speech.

Integration with Student Information System (SIS)

- Integrate the chatbot with the university's SIS to provide real-time access to student data
and academic records.

Appointment Scheduling
- Enable users to schedule appointments with university advisors or counselors through the
chatbot.
Chatbot Analytics Dashboard
- Create an analytics dashboard to track user interactions, popular queries, and system
performance metrics for continuous improvement.

Integration with Social Media Platforms

- Integrate the chatbot with popular social media platforms to reach a wider audience and
provide support through familiar channels.

Student Feedback Mechanism

- Implement a feedback mechanism within the chatbot for students to provide suggestions,
report issues, and rate their experience.

9. BIBLIOGRAPHY

i) Books referred:

1. Sailunaz, K., & Alhajj, R. (2019). Emotion and sentiment analysis from Twitte rtext.
Journal of Computational Science, 36, 101003.
2. Fang, Y., Tan, H., & Zhang, J. (2018). Multi-strategy sentiment analysis of
consumer reviews based on semantic fuzziness. IEEE Access, 6, 20625-20631.
3. Ahmad, S., Asghar, M. Z., Alotaibi, F. M., & Awan, I. (2019). Detection and
classification of socialmedia – based extreme staffiliations using sentiment analysis
techniques. Human-centric Computing and InformationSciences,9(1), 24.
4. Gutiérrez-Batista,K.,Campaña,J.R.,Vila,M.A.,&Martin-Bautista,

M. J. (2018, June). Fuzzy Analysis of Sentiment Terms for Topic Detection Process in
Social Networks. In International Conference on Information Processing and
Management of Uncertainty in Knowledge-Based Systems (pp.3-14). Springer, Cham.

5. Ullah,R., Amblee, N.,Kim, W.,&Lee,H. (2016). From valence to emotions:

Exploring the distribution of emotions in online product reviews. Decision Support
Systems, 81, 41-53.
6. Cohen, I., Cozman, F. G., Sebe, N., Cirelo, M. C., & Huang, T. S. (2004).
Semisupervised learning of classifiers: Theory, algorithms, and their application to
human-computer interaction. IEEE Transactions on Pattern Analysis and Machine
Intelligence, 26(12), 1553-1566.
7. Sun, Q., Niu, J., Yao, Z., & Yan, H. (2019). Exploring eWOM in online customer
reviews: Sentiment analysis at a fine-grained level. Engineering Applications of
Artificial Intelligence, 81, 68-78. Sun, Q., Niu, J., Yao, Z., &Yan, H. (2019).
Exploring eWOM in online customer reviews: Sentiment analysis at a fine-grained
level. Engineering Applications of Artificial Intelligence, 81, 68-78.

ii) Websites:

1. https://data.world/crowdflower/brands-and-product-emotions

2. https://www.kaggle.com/thoughtvector/customer-support-on-
twitter#twcs.csv

3. https://www.kaggle.com/kazanova/sentiment140

4. Kaplan,A.M.,&Haenlein,M.
(2012).Socialmedia:backtotherootsandbacktothefuture. Journal ofSystemsand
Information Technology.
 10. APPENDIX

10.1 SOURCE CODE

rom __future__ import print_function

import sys
import os
import pandas as pd
import numpy as np
import re
import nltk
from keras.layers import Input, Embedding, LSTM, TimeDistributed, Dense, Bidirectional
from keras.models import Model, load_model
INPUT_LENGTH = 20
OUTPUT_LENGTH = 20

import os
print(os.listdir("../input"))

lines = open('../input/movie_lines.txt', encoding='utf-8', errors='ignore').read().split('\n')

conv_lines = open('../input/movie_conversations.txt', encoding='utf-8',
errors='ignore').read().split('\n')

id2line = {}
for line in lines:
_line = line.split(' +++$+++ ')
if len(_line) == 5:
convs = []
for line in conv_lines[:-1]:
_line = line.split(' +++$+++ ')[-1][1:-1].replace("'","").replace(" ","")
c#id and conversation sample
for k in convs[300]:
# Sort the sentences into questions (inputs) and answers (targets)
questions = []
answers = []
for conv in convs:
for i in range(len(conv)-1):
questions.append(id2line[conv[i]])
answers.append(id2line[conv[i+1]])
# Compare lengths of questions and answers
print(len(questions))
print(len(answers))

def clean_text(text):
'''Clean text by removing unnecessary characters and altering the format of words.'''
text = text.lower()
text = re.sub(r"i'm", "i am", text)
text = re.sub(r"he's", "he is", text)
text = re.sub(r"she's", "she is", text)
text = re.sub(r"it's", "it is", text)
text = re.sub(r"that's", "that is", text)
text = re.sub(r"what's", "that is", text)
text = re.sub(r"where's", "where is", text)
text = re.sub(r"how's", "how is", text)
text = re.sub(r"\'ll", " will", text)
text = re.sub(r"\'ve", " have", text)
text = re.sub(r"\'re", " are", text)
text = re.sub(r"\'d", " would", text)
text = re.sub(r"\'re", " are", text)
text = re.sub(r"won't", "will not", text)
text = re.sub(r"can't", "cannot", text)
text = re.sub(r"n't", " not", text)
text = re.sub(r"n'", "ng", text)
text = re.sub(r"'bout", "about", text)
text = re.sub(r"'til", "until", text)
text = re.sub(r"[-()\"#/@;:<>{}`+=~|]", "", text)
# text = re.sub(r"[-()\"#/@;:<>{}`+=~|.!?,]", "", text)
text = " ".join(text.split())
 return text
# Clean the data
clean_questions = []
for question in questions:
clean_questions.append(clean_text(question))
clean_answers = []
for answer in answers:
clean_answers.append(clean_text(answer))
# Find the length of sentences (not using nltk due to processing speed)
lengths = []
# lengths.append([len(nltk.word_tokenize(sent)) for sent in clean_questions]) #nltk approach
for question in clean_questions:
lengths.append(len(question.split()))
for answer in clean_answers:
lengths.append(len(answer.split()))
# Create a dataframe so that the values can be inspected
lengths = pd.DataFrame(lengths, columns=['counts'])
print(np.percentile(lengths, 80))
print(np.percentile(lengths, 85))
print(np.percentile(lengths, 90))
print(np.percentile(lengths, 95))

# Remove questions and answers that are shorter than 1 word and longer than 20 words.
min_line_length = 2
max_line_length = 20

# Filter out the questions that are too short/long

short_questions_temp = []
short_answers_temp = []
for i, question in enumerate(clean_questions):
if len(question.split()) >= min_line_length and len(question.split()) <= max_line_length:
short_questions_temp.append(question)
short_answers_temp.append(clean_answers[i])

# Filter out the answers that are too short/long

short_questions = []
short_answers = []

for i, answer in enumerate(short_answers_temp):

if len(answer.split()) >= min_line_length and len(answer.split()) <= max_line_length:
short_answers.append(answer)
short_questions.append(short_questions_temp[i])

print(len(short_questions))
print(len(short_answers))
138528
138528
r = np.random.randint(1,len(short_questions))

for i in range(r, r+3):

print(short_questions[i])
print(short_answers[i])
print()
that is wrong?
security's locking down the elevators.

i am not giving it up jus' yet...

c'mon, i say we bounce now, kick it for a lil' bit, play some craps. ...maybe spend the night?
they musta been beefing big time with one another, cuz this shit, got way past words,
whatever it was.
...what are they doing right now...?

1.1 Preprocessing for word based model

#choosing number of samples
num_samples = 30000 # Number of samples to train on.
short_questions = short_questions[:num_samples]
short_answers = short_answers[:num_samples]
#tokenizing the qns and answers
short_questions_tok = [nltk.word_tokenize(sent) for sent in short_questions]
short_answers_tok = [nltk.word_tokenize(sent) for sent in short_answers]
#train-validation split
data_size = len(short_questions_tok)

# We will use the first 0-80th %-tile (80%) of data for the training
training_input = short_questions_tok[:round(data_size*(80/100))]
training_input = [tr_input[::-1] for tr_input in training_input] #reverseing input seq for better
performance
training_output = short_answers_tok[:round(data_size*(80/100))]

# We will use the remaining for validation

validation_input = short_questions_tok[round(data_size*(80/100)):]
validation_input = [val_input[::-1] for val_input in validation_input] #reverseing input seq
for better performance
validation_output = short_answers_tok[round(data_size*(80/100)):]

print('training size', len(training_input))

print('validation size', len(validation_input))
training size 24000
validation size 6000
# Create a dictionary for the frequency of the vocabulary
# Create
vocab = {}
for question in short_questions_tok:
for word in question:
if word not in vocab:
vocab[word] = 1
else:
vocab[word] += 1

for answer in short_answers_tok:

for word in answer:
if word not in vocab:
vocab[word] = 1
else:
vocab[word] += 1
# Remove rare words from the vocabulary.
# We will aim to replace fewer than 5% of words with <UNK>
# You will see this ratio soon.
threshold = 15
count = 0
for k,v in vocab.items():
if v >= threshold:
count += 1
print("Size of total vocab:", len(vocab))
print("Size of vocab we will use:", count)
Size of total vocab: 16560
Size of vocab we will use: 1938
#we will create dictionaries to provide a unique integer for each word.
WORD_CODE_START = 1
WORD_CODE_PADDING = 0
word_num = 2 #number 1 is left for WORD_CODE_START for model decoder later
encoding = {}
decoding = {1: 'START'}
for word, count in vocab.items():
if count >= threshold: #get vocabularies that appear above threshold count
encoding[word] = word_num
decoding[word_num ] = word
word_num += 1
print("No. of vocab used:", word_num)
No. of vocab used: 1940
#include unknown token for words not in dictionary
decoding[len(encoding)+2] = '<UNK>'
encoding['<UNK>'] = len(encoding)+2
dict_size = word_num+1
dict_size

def transform(encoding, data, vector_size=20):

"""
:param encoding: encoding dict built by build_word_encoding()
:param data: list of strings
:param vector_size: size of each encoded vector
"""
transformed_data = np.zeros(shape=(len(data), vector_size))
for i in range(len(data)):
for j in range(min(len(data[i]), vector_size)):
try:
transformed_data[i][j] = encoding[data[i][j]]
except:
transformed_data[i][j] = encoding['<UNK>']
 return transformed_data
#encoding training set
encoded_training_input = transform(
encoding, training_input, vector_size=INPUT_LENGTH)
encoded_training_output = transform(
encoding, training_output, vector_size=OUTPUT_LENGTH)

print('encoded_training_input', encoded_training_input.shape)
print('encoded_training_output', encoded_training_output.shape)
encoded_training_input (24000, 20)
encoded_training_output (24000, 20)
#encoding validation set
encoded_validation_input = transform(
encoding, validation_input, vector_size=INPUT_LENGTH)
encoded_validation_output = transform(
encoding, validation_output, vector_size=OUTPUT_LENGTH)
print('encoded_validation_input', encoded_validation_input.shape)

print('encoded_validation_output', encoded_validation_output.shape) print (k,

id2line[k])onvs.append(_line.split(',')) id2line[_line[0]] = _line[4]

10.2 SCREEN SHOTS