Outline

• `A^\star` Algorithm
• In-Class Exercise
• Python

Informed Search Strategies

• On Monday, we were discussing search strategies for problem solving agents, goal-oriented agents that operate on an unfactored domain.
• We distinguished between uninformed strategies that don't use infomration about the underlying domain other than the goal test, and informed strategies, which do use other information.
• We looked at several uninformed strategies such as: DFS, BFS, UCS, IDS, ILS.
• We now want to consider search strategies where one has problem specific knowledge.
• Here the node we select for expansion is chosen according to some evaluation function `f(n)`.
• In a Best-First-Search we assume `f(n)` is a cost and we always expand the node for which `f(n)` is smallest.
• The question is how to choose `f`?
• A key component of `f` is usually some heuristic function, `h(n)` where this is an estimate of the cost from a given node `n` to the goal.

Example Heuristic Functions

• In a maze game, `h(n)` might be straight line distance (straight line mathematical distance from current position to the goal)
• Or it could be the Manhattan distance, (the distance to the goal using horizontal and vertical line segments of a given length).
• As an example, we could use the sum of the straight-line distance of each square from its ideal location as our heuristic with the 8-puzzle.
• Greedy Best First Search (GBFS) chooses for its next node to expand, the node of smallest cost according to this heuristic.
• It is memory efficient in that it does not remember where it has been.

`A^star`-search

• The problem with Greedy Best First Search is that it is not complete. You can end up going back and forth between two states.
• In 1968, Peter Hart, Nils Nilsson and Bertram Raphael of SRI came up with a different choice of `f` to solve this problem.
• Their algorithm is called`A^star` search.
• They define `f(n)` to be `c(n)+h(n)` where `c(n)` is cost from the root node to the current node.
• They came up with this while devising a sequence of algorithms A1, A2, etc based-on Dijkstra's algorithm (1956) to help Shakey the Robot navigate a room filled with obstacles.

`A^\star`-algorithm

• Recall in informed search we have a fitness function `f` which says how good a current state is.
• For the Greedy algorithm, `f = h`, where `h` is a heuristic function estimating the cost to a solution; for `A^\star`, `f = c + h`, where `h` is as in the Greedy Algorithm and `c` was the cost to get to the current state from the initial state.
• The pseudo-code for the `A^\star`-algorithm looks like what you would do for uniform cost search:

function A-STAR-SEARCH(problem) returns a solution, or failure 
    node := a node with STATE = problem.INITIAL-STATE, PATH-COST = 0,
        H-COST = heuristic's cost to solution
    frontier := a priority queue ordered by f=c+h, with node as
        the only element
    explored := an empty set
    loop do
        if EMPTY?(frontier) then return failure
        node := POP(frontier) /* lowest f=c+h-value in frontier 
            since priority-queue */
        if problem.GOAL-TEST(node.STATE) then return SOLUTION(node)
        add node.STATE to explored
        for each action in problem.ACTIONS(node.STATE) do
            child := CHILD-NODE(problem, node, action)
            if child.STATE is not in explored and  child.STATE is not in frontier then
                frontier := INSERT(child, frontier)
            else if child.STATE is in frontier with higher f value
                replace that frontier node with child

`A^star`-Example Map

We will use the following road map of Romania to illustrate the `A^star`-algorithm:

`A^star`-Example Map

• The trees below illustrate a search for Bucharest using `A^\star` starting at Arad.
• The darkened nodes are the explored ones, the node with the triangle next to it is the node under consideration, all other nodes are on the frontier.

In-Class Exercise

• Consider the following 8-puzzle configuration:

  6	2	8
  1		4
  5	7	3

• Suppose it is three moves from the initial starting puzzle and the heuristic function is the Manhattan distance.
• Compute the fitness function for the four possible moves in the above situation, showing work.
• Which move would be chosen?
• Post your answers to the Aug 31 In-Class Exercise Thread.

Python

• For this semester, we are going to mainly code our AI projects in Python.
• Python is a programming language created by Guido van Rossum whose origins trace to the late 1980s.
• When looking for a language to code AI projects there are several things to look for:
  1. Good string and list processing facilities (minimize awkward additional user coding)
  2. Scripted/interpreted coding available for faster testing and development
  3. Higher-order function support. i.e., Can easily make functions which take other functions as arguments.
  4. Syntax is not too weird compared to what everybody else uses.
  5. Good set of built-in libraries.
  6. Wide-range of free libraries/projects can build off.
  7. People outside of AI use it, so other people can appreciate code.
• A case can be made that Python satisfies each of these requirements.
• The first three points are probably why LISP was originally popular as an AI language.
• Unfortunately, (4) and to a lesser degree (7) are weaknesses of LISP/SCHEME/Racket.
• According to TIOBE Language Popularity Index , Python is the most popular programming language.

Getting Started

• Python can be obtained from:
  https://python.org/download/.
• There are two main variants of Python 2.x, 3.x.
• Many machine learning project have finally started to migrate to Python 3.x, so we will use it
• Python 2.7.x is available by default on Mac's running MacOS (however, it is easy to install python 3 using brew).
• Some differences between Version 2 and 3 are Unicode support in strings, exception chaining, annotations, etc -- none of which we'll really make use this semester.

Running Python

• Assuming you have set up your path environment, you can launch python in interactive mode by just typing:

  python
  

  at the command prompt. You should see something like:

  Python 3.9.13 (main, May 24 2022, 21:28:31) 
  [Clang 13.1.6 (clang-1316.0.21.2)] on darwin
  Type "help", "copyright", "credits" or "license" for more information.
  >>>
  

• Typing quit() on a line or hitting CTRL-D returns you to the command prompt.
• As an example, we could type:

  >>>print("hello world")
  

  which would print hello world to the terminal.
• As an example difference between Python 2.x and Python 3.x, in Python 2.x we could have omitted in the parentheses in the print statement.