print [v*10 for v in l1 if if v1>4]

should read

print [v*10 for v in l1 if if v>4]

The example list is given as:

string_list = ['a', 'b', 'c', 'd',]

The third example under the List and dictionary heading states the following:

string_list[2] # returns 'b'

Actually, since [2] is the offset, and list offsets start with [0],

string_list[2] should actually return 'c' not 'b' .

v1 should be v

In the addlinkref function, the call to the separatewords function appears as separateWords rather than in all lowercase, as it defined within the text of the book. Mixing the two 'spellings' causes an error.

The default value for sigma is printed as 10.0, but this should be 1.0 in order to match the graph and the printed results.

Wrong:

def gaussian(dist,sigma=10.0):
return math.e**(-dist**2/(2*sigma**2))

Right:

def gaussian(dist,sigma=1.0):
return math.e**(-dist**2/(2*sigma**2))

The input vector in the example below is wacky:

>>> numpredict.cumulativegraph(data, (1,1), 120)

To match the graph in Figure 8-10, try the following:

>>> numpredict.cumulativegraph(data,[99,20],120)

(Page 186 in printed version?)

The input vector and the high value are wacky:

>>> numpredict.probabilitygraph(data,(1,1),6)

To match Figure 8-11, try the following:

>>> numpredict.probabilitygraph(data,[99,20],120)

(Page 186?)

reload(recommendations)

is performed before the recommendations module has ever been loaded.

Book gives sim_distance between Lisa and Gene of 0.148148148148. My result was 0.29429805508554946; verified with calculator.

last line of code reads:

return 1/(1+*sqr*t(sum_of_squares))

Should read

return 1/(1+sqrt(sum_of_squares))

AND

Result is given below as 0.148148148148

This is equivalent to 1/(1+5.75)

5.75 is sum_of_squares NOT sqrt(sum_of_squares)

Result should be 0.294298055086

This is (supposedly) the result of using the function 'sim_distance' as it appears on this page, but it actually uses the statement

return 1/(1 + sum_of_squares),

rather than the (correct) statement

return 1/(1 + sqrt(sum_of_squares)).

Apparently, the error is the result of *using* the wrong version of the function, while the correct version is *printed* .

The sim_distance function should return 1/(1+sqrt(sum_of_squares)) rather than 1/(1+sum_of_squares) when inverting the Euclidean distance. The formula for Euclidean distance includes a square root, but the square root is never taken of the sum of all the squares in this segment of code.

In the code snippet for sim_distance:

return 1/(1+sqrt(sum_of_squares))

Shouldn't this be

return 1/(1+sqrt(sum_of_squares/len(si)))

Also, in the example code zip on the companion website, this is

return 1/(1+sum_of_squares)

which should also be

return 1/(1+sqrt(sum_of_squares/len(si)))


I guess this error has no effect when getting recommendations for a single movie or critic; the resulting similarity values deviate, but keep the same order. However, this error has serious effect when ordering similarities over movies/critics. This is done in getting recommendations item based, on page 24.
Am I correct? (If I'm not, please excuse me for this sunday morning observation *yawn* )

Definition of sim_pearson is subject to integer math errors, at least in Python 2.5.1. The number of overlapping elements is saved as "n = len(is)". This is used later to determine the numerator of the formula.

It turns out this can allow the function to return values > 1, for this reason:

13 * 11 / 3 ==> 47

whereas:

13 * 11 / 3.0 ==> 47.666666666666664


Changing the initial line to be "n = float(len(si))" is enough to prevent this.


As someone in a separate errata noted, the function should also return 1.0 if the denominator is 0.

In the pydelicious.py module, an exception is raised when "feedparser" is imported.

The code to split text into words uses this regular expression:

[^A-Z^a-z]

the above includes caret ('^') in the set with the alphabetic characters, so caret will not be used to split words. For example:

>>> re.compile("[^A-Z^a-z]").split("foo^bar")
['foo^bar']


The correct regex is [^A-Za-z]:

>>> re.compile("[^A-Za-z]").split("foo^bar")
['foo', 'bar']

The variable "outersum" is defined but never used.

dist = sum([abs(rows[i] - row[i-1) for row in range(2, len(ow))])

This makes no sense. Presumably sum should be min.

This is a lovely book, but I agree with an earlier submitter, very poorly proofread. This is especially the case as the code isn't commented. Even if the code were error free, it is quite terse and hard for a non Python expert to read. The errors really detract from readability.

Page C has only three links to other pages. It should have four links to other pages.

To be most effective, a call to self.dbcommit() should be inserted after the self.con.execute('drop table if exists pagerank') call (i.e. just after the first command of the calculatepagerank function). This permits calculatepagerank to be called multiple times in a single python session without the database returning an error stating that it already contains a pagerank table, and subsequently remaining locked due to the error.

for d in range(0, len(r), 2):
should be
for d in range(0, len(people)):
Iterating over the schedule is incorrect, the list of people should be iterated over. This is why the out and ret variables are retrieved via r[2*d] and r[2*d+1], respectively. As is, this causes an index out of bounds exception since the length of the schedule is twice the length of the number of people.

The index for the line beginning with out= should be [int(r[2*d])] rather than [r[d]], and the index for the line beginning with ret= should be [int(r[2*d+1])] rather than [r[d+1]].

There is no need to change the range of the for loop in the printschedule function, however, or to reverse any of the destination and origin assignments, as was erroneously reported elsewhere in this errata list.

int(sol[d]) should be int(sol[2*d])
in(sol[d+1]) should be int(sol[2*d+1])

and therefore the calculate result at the next page should be 5469

In theory, you could try every possible combination, but in this example there are 10 flights, all with 6 possibilities, giving a total of 6^10 combinations.

instead of

In theory, you could try every possible combination, but in this example there are 16 flights, all with 9 possibilities, giving a total of 9^16 combinations.

b'cause 6 family members having 10 flights to LGA

I believe that calculation should be:

(10 flights to LGA * 10 flights from LGA) ^ (# of family members) =
(10^2)^6 = 10^12

or in Python,
(10**2)**6 = 10**12

Oh, and 9**16 is much closer to 300 trillion than it is to 300 billion

The randomoptimize function should return bestr, not r.

The domain goes from 0-10, i.e. 0..9 rather than 0..7. (See schedule.txt for confirmation; also on p. 97, 8 could not be included as part of the solution if the highest available value were 7.) This means the line specifying the domain should read:

domain=[(0,10)]*(len(optimization.people)*2)

The spelling of neighbors is inconsistent in the code sample. All instances of the word neighbors/neighbours in the code sample should be changed either to "neighbors" or "neighbours", but not a mix of both.

The mutate function is missing an else clause (or some other mechanism for returning a default value). A possible solution would be to remove the elif conditional and guarantee that the function always returns a value:

# Mutate operation
def mutate(vec):
i=random.randint(0,len(domain)-1)
if random.random()<0.5 and vec[i]>domain[i][0]:
return vec[0:i]+[vec[i]-step]+vec[i+1:]
else:
return vec[0:i]+[vec[i]+step]+vec[i+1:]

the mutate function should has a else clause which return vec. Otherwise None will be added into pop occasionally

The output of dorm.printsolution(s) uses the value of s as generated by s=optimize.randomoptimize(), for a solution cost of 18 (the original generated solution.)

optimize.geneticoptimize() is then called, but the results are not reassigned to s, and the output is confusing.

It might be more clear if this session were changed to:

reload(dorm)
s=optimize.randomoptimize(dorm.domain,dorm.dormcost)
dorm.printsolution(s)
dorm.dormcost(s)
r=optimize.geneticoptimize(dorm.domain,dorm.dormcost)
dorm.printsolution(r)


so that the before and after can be seen.

After importing docclass, the db should be initialized.

cl.setdb('test.db')

Or this line can be added to docclass.py

The recursive calls at the end of the buildtree function should propagate the scoref parameter. Otherwise if you use a scoref function besides the default "entropy" function it will only be used on the first call.

So instead of

trueBranch=buildtree(best_sets[0])

it should be

trueBranch=buildtree(best_sets[0], scoref)

mdclassify function is called qualified by treepredict2, but treepredict2 is neither imported (doesn't exist anyway) or defined anywhere. Changing

treepredict2.mdclassify(['google', 'France',None,None],tree)

to simply

treepredict.mdclassify(['google', 'France',None,None],tree)

appears to generate the intended results.

It appears as though the Zillow API does not return "totalRooms" anymore (assuming it once did). Furthermore, some of the houses that it searches for appear to return no actual values from Zillow, or still cause the exception block to be hit. Later on, when the code asks for len(row) in the variance method of treepredict.py, this will cause "TypeError: object of type 'NoneType' has no len()".

As a work around:

rooms=doc.getElementsByTagName('totalRooms')[0].firstChild.data

should be commented out. Also, in getpricelist() function, change

l1.append(data)

to

if data != None
l1.append(data)


this should prevent null rows getting added and therefore prevent the TypeError exception described above.

the cumulativegraph function is being passed the vector (1,1), which means it will draw the cumulative probability for the price of bottles of wine which have a rating of 1 and are 1 year old. These wine bottles would be so terrible that the cumulative probability would reach 1 at a price of 0, meaning there's nothing to see on the graph generated.

A better example would be to use say a wine bottle rating of 99 that's 10 years old, with a call like:

numpredict.cumulativegraph(data,(99,10),120)

This way, they'll actually be something useful displayed on the graph when its printed and it should look more like Figure 8-10 does.

Like the error on page 186, using the vector (1,1) - a wine bottle with a rating of 1 and 1 year old, means that the wine would be so bad that it would all cost essentially 0. Instead, use a vector like say (99,10).

Also, the value of 6 used for high is quite small. To get something that looks similar to figure 8-11, the value 120 should be used instead. So, the line which reads:

numpredict.probabilitygraph(data,(1,1),6)

should become something like

numpredict.probabilitygraph(data,(99,10),120)

The paragraph after the code sample states "The points will be O if the people are a match and X if they are not." The code sample however draws a scatterplot where people that are a match are represented with a green O and people that are not a match are represented with a red O (not an X). To get a scatterplot that uses red X's instead of red O's, change the line:

plot(xdn,ydn,'ro')

to

plot(xdn,ydn,'rx')

Alternatively, to get a scatterplot that looks like that in figure 9-1 (which uses neither O's nor X's), change the same line:

plot(xdn,ydn,'ro')

to

plot(xdn,ydn,'r+')

If the plotagematches function is really to be called from one's Python session (rather than being added to the advancedclassify.py file) then one does not need to reload advancedclassify, and should only type "plotagematches(agesonly)" instead of "advancedclassify.plotagematches(agesonly)" into the Python session.

There is a sentence which states "There are two other points, X0 and X1, which are examples that have to be classified". The diagram on the other hand uses points X1 and X2, but no X0. I believe that the sentence should be changed to "There are two other points, X1 and X2, which are examples that have to be classified."

The URL for Yahoo! Maps Web Services has changed. The line reading,

'http:\\api.local.yahoo.com/MapServices/V1/'+\

should now read,

'http://local.yahooapis.com/MapsService/V1/'+\

Apparently there are two 824 3rd Avenues in New York city: one that's approximately 0.9 miles from 220 W 42nd St, and another that's about 6.6 miles away. It might be good to include zip codes with some, or all, of the addresses from the matchmaker.csv file to avoid confusion. [The new Yahoo! Maps Services returns the latitude and longitude for the second address - the one that's circa 6.6 miles away - as the default rather than those of the address that's approx. 0.9 miles away, as listed in the book.]

In the book, scaleinput should be defined as:

# Create a function that scales data
def scaleinput(d):
return [(d[i] - low[i]) / (high[i] - low[i]) for i in range(len(low))]

In the printed copy, the return statement tries to access d.data[i], even though the data member was passed in to scaleinput, in both scaledata and in the interpreter example below the code.

Just above the definition of the rbf function there should be an

import math

statement to ensure that the constant math.e is defined.

To be in accordance with the other gammas, and with the code listed in PCI_code.zip, the first line of the rbf function definition should read,

def rbf(v1, v2, gamma=10):

For the purposes of the book, I believe that the gamma parameter is always explicitly passed, however.

Before you can execute any of the statements, you first need to reload advancedclassify using:

reload(advancedclassify)

The book also never defines the variable "offset" which is being parsed into the nlclassify function. I'm not sure what a reasonable value for this would be.

Just after the missing reload(advancedclassify) statement (See Bryce's comment for more), one should execute

offset=advancedclassify.getoffset(agesonly)

To properly define the otherwise undefined offset. This should produce a value of some -0.0076450020098023288.

The lines reading,

m.save(test.model)
m=svm_model(test.model)

should read,

m.save('test.model')
m=svm_model('test.model')

Also, in order for the svmc.pyd file to work with your Python environment, it must be of the correct version. The svmc.pyd file included in PCI_code.zip is for Python 2.4, the one available from the LIBSVM website (as of November 3, 2009) is for Python 2.6. I used this website to get a version that works with Python 2.5: <http://www.cs.sunysb.edu/~algorith/implement/libsvm/distrib/>. [It's also possible to build the svmc.pyd with C.]

isinstance(t, node):

should read

hasattr(t, 'children'):

The former does not function correctly (under Python 2.5.2 at any rate).

The line

if isinstance(t1, node) and isinstance(t2, node):

should read

if hasattr(t1, 'children') and hasattr(t2, 'children'):

The former does not allow the program to converge to the correct solution. [The latter code snippet also appears in the book's source code as distributed in PCI_Code.zip.]

As currently presented, the when there is a tie between players i and j it is as if player i lost. Presently the code reads,

elif winner==-1:
losses[i]+=1
losses[i]+=1
pass

However, it should read,

elif winner==-1:
losses[i]+=1
losses[j]+=1
pass

Applying this change (replacing the second losses[i] with losses[j]) will assist in evolving improved game-playing AI. [The above error appears in the online code, PCI_code.zip, as well.]

The command should be
$ tar xvf numpy-1.0.2.tar
instead of
$ tar xvf numpy-1.0.2.tar.gz