Resources That will Make You Better at IT, Education and specifically in Digital Marketing.: Master AI with BCA 303T

LEARNING OBJECTIVES:

In this course, the learners will be able to develop expertise related to the following:

1. To learn the basics of designing intelligent agents that can solve general purpose problems.

2. To represent and process knowledge, plan and act, reason under uncertainty and can learn from experiences.

UNIT–I

No. of Hours: 12 Chapter/Book Reference: TB1 [Chapters - 1, 2, 3]; TB2 [Chapters- 1, 3, 4]

Overview of AI: Introduction to AI, Importance of AI, AI and its related field, AI techniques,

Problem solving agents, Criteria for success.

Problems, problem space and search: Defining the problem as a state space search, Depth First Search, Breadth First search, Production Systems and its characteristics, Issues in the design of the search programs.

Heuristic search techniques: Generate and test, hill climbing, best first search technique, A*, AO*, problem reduction, constraint satisfaction.

UNIT–II

No. of Hours: 12 Chapter/Book Reference: TB1 [Chapters - 5, 6]; TB2 [Chapters - 7, 8, 9,

10] RB1 [Chapters - 5, 6, 7]

Knowledge Representation: Definition and importance of knowledge, Knowledge representation, various approaches used in knowledge representation, Issues in knowledge representation, Semantic net frame.

Logical Reasoning: Logical agents, propositional logic, inferences, Syntax and semantics of First Order Logic, Inference in First Order Logic Knowledge Base, forward chaining, backward chaining, unification, resolution

UNIT–III

No. of Hours: 10 Chapter/Book Reference: TB1 [Chapters - 7, 8, 15]; TB2 [Chapters - 13,

14]

Handling Uncertainty: Non-Monotonic Reasoning, Probabilistic reasoning, Bayes ‘Theorem, Certainty factors and Rule-based Systems, Bayesian Networks, Dempster-Shafer Theory, Introduction to Fuzzy logic. Fuzzy set definition & types. Membership functions. Designing a fuzzy set for a given application

Natural Language Processing: Introduction, Syntactic Processing, Semantic Processing, Pragmatic Processing.

UNIT–IV

No. of Hours: 10 Chapter/Book Reference: TB1 [Chapter 17]; TB2 [Chapters - 18, 19]

Learning: Introduction to Learning, Rote Learning, learning by taking advice, learning in problem solving, learning from examples: Induction, Explanation-based Learning, Discovery, Analogy, Neural Networks, and Genetic Learning.

Expert System: Introduction to expert System, Case study of Expert system (Prolog/any programming Language).

TEXT BOOKS:

TB1. Rich and Knight, “Artificial Intelligence”, Tata McGraw Hill, 1992.

TB2. Stuart Russell and Peter Norvig, “Artificial Intelligence: A Modern Approach”, Prentice Hall, Second Edition (Indian reprint: Pearson Education)

REFERENCE BOOKS:

RB1. George F.Luger Artificial Intelligence Pearson Education

RB2. Ben Coppin Artificial Intelligence Illuminated Jones and Bartlett Publisher

BT levels” most commonly refers to Bloom’s Taxonomy levels—a framework used in education to classify learning objectives by complexity. Bloom’s Taxonomy is a widely used educational framework that classifies learning objectives into levels of increasing complexity. It was originally developed by Benjamin Bloom in 1956 and later revised in 2001 to better reflect active thinking and modern teaching practices.

Example :

Internal Exam : October Mid

Practical Exam : November End

Final Exam : December Starting

===========================================================

Assignment-1 [Handwritten]

Assignment -2

Assignment-3

==========================================================

Refer AI Question Bank for Practice

===========================================================

Explore : https://indiaai.gov.in/

INDIAai (https://indiaai.gov.in/) is the Government of India’s official portal for Artificial Intelligence, created by the Ministry of Electronics and Information Technology (MeitY) to build a national AI ecosystem. It serves as a central hub for AI innovation, education, research, and policy development in India.

Overview of INDIAai

Launched by: Ministry of Electronics and Information Technology (MeitY)
Purpose: To democratize AI access, foster innovation, and promote ethical, inclusive AI development across India.
Vision: Position India as a global leader in responsible and scalable AI adoption.

🌍 Major Initiatives

Global IndiaAI Summit (2024, New Delhi): Focused on compute capacity, foundational models, datasets, and ethical AI.
India–AI Impact Summit 2026: Announced by Prime Minister Narendra Modi; first global AI summit hosted in the Global South (Feb 19–20, 2026).
Global Partnership on AI (GPAI): India’s collaboration with international AI research and policy networks.

📚 Resources Available on the Portal

News & Articles: Latest AI developments and government initiatives.
Case Studies & Research Reports: Indian and global AI applications.
Startups Directory: Profiles of emerging AI ventures.
Events Calendar: Summits, workshops, and hackathons.
Educational Materials: AI learning modules and FutureSkills programs.

Unit-by-Unit PowerPoint content for quick access.

Unit-wise notes for your convenience

Explore https://course.fast.ai/Resources/kaggle.html

Earn a Coursera Certificate based on "AI" or from INDIAAI course (any AI course)

Free AI Courses

[Kaggle Learn](https://www.kaggle.com/learn?utm_source=chatgpt.com)

[fast.ai](https://course.fast.ai?utm_source=chatgpt.com)

[DeepLearning.AI](https://www.deeplearning.ai?utm_source=chatgpt.com)

[NPTEL](https://nptel.ac.in?utm_source=chatgpt.com)

[Coursera](https://www.coursera.org?utm_source=chatgpt.com) (audit for free)

Links For Coding & AI Implementation

[Google Colab](https://colab.research.google.com?utm_source=chatgpt.com) Python, free GPU, notebooks for All AI practicals
[Kaggle](https://www.kaggle.com?utm_source=chatgpt.com) Datasets, competitions, notebooks ML, data preprocessing, projects
[Hugging Face](https://huggingface.co?utm_source=chatgpt.com) NLP models, LLMs, datasets NLP, Transformers
[Scikit-learn Documentation](https://scikit-learn.org?utm_source=chatgpt.com) Machine Learning algorithms Classification & clustering
[TensorFlow](https://www.tensorflow.org?utm_source=chatgpt.com) Deep Learning Advanced AI
[PyTorch](https://pytorch.org?utm_source=chatgpt.com) Research and AI development Deep Learning

Links for Robotics & Simulation

[Roboflow](https://roboflow.com?utm_source=chatgpt.com) – Computer vision projects with Colab integration.

[OpenCV](https://opencv.org?utm_source=chatgpt.com) – Image processing.

[ROS (Robot Operating System)](https://www.ros.org?utm_source=chatgpt.com) – Robotics programming.

[NVIDIA Isaac Lab](https://developer.nvidia.com/isaac-lab?utm_source=chatgpt.com) – Robot simulation.

Physical Visits (Delhi NCR)

National Science Centre – Robotics exhibits, AI demonstrations, STEM workshops.
Indian Institute of Technology Delhi – Robotics and AI research labs (through prior permission).
Indraprastha Institute of Information Technology Delhi – AI and robotics labs, seminars, and technical events. Their robotics club, CYBORG, regularly conducts hands-on activities.
Atal Tinkering Labs – Many schools and innovation hubs host robotics demonstrations and maker activities.

THE BIG PICTURE OF YOUR ENTIRE SYLLABUS

I recommend teaching the syllabus through this conceptual journey:

ARTIFICIAL INTELLIGENCE

│

┌─────────────────┼─────────────────┐

│ │ │

SEARCH REASONING LEARNING

│ │ │

BFS / DFS Logic / Probability ML / NN

A* / AO* Fuzzy Logic Genetic

CSP Uncertainty Learning

│ │ │

└─────────────────┼─────────────────┘

│

APPLICATIONS

│

┌─────────────────┼─────────────────┐

│ │ │

NLP Expert Systems Robotics

What AI does

1. Understand: Read text, images, voice

2. Reason: Solve problems, plan steps

3. Create: Write, code, design, make images/video

4. Act: Use tools, search web, send emails, book meetings

2. Types of AI you use daily

3. How an AI Agent works

Goal → Think → Use Tools → Learn from Result → Repeat

Ex: "Find me 3 IT jobs in Delhi" → Searches → Filters → Summarizes → Sends you

4. What you can build with AI right now

1. Personal agent: Email writer, meeting scheduler, researcher

2. Business agent: Customer support, resume screener, content creator

3. Creative agent: Image generator, video editor, music maker

Best AI Tools for 2026

Work: Meeting notes, emails, research, data analysis
Study: Tutor, flashcards, paper summarizer
Content: Image gen, video, voice cloning, social posts

1. For WORK 💼

2. For STUDY 📚

3. For CONTENT 🎨

Top 3 "Must-Have" Stack for 2026

Meta AI: Daily assistant + images + brainstorming

NotebookLM: For study and research with your own files

Canva + HeyGen: For all content and videos

Is Google Maps intelligent?
Is Siri intelligent?
Is ChatGPT intelligent?
Is a calculator intelligent?
Is a chess-playing computer intelligent?
Is a washing machine intelligent?
Is a self-driving car intelligent?

Artificial Intelligence is not just about robots. AI is about designing systems that can perceive, reason, learn, and act to achieve goals.

Perceive → Interpret → Represent → Reason → Learn → Decide → Act → Evaluate

A useful classroom model is:

Perceive → Represent → Reason → Learn → Decide → Act (PR²LDA)

What does Perceive mean in AI?

Perception is the process through which an AI system collects information or observations from its environment using available inputs such as:

Cameras → images and video
Microphones → speech and sounds
Sensors → temperature, motion, pressure, distance
Text → documents, messages, web content
User input → commands and questions
Databases/APIs → structured information

Perception is not the same as understanding.

Artificial Intelligence is not just about robots. AI is about designing systems that can perceive information from their environment, represent that information in a meaningful form, reason about it, learn from experience, make decisions, and act to achieve specific goals.

Perceive → Interpret → Represent → Reason → Learn → Decide → Act → Evaluate

For example:

Self-driving car

Camera detects an object

↓

PERCEIVE

"Something is in front of me"

↓

INTERPRET

"That object appears to be a pedestrian"

↓

REPRESENT

Pedestrian = Object + Location + Distance + Movement

↓

REASON

Pedestrian may cross the road

↓

DECIDE

Reduce speed / Brake

↓

ACT

Apply brakes

↓

EVALUATE

Did the action achieve the goal safely?

                    ┌───────────────┐

                    │   ENVIRONMENT │

                    └───────┬───────┘

│

▼

                     👁 PERCEIVE

                  Collect Information

│

▼

                    🧩 INTERPRET

                 Extract Meaning

│

▼

                   🗂 REPRESENT

              Organize Knowledge

│

▼

                     🧠 REASON

                Analyze Possibilities

│

▼

                    📚 LEARN

                Improve from Experience

│

▼

                    🎯 DECIDE

                 Select Best Action

│

▼

                     ⚙️ ACT

               Take Action in World

│

▼

                    🔄 EVALUATE

               Check the Result

│

                            └──────────► New Perception

1. Introduction to Artificial Intelligence

Simple definition

AI is the field of computer science concerned with creating systems that can perform tasks that normally require human-like intelligence.

These tasks include:

Perception
Reasoning
Learning
Problem solving
Decision making
Language understanding
Planning

Classroom analogy

Imagine a student preparing for an examination.

The student:

Observes the question.
Understands the problem.
Recalls knowledge.
Reasons about possible answers.
Chooses the best answer.
Acts by writing it.

An AI system tries to replicate some of these capabilities computationally.

2. Importance of AI

"Why did AI become so important now?"

Discuss:

Huge amounts of data
Faster processors
GPUs
Cloud computing
Better algorithms
Deep learning
Availability of open-source frameworks
Generative AI

Real-world examples

Domain	AI Application
Healthcare	Disease prediction
Education	Personalized learning
Banking	Fraud detection
Agriculture	Crop monitoring
Transport	Autonomous driving
Retail	Recommendation systems
Cybersecurity	Threat detection
Entertainment	Content recommendation
Language	Translation and chatbots

Artificial Intelligence

│

├── Machine Learning

│ │

│ └── Deep Learning

│ │

│ └── Generative AI

│

├── Knowledge Representation

├── Search

├── Reasoning

├── Robotics

└── NLP

Important point:

AI ≠ Machine Learning

Machine Learning is one approach within AI.

Similarly:

Deep Learning ⊂ Machine Learning

And modern generative AI systems are built using advanced machine learning/deep learning methods.

3. AI AND RELATED FIELDS

This is an important examination topic.

Field	Main Question
AI	How can machines behave intelligently?
ML	How can machines learn from data?
Deep Learning	How can neural networks learn complex representations?
NLP	How can computers process human language?
Computer Vision	How can machines understand images/videos?
Robotics	How can machines perceive and act in the physical world?
Expert Systems	How can expert knowledge be represented computationally?
Data Science	How can data be analyzed for insights and decisions?

Classroom activity

A scenario:

"A farmer uses a smartphone app that identifies crop disease from a leaf photograph."

Which fields are involved?

Answer could include:

Computer Vision
Machine Learning
Deep Learning
AI
Agriculture

4. AI TECHNIQUES

Search
Knowledge representation
Reasoning
Planning
Learning
Natural language processing
Pattern recognition
Neural networks
Fuzzy logic
Evolutionary computation

5. PROBLEM-SOLVING AGENTS

This is one of the most important concepts of Unit I.

What is an agent?

An agent is something that:

Perceives its environment through sensors and acts upon that environment through actuators.

Human example

Eyes/Ears

↓

Perception

↓

Brain

↓

Decision

↓

Hands/Legs

↓

Action

AI example

Camera/Sensor

↓

Perception

↓

AI System

↓

Decision

↓

Motor/Software Action

Example: Self-driving car

Sensors:

Camera
Radar
LiDAR
GPS

Decision:

"Pedestrian detected."

Action:

Brake.

6. CRITERIA FOR SUCCESS

A rational agent should:

Achieve its goal
Use available information
Make appropriate decisions
Perform efficiently
Handle changing environments

Introduce the concept:

Rationality ≠ Perfection

A rational agent makes the best decision based on available information, not necessarily a decision that guarantees a perfect outcome.

Differentiate between Automation and AI Agent

🔎 7. PROBLEM, PROBLEM SPACE AND SEARCH

This is where you should begin practical AI programming.

Analogy

Imagine finding a route from Delhi to Jaipur.

You have:

Initial state = Delhi
Goal state = Jaipur
Possible cities = states
Roads = actions
Route = solution

This is a state-space search problem.

Initial State

↓

Possible Actions

↓

New States

↓

More Actions

↓

Goal State

8. BREADTH-FIRST SEARCH — BFS

BFS explores level by level.

Analogy

Imagine searching for a person in a building.

You first check:

Floor 1
Then Floor 2
Then Floor 3

You don't go deep into one room immediately.

Data structure

Queue

First In → First Out

Python practical

from collections import deque

def bfs(graph, start, goal):

queue = deque([[start]])

visited = set()

while queue:

path = queue.popleft()

node = path[-1]

if node == goal:

return path

if node not in visited:

visited.add(node)

for neighbor in graph[node]:

new_path = list(path)

new_path.append(neighbor)

queue.append(new_path)

return None

Classroom example

Use:

A → B, C

B → D, E

C → F

D → G

9. DEPTH-FIRST SEARCH — DFS

DFS explores deeply before backtracking.

Data structure

Stack

Last In → First Out

Analogy

Imagine exploring a maze.

You follow one path until:

You reach the destination, or
You reach a dead end.

Then you go back.

Python practical

def dfs(graph, node, goal, visited=None):

if visited is None:

visited = set()

if node == goal:

return True

visited.add(node)

for neighbor in graph[node]:

if neighbor not in visited:

if dfs(graph, neighbor, goal, visited):

return True

return False

DFS (Depth‑First Search) and BFS (Breadth‑First Search) are *fundamental search algorithms in AI*

"AI agents "often solve search problems in pathfinding, puzzle solving, decision trees and in many more ways .

BFS vs DFS

Feature	BFS	DFS
Structure	Queue	Stack
Search	Level-wise	Depth-wise
Complete	Yes, under standard conditions	Not always
Memory	Higher	Lower generally
Shortest path	Yes for equal-cost edges	No guarantee
Best use	Shortest path	Deep exploration

Exam question

Qs. Differentiate between BFS and DFS? (5-Marks)

10. PRODUCTION SYSTEMS

Production Systems in AI

A production system in artificial intelligence is a rule based computational model that represents knowledge as condition–action (IF–THEN) rules and uses an inference mechanism to search for solutions by repeatedly matching rules against the current state of the problem. It is one of the earliest and most influential architectures for knowledgebased systems and expert systems.

Designing a production system is closely tied to designing a search program that explores possible sequences of rule applications.

Core Components of a Production System

A typical AI production system has four main components:

1. Rule Base (Production Rules)
   A set of rules of the form Ci → Ai, where Ci is the condition (pattern to match) and Ai is the action (conclusion or operation).
   Rules encode domain knowledge in a modular, humanreadable “IF condition THEN action” format.

2. Working Memory (Global Database)
   A dynamic data structure that holds the current facts, states, and intermediate results about the problem.
   As rules fire, facts are added, modified, or removed from working memory, representing the evolving state of the search.
3. Inference Engine (Control System)
   The mechanism that repeatedly:
     Matches rule conditions against working memory,
     Selects which applicable rule(s) to fire (conflict resolution),
     Executes the actions, updating working memory.
   Implements strategies like forward chaining (datadriven) or backward chaining (goaldriven).
4. Control Strategy / Search Mechanism
   Defines how the system searches through the space of possible rule applications to reach a goal.
   Includes decisions about rule ordering, priority, and when to stop (e.g., goal reached, no rules applicable).

Types of production systems in AI (basic, monotonic, nonmonotonic, commutative) illustrate different structural and logical properties of rule based reasoning.

Please note : The inference engine sits between the knowledge base and working memory, orchestrating rule matching and execution.

Key Characteristics of Production Systems

Production systems are characterized by several important properties:

1. Simplicity and Uniformity

All knowledge is expressed in a uniform IF–THEN structure, making rules easy to read, write, and audit.

2. Modularity

Each rule is an independent knowledge unit; rules can be added, removed, or modified with minimal impact on others.

3. Modifiability

Systems can start with a skeletal rule set and be incrementally refined for specific applications.

4. Knowledge Intensive Design

The rule base stores pure knowledge separate from control logic; semantics are largely captured by the rule structure itself.

5. Expressiveness and Intuitiveness

Naturallanguagelike rules make it easier to encode expert knowledge and explain system behavior.

6. GoalOriented Processing

The system continues applying rules until a specified goal state or termination condition is reached.

Production systems are often classified by their logical behavior:

Monotonic – Once a fact is derived, it remains true; knowledge only grows.
Nonmonotonic – Facts can be retracted or revised as new information arrives.
Commutative – The order of rule application does not affect the final result.
Partially commutative – Order matters only in some cases.

Monotonic vs nonmonotonic reasoning shows whether derived facts can be retracted, affecting how the system handles changing or uncertain information.

Production Systems as Search Mechanisms

In AI, a production system implements search over a state space:

State = contents of working memory at a given time.
Operator = firing a rule, which transforms one state into another.
Search process = sequence of rule firings from an initial state to a goal state.

Thus, designing a production system is closely tied to designing a search program that explores possible sequences of rule applications.

State space search flowcharts show the generic loop: initialize state, check goal, generate successors, avoid revisiting states—exactly what a production system’s control strategy does over rule based states.

Issues in the Design of Search Programs

When designing search programs (including those underlying production systems), several key issues arise:

1. State Space Complexity

Size of the state space can be enormous or even infinite, especially in realworld domains.

Exhaustive search quickly becomes infeasible; the number of possible states grows exponentially with problem depth (combinatorial explosion).

Designers must choose representations and abstractions that keep the effective state space manageable.

The 8puzzle is a classic example where the state space is large but finite; even such simple problems illustrate how quickly search spaces grow.

2. Choice of Search Strategy

Designers must decide among:

Uninformed searches (BFS, DFS, uniformcost) vs informed/heuristic searches (A, greedy bestfirst).

Forward vs backward chaining in rulebased systems.

Tradeoffs between completeness (guaranteed to find a solution if one exists), optimality (best solution), time, and space complexity.

3. Memory Management

Many search algorithms require storing large numbers of states (e.g., BFS stores all frontier nodes). In production systems, working memory can grow large as facts accumulate, especially in nonpruned forward chaining.

Memory constraints force designers to use techniques like iterative deepening, beam search, or limited depth strategies.

4. Heuristic Design and Quality

Effective heuristics are crucial for pruning the search space and guiding it toward promising regions.

Poor heuristics can mislead the search, causing it to explore irrelevant branches or miss good solutions.

In rule based systems, heuristic knowledge may be encoded as rule priorities, metarules, or control strategies.

5. Handling Dynamic and Uncertain Environments

Real world problems often involve changing information, partial observability, and uncertainty.)

Monotonic production systems struggle when facts must be retracted; nonmonotonic reasoning and belief revision mechanisms are needed.

Search programs must be robust to noise, incomplete data, and evolving goals.

6. Efficiency vs Accuracy Tradeoff

More thorough search (e.g., exhaustive, optimal algorithms) increases accuracy but may be too slow for realtime or largescale applications.

Approximate or anytime algorithms provide “good enough” solutions quickly but may not guarantee optimality.

In production systems, this shows up as a tension between firing many rules for completeness vs using aggressive pruning and prioritization for speed.

7. Control and Conflict Resolution

When multiple rules are applicable, the system must decide which rule to fire (conflict resolution). Poor conflict resolution strategies can lead to:

Inefficiency – many irrelevant rules fire, wasting cycles.

Opacity – difficulty understanding why a particular path was taken.

Designing clear priorities, metarules, or structured control knowledge is essential.

8. Lack of Learning

Classical rule based production systems do not automatically learn from past problem solving episodes.

Each new problem may require reexploring similar search paths unless explicit learning mechanisms (e.g., case libraries, rule induction) are added.

Modern AI often hybrids production systems with machine learning to address this limitation.

Summary

A production system can be explained as:

IF condition

THEN action

Example:

IF temperature > 38°C

THEN suspect fever

Components:

Production rules
Working memory
Control strategy

Characteristics

Rule-based
Modular
Knowledge represented as rules
Uses inference
Can separate knowledge from control

11. HEURISTIC SEARCH

This is a major transition.

"Blind search asks: What can I try?"

"Heuristic search asks: What should I try first?"

A heuristic is an estimate or rule of thumb that helps guide search.

Heuristic search in AI is a guided search method that uses a rule of thumb or estimate to reach a goal faster than checking every possibility. It is useful when brute-force search or Blind search would take too much time or memory.

Heuristic search in AI

Heuristic search is a search technique that uses a smart estimate to choose the most promising path toward the goal. The estimate is called a heuristic function $ℎ (𝑛)$ (n), which approximates the cost from a node to the goal.

Core idea

Instead of exploring every possible path, the algorithm prefers nodes that look closer to the goal. This makes the search faster and more practical for large problems

Simple idea

Think of it like planning a route on Google Maps. Instead of exploring all roads, the system picks the roads that seem most promising based on an estimate of distance or cost. In AI, that estimate is called a heuristic function.

How it works

A heuristic search algorithm usually does this:

Starts from an initial state.
Uses a heuristic value to estimate how close each possible move is to the goal.
Expands the most promising option first.
Repeats until it finds a goal state or runs out of good choices.

Why it is useful

Heuristic search is faster and more efficient than uninformed search because it does not blindly explore the whole search space. It is common in pathfinding, game playing, and optimization problems.

Main limitation

It does not always guarantee the best solution. Sometimes it finds a good solution quickly, but not the optimal one, because it relies on estimates rather than full exploration.

Example

If you are solving a maze, a heuristic might estimate “how far this position is from the exit.” The search then prefers moves that appear to bring you closer to the exit, instead of trying every possible path.vationventures+1

Common algorithms

Some well-known heuristic search methods are:

Best-first search.
Hill climbing.
A* search, which combines actual cost and estimated cost.

Easy way to remember

Heuristic search is like choosing a path using a smart guess about which direction is closer to the goal. Uninformed search is like searching step by step without any clue about which branch is better.mcgill+1

A* and hill climbing

A* is a classic heuristic search method that uses $𝑓 (𝑛) = 𝑔 (𝑛) + ℎ (𝑛)$ (n)=g(n)+h(n), where $𝑔 (𝑛)$ (n) is the cost so far and $ℎ (𝑛)$ (n) is the estimated cost to the goal. That is why A* is widely used in pathfinding.

Hill climbing is another heuristic search method that repeatedly moves to a better neighboring state until no improvement is found. It is simple, but it can get stuck at a local optimum.

If you are finding the shortest route on a map, heuristic search uses estimated distance to the destination, while uninformed search may check many roads one by one.

A* example

A* is the best-known heuristic search algorithm. It uses:

𝑓 (𝑛) = 𝑔 (𝑛) + ℎ (𝑛)

where $𝑔 (𝑛)$ is the cost from the start node to $𝑛$ , and $ℎ (𝑛)$ is the estimated cost from $𝑛$ to the goal.ubc+2

Why it matters

Heuristic search is useful when exact search would be too slow. It is widely used in route finding, game playing, and optimization.

Limitation

Heuristic search is efficient, but it depends on the quality of the heuristic. If the estimate is poor, the algorithm may become slow or miss the best path.

Tiny example

If you are navigating a map, a heuristic can be the straight-line distance to the destination. The search then prefers roads that seem to reduce that distance

Algorithms

A* flowchart

Start with the initial node.
Put it in the open list.
Pick the node with the smallest $f(n) = g(n) + h(n)$
If it is the goal, stop and return the path.
Otherwise, expand its neighbors.
Update their costs and parents if a better path is found.
Move the current node to the closed list.
Repeat until the goal is found or the open list becomes empty.

Hill climbing flowchart

Start with the initial state.
Evaluate all neighboring states.
Choose the neighbor with the best value.
If it is better than the current state, move to it.
If no neighbor is better, stop.
The current state is the final solution, though it may be only a local optimum.

Simple comparison

A* searches more intelligently and can find the optimal path when the heuristic is suitable.
Hill climbing is simpler, but it can get stuck at a local optimum.

1. Heuristic search: search using experience or smart guess.

2. A*: finds best path using actual cost plus estimated cost.

3. Hill climbing: keeps moving to a better nearby state until no improvement is possible.

“If I want to reach a goal, I can either search blindly or use a smart guess.

Heuristic search uses the smart guess.

A* uses smart guess plus real cost.

Hill climbing only moves to the best nearby option.”

Using python Language full Hill climbing code explained line by line in very simple language

graph = {

'A': ['B', 'C'],

'B': ['D', 'E'],

'C': ['F'],

'D': ['G'],

'E': ['G'],

'F': ['G'],

'G': []

}

scores = {

'A': 1,

'B': 3,

'C': 2,

'D': 4,

'E': 5,

'F': 6,

'G': 10

}

def neighbors(node):

return graph[node]

def value(node):

return scores[node]

best = hill_climbing('A', neighbors, value)

print(best)

Line-by-line explanation

1. graph = {...}

This creates a dictionary.

It stores which node is connected to which other nodes.

Example:

A is connected to B and C
B is connected to D and E

So this is called a graph representation using a dictionary.

2. scores = {...}

This is another dictionary.

It stores the value of each node.

Example:

A = 1
B = 3
C = 2

These values help the algorithm decide which node is better.

3. def neighbors(node):

This defines a function named neighbors.

A function is a block of code that does a specific job.

4. return graph[node]

This returns the list of neighbors of that node.

Example:

if node = 'A'
then graph['A'] gives ['B', 'C']

So this function tells us the next possible nodes.

5. def value(node):

This defines another function named value.

It gives the score of a node.

6. return scores[node]

This returns the score stored in the scores dictionary.

Example:

value('B') gives 3
value('G') gives 10

7. best = hill_climbing('A', neighbors, value)

This starts the hill climbing algorithm from node A.

It uses:

neighbors to find nearby nodes
value to compare their scores

The algorithm keeps moving to the better node.

8. print(best)

This prints the final best node found by hill climbing.

In this example, the output will be:

python

Pyhon implementation of A* with step-wise explanation.

A* Python code

import heapq

def a_star(graph, start, goal, h):

    open_list = []

    heapq.heappush(open_list, (h(start, goal), 0, start))

    came_from = {}

    g_cost = {start: 0}

    closed_set = set()

    while open_list:

        f, g, current = heapq.heappop(open_list)

        if current == goal:

            path = [current]

            while current in came_from:

                current = came_from[current]

                path.append(current)

            return path[::-1]

        if current in closed_set:

            continue

        closed_set.add(current)

        for neighbor, cost in graph.get(current, {}).items():

            new_g = g_cost[current] + cost

            if neighbor not in g_cost or new_g < g_cost[neighbor]:

                g_cost[neighbor] = new_g

                came_from[neighbor] = current

                new_f = new_g + h(neighbor, goal)

                heapq.heappush(open_list, (new_f, new_g, neighbor))

    return None

Example graph

graph = {

    'A': {'B': 1, 'C': 4},

    'B': {'D': 2, 'E': 5},

    'C': {'F': 1},

    'D': {'G': 3},

    'E': {'G': 1},

    'F': {'G': 2},

    'G': {}

heuristic_values = {

    'A': 7, 'B': 6, 'C': 2, 'D': 4, 'E': 2, 'F': 1, 'G': 0

def h(node, goal):

    return heuristic_values[node]

path = a_star(graph, 'A', 'G', h)

print(path)

Step-wise explanation

1. `graph`

This stores the graph and the cost of moving from one node to another.

Example:

A -> B costs 1
A -> C costs 4

2. `h(node, goal)`

This is the heuristic function.
It gives an estimated cost from a node to the goal.

3. `open_list`

This is a priority queue.
A* always picks the node with the lowest f value first.

4. `g_cost`

This stores the real cost from the start node to the current node.

5. `f = g + h`

A* uses this formula:

g = actual cost so far
h = estimated future cost
f = total estimated cost

6. `came_from`

This remembers the parent of each node so that we can rebuild the final path.

7. Main loop

Pick the node with the smallest f
If it is the goal, stop
Otherwise, check all neighbors
Update costs if a better path is found

8. Path reconstruction

When the goal is found, the algorithm moves backward using came_from and builds the final path.

Output for this example

['A', 'B', 'E', 'G']

“A* tries to find the shortest path by combining two things:

the cost already traveled and the estimated cost to the goal.”

AO* program with a step-wise explanation. AO* is used for AND-OR graphs, where some choices need one best child and some need all children together

Python code

class AOStar:

    def __init__(self, graph, heuristic):

        self.graph = graph

        self.heuristic = heuristic

        self.status = {}

        self.solution = {}

    def minimum_cost(self, node):

        children_groups = self.graph.get(node, [])

        min_cost = float('inf')

        best_group = None

        for group in children_groups:

            cost = 0

            for child, edge_cost in group:

                cost += edge_cost + self.heuristic.get(child, 0)

            if cost < min_cost:

                min_cost = cost

                best_group = group

        return min_cost, best_group

    def ao_star(self, node):

        if node not in self.graph or not self.graph[node]:

            self.status[node] = 'Solved'

            return self.heuristic.get(node, 0)

        min_cost, best_group = self.minimum_cost(node)

        self.heuristic[node] = min_cost

        self.solution[node] = best_group

        all_solved = True

        for child, _ in best_group:

            if self.status.get(child) != 'Solved':

                all_solved = False

                self.ao_star(child)

        if all_solved:

            self.status[node] = 'Solved'

        return self.heuristic[node]

graph = {

    'A': [[('B', 1), ('C', 1)], [('D', 2)]],

    'B': [[('E', 2)], [('F', 3)]],

    'C': [[('G', 2)]],

    'D': [],

    'E': [],

    'F': [],

    'G': []

heuristic = {

    'A': 10,

    'B': 4,

    'C': 3,

    'D': 2,

    'E': 1,

    'F': 5,

    'G': 2

ao = AOStar(graph, heuristic)

ao.ao_star('A')

print("Solution graph:", ao.solution)

print("Status:", ao.status)

print("Updated heuristic:", ao.heuristic)

Line-by-line Explanation of the AO* code in very simple way

1. Class and setup

class AOStar:

This creates a class named AOStar. A class is like a blueprint for the algorithm.

def __init__(self, graph, heuristic):

This is the constructor. It runs when we create an object of the class.

self.graph = graph
self.heuristic = heuristic
self.status = {}
self.solution = {}

These lines store:

the graph structure,
heuristic values,
whether a node is solved,
the final selected solution path or subgraph.

2. Finding minimum cost

def minimum_cost(self, node):

This function finds the cheapest option for a given node.

children_groups = self.graph.get(node, [])

This gets all possible child groups of that node.

min_cost = float('inf')
best_group = None

These are used to store the lowest cost found so far and the best group.

for group in children_groups:

This loops through each possible group of children.

cost = 0

This starts cost calculation for one group.

for child, edge_cost in group:
    cost += edge_cost + self.heuristic.get(child, 0)

For each child in the group:

add the edge cost,
add the heuristic value of that child.

if cost < min_cost:
    min_cost = cost
    best_group = group

If this group is cheaper than the previous best, store it.

return min_cost, best_group

Return the minimum cost and the best group.

3. Main AO* function

def ao_star(self, node):

This is the main AO* search function.

if node not in self.graph or not self.graph[node]:

If the node has no children, it is a leaf node.

self.status[node] = 'Solved'
return self.heuristic.get(node, 0)

A leaf node is marked as solved and its heuristic value is returned.

4. Choosing the best group

min_cost, best_group = self.minimum_cost(node)

This finds the best child group for the current node.

self.heuristic[node] = min_cost

Update the heuristic value of the current node with the new minimum cost.

self.solution[node] = best_group

Store the chosen best group as part of the solution.

5. Solving child nodes

all_solved = True

Assume all children are solved.

for child, _ in best_group:

Check each child in the best group.

if self.status.get(child) != 'Solved':
    all_solved = False
    self.ao_star(child)

If a child is not solved yet:

mark that not all children are solved,
recursively solve that child.

6. Marking node as solved

if all_solved:
    self.status[node] = 'Solved'

If all required children are solved, then the current node is also solved.

return self.heuristic[node]

Return the updated cost of the node.

7. Graph example

graph = {
    'A': [[('B', 1), ('C', 1)], [('D', 2)]],
    'B': [[('E', 2)], [('F', 3)]],
    'C': [[('G', 2)]],
    'D': [],
    'E': [],
    'F': [],
    'G': []
}

This means:

A has two choices:
- solve B and C together,
- or solve D.
B also has two choices:
- E,
- or F.

This is why AO* is useful: it can handle AND and OR conditions.

8. Heuristic values

heuristic = {
    'A': 10,
    'B': 4,
    'C': 3,
    'D': 2,
    'E': 1,
    'F': 5,
    'G': 2
}

These are estimated costs of nodes.

Smaller values mean the node looks cheaper or more promising.

9. Running the algorithm

ao = AOStar(graph, heuristic)
ao.ao_star('A')

This creates an AO* object and starts the search from node A.

10. Printing result

print("Solution graph:", ao.solution)
print("Status:", ao.status)
print("Updated heuristic:", ao.heuristic)

These lines show:

which nodes were chosen,
which nodes are solved,
the updated heuristic values.

“AO* is used when a problem has AND and OR choices.
It checks all possible child groups, chooses the cheapest one, solves those children, and updates the parent cost.
It continues until the starting node is solved.”

Very short version

“AO* is a heuristic search algorithm for AND-OR graphs.
It selects the best solution group, solves child nodes, and backtracks cost updates until the root is solved.”

12. GENERATE AND TEST

Simple idea:

Generate a possible solution

↓

Test the solution

↓

Correct?

/ \

Yes No

↓ ↓

Stop Generate again

Example

Password guessing is conceptually similar:

Generate candidate

↓

Test candidate

↓

Correct?

PROBLEM REDUCTION

Large problem:

Solve Exam

↓

Study Syllabus

↓

Study Units

↓

Study Topics

↓

Practice Questions

Break a complex problem into smaller subproblems.

CONSTRAINT SATISFACTION PROBLEMS — CSP

A CSP contains:

Variables
Domains
Constraints

Example: Timetable

Variables:

Subject A

Subject B

Subject C

Domains:

Monday

Tuesday

Wednesday

Constraints:

Two subjects cannot occupy the same room/time.

Other examples:

Sudoku
Map coloring
N-Queens
Exam scheduling

UNIT II — KNOWLEDGE REPRESENTATION AND LOGICAL REASONING

The central question:

"How can a machine represent what it knows?"

KNOWLEDGE REPRESENTATION

Knowledge representation is the process of representing knowledge in a form that a computer can use for reasoning.

Analogy

A human student has knowledge stored mentally.

AI needs a computational equivalent.

Real World

↓

Knowledge

↓

Representation

↓

Reasoning

↓

Decision

1. Knowledge in Artificial Intelligence

1.1 Meaning of Knowledge

Knowledge is organized information about objects, events, properties, relationships, rules, and procedures that can be used to solve problems or make decisions.

Example

Suppose an AI system stores the following information:

Delhi is a city.
Delhi is located in India.
India is a country.
All cities located in India have Indian Standard Time.
Delhi is located in India.

The system can infer:

Delhi follows Indian Standard Time.

The first statements are stored knowledge, while the final statement is derived knowledge.

1.2 Data, Information, and Knowledge

Concept	Meaning	Example
Data	Raw facts or symbols	39, fever, cough
Information	Processed or organized data	Patient has fever
Knowledge	Information plus relationships and rules	Fever and cough may indicate infection
Wisdom/Decision	Appropriate action based on knowledge	Recommend medical consultation

1.3 Types of Knowledge

Type	Meaning	Example
Factual knowledge	Describes facts about the world	Delhi is in India
Structural knowledge	Describes relationships	A car has an engine
Procedural knowledge	Describes how to perform a task	To log in, enter username and password
Heuristic knowledge	Experience-based rule of thumb	If the road is wet, drive slowly
Meta-knowledge	Knowledge about knowledge	This rule is more reliable than that rule
Common-sense knowledge	General everyday knowledge	Ice melts when heated
Domain knowledge	Knowledge of a specific field	A router forwards packets

2. Importance of Knowledge

Knowledge is essential because an intelligent system must do more than store data. It must interpret facts, identify relationships, reason about alternatives, and take suitable action.

Applications

Medical diagnosis.
Chatbots and question-answering systems.
Recommendation systems.
Robotics.
Natural-language understanding.
Expert systems.
Semantic search.
Fraud detection.
Educational tutoring systems.
IoT fault diagnosis.

A good knowledge representation should help a computer store, retrieve, update, explain, and reason with knowledge.

3. Knowledge Representation

3.1 Definition

Knowledge Representation (KR) is the process of formally representing real-world knowledge in a form that a computer can understand and use for reasoning.

A knowledge representation system generally contains:

Knowledge Base+Inference Mechanism=Intelligent Behaviour\text{Knowledge Base} + \text{Inference Mechanism} = \text{Intelligent Behaviour}Knowledge Base+Inference Mechanism=Intelligent Behaviour

3.2 Knowledge Base

A Knowledge Base (KB) is a collection of facts and rules.

Example

text

Fact 1: Student(Riya)

Fact 2: Studies(Riya, AI)

Rule: If a person studies AI, then the person learns reasoning.

From these statements:

text

LearnsReasoning(Riya)

can be derived.

3.3 Components of Knowledge Representation

Component	Purpose
Facts	Store known truths
Concepts	Represent objects or categories
Relations	Connect concepts
Rules	Express conditions and conclusions
Constraints	Restrict valid possibilities
Inference engine	Derive new facts
Explanation facility	Explain how a conclusion was reached

4. Properties of Good Knowledge Representation

A good KR system should provide the following:

4.1 Representational Adequacy

It should represent all important objects, properties, relationships, events, and rules of the domain.

4.2 Inferential Adequacy

It should allow the system to derive new knowledge from existing knowledge.

4.3 Inferential Efficiency

It should support reasoning without unnecessary computation.

4.4 Acquisitional Efficiency

It should be easy to add new facts and rules.

4.5 Explainability

It should explain why a conclusion was reached.

Example

Instead of displaying only:

text

Loan rejected.

an explainable system should display:

text

Loan rejected because income is below the threshold and credit history is poor.

5. Approaches to Knowledge Representation

The major approaches covered in this unit are:

Logical representation.
Semantic-network representation.
Frame representation.
Production-rule representation.
Ontology-based representation.

5.1 Comparison of Approaches

Approach	Main structure	Best suited for	Limitation
Logic	Formal statements	Precise reasoning	Can become complex
Semantic network	Nodes and labelled links	Relationships and inheritance	Ambiguous semantics
Frames	Slots and fillers	Objects and stereotyped situations	Exceptions may be difficult
Production rules	IF–THEN rules	Expert systems and decisions	Rule explosion
Ontology	Concepts, properties, axioms	Shared domain vocabulary	Requires careful design

6. Logical Representation

Logical representation uses formal symbols and rules to describe knowledge.

Example

Natural-language statement:

All humans are mortal.

Logical form:

∀x Human(x)→Mortal(x)\forall x \; Human(x) \rightarrow Mortal(x)∀xHuman(x)→Mortal(x)

Another statement:

Human(Socrates)Human(Socrates)Human(Socrates)

Conclusion:

Mortal(Socrates)Mortal(Socrates)Mortal(Socrates)

Advantages

Precise and unambiguous.
Supports formal inference.
Suitable for theorem proving.
Easy to verify mathematically.

Limitations

Difficult to represent uncertain knowledge.
Difficult to represent vague concepts.
Large knowledge bases may require expensive reasoning.
Natural-language conversion is challenging.

7. Semantic Networks

7.1 Definition

A semantic network is a graph-based knowledge representation method in which:

Nodes represent objects, concepts, or events.
Edges represent relationships between nodes.

Semantic networks are commonly represented as labelled directed graphs.[youtube]

7.2 Basic Example

text

is-a

Dog -------> Animal

| has

Tail

This represents:

Dog is an animal.
Dog has a tail.

7.3 Common Relationships

Relationship	Meaning	Example
is-a	Class relationship	Dog is-a Animal
instance-of	Object belongs to a class	Bruno instance-of Dog
has-part	Component relationship	Car has-part Engine
owns	Possession	Riya owns Laptop
located-in	Location	College located-in Delhi
causes	Causal relationship	Rain causes WetRoad
uses	Functional relationship	Student uses Library

20. APPROACHES TO KNOWLEDGE REPRESENTATION

Teach:

Logical representation
Semantic networks
Frames
Production rules
Ontologies

21. SEMANTIC NETWORK

Example:

Animal

↑

Mammal

↑

Dog

has-a

↓

Tail

A semantic network represents:

Concepts
Relationships
Properties

22. FRAMES

A frame is like a structured record.

Example

FRAME: Student

Name: Rahul

Age: 20

Course: BCA

Semester: 5

Analogy:

A frame is similar to a class/object structure in programming.

23. PROPOSITIONAL LOGIC

Example:

P = It is raining.

Q = The road is wet.

Rule:

P → Q

Meaning:

If it is raining, then the road is wet.

24. FIRST-ORDER LOGIC

FOL introduces:

Objects
Predicates
Variables
Quantifiers

Example:

Human(Socrates)

Rule:

∀x Human(x) → Mortal(x)

Therefore:

Mortal(Socrates)

25. FORWARD CHAINING

Starts with known facts.

Facts

↓

Rules

↓

New Facts

↓

More Rules

↓

Conclusion

Example:

Fact:

Bird(Tweety)

Rule:

Bird(x) → CanFly(x)

Conclusion:

CanFly(Tweety)

26. BACKWARD CHAINING

Starts with a goal.

Goal

↓

Which rule can prove it?

↓

What conditions are needed?

↓

Can conditions be proven?

Analogy

A detective asks:

"How can I prove the suspect is guilty?"

Then works backward from the conclusion.

27. UNIFICATION

Unification finds substitutions that make expressions identical.

Example:

Likes(John, x)

Likes(John, Mary)

Substitution:

x = Mary

28. RESOLUTION

Resolution is an inference technique used to derive conclusions by contradiction.

This is an important theoretical and examination topic.

I recommend teaching it with:

Clauses
Conversion to CNF
Negation of goal
Resolution
Empty clause

Case Study Framework

Explore more case studies here also

Title: AI‑Powered Library Search System for Academic Resources

1. Problem Statement

Students and faculty often struggle to locate relevant academic resources (books, research papers, journals) in large digital libraries. Traditional keyword‑based search fails to capture context, leading to irrelevant or incomplete results.

Challenge: How can AI‑driven search techniques improve accuracy, relevance, and user satisfaction in academic resource retrieval?

2. Objectives

Implement a smart search engine using AI techniques.
Compare keyword‑based search vs semantic search.
Demonstrate how heuristic search algorithms (A*, BFS, DFS) can optimize query handling.
Evaluate system performance using metrics like precision, recall, and response time.

3. Methodology

Data Collection

Use a dataset of academic papers, books, and journals (e.g., from Google Scholar, arXiv, or institutional repositories).

System Design

Phase 1: Implement keyword‑based search (TF‑IDF, inverted index).
Phase 2: Implement semantic search using NLP + embeddings (Word2Vec, BERT).
Phase 3: Apply heuristic search algorithms to optimize query expansion and ranking.

Tools & Technologies

Python (scikit-learn, NLTK, spaCy, gensim)
Database: MySQL / MongoDB
Graph search: networkx library

Evaluation

Compare keyword vs semantic search results.
Measure accuracy (precision/recall), efficiency (response time), and user satisfaction (survey/feedback).

4. Expected Outcomes

Semantic search provides more relevant results than keyword search.
Heuristic search improves efficiency in query handling.
Students and faculty experience faster, smarter resource discovery.
Case study demonstrates practical application of AI + search techniques in education.

5. Deliverables

Working prototype of the AI‑powered search system.
Comparative analysis report (keyword vs semantic search).
Presentation with flowcharts, algorithm explanation, and performance metrics.

📖 Case Study 2

Title: AI‑Driven Job Portal Recommendation Engine

1. Problem Statement

Job seekers often face difficulty finding suitable opportunities due to generic keyword matching. Employers also struggle to identify the right candidates quickly.

Challenge: How can AI search techniques improve job‑candidate matching efficiency?

2. Objectives

Implement a recommendation engine for job portals.
Compare rule‑based search vs AI‑driven semantic search.
Use heuristic search to rank candidates/jobs by relevance.

3. Methodology

Dataset: Job listings + candidate resumes (sample datasets or synthetic data).
Techniques:

Keyword search (TF‑IDF).
Semantic search (embeddings, cosine similarity).
Heuristic ranking (A* search for best fit).

Tools: Python, scikit‑learn, spaCy, gensim.

4. Expected Outcomes

Improved candidate‑job matching accuracy.
Faster retrieval compared to traditional search.
Demonstrated use of AI in recruitment systems.

📖 Case Study 3

Title: Smart Campus Navigation Using AI Search Algorithms

1. Problem Statement

Large campuses confuse new students and visitors. Traditional maps are static and don’t adapt to real‑time changes (blocked paths, events).

Challenge: How can AI search techniques optimize navigation inside a campus?

2. Objectives

Design a smart navigation system for campus routes.
Apply graph search algorithms (Dijkstra, A*, BFS).
Integrate real‑time updates (blocked paths, shortest routes).

3. Methodology

Dataset: Campus map converted into a graph (nodes = locations, edges = paths).
Techniques:

BFS/DFS for basic pathfinding.
Dijkstra/A* for shortest path with heuristics.

Tools: Python, networkx, Google Maps API (optional).

4. Expected Outcomes

Efficient route suggestions for students/faculty.
Demonstrated application of AI search in real‑world navigation.
Prototype mobile/web app for campus use.

📖 Case Study 4

Title: AI‑Powered Medical Diagnosis Support System

1. Problem Statement

Doctors often need quick decision support for diagnosis. Traditional systems rely on static rules and don’t adapt well to complex symptom combinations.

Challenge: How can AI search techniques assist in faster, more accurate diagnosis?

2. Objectives

Build a decision support system for medical diagnosis.
Compare rule‑based search vs heuristic search.
Use AI to suggest possible conditions based on symptoms.

3. Methodology

Dataset: Public medical datasets (e.g., symptom‑disease mappings).
Techniques:

Decision trees for rule‑based diagnosis.
Heuristic search for narrowing down possibilities.
NLP for symptom input.

Tools: Python, scikit‑learn, NLTK.

4. Expected Outcomes

Faster diagnosis suggestions.
Demonstrated efficiency of heuristic search in medical decision support.
Prototype system usable for academic demonstration.

CLASS Framework for AI- BCA-303
1) Podcast-based learning

2) Flip class
3) PPT presentation
4) Research paper publication
5) Minor Project
6) Assignments : 3
7) Lab file
8)Case studies just click here
9) Group Discussion (GD)
10)Blog writing on AI / ML
11) Quiz
12)AI tool comparison (compare different AI tools for the same task) like chatgpt, perplexity, copilot, claude etc.
13)Journal/article review (summarize and critique a recent AI paper)
14)Peer teaching (students teach one topic to the class)
15) Prompt engineering exercises (for generative AI)
16)Model implementation challenge (implement a given algorithm)
17)Debugging challenge (find and fix errors in ML code)
18)Ethics debate (e.g., "Should AI replace human decision-making?")
19) GitHub portfolio submission (upload code and documentation)

20) Research proposal writing (identify a problem and propose an AI solution)

Each student to:

1. Create a GitHub portfolio.

2. Complete 10 Kaggle micro-courses.

3. Build 5 Google Colab notebooks.

4. Participate in one Kaggle competition.

5. Fine-tune one Hugging Face NLP model.

6. Develop one end-to-end AI mini-project.

7. Visit one AI/robotics lab or science centre and submit a reflection report.

8. Present one recent AI research paper.

Pages

Master AI with BCA 303T

Core idea

Easy way to remember

A* and hill climbing

A* example

Why it matters

Limitation

Tiny example

A* flowchart

Hill climbing flowchart

Simple comparison

A* Python code

Example graph

Step-wise explanation

1. graph

2. h(node, goal)

3. open_list

4. g_cost

5. f = g + h

6. came_from

7. Main loop

8. Path reconstruction

Output for this example

“A* tries to find the shortest path by combining two things:

Python code

1. Class and setup

2. Finding minimum cost

3. Main AO* function

4. Choosing the best group

5. Solving child nodes

6. Marking node as solved

7. Graph example

8. Heuristic values

9. Running the algorithm

10. Printing result

Very short version

No comments:

Post a Comment

E-Learning Resource - Tecnia Library

Pages

Pages

1. `graph`

2. `h(node, goal)`

3. `open_list`

4. `g_cost`

5. `f = g + h`

6. `came_from`