Artificial Intelligence A Primer for the Labs

Transcription

1 Artificial Intelligence A Primer for the Labs Mathias Broxvall, Lia Susana d.c. Silva Lopez, November 2011

2

3 Chapter 1 General python instructions This document contains a quick primer for using Python in the laborations for the Artificial Intelligence course at Örebro University, autumn To do the exercises here, you will need Python and the IDLE environment. These are installed on all computers on the NT network, and can also be downloaded from You may also want to use the book Python programming by Zelle, or one of the Python tutorials or reference manual linked to from the course web page, as the present document does not give any complete description of Python. 1.1 Programming in Python To refresh your memory of Python programming, look at this function that computes the faculty of an integer ( 0). def fac(n): res = 1 for i in range(2,n+1): res=res*i return res You can notice some peculiarities of Python in this little function. First, there are no curly brackets ({, }) as in C, to show the structure of the different statements in the function. Instead, indentation (tabs) is used. You can also notice that certain statements, namely those with other statements indented under them, end with a colon (:). You should remember to use this colon whenever you e.g. start a function definition, or write an if statement (conditional) or a for or while statement (iteration). You may also notice that the variables are not declared as in C. We do assign a value to res in the beginning, but we never say that res has to be an integer. Indeed, we could assign any other type of value to res as well, like a string or a list. While C is a strongly typed language, Python is weakly typed. However, you should take care to always use your variables in a consistent manner. 1

4 The absence of variable declarations can make it difficult to see where a certain variable belongs. You can use the following rule of thumb: If a variable is among the parameters of a function, or assigned a value inside that function, it is a local variable in that function. Otherwise, it is a global variable. Of course, you should avoid referring to global variables inside functions. Information to functions should always be passed via their parameters. This makes the functions easier to understand, and more generally useful. If you define the function above in a file that you load, you can then type in the Python shell window: fac(3) to call the function with the value 3 as argument (it will be bound to the parameter n). You can of course also call the function inside other functions. Because you can incrementally write, modify and test functions, without having to compile anything, Python is called an incremental language. You can always print out the value of a variable, or even go in and manually inspect or modify you data structures in a very easy way. The following is another function for computing the faculty: def facr(n): if n <= 1: return 1 else: return n*facr(n-1) This function is recursive: it calls itself on the last line. Remember that a recursive function needs to handle two cases: a base case when a value can be computed and returned directly (lines 2 and 3 above) a recursive case when the function has to call itself, but with different arguments, to complete the computation (lines 4 and 5). It is important that the recursive call is made with a smaller or simpler value than before, in this case n-1 instead of n. In that way, the base case (with the really simple or small values, like 1 above), will eventually be reached. The first faculty function solved the same problem in an iterative way, using a for-loop. Sometimes you can write a function either recursively or iteratively, but in other cases the recursive way is the only way. 2

5 1.2 Some important data types The following section goes through the most important data types in Python. As mentioned before, variables in Python are not typed, but you can always check what type the present value of a variable is by using the function type, as in: type(3) == int The types in this section are bool, int, float, str, list, tuple and dict Booleans The boolean type consists of the values True and False, and the boolean operations are and, or, and not. All tests, such as equality (x==y), return a boolean value Numbers Numbers in Python can either be integers (like 1 and 12) or floating point numbers like 1.0 or There are the usual arithmetic operators: +, -, *, / and ** (power, m**n means m n ). Note that if the arguments to / are integers, then it is interpreted as integer division, and the result is also an integer. The remainder can then be obtained by %. If at least one of the numbers is floating point, then / works like ordinary division. You can convert a number to floating point with the function float, and to an integer with the function int. There are also the functions min and max, which can take any number of arguments, and abs which takes one argument. There are also comparisons, like == (equals),!= (not equals), <, >, <= and >= Characters and strings Strings are written surrounded by single or double quotes: hello, "hello". A character is a string of length 1: a or "a". The function len(s) gives the length of a string s, and the character at position n is obtained by s[n], where the first character is at position 0. You can also use negative numbers to count backwards: s[-1] gives the last character in the string, and so on. You can get a part of a string with s[n:m]: this gives the substring from position n to position m 1 (position m is not included). Finally, s[n:] gives the substring from position n to the end, and s[:m] gives the substring from the beginning to position m 1. You can concatenate (put together) strings with the operation +, and use * to repeat the same string a number of times (e.g. 3* a ). These operations do not change the strings involved, but creates a new string. Finally, you can check if a character or a substring occurs in a string by in a in cab To work with strings, one can either iterate over the positions in the strings. Eg. 3

6 for i in range(0,len(s)): print s[i] One can also iterate directly over the characters, as in the following example: for c in "YANKEES": print("give me a "+c+"!") A nice way to construct strings from other data is to use the string formatting operator %. It takes a string on the left side, and a number of arguments on the right side, and it returns a new string. For instance: "I am %d years" % 5 would return the string "I am 5 years". The %d part of the formatting string indicates where the argument should go, and that it should be shown as a decimal (base 10) integer. You can also use %f for floating point arguments and %s for strings (or almost anything else). You can use several arguments, inside parentheses: "My name is %s, I m %d years old, and %f meters tall." % ("Gimli", 150, 1.40) Lists Lists are very versatile data structures, and very useful for AI applications. A list is a sequence of objects, which can be of any type including another list. The following are some examples: [5, 3, 8, 10] [ hello, there ] [[1,2],[4,2],[6,12]] You can access elements in a list just like in a string, e.g. l[1] or l[1:3]. If there are lists inside the list, you can access their elements by repeating those operations, e.g. l[2][1] would give element in position 1 of the list at position 2 in the list l, which would be 12 if l was the third list above. In addition, you can change the elements of a list, like: l[0] = [2,1] l[1][0] = 3 You can concatenate lists with the operation +, and use * to repeat the same list a number of times. With in, you can check whether a certain element occurs in the list. An efficient way to create lists is to use list comprehension. For instance, the following statement creates the multiplication table for the number 3. mult_3 = [ 3*x for x in range(1,11) ] It takes elements x ranging from 1 to 10, and create a list of elements computed as 3*x. Here is a statement for computing the entire multiplication table, as a matrix: mult_table = [ [x*y for x in range(11) ] for y in range(1,11) ] One can iterate over the elements of a list, just like over the characters of a string. Indeed, when one writes e.g. for i in range(1,11), the expression range(1,11) actually returns a list containing numbers from 1 to 11. 4

7 1.2.5 Tuples Tuples are pretty similar to lists, but you cannot modify their elements. Here are some examples: (1,2) ("Bill", "Fulton", 55) (1,) Note that you need to include a comma when you have a tuple of length one, as in the last line. A useful feature of tuples is that you can assign their elements to multiple variables at the same time: person = ("Bill", "Fulton", 55) firstname, familyname, age = person This comes particularly handy when you have a function that returns several values. def inverse_and_square_and_root(x): return (1.0/x, x**2, x**0.5) When you call this function, you can assign the result to three different variables: x_inverse, x_square, x_root = inverse_and_square_and_root(2.0) Dictionaries Dictionaries are also similar to lists, but instead of referring to elements by position, one refer to them by a key, which is a string. The following is an example: cities = { "London" : "England", "Glasgow" : "Scotland", "Cardiff": "Wales" } One can now access and update the different elements like this: x = cities["london"] cities["birmingham"] = "England" One can also check if a key exists in the dictionary using in: "London" in cities The values (as opposed to the keys) need not be strings. They can be of any type, including another dictionary. One can iterate over the keys of a dictionary: for x in cities: print(x+" lies in "+cities[x]+".") Dictionaries are useful for storing and accessing symbolic information. This makes them well suited for AI applications. Python dictionaries are implemented as hash tables, which make them quite efficient. 5

8 6

9 Chapter 2 Object orientation 2.1 Classes and objects Python supports object-oriented programming. You can define classes, and create objects belonging to these classes. We will only take a very cursory look at classes and objects here. The following is an example of a class definition: class Gridmap: grid=[] width=0 height=0 This is an extremely simple class - in practice nothing more than a record with three fields. Each field is supplied with a default value. We can create instances of this class by calling its constructor, which is a function with the same name as the class itself. You can also give values to the different fields: my_map = Gridmap() my_map.grid = [[0,0],[0,0]] my_map.width=2 my_map.height=2 The different fields can then be accessed in the obvious way: w = my_map.width h = my_map.height print(my_map.grid[0][0]) You can also define classes with methods. The following class, which is a subclass of the previous class, has two methods. One is for initializing an instance when the constructor is called. The other is for checking whether a certain square in the grid is a free passage. class Labyrinth(Gridmap): def init (self,grid,startx,starty,goalx,goaly): 7

10 self.grid=grid self.start=(startx,starty) self.goal=(goalx,goaly) self.width=len(grid[0]) self.height=len(grid) def is_free_passage(self,x,y): return self.grid[y][x] == 1 mylab = Labyrinth(labyrinth,6,0,1,7) print(mylab.is_free_passage(2,2)) You may notice that the first parameter in each method is called self. When a method is called, this parameter will be bound to the object that the method belongs to, i.e. the object given in front of the method name (mylab in the last line above). It will be the object just being initialized when the constructor is invoked. The parameter need not be called self, but it is good practice to do so. 8

11 Chapter 3 Functional programming Python can also be used as a functional programming language. Among other things, this means that functions are first-order objects in Python. For instance, try typing len in the shell window. You get the response <built-in function len>. Now try the assignment foo = len, and then try foo("hello"). The variable foo has been bound to the function len! Or to be more specific, foo has been bound to the same function object as len. You can also create function objects without any name. This is done by using lambda expressions. The following is one example: lambda x: 2*x This is a function with one parameter x, which computes and returns 2*x. You can call this function like any other function, i.e. by supplying arguments directly after it: (lambda x: 2*x)(3) You could indeed also give it a name: foo = lambda x: 2*x The latter has the same effect as an ordinary function definition. There are a number of functions in Python that take a function as one of their arguments. They are called higher-order functions. When you call them, it can sometimes come in handy to use a lambda expression. The function map takes a function and a list (or string, or similar) and applies the function to every element in the list, and returns a list with the resulting elements. map(lambda x: 2*x, [1,2,3,4,5]) The function filter takes a function and a list (or string, or similar) and applies the function to every element in the list, and returns a list with the elements for which the function returned True. In other words, filter performs a test on each element, and only keeps those that pass the test. filter(lambda x: x>2, [1,2,3,4,5]) 9

12 The function functools.reduce takes a binary function and a list, and applies the function to the values in the list, until a single aggregated value has been computed. For instance: import functools functools.reduce(lambda x,y: x*y, [1,2,3,4,5]) is equivalent to 1*2*3*4*5. Likewise, reduce(max,[1,2,3,4,5]) returns the maximal value in the list. You can also write your own higher-order functions. The following is a function that checks whether every element satisfies a given test. def every(fn,item_list): for i in item_list: if not fn(i): return False return True 3.1 Evaluation and execution There is a function in Python called eval, which takes a Python expression in the form of a string and evaluates it. For instance, try: eval("2+3") The command exec takes a string as well, and interprets and executes this string as Python code. For instance, try: exec "for i in [1,2,3]:\n\tprint(i)" Note that \n stands for a newline, and \t stands for a tab (to get the indentation). The eval function and the exec command actually make it possible to write programs that write and execute code. Your program becomes a programmer. Note: The eval function is often considered a dangerous function since it risks creating security holes if user generated input is fed directly or indirectly to eval. Also for most systems it is less efficient since the that s evaluated cannot be statically compiled. 10

13 Chapter 4 Search algorithms A very simple way to find solutions to problems in a brute force search is by a simple recursion. We will illustrate this by an example. 4.1 The Knapsack problem Image that you have a backpack ( knapsack ), of finite size S, and a number of objects that you want to take with you. Each object has a name, a size and a value. We can describe each object as tuples ("name",size,value). Let s assume for instance that we have a backpack of size 6 and the objects given by the list below: [("A",3,4),("B",2,2),("C",2,3)] Since the total size of all the objects are 7 (check this yourself!) we obviously cannot take all the objects with us? Now, the problem is, how can you maximize the value of the objects to take with you if you can t fit everything inside your backpack? The easiest way to answer this is to try all combinations and check the values of each combination. This can be reduced into three recursive cases. Firstly, if we have no objects to take, then value will then be zero. Secondly, if the first object in the list is bigger than the backpack we can just check how much we can get if we only consider the rest of the items. Lastly, if the first item would fit in the backpack, we can see what the total value would be if we take it or if we don t. In both of these two cases we recurse on the rest of the items. In python we can write this as follows: # Items are a list of tuples [(name,size,value),...] # Return value is tuple ([name,name,name,...], total_value) def knapsack(items,sizeleft): if items == []: # No more things left to pack return ([],0); elif items[0][1] > sizeleft: 11

14 # Next item is too large return knapsack(items[1:],sizeleft) else: # Case 1: do not pack this item items1,value1 = knapsack(items[1:],sizeleft) # Case 2: do pack this item items2,value2 = knapsack(items[1:],sizeleft - items[0][1]) # Return alternative giving the highest value? if value1 > value2+items[0][2]: return (items1,value1) else: return ([items[0][0]]+items2,value2+items[0][2]) If we test this algorithm on our problem, we see that the best solution is to take object A and C if our backpack is of size 6. Otherwise, other object combinations are better. >>> knapsack([("a",3,4),("b",2,2),("c",2,3)],3) ([ A ], 4) >>> knapsack([("a",3,4),("b",2,2),("c",2,3)],4) ([ B, C ], 5) >>> knapsack([("a",3,4),("b",2,2),("c",2,3)],5) ([ A, C ], 7) >>> knapsack([("a",3,4),("b",2,2),("c",2,3)],6) ([ A, C ], 7) >>> knapsack([("a",3,4),("b",2,2),("c",2,3)],7) ([ A, B, C ], 9) What we have done with this algorithm is an example of depth-first search, where we explore the full search space of the problem, to find an optimal solution. Unfortunately this solution is quite inefficient, but since the problem above is NP-complete you probably would not find any better method (and if you do, it is a revolutionary discovery!). 4.2 Stack based search An alternative way to implement a depth-first search is to implement your own stack. Remember that a stack is a data structure which has two operations: push an element to the top of the stack, and pop the element from the top of the stack. In Python, a stack can easily be represented by a list, and you can use the methods l.append(e) and l.pop() to push and pop from the stack. These methods actually modify the list which they are applied to. Notice that the top of the stack is at the end of the list. The following is an implementation of the path finding algorithm using a stack. In practice, this algorithm will perform exactly the same search as a recursive approach. def find_path_df(labyrinth,startx,starty,endx,endy): 12

15 # create initial stack with one element - the path # starting at the given start position stack = [ [(startx,starty)] ] # While the stack is not empty, go on... while stack: # Get the path at the top of the stack current_path = stack.pop() # Get the last place of that path x,y = current_path[-1] # Check if we have reached the goal if true: # *** Add your own goal check here! *** return current_path else: # Check were we can go from here # *** Add your own computation of next steps here! *** next_steps = [] # Add the new paths (one step longer) to the stack for s in next_steps: # *** You may want to perform some check here! *** stack.append(current_path+[s]) return False Now, a very nice thing about the stack-based depth-first algorithm, is that it is very easy to change it to a different search strategy. For instance, you can implement a breadth-first algorithm simply by changing the stack to a queue. Recall that in a queue, you insert elements at one end, and remove them from the other. To insert an element into a queue, you can use q.insert(0,e). 13