B. Tech. Forth Semester (Information Technology), Rashtrasant Tukadoji Maharaj University, Nagpur

Subject Code: BIT4T13

• Course Objectives
  • Introduce students to the fundamental concepts and history of Artificial Intelligence.
  • Explore various problem-solving techniques and search algorithms used in AI.
  • Familiarize students with knowledge representation methods and reasoning techniques.
  • Develop an understanding of handling uncertainty and probability in AI systems.
  • Introduce the concept of intelligent agents and their applications
• Course Outcomes
  After completion of syllabus, students would be able to:
  • CO 1: Define Artificial Intelligence and explain its historical development and current applications
  • CO 2: Formulate problems using state space representation and apply appropriate search techniques to solve them
  • CO 3: Implement and compare uninformed and informed search algorithms for problem-solving.
  • CO 4: Utilize various knowledge representation techniques such as predicate logic, semantic nets, and frames.
  • CO 5: Apply probabilistic reasoning and Bayesian networks to handle uncertainty in AI systems..

Syllabus

UNIT 1- Introduction to AI:
Introduction: What is Al? History & Applications, Artificial intelligence as representation & Search, Production system, Basics of problem solving: problem representation paradigms, defining problem as a state space representation, Characteristics

UNIT 2- Search Techniques:
Search Techniques: Uninformed Search techniques, Informed Heuristic Based Search, Generate and test, Hill-climbing. Best-First Search, Problem Reduction, and Constraint Satisfaction.

UNIT 3- Knowledge representation:
Knowledge representation: Knowledge representation Issues, First order logic, Predicate Logic, Structured Knowledge Representation: Backward Chaining. Resolution, Semantic Nets, Frames, and Scripts, Ontology. Backward Chaining.

UNIT 4- Uncertain knowledge & Intelligent Agents:
Uncertainty: Handling uncertain knowledge, rational decisions, basics of probability, axioms of probability, Baye’s Rule and conditional independence, Bayesian networks, Exact and Approximate inference in Bayesian Networks, Fuzzy Logic.
Intelligent Agents: Introduction to Intelligent Agents, Rational Agents, their structure, reflex, model-based, goal-based, and utility-based agents, behaviour and environment in which a particular agent operates.

UNIT 5- Knowledge and learning:
Learning: What is learning? Knowledge and learning. Learning in Problem Solving. Learning. For example, learning probabilistic models
Expert Systems: Fundamental blocks, Knowledge Engineering. Knowledge Acquisition. Knowledge-Based Systems, Basic understanding of Natural language.

Lecture Notes: Unit I – Introduction to Artificial Intelligence

1. What is Artificial Intelligence?

Artificial Intelligence (AI) is the branch of computer science focused on creating systems that can perform tasks requiring human-like intelligence. According to Russell and Norvig (2010), AI encompasses systems that “act rationally” or mimic human cognitive abilities such as reasoning, learning, problem-solving, perception, and decision-making.

• Definition: AI involves designing machines to think and act like humans or to optimize outcomes through rational decision-making.
• Key Goals:
  • Mimic human intelligence (e.g., understanding language, recognizing images).
  • Solve complex problems efficiently using computational methods.
• Perspectives (Rich and Knight, 2008):
  • Acting Humanly: Passing the Turing Test by exhibiting intelligent behavior indistinguishable from humans.
  • Thinking Humanly: Modeling cognitive processes to emulate human thought.
  • Acting Rationally: Making optimal decisions based on available information.
  • Thinking Rationally: Using logical reasoning to derive conclusions.

2. History of AI

The history of AI spans several decades, marked by key milestones (Russell and Norvig, 2010):

• 1940s-1950s: Foundation laid by Alan Turing’s work on computation and the Turing Test (1950).
• 1956: The term “Artificial Intelligence” coined at the Dartmouth Conference by John McCarthy.
• 1960s-1980s: Early AI systems like expert systems (e.g., DENDRAL, MYCIN) and rule-based approaches.
• 1980s-1990s: Rise of machine learning, neural networks, and knowledge-based systems.
• 2000s-Present: Advances in deep learning, natural language processing (e.g., Siri, GPT), and applications in robotics, healthcare, and autonomous systems.

3. Applications of AI

AI has diverse applications across industries (Rich and Knight, 2008):

• Healthcare: Diagnosis systems, medical imaging analysis.
• Finance: Fraud detection, algorithmic trading.
• Transportation: Autonomous vehicles, route optimization.
• Entertainment: Recommendation systems (e.g., Netflix, Spotify), game AI.
• Robotics: Industrial automation, service robots.
• Natural Language Processing: Chatbots, translation systems.
• Computer Vision: Facial recognition, object detection.

4. Artificial Intelligence as Representation and Search

AI systems rely heavily on representation (modeling the world or problem) and search (finding solutions within the model) (Russell and Norvig, 2010).

• Representation:
  • Knowledge about the problem is encoded in a structured form (e.g., rules, graphs, or logic).
  • Example: Representing a chessboard as a grid with pieces and their positions.
• Search:
  • Algorithms explore the solution space to find optimal or satisfactory outcomes.
  • Types: Uninformed search (e.g., breadth-first, depth-first), informed search (e.g., A* algorithm).
• Role in AI: Representation defines the problem’s structure, while search identifies the path to the solution.

5. Production Systems

A production system is a framework for solving problems using a set of rules (Rich and Knight, 2008):

• Components:
  • Rule Base: A set of “if-then” rules (e.g., IF condition THEN action).
  • Working Memory: Stores current state or facts about the problem.
  • Control Strategy: Decides which rule to apply (e.g., forward chaining, backward chaining).
• Example: Expert systems like MYCIN use production rules to diagnose diseases.
• Advantages:
  • Modular: Easy to add or modify rules.
  • Flexible: Applicable to various domains.
• Limitations: Can become complex with large rule sets; requires efficient conflict resolution.

6. Basics of Problem Solving

Problem-solving in AI involves defining and solving problems systematically (Russell and Norvig, 2010).

6.1 Problem Representation Paradigms

• State Space Representation:
  • A problem is modeled as a set of states, with transitions defined by actions.
  • Components:
    • Initial State: Starting point of the problem.
    • Goal State: Desired outcome.
    • Operators: Actions that transform one state to another.
    • State Space: All possible states and transitions (often represented as a graph).
  • Example: In the 8-puzzle problem, states are board configurations, and operators are tile movements.
• Other Paradigms:
  • Constraint Satisfaction: Representing problems with variables and constraints (e.g., scheduling).
  • Logic-Based: Using formal logic to represent knowledge (e.g., propositional or first-order logic).
  • Heuristic-Based: Using domain-specific knowledge to guide search.

6.2 Defining Problems as State Space Representation

• Steps:
  1. Define the initial state.
  2. Specify the goal state(s).
  3. Identify operators (actions) that transition between states.
  4. Define the state space (all possible states and transitions).
• Example: For a robot navigating a maze:
  • Initial State: Robot’s starting position.
  • Goal State: Exit of the maze.
  • Operators: Move up, down, left, or right.
  • State Space: All possible positions in the maze.

6.3 Characteristics of Problems

• Well-Defined Problems (Russell and Norvig, 2010):
  • Clear initial and goal states.
  • Known operators and constraints.
  • Example: Solving a Rubik’s Cube.
• Ill-Defined Problems:
  • Vague goals or incomplete information.
  • Example: Designing a creative artwork.
• Key Characteristics:
  • Decomposability: Can the problem be broken into smaller subproblems?
  • Reversibility: Can actions be undone?
  • Predictability: Are outcomes of actions known?
  • Solution Space Size: How large is the state space?
  • Knowledge Requirements: Does the problem require domain-specific knowledge?

Lecture Notes: Unit II – Search Techniques in Artificial Intelligence

1. Introduction to Search Techniques

Search techniques are fundamental to AI for solving problems represented as state spaces (Russell and Norvig, 2010). They involve systematically exploring the state space to find a path from the initial state to the goal state. Search techniques are broadly classified into uninformed (blind) and informed (heuristic-based) methods.

2. Uninformed Search Techniques

Uninformed search techniques explore the state space without domain-specific knowledge, relying solely on the problem’s structure (Rich and Knight, 2008).

• Breadth-First Search (BFS):
  • Explores all nodes at the current depth before moving to the next level.
  • Properties:
    • Complete: Finds a solution if one exists.
    • Optimal: Finds the shallowest solution (if cost is uniform).
    • Time Complexity: O(b^d), where b is the branching factor and d is the depth.
    • Space Complexity: O(b^d) (stores all nodes at the deepest level).
  • Example: Finding the shortest path in a maze.
• Depth-First Search (DFS):
  • Explores as far as possible along each branch before backtracking.
  • Properties:
    • Not complete in infinite spaces (may get stuck in loops).
    • Not optimal: May find a deeper solution.
    • Time Complexity: O(b^m), where m is the maximum depth.
    • Space Complexity: O(bm) (linear space).
  • Example: Solving puzzles with deep solutions.
• Uniform-Cost Search:
  • Expands the node with the lowest path cost.
  • Properties:
    • Complete and optimal if costs are positive.
    • Time/Space Complexity: Depends on cost distribution, up to O(b^d).
  • Example: Route planning with varying edge costs.

3. Informed (Heuristic-Based) Search Techniques

Informed search uses domain-specific knowledge (heuristics) to guide the search toward the goal, making it more efficient (Russell and Norvig, 2010).

• Generate and Test:
  • Generates possible solutions and tests them against the goal.
  • Mechanism:
    • Generate a candidate solution.
    • Test if it satisfies the goal condition.
    • Repeat until a solution is found or all candidates are exhausted.
  • Properties:
    • Simple but inefficient for large state spaces.
    • Complete if all solutions are generated.
  • Example: Checking combinations in a lock.
• Hill-Climbing:
  • Iteratively moves to a neighboring state with a better (lower) cost, based on a heuristic evaluation.
  • Variants:
    • Simple Hill-Climbing: Selects the first better neighbor.
    • Steepest-Ascent Hill-Climbing: Selects the best neighbor.
  • Properties:
    • Not complete: May get stuck in local optima.
    • Not optimal: May not find the global optimum.
    • Time Complexity: Depends on the state space; often fast but incomplete.
  • Example: Optimizing a function with a single peak.
• Best-First Search:
  • Selects the node with the lowest heuristic value (estimated cost to goal).
  • Greedy Best-First Search:
    • Uses heuristic h(n) to prioritize nodes.
    • Properties:
      • Not complete or optimal (may follow misleading heuristics).
      • Time/Space Complexity: O(b^d) in the worst case.
  • A Search*:
    • Combines path cost g(n) and heuristic h(n): f(n) = g(n) + h(n).
    • Properties:
      • Complete and optimal if h(n) is admissible (never overestimates the true cost).
      • Time/Space Complexity: Exponential but more efficient than uninformed search.
  • Example: Pathfinding in navigation systems (e.g., GPS).

4. Problem Reduction

Problem reduction transforms a complex problem into simpler subproblems (Rich and Knight, 2008).

• Mechanism:
  • Decompose the problem into a set of smaller subproblems (AND/OR graph).
  • Solve each subproblem independently.
  • Combine solutions to solve the original problem.
• AND/OR Graphs:
  • AND nodes: All subproblems must be solved.
  • OR nodes: At least one subproblem must be solved.
• Example:
  • Planning a trip: Break into subproblems like booking flights, hotels, and activities.
• Properties:
  • Effective for decomposable problems.
  • May increase complexity if subproblems are not independent.
• Applications: Planning, game playing (e.g., decomposing a chess strategy).

5. Constraint Satisfaction

Constraint Satisfaction Problems (CSPs) involve finding values for variables subject to constraints (Russell and Norvig, 2010).

• Components:
  • Variables: Represent elements of the problem (e.g., time slots, colors).
  • Domains: Possible values for each variable.
  • Constraints: Restrictions on variable assignments (e.g., no conflicts).
• Search Techniques for CSPs:
  • Backtracking Search:
    • Assigns values to variables incrementally, backtracks on conflicts.
    • Enhanced with constraint propagation (e.g., arc consistency).
  • Local Search:
    • Iteratively improves an initial assignment to minimize constraint violations.
  • Example: Scheduling classes where no teacher has overlapping sessions.
• Properties:
  • Efficient for problems with finite domains and clear constraints.
  • Can be combined with heuristics (e.g., minimum remaining values).
• Applications: Scheduling, map coloring, cryptarithmetic puzzles.

Lecture Notes: Unit III – Knowledge Representation in Artificial Intelligence

1. Knowledge Representation: Introduction

Knowledge representation (KR) is the process of structuring and encoding knowledge in a form that an AI system can use to reason and solve problems (Russell and Norvig, 2010). It involves choosing appropriate structures to represent facts, relationships, and rules about the world.

• Purpose:
  • Enable reasoning, inference, and decision-making.
  • Support efficient storage and retrieval of knowledge.
• Key Issues in Knowledge Representation (Rich and Knight, 2008):
  • Expressiveness: Ability to represent diverse types of knowledge (facts, rules, relationships).
  • Reasoning Efficiency: Supporting fast and accurate inference.
  • Granularity: Balancing detail and abstraction.
  • Handling Uncertainty: Managing incomplete or uncertain information.
  • Scalability: Supporting large knowledge bases.
  • Ease of Update: Allowing modifications without disrupting the system.

2. First-Order Logic (FOL)

First-Order Logic, also known as Predicate Logic, is a formal system for representing and reasoning about knowledge (Russell and Norvig, 2010).

• Components:
  • Constants: Specific objects (e.g., “John”, “Car1”).
  • Predicates: Relations or properties (e.g., Loves(John, Mary), IsRed(Car1)).
  • Variables: Placeholders for objects (e.g., x, y).
  • Connectives: Logical operators (e.g., ∧ (and), ∨ (or), ¬ (not), → (implies), ↔ (if and only if)).
  • Quantifiers:
    • Universal (∀): For all (e.g., ∀x Person(x) → Mortal(x)).
    • Existential (∃): There exists (e.g., ∃x Person(x) ∧ Loves(x, Mary)).
• Syntax and Semantics:
  • Syntax: Rules for constructing valid formulas.
  • Semantics: Interpretation of formulas in a domain (truth values).
• Advantages:
  • Expressive: Can represent complex relationships and generalizations.
  • Sound and complete inference mechanisms.
• Limitations:
  • Computationally expensive for large knowledge bases.
  • May not handle uncertainty well.
• Example: Representing “All humans are mortal” as ∀x Human(x) → Mortal(x).

3. Predicate Logic

Predicate Logic (a term often used interchangeably with FOL) emphasizes predicates to describe relationships or properties (Rich and Knight, 2008).

• Key Features:
  • Predicates take arguments (e.g., Father(John, Mary)).
  • Supports quantification over variables.
  • Enables inference through rules like modus ponens.
• Applications:
  • Expert systems (e.g., encoding medical knowledge).
  • Natural language processing (e.g., parsing sentences).
• Example: Representing “John is a father of Mary” as Father(John, Mary).

4. Structured Knowledge Representation

Structured representations organize knowledge into interconnected components for efficient reasoning (Russell and Norvig, 2010).

4.1 Semantic Nets

• Description: Graph-based representation where nodes represent concepts/objects and edges represent relationships.
• Components:
  • Nodes: Entities (e.g., “Dog”, “Fido”).
  • Edges: Relations (e.g., “is-a”, “has-property”).
• Example: Fido → [is-a] → Dog → [has-property] → Mammal.
• Advantages:
  • Intuitive for hierarchical relationships.
  • Supports inheritance (e.g., Fido inherits Mammal properties).
• Limitations:
  • Limited expressiveness for complex logic.
  • Ambiguity in representing certain relationships.
• Applications: Knowledge bases, ontology design.

4.2 Frames

• Description: Data structures that represent stereotyped situations with slots for attributes (Rich and Knight, 2008).
• Components:
  • Frame: A concept or object (e.g., “Car”).
  • Slots: Attributes with values (e.g., Color: Red, Wheels: 4).
  • Procedures: Rules or actions triggered by slot values.
• Example:Frame: Car Slot: Color = Red Slot: Wheels = 4 Slot: Owner = John
• Advantages:
  • Organizes knowledge hierarchically.
  • Supports default values and inheritance.
• Limitations:
  • Complex to implement for dynamic knowledge.
  • Less suited for logical inference.
• Applications: Expert systems, object-oriented systems.

4.3 Scripts

• Description: Structured representations of sequences of events for stereotypical situations (Rich and Knight, 2008).
• Components:
  • Entry Conditions: Prerequisites for the script.
  • Roles: Actors or objects involved.
  • Scenes: Ordered sequence of events.
• Example: Restaurant script:
  • Entry: Customer is hungry, restaurant is open.
  • Roles: Customer, waiter, chef.
  • Scenes: Enter, order, eat, pay, leave.
• Advantages:
  • Captures temporal and causal relationships.
  • Useful for understanding narratives.
• Limitations:
  • Limited to specific scenarios.
  • Hard to generalize across domains.
• Applications: Natural language understanding, story generation.

5. Ontology

• Definition: A formal representation of knowledge as a set of concepts and relationships within a domain (Russell and Norvig, 2010).
• Components:
  • Classes: Concepts (e.g., “Animal”).
  • Instances: Specific objects (e.g., “Fido”).
  • Relations: Connections between concepts (e.g., “is-a”, “part-of”).
  • Axioms: Rules or constraints.
• Example: In a biological ontology, “Dog is-a Mammal” and “Mammal has-part Heart.”
• Advantages:
  • Enables knowledge sharing and reuse.
  • Supports automated reasoning.
• Applications: Semantic web, knowledge management systems.

6. Backward Chaining

Backward chaining is a goal-driven inference method used in rule-based systems (Rich and Knight, 2008).

• Mechanism:
  • Start with the goal (hypothesis).
  • Work backward to find facts or rules that support the goal.
  • Recursively apply rules until known facts are reached.
• Example:
  • Goal: Prove “Fido is a Mammal.”
  • Rule: If x is a Dog, then x is a Mammal.
  • Fact: Fido is a Dog.
  • Conclusion: Fido is a Mammal.
• Properties:
  • Efficient for specific queries.
  • Suitable for systems with many rules but few goals.
• Applications: Expert systems (e.g., MYCIN for medical diagnosis).

7. Resolution in First-Order Logic

Resolution is a complete inference method for FOL to prove theorems or answer queries (Russell and Norvig, 2010).

• Mechanism:
  • Convert knowledge base and query to Conjunctive Normal Form (CNF).
  • Apply resolution rule: From clauses (A ∨ B) and (¬B ∨ C), infer (A ∨ C).
  • Continue until the empty clause (contradiction) is derived or no new clauses can be generated.
• Example:
  • Knowledge: ∀x Human(x) → Mortal(x), Human(Socrates).
  • Query: Mortal(Socrates)?
  • Resolution proves the query by contradiction.
• Properties:
  • Sound and complete for FOL.
  • Computationally intensive for large knowledge bases.
• Applications: Automated theorem proving, logic programming.

Lecture Notes: Unit IV – Uncertain Knowledge and Intelligent Agents

1. Uncertain Knowledge

Many real-world problems involve uncertainty due to incomplete or noisy information. AI systems must handle such uncertainty to make rational decisions (Russell and Norvig, 2010).

1.1 Handling Uncertain Knowledge

• Challenges (Rich and Knight, 2008):
  • Incomplete information: Missing data or partial observations.
  • Ambiguity: Multiple interpretations of data.
  • Noise: Errors in observations or measurements.
• Approaches:
  • Probabilistic reasoning: Using probabilities to model uncertainty.
  • Non-probabilistic methods: Fuzzy logic, certainty factors.
• Goal: Make rational decisions despite uncertainty by quantifying and reasoning over probabilities or other measures.

1.2 Rational Decisions

• Rational decisions maximize expected utility, balancing potential outcomes with their probabilities (Russell and Norvig, 2010).
• Steps:
  • Identify possible actions and outcomes.
  • Assign probabilities to outcomes.
  • Assign utilities (values) to outcomes.
  • Choose the action that maximizes expected utility.
• Example: A medical diagnosis system deciding on a treatment based on probable diagnoses.

1.3 Basics of Probability

• Definition: Probability quantifies the likelihood of an event occurring, ranging from 0 (impossible) to 1 (certain).
• Key Concepts:
  • Sample Space: Set of all possible outcomes.
  • Event: A subset of the sample space.
  • Probability Function: Assigns a value P(A) to an event A.
• Axioms of Probability (Russell and Norvig, 2010):
  • 0 ≤ P(A) ≤ 1 for any event A.
  • P(Ω) = 1, where Ω is the sample space.
  • For mutually exclusive events A and B, P(A ∪ B) = P(A) + P(B).

1.4 Bayes’ Rule and Conditional Independence

• Bayes’ Rule:
  • Formula: P(A|B) = [P(B|A) * P(A)] / P(B)
  • Used to update probabilities based on new evidence.
  • Example: Diagnosing a disease given symptoms.
• Conditional Independence:
  • Events A and B are conditionally independent given C if P(A, B|C) = P(A|C) * P(B|C).
  • Simplifies probabilistic reasoning by reducing dependencies.
• Applications: Medical diagnosis, spam filtering.

1.5 Bayesian Networks

• Definition: A graphical model representing variables and their probabilistic dependencies (Russell and Norvig, 2010).
• Components:
  • Nodes: Represent random variables.
  • Edges: Represent conditional dependencies.
  • Conditional Probability Distributions (CPDs): Specify P(X|Parents(X)).
• Example: A network modeling rain, sprinkler, and wet grass, where P(Wet|Rain, Sprinkler) is defined.
• Advantages:
  • Compact representation of joint probability distributions.
  • Efficient for inference and reasoning.

1.6 Exact and Approximate Inference in Bayesian Networks

• Exact Inference:
  • Methods: Variable elimination, junction tree algorithms.
  • Computes precise probabilities but can be computationally expensive.
  • Example: Calculating P(Disease|Symptoms) exactly.
• Approximate Inference:
  • Methods: Monte Carlo sampling, belief propagation.
  • Trades accuracy for efficiency in large networks.
  • Example: Estimating probabilities in complex networks with many variables.
• Applications: Fault diagnosis, decision support systems.

1.7 Fuzzy Logic

• Definition: A method to handle uncertainty using degrees of truth (values between 0 and 1) rather than binary true/false (Rich and Knight, 2008).
• Components:
  • Fuzzy Sets: Elements have membership degrees (e.g., “tall” with membership 0.8).
  • Fuzzy Rules: If-then rules with fuzzy predicates (e.g., IF temperature is high THEN fan speed is fast).
  • Inference: Combines rules using operations like min (AND), max (OR).
  • Defuzzification: Converts fuzzy outputs to crisp values.
• Advantages:
  • Handles imprecise or vague concepts.
  • Intuitive for human-like reasoning.
• Limitations:
  • Less formal than probability theory.
  • May lack scalability for complex systems.
• Applications: Control systems (e.g., washing machines), decision-making.

2. Intelligent Agents

An intelligent agent is a system that perceives its environment and takes actions to achieve goals (Russell and Norvig, 2010).

2.1 Introduction to Intelligent Agents

• Definition: An agent is anything that can perceive its environment through sensors and act upon it through actuators.
• Examples:
  • A robot with cameras (sensors) and motors (actuators).
  • A software agent processing user inputs and generating outputs.

2.2 Rational Agents

• Definition: A rational agent selects actions that maximize its expected performance measure, given its knowledge and perceptions.
• Properties (Rich and Knight, 2008):
  • Performance Measure: Criteria for success (e.g., speed, accuracy).
  • Percepts: Sensory inputs at a given time.
  • Knowledge: Prior information about the environment.
  • Actions: Available choices to achieve goals.

2.3 Structure of Agents

• Components:
  • Sensors: Perceive the environment.
  • Actuators: Perform actions.
  • Agent Function: Maps percept sequences to actions.
  • Agent Program: Implements the agent function.
• Example: A thermostat senses temperature and turns the heater on/off.

2.4 Types of Agents

• Simple Reflex Agents:
  • Act based on current percepts using condition-action rules.
  • Example: A vacuum cleaner that moves forward unless it detects an obstacle.
  • Limitations: No memory, limited to simple environments.
• Model-Based Reflex Agents:
  • Maintain an internal model of the world to handle partially observable environments.
  • Example: A self-driving car updating its map based on sensor data.
• Goal-Based Agents:
  • Act to achieve specific goals, considering future consequences.
  • Example: A navigation system planning a route to a destination.
• Utility-Based Agents:
  • Choose actions to maximize a utility function, balancing multiple objectives.
  • Example: A stock-trading agent optimizing profit and risk.
• Learning Agents:
  • Improve performance over time by learning from experience.
  • Example: A recommendation system refining suggestions based on user feedback.

2.5 Behavior and Environment

• Environment Types (Russell and Norvig, 2010):
  • Fully Observable vs. Partially Observable: Can the agent see the entire state?
  • Deterministic vs. Stochastic: Are outcomes predictable?
  • Static vs. Dynamic: Does the environment change during decision-making?
  • Discrete vs. Continuous: Are states and actions finite or infinite?
  • Single-Agent vs. Multi-Agent: Does the agent compete or cooperate with others?
• Agent Behavior:
  • Adapts to the environment’s properties.
  • Example: A chess-playing agent operates in a fully observable, deterministic, discrete, and competitive environment.

Lecture Notes: Unit V – Knowledge and Learning in Artificial Intelligence

1. Learning

1.1 What is Learning?

Learning in AI refers to the process by which a system improves its performance on a task through experience (Russell and Norvig, 2010). It involves acquiring new knowledge or refining existing knowledge without explicit programming.

• Definition: Learning is the ability to adapt to new situations, generalize from examples, and improve over time.
• Key Aspects:
  • Acquiring new knowledge or skills.
  • Modifying existing behaviors based on feedback.
  • Generalizing from specific instances to broader contexts.

1.2 Knowledge and Learning

• Relationship (Rich and Knight, 2008):
  • Knowledge provides the foundation for learning (e.g., prior rules or models).
  • Learning enhances or refines knowledge, enabling better problem-solving or decision-making.
• Types of Learning:
  • Supervised Learning: Learning from labeled data (e.g., predicting house prices from features).
  • Unsupervised Learning: Finding patterns in unlabeled data (e.g., clustering customers).
  • Reinforcement Learning: Learning through trial and error based on rewards (e.g., training a game-playing agent).
• Importance: Learning enables AI systems to adapt to dynamic environments and handle complex tasks.

1.3 Learning in Problem Solving

• Role (Russell and Norvig, 2010):
  • Improves efficiency of search or decision-making by leveraging past experiences.
  • Adapts strategies to specific problem instances.
• Techniques:
  • Learning Heuristics: Improving search by refining heuristic functions (e.g., learning better evaluation functions in chess).
  • Pattern Recognition: Identifying patterns in problem states to guide solutions.
  • Case-Based Reasoning: Solving new problems by adapting solutions from similar past problems.
• Example: A navigation system learning optimal routes based on traffic patterns.

1.4 Learning Probabilistic Models

• Definition: Learning probabilistic models involves estimating parameters of probability distributions from data (Russell and Norvig, 2010).
• Examples:
  • Bayesian Networks: Learning conditional probability distributions from data (e.g., P(Disease|Symptoms)).
  • Hidden Markov Models: Inferring state transitions and emission probabilities for sequence data (e.g., speech recognition).
• Methods:
  • Maximum Likelihood Estimation (MLE): Choosing parameters that maximize the likelihood of observed data.
  • Expectation-Maximization (EM): Iteratively estimating parameters for models with latent variables.
  • Bayesian Learning: Updating prior probabilities with new evidence.
• Applications: Medical diagnosis, spam filtering, weather prediction.

2. Expert Systems

Expert systems are AI programs that emulate human expertise in specific domains using knowledge bases and inference mechanisms (Rich and Knight, 2008).

2.1 Fundamental Blocks

• Components:
  • Knowledge Base: Stores domain-specific facts and rules (e.g., medical diagnostic rules).
  • Inference Engine: Applies reasoning to derive conclusions (e.g., forward or backward chaining).
  • User Interface: Facilitates interaction with users (e.g., inputting symptoms, viewing results).
  • Explanation System: Justifies the system’s reasoning or conclusions.
• Example: MYCIN, an expert system for diagnosing bacterial infections.

2.2 Knowledge Engineering

• Definition: The process of designing, building, and maintaining expert systems by extracting and structuring knowledge (Russell and Norvig, 2010).
• Steps:
  • Identify domain experts.
  • Elicit knowledge through interviews, observation, or analysis.
  • Represent knowledge using rules, frames, or other structures.
  • Validate and refine the knowledge base.
• Challenges:
  • Extracting tacit knowledge from experts.
  • Ensuring completeness and consistency of the knowledge base.

2.3 Knowledge Acquisition

• Definition: The process of gathering knowledge from human experts or data sources to populate the knowledge base (Rich and Knight, 2008).
• Methods:
  • Manual: Interviews, questionnaires, or protocol analysis.
  • Automated: Machine learning techniques to extract rules or patterns from data.
  • Hybrid: Combining manual and automated approaches.
• Example: Acquiring diagnostic rules from doctors for a medical expert system.
• Challenges:
  • Knowledge bottleneck: Difficulty in extracting and formalizing expertise.
  • Handling conflicting or uncertain knowledge.

2.4 Knowledge-Based Systems

• Definition: Systems that use a knowledge base to solve problems in specific domains (Russell and Norvig, 2010).
• Characteristics:
  • Domain-specific: Focused on areas like medicine, finance, or engineering.
  • Rule-based or logic-based reasoning.
  • Often incorporate uncertainty handling (e.g., certainty factors, probabilities).
• Examples:
  • DENDRAL: Chemical structure analysis.
  • XCON: Computer configuration.
• Advantages:
  • High accuracy in narrow domains.
  • Explainable decisions.
• Limitations:
  • Limited to specific domains.
  • Brittle when faced with novel situations.

3. Basic Understanding of Natural Language

Natural Language Processing (NLP) enables AI systems to understand and generate human language (Rich and Knight, 2008).

• Key Components:
  • Syntax: Analyzing sentence structure using grammars (e.g., context-free grammars).
  • Semantics: Understanding meaning (e.g., mapping sentences to logical forms).
  • Pragmatics: Interpreting context and intent (e.g., resolving ambiguity in “bank”).
• Challenges:
  • Ambiguity: Words or sentences with multiple meanings.
  • Context dependence: Meaning varies with situation or speaker.
  • Complexity: Handling idioms, slang, or cultural nuances.
• Basic Techniques:
  • Tokenization: Splitting text into words or phrases.
  • Parsing: Constructing syntactic structures (e.g., parse trees).
  • Semantic Analysis: Mapping text to knowledge representations.
• Applications:
  • Chatbots, machine translation, sentiment analysis.
• Example: A system parsing “The cat chased the mouse” to understand the subject, verb, and object relationships.

References

1. Rich, E., & Knight, K. (2008). Artificial Intelligence. Tata McGraw Hill.
2. Russell, S., & Norvig, P. (2010). Artificial Intelligence: A Modern Approach (3rd ed.). Prentice Hall.

Lab Practicals for Artificial Intelligence Course

The following 12 lab practicals are designed to provide hands-on experience with the concepts covered in the Artificial Intelligence course syllabus (Units I–V). Each practical includes a problem statement, objectives, and Python code to implement the solution. Prerequisites include familiarity with Python and libraries like numpy and matplotlib (where applicable).

---

Practical 1: State Space Representation for the 8-Puzzle Problem (Unit I)

Problem Statement: Implement a state space representation for the 8-puzzle problem, where the goal is to move tiles from an initial configuration to a goal configuration using valid moves.

Objectives:

• Understand problem representation as a state space.
• Define initial state, goal state, and operators.
• Visualize the state space for a simple puzzle instance.

def print_puzzle(state):
    for i in range(0, 9, 3):
        print(state[i:i+3])
    print()

def get_successors(state):
    successors = []
    blank_idx = state.index(0)
    moves = {'up': -3, 'down': 3, 'left': -1, 'right': 1}
    for move, offset in moves.items():
        new_idx = blank_idx + offset
        if move == 'left' and blank_idx % 3 == 0:
            continue
        if move == 'right' and blank_idx % 3 == 2:
            continue
        if 0 <= new_idx < 9:
            new_state = state.copy()
            new_state[blank_idx], new_state[new_idx] = new_state[new_idx], new_state[blank_idx]
            successors.append(new_state)
    return successors

# Example usage
initial_state = [1, 2, 3, 4, 0, 5, 6, 7, 8]
goal_state = [1, 2, 3, 4, 5, 6, 7, 8, 0]
print("Initial State:")
print_puzzle(initial_state)
print("Successors:")
for succ in get_successors(initial_state):
    print_puzzle(succ)

---

Practical 2: Breadth-First Search (Unit II)

Problem Statement: Implement Breadth-First Search (BFS) to find the shortest path in a graph (e.g., a simplified maze).

Objectives:

• Implement BFS to explore all nodes at the current depth before moving deeper.
• Understand completeness and optimality of BFS.
• Visualize the search process.

from collections import deque

def bfs(graph, start, goal):
    queue = deque([(start, [start])])
    visited = set()
    while queue:
        node, path = queue.popleft()
        if node == goal:
            return path
        if node not in visited:
            visited.add(node)
            for neighbor in graph[node]:
                if neighbor not in visited:
                    queue.append((neighbor, path + [neighbor]))
    return None

# Example graph (adjacency list)
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}
print("Path from A to F:", bfs(graph, 'A', 'F'))

---

Practical 3: A* Search Algorithm (Unit II)

Problem Statement: Implement the A* search algorithm to solve the 8-puzzle problem using a heuristic (e.g., Manhattan distance).

Objectives:

• Implement A* search with an admissible heuristic.
• Compare A* with uninformed search in terms of efficiency.
• Understand the role of heuristics in informed search.

import heapq

def manhattan_distance(state, goal):
    return sum(abs(state.index(i) // 3 - goal.index(i) // 3) + abs(state.index(i) % 3 - goal.index(i) % 3) for i in range(1, 9))

def a_star(initial_state, goal_state):
    frontier = [(0, initial_state, [])]
    visited = set()
    while frontier:
        cost, state, path = heapq.heappop(frontier)
        state_tuple = tuple(state)
        if state == goal_state:
            return path
        if state_tuple not in visited:
            visited.add(state_tuple)
            for succ in get_successors(state):  # Using get_successors from Practical 1
                if tuple(succ) not in visited:
                    new_cost = len(path) + 1 + manhattan_distance(succ, goal_state)
                    heapq.heappush(frontier, (new_cost, succ, path + [succ]))
    return None

# Example usage
initial_state = [1, 2, 3, 4, 0, 5, 6, 7, 8]
goal_state = [1, 2, 3, 4, 5, 6, 7, 8, 0]
path = a_star(initial_state, goal_state)
print("A* Path:", path)

---

Practical 4: Constraint Satisfaction Problem (Unit II)

Problem Statement: Solve the 4-Queens problem using backtracking to place queens on a 4×4 chessboard with no conflicts.

Objectives:

• Implement a CSP solver using backtracking.
• Understand constraints and variable assignments.
• Visualize the solution.

def is_safe(board, row, col):
    for i in range(row):
        if board[i] == col or abs(board[i] - col) == abs(i - row):
            return False
    return True

def solve_n_queens(n):
    def backtrack(board, row):
        if row == n:
            return [board[:]]
        solutions = []
        for col in range(n):
            if is_safe(board, row, col):
                board[row] = col
                solutions.extend(backtrack(board, row + 1))
        return solutions
    
    board = [-1] * n
    return backtrack(board, 0)

# Example usage
solutions = solve_n_queens(4)
for sol in solutions:
    print("Solution:", sol)

---

Practical 5: First-Order Logic Representation (Unit III)

Problem Statement: Represent a simple knowledge base in first-order logic and perform basic inference using Python.

Objectives:

• Represent facts and rules using predicate logic.
• Implement a simple inference mechanism.
• Understand FOL syntax and semantics.

class KnowledgeBase:
    def __init__(self):
        self.facts = []
        self.rules = []
    
    def add_fact(self, fact):
        self.facts.append(fact)
    
    def add_rule(self, premise, conclusion):
        self.rules.append((premise, conclusion))
    
    def infer(self, query):
        for fact in self.facts:
            if fact == query:
                return True
        for premise, conclusion in self.rules:
            if conclusion == query and all(p in self.facts for p in premise):
                return True
        return False

# Example usage
kb = KnowledgeBase()
kb.add_fact("Human(Socrates)")
kb.add_rule(["Human(Socrates)"], "Mortal(Socrates)")
print("Is Socrates mortal?", kb.infer("Mortal(Socrates)"))

---

Practical 6: Backward Chaining (Unit III)

Problem Statement: Implement backward chaining to prove a query using a rule-based system.

Objectives:

• Understand goal-driven reasoning.
• Implement backward chaining for inference.
• Apply to a simple knowledge base.

class BackwardChaining:
    def __init__(self):
        self.facts = set()
        self.rules = []
    
    def add_fact(self, fact):
        self.facts.add(fact)
    
    def add_rule(self, premise, conclusion):
        self.rules.append((premise, conclusion))
    
    def prove(self, goal):
        if goal in self.facts:
            return True
        for premise, conclusion in self.rules:
            if conclusion == goal:
                if all(self.prove(p) for p in premise):
                    return True
        return False

# Example usage
bc = BackwardChaining()
bc.add_fact("A")
bc.add_fact("B")
bc.add_rule(["A", "B"], "C")
bc.add_rule(["C"], "D")
print("Can prove D?", bc.prove("D"))

---

Practical 7: Semantic Network Implementation (Unit III)

Problem Statement: Implement a simple semantic network to represent hierarchical relationships (e.g., animals and their properties).

Objectives:

• Represent knowledge using a graph-based structure.
• Support inheritance queries.
• Understand semantic nets.

class SemanticNet:
    def __init__(self):
        self.nodes = {}
    
    def add_node(self, node, parent=None, properties=None):
        self.nodes[node] = {'parent': parent, 'properties': properties or {}}
    
    def get_properties(self, node):
        props = self.nodes[node]['properties'].copy()
        parent = self.nodes[node]['parent']
        while parent:
            props.update(self.nodes[parent]['properties'])
            parent = self.nodes[parent]['parent']
        return props

# Example usage
net = SemanticNet()
net.add_node("Mammal", None, {"has_hair": True})
net.add_node("Dog", "Mammal", {"barks": True})
net.add_node("Fido", "Dog", {})
print("Fido's properties:", net.get_properties("Fido"))

---

Practical 8: Bayesian Network Inference (Unit IV)

Problem Statement: Implement a simple Bayesian network to compute probabilities (e.g., rain, sprinkler, wet grass scenario).

Objectives:

• Represent a Bayesian network.
• Perform exact inference using joint probability.
• Understand probabilistic reasoning.

class BayesianNetwork:
    def __init__(self):
        self.prob = {
            'Rain': 0.2,
            'Sprinkler|Rain': {True: 0.01, False: 0.4},
            'WetGrass|Rain,Sprinkler': {(True, True): 0.99, (True, False): 0.8, (False, True): 0.9, (False, False): 0.0}
        }
    
    def infer(self, evidence, query):
        # Simple enumeration for P(WetGrass|Rain=True)
        if query == 'WetGrass' and evidence.get('Rain') is True:
            p_sprinkler = self.prob['Sprinkler|Rain'][True]
            p_wet = (self.prob['WetGrass|Rain,Sprinkler'][(True, True)] * p_sprinkler +
                     self.prob['WetGrass|Rain,Sprinkler'][(True, False)] * (1 - p_sprinkler))
            return p_wet
        return None

# Example usage
bn = BayesianNetwork()
print("P(WetGrass|Rain=True):", bn.infer({'Rain': True}, 'WetGrass'))

---

Practical 9: Fuzzy Logic Controller (Unit IV)

Problem Statement: Implement a fuzzy logic controller for a temperature control system (e.g., adjusting fan speed based on temperature).

Objectives:

• Implement fuzzy sets and rules.
• Perform fuzzification, inference, and defuzzification.
• Understand handling uncertainty with fuzzy logic.

def fuzzy_membership(value, low, high):
    if value <= low:
        return 0
    if value >= high:
        return 1
    return (value - low) / (high - low)

def fuzzy_controller(temp):
    # Fuzzy sets: cold (0-15), warm (10-25), hot (20-40)
    cold = fuzzy_membership(temp, 0, 15)
    warm = fuzzy_membership(temp, 10, 25)
    hot = fuzzy_membership(temp, 20, 40)
    
    # Rules: IF cold THEN slow, IF warm THEN medium, IF hot THEN fast
    slow = cold
    medium = warm
    fast = hot
    
    # Defuzzification (weighted average)
    if slow + medium + fast == 0:
        return 0
    return (slow * 10 + medium * 50 + fast * 100) / (slow + medium + fast)

# Example usage
print("Fan speed for temp=20:", fuzzy_controller(20))

---

Practical 10: Simple Reflex Agent (Unit IV)

Problem Statement: Implement a simple reflex agent for a vacuum cleaner world that moves based on dirt and obstacles.

Objectives:

• Understand the structure of a reflex agent.
• Implement condition-action rules.
• Simulate agent behavior in a simple environment.

class VacuumAgent:
    def __init__(self):
        self.position = 0
        self.world = [1, 0, 1]  # 1=dirty, 0=clean
    
    def act(self):
        if self.world[self.position] == 1:
            self.world[self.position] = 0
            return "Suck"
        elif self.position < len(self.world) - 1:
            self.position += 1
            return "Move Right"
        return "NoOp"

# Example usage
agent = VacuumAgent()
for _ in range(5):
    print("Action:", agent.act(), "World:", agent.world)

---

Practical 11: Decision Tree Learning (Unit V)

Problem Statement: Implement a decision tree learner for a simple dataset (e.g., play tennis based on weather).

Objectives:

• Understand supervised learning.
• Implement a basic decision tree algorithm.
• Apply to a classification problem.

from collections import Counter
import math

def entropy(data):
    counts = Counter(data)
    return -sum((count / len(data)) * math.log2(count / len(data)) for count in counts.values())

def build_decision_tree(data, attributes):
    labels = [row[-1] for row in data]
    if len(set(labels)) == 1:
        return labels[0]
    if not attributes:
        return Counter(labels).most_common(1)[0][0]
    
    best_attr = max(attributes, key=lambda attr: entropy([row[attr] for row in data]))
    tree = {best_attr: {}}
    for value in set(row[best_attr] for row in data):
        subset = [row for row in data if row[best_attr] == value]
        subtree = build_decision_tree(subset, [a for a in attributes if a != best_attr])
        tree[best_attr][value] = subtree
    return tree

# Example usage
data = [
    [0, 0, 0, 'Yes'],  # Outlook, Temp, Humidity, Play
    [0, 1, 1, 'No'],
    [1, 0, 1, 'Yes']
]
attributes = [0, 1, 2]
print("Decision Tree:", build_decision_tree(data, attributes))

---

Practical 12: Simple Natural Language Processing (Unit V)

Problem Statement: Implement a basic NLP program to tokenize and parse a sentence into subject, verb, and object.

Objectives:

• Understand basic NLP tasks.
• Implement tokenization and simple parsing.
• Process natural language input.

def parse_sentence(sentence):
    tokens = sentence.lower().split()
    # Simple rule: subject verb object
    if len(tokens) >= 3:
        return {'subject': tokens[0], 'verb': tokens[1], 'object': tokens[2]}
    return None

# Example usage
sentence = "John chased the cat"
print("Parsed:", parse_sentence(sentence))

---

Notes

• Environment: Use Python 3.x with libraries like numpy, matplotlib, or others as needed.
• Extensions:
  • Add visualization (e.g., plot search trees, display puzzle states).
  • Test with larger or more complex inputs.
  • Compare performance of different algorithms (e.g., BFS vs. A*).
• References:
  1. Rich, E., & Knight, K. (2008). Artificial Intelligence. Tata McGraw Hill.
  2. Russell, S., & Norvig, P. (2010). Artificial Intelligence: A Modern Approach (3rd ed.). Prentice Hall.

Question Bank for Artificial Intelligence Course

The following question bank contains 20 questions per unit (Units I–V) for the Artificial Intelligence course, designed to test theoretical understanding, problem-solving skills, and practical application. Questions are categorized into short-answer (factual), descriptive (conceptual), and problem-solving (application-based) types.

---

Unit I: Introduction to AI

1. Short Answer
   1. Define Artificial Intelligence in the context of rational agent behavior.
   2. What is the Turing Test, and why is it significant in AI?
   3. Name two pioneers of AI and their contributions.
   4. List three real-world applications of AI.
   5. What is meant by “representation and search” in AI?
   6. Define a production system in AI.
   7. What is a state space representation?
   8. Name two characteristics of a well-defined problem.
   9. What is the role of operators in problem-solving?
   10. Differentiate between thinking humanly and acting rationally in AI.
2. Descriptive
   11. Explain the history of AI from the 1950s to the present, highlighting key milestones.
   12. Discuss the role of AI in healthcare with examples.
   13. Describe the components of a production system and their significance in AI.
   14. Explain the importance of problem representation paradigms in AI problem-solving.
   15. Discuss the challenges in defining a problem as a state space representation.
3. Problem-Solving
   16. Represent the 8-puzzle problem as a state space, specifying initial state, goal state, and operators.
   17. Design a production system for a simple tic-tac-toe game.
   18. For a robot navigating a 3×3 grid, define the state space and possible operators.
   19. Identify the characteristics of the Traveling Salesman Problem as a well-defined or ill-defined problem.
   20. Create a state space representation for a water jug problem with two jugs (4L and 3L) to achieve 2L in one jug.

---

Unit II: Search Techniques

1. Short Answer
   1. Define uninformed search and give an example.
   2. What is the key difference between BFS and DFS?
   3. What makes a heuristic admissible in informed search?
   4. Define the generate-and-test strategy.
   5. What is hill-climbing search, and what is its main limitation?
   6. Explain the role of the evaluation function in Best-First Search.
   7. What is problem reduction in AI?
   8. Define a Constraint Satisfaction Problem (CSP).
   9. Name two uninformed search techniques.
   10. What is the significance of the A* algorithm’s optimality?
2. Descriptive
   11. Compare and contrast Breadth-First Search and Depth-First Search in terms of completeness and optimality.
   12. Explain how the A* algorithm uses heuristics to improve search efficiency.
   13. Discuss the limitations of hill-climbing search and suggest ways to overcome them.
   14. Describe the process of solving a CSP using backtracking search.
   15. Explain problem reduction with an example, such as planning a trip.
3. Problem-Solving
   16. Implement BFS to find the shortest path in a graph with 5 nodes (A to E).
   17. Solve the 4-Queens problem as a CSP, showing one valid configuration.
   18. Design a heuristic function for the 8-puzzle problem and justify its admissibility.
   19. Use problem reduction to break down a tower of Hanoi problem (3 disks) into subproblems.
   20. Apply Best-First Search to a weighted graph to find a path from node A to node F, showing steps.

---

Unit III: Knowledge Representation

1. Short Answer
   1. What is knowledge representation in AI?
   2. Define a predicate in First-Order Logic (FOL).
   3. What is the role of quantifiers in FOL?
   4. What is a semantic net, and what does it represent?
   5. Define a frame in the context of knowledge representation.
   6. What is a script in AI?
   7. Explain the concept of an ontology.
   8. What is backward chaining?
   9. Define resolution in FOL.
   10. Name one advantage of semantic nets over frames.
2. Descriptive
   11. Discuss the key issues in knowledge representation and their impact on AI systems.
   12. Explain how FOL can represent complex relationships with an example.
   13. Compare semantic nets and frames as knowledge representation methods.
   14. Describe the process of backward chaining with a rule-based example.
   15. Explain how resolution is used for theorem proving in FOL.
3. Problem-Solving
   16. Represent the statement “All humans are mortal, and Socrates is human” in FOL and prove Socrates is mortal.
   17. Design a semantic net for a university system (e.g., students, courses, professors).
   18. Create a frame structure for a “Car” with attributes like color, model, and owner.
   19. Develop a script for a “Restaurant Visit” scenario, including roles and scenes.
   20. Use backward chaining to prove a goal in a knowledge base with rules: (A ∧ B → C), (C → D), facts: A, B.

---

Unit IV: Uncertain Knowledge & Intelligent Agents

1. Short Answer
   1. What is uncertain knowledge in AI?
   2. Define a rational decision in the context of AI.
   3. State one axiom of probability.
   4. What is Bayes’ Rule, and where is it used?
   5. Define conditional independence in probability.
   6. What is a Bayesian network?
   7. Name one method for exact inference in Bayesian networks.
   8. What is fuzzy logic?
   9. Define an intelligent agent.
   10. What is a reflex agent?
2. Descriptive
   11. Explain how AI systems handle uncertainty using probabilistic methods.
   12. Discuss the role of Bayes’ Rule in reasoning under uncertainty.
   13. Describe the structure of a Bayesian network with an example.
   14. Compare exact and approximate inference in Bayesian networks.
   15. Explain the concept of fuzzy logic and its application in control systems.
3. Problem-Solving
   16. Given P(A) = 0.3, P(B|A) = 0.7, P(B|¬A) = 0.2, compute P(A|B) using Bayes’ Rule.
   17. Design a Bayesian network for a medical diagnosis system (e.g., disease, symptom, test).
   18. Implement a fuzzy logic rule for a thermostat (e.g., IF temperature is high THEN fan is fast).
   19. Design a simple reflex agent for a thermostat controlling room temperature.
   20. Compare the behavior of a goal-based agent and a utility-based agent in a navigation task.

---

Unit V: Knowledge and Learning

1. Short Answer
   1. Define learning in the context of AI.
   2. What is supervised learning?
   3. Name one technique for learning probabilistic models.
   4. Define an expert system.
   5. What is knowledge engineering?
   6. What is knowledge acquisition in AI?
   7. Name one application of knowledge-based systems.
   8. What is tokenization in NLP?
   9. Define reinforcement learning.
   10. What is the role of an inference engine in expert systems?
2. Descriptive
   11. Explain the relationship between knowledge and learning in AI systems.
   12. Discuss how learning can improve problem-solving in AI with examples.
   13. Describe the process of knowledge acquisition for an expert system.
   14. Explain the components of an expert system and their roles.
   15. Discuss the challenges in natural language processing with examples.
3. Problem-Solving
   16. Design a simple decision tree for a dataset predicting whether to play tennis based on weather.
   17. Implement a rule-based expert system to diagnose a simple medical condition (e.g., flu).
   18. Develop a probabilistic model for a weather prediction system using MLE.
   19. Parse a sentence like “The dog barked” into subject, verb, and object using basic NLP rules.
   20. Simulate a reinforcement learning scenario for a robot learning to avoid obstacles.

---

Notes

• Difficulty Levels: Short-answer questions test factual recall, descriptive questions assess conceptual understanding, and problem-solving questions require application and analysis.
• Usage: These questions can be used for assignments, quizzes, or exams to evaluate student understanding.
• References:
  1. Rich, E., & Knight, K. (2008). Artificial Intelligence. Tata McGraw Hill.
  2. Russell, S., & Norvig, P. (2010). Artificial Intelligence: A Modern Approach (3rd ed.). Prentice Hall.