Week 6 Homework

NOTE: due before class Tuesday
NOTE CHANGE OF MIDTERM DATE ON COURSE PAGE

Homework Problems From Art Farely's Talk

No problems in homework. However, for midterm, be able to summarize his talk.

Homework Problems From Textbook Reading

Homework Problems From Turing Test

My sentence 1: My sentence 2: My sentence 3: My sentence 4: My sentence 5: My sentence 6: My sentence 7: My sentence 8: My sentence 9: My sentence 10:

Homework Problems From Ruby

I don't want to lose momentum with Ruby, so will ask you to complete a couple of problems.

My overall goal on the Ruby side is to get to a place where we can explore RK's conjecture that the Internet is a vast knowledge base that some strong AI could use. We won't be attempting to build a strong AI in class. More like a really wimpy AI. But still one that accesses information on the web.

To do this, we will need to do several things. First, we will need to get information off of the web. This is not too difficult in Ruby. Second, we will need to take the raw information we get and break it into pieces. This is also not too difficult in Ruby. Third, we need to take the pieces and make sense of it. This is way hard in any language. It's really what makes an AI "strong". We will work mainly with steps one and two for now.

Below is some code that pulls some information off the web. In particular, it accesses a page on the web and puts it in a Ruby string.

require 'net/http' require 'uri' def get_page(site,path) the_page = site + path #builds larger string out of two pieces res = Net::HTTP.get URI.parse(the_page) return res #should be raw html end

Copy the code above into your playground (fxri). Now let's try it out. Type this in the playground (or copy and paste it from this page):

s = 'http://www.cs.uoregon.edu/classes/08W/cis170' p = '/homework/week4-homework.html' h = get_page(s,p)

What you see is the raw html for the homework 4 page. Much of the web is written in html. So if we want to use the web, we will have to figure out how to deal with html. And to do that, we will have to learn some ways to take a large, ugly string like what is in h, and break it into digestible pieces. Ruby has a large number of methods for manipulating strings, so it is a good fit for our problem of pulling stuff off the web and then digesting it. For instance, copy the definition below into your playground:

def get_rules(raw_html) rules = raw_html[/<xmp id='rules'>(.*)<\/xmp>/m] #uses regular expression rules = rules.delete("\t") #uses dot method return rules end

The first line makes use of a "regular expression": the text between the two forward slashes, i.e., /.../m. This is a pattern that can match against a string. The pattern between the slashes says find all occurences in raw_html that start with <xmp id='rules'> and end with <xmp>. The (.*) matches everything in between. The m at the end says search over multiple lines.

The next line makes use of a "dot method". It has the form of a variable name followed by a dot (period), followed be a method name. You should read this as "apply the method delete to the data in the variable rules." Given that the variable rules holds an html string, the dot-method delete will remove all tabs (denoted by \t) from that string.

Let's see if it works. Type/copy the code below into the playground and see what you get.

r = get_rules(h) => "<xmp id='rules'>\n\nabc => de\n000 => 00\n001 => 10\n010 => 10\n011 => 01\n100 => 10\n101 => 01\n110 => 01\n111 => 11\n\n</xmp>"

Cool, huh. You've managed to pull out the raw rules from the giant ugly string. (Note that the \n represents a newline/enter/carriage-return.) Eventually we will see if we can stick the rules in the cloud. Kind of our first wimpy AI: a program that can find rules on the web and then download them to its own "brain".

Stay in the playground to answer the following questions. Your turn-in will be the results from the playground. You can use control-c to copy from fxri and then paste that into a text document that you turn-in as homework.

These questions assume you have a variable r that holds the string shown above. You can test this out by typing r enter/return and checking you get the string with rules.

Let's see if we can pull out just the rules. Using the regular expression in the get_rules method (above) as an example, construct a new expression that produces below:
where you have to fill in the ..., i.e., replace the dots with your regular expression. This is your first turn-in.
Your second (and last) problem is to look at the rules one by one. There is a cool dot-method for a string splitting on the newline char, i.e., \n. In this way, we can split up just_rules into individual rules, i.e., "000 => 00", etc. I've given you the skeleton of how to do this below. Your job is complete the code where I have the two comments. Copy and paste the code below into your playground and see what happens.
You should see the full rule being printed for both lhs and rhs. This is not what we want. For each rule, we want to pull out the pieces. When you have finished, you should see this:
As a hint, I'll tell you there is a dot-method slice that takes two arguments, the first is a starting position in the string, and the second is a count. As an example, "abcd".slice(0,1) will give the value "a": it starts at the 0th position (first char in the string) and returns one char starting there. The value of "abcd".slice(2, 2) is "cd": it starts at the 2nd position (3rd char in string) and returns 2 chars starting there.
When you get the right answer, turn-in your just_rule.each_line code.

In summary, you have two turn-ins which you should perfect in the playground and then copy and paste the code into a text document and turn-in.

For the curious, if I were going to follow our examples above to conclusion, I would work on the idea that I could build up the $cloud container by something along the lines of: