BoneCP：http://jolbox.com/

2) “converters.py”, 去掉这行:
from sets import BaseSet, Set

3) “converters.py”, 将“Set”改为“set” 只有两处，如下：
line 48: return set([ i for i in s.split(',') if i ])
line 128: set: Set2Str,

看新项目的领域完全和自己所学习过的东西不一样，看来有很多的事情要做了。几个事情都纠结在了一起，但是又不得不做，自己怎么来整理头绪？

Del.icio.us : tools

比如说可以用渐进的策略，一点点的改善，尽量取得共赢。也可以休克的来做，直接推翻了重来，不过这个似乎不是解决问题，而且规避问题。因为解决问题太麻烦，不如消灭了算了。只是副作用当然也很大，看自己如何来衡量了。

解决问题，从内外两个方面来找源头，如果可以从源头上解决问题，那么问题的解决应该是很容易的，不论是消灭问题还是解决问题，从源头上解决都是个好方法。只是自己能不能找对源头呢？也许不一定是那个自己认为的源头……也许当我再过几十年回首的时候才能看清楚自己现在的问题究竟是问题在哪里，也许，也只是也许了。

还是不知道。不禁想起了以前看的一句话：既然我避免不了那个结局，那就拒绝那个开始。

Del.icio.us : solve problem

建立一个简单的分类器只要70来行的python代码，也不需要太复杂的什么依赖包之类的，真好~就像是遗传编程那个部分的例子一样，写代码看到成果的感觉真让人开心

下来是朴素的分类器，称之为naive bayes的简单分类器，确实比较容易~连我都看得懂……

Del.icio.us : classifier

真有趣~

Del.icio.us : phd

# distance function
distancew = fwrapper(lambda p:(p[0]-p[2])**2+(p[1]-p[3])**2,4,'distance')
flist = [addw,mulw,ifw,gtw,subw,distancew]

然后重新启动测试，结果很神奇，相较于上一次，直观的感觉就是GP果然nb很多了啊，大约是一段时间以后，AP已经没法前十了，一般都是在20名以后：

gp/74 gp/82 gp/85 gp/90 gp/91 gp/92 gp/93 gp/94 gp/96 gp/101 apr:24
gp/66 gp/79 gp/80 gp/85 gp/86 gp/86 gp/90 gp/91 gp/92 gp/92 apr:32
gp/85 gp/86 gp/90 gp/91 gp/92 gp/95 gp/98 gp/99 gp/99 gp/102 apr:40
gp/80 gp/83 gp/90 gp/92 gp/92 gp/93 gp/94 gp/96 gp/96 gp/97 apr:27
gp/75 gp/80 gp/82 gp/88 gp/88 gp/91 gp/92 gp/94 gp/94 gp/96 apr:40
gp/75 gp/78 gp/80 gp/82 gp/84 gp/89 gp/90 gp/92 gp/93 gp/95 apr:22
gp/69 gp/70 gp/71 gp/71 gp/83 gp/91 gp/93 gp/95 gp/97 gp/98 apr:20
gp/64 gp/68 gp/70 gp/71 gp/71 gp/75 gp/81 gp/87 gp/92 gp/92 apr:28
gp/83 gp/84 gp/85 gp/92 gp/93 gp/93 gp/94 gp/98 gp/100 gp/100 apr:28
gp/82 gp/82 gp/86 gp/88 gp/89 gp/94 gp/95 gp/96 gp/98 gp/100 apr:30
gp/66 gp/75 gp/84 gp/85 gp/87 gp/88 gp/90 gp/91 gp/91 gp/91 apr:31
gp/74 gp/79 gp/81 gp/85 gp/86 gp/86 gp/92 gp/93 gp/98 gp/99 apr:22
gp/67 gp/71 gp/78 gp/81 gp/81 gp/84 gp/85 gp/89 gp/90 gp/96 apr:27
gp/76 gp/78 gp/78 gp/81 gp/83 gp/84 gp/84 gp/88 gp/89 gp/91 apr:29
gp/65 gp/75 gp/75 gp/79 gp/81 gp/82 gp/84 gp/85 gp/85 gp/87 apr:17
gp/62 gp/70 gp/75 gp/82 gp/86 gp/87 gp/88 gp/89 gp/93 gp/93 apr:29
gp/66 gp/76 gp/76 gp/77 gp/78 gp/78 gp/80 gp/80 gp/81 gp/88 apr:19
gp/71 gp/76 gp/83 gp/83 gp/86 gp/88 gp/88 gp/91 gp/93 gp/95 apr:26
gp/79 gp/87 gp/87 gp/90 gp/90 gp/95 gp/98 gp/101 gp/104 gp/106 apr:27

嗯，基础函数真神奇，书里边对这个也有说明，只要增加基础函数，就有可能让程序有很大的进步，比如现在平均的得分大约是70，那么也就是说现在排名第一程序只输了35次，在200次的比赛中只输3次，还是挺不错的~

那么，不知道和真人的水平相比如何……加赛！稍微修改了一下，在return之前：

gridgame([humanplayer(),scores[0][1]])

这样就可以加赛了~

不过这个随机性很强……这次开始ap总是处于不败……为什么呢？

ap/62 gp/75 gp/77 gp/87 gp/97 gp/98 gp/104 gp/107 gp/112 gp/112 apr:0
ap/65 gp/74 gp/92 gp/94 gp/105 gp/107 gp/109 gp/109 gp/111 gp/126 apr:0
ap/77 gp/104 gp/104 gp/105 gp/109 gp/114 gp/118 gp/118 gp/119 gp/121 apr:0
ap/66 gp/92 gp/102 gp/104 gp/105 gp/105 gp/106 gp/109 gp/110 gp/116 apr:0
ap/88 gp/92 gp/104 gp/105 gp/105 gp/108 gp/109 gp/110 gp/110 gp/111 apr:0
ap/62 gp/96 gp/102 gp/112 gp/112 gp/112 gp/113 gp/115 gp/115 gp/115 apr:0
ap/99 gp/119 gp/127 gp/128 gp/129 gp/133 gp/133 gp/134 gp/134 gp/134 apr:0
ap/69 gp/92 gp/98 gp/102 gp/104 gp/105 gp/109 gp/109 gp/109 gp/110 apr:0
ap/98 gp/114 gp/121 gp/132 gp/132 gp/133 gp/134 gp/134 gp/135 gp/136 apr:0
ap/76 gp/103 gp/107 gp/108 gp/108 gp/113 gp/114 gp/115 gp/115 gp/115 apr:0
ap/60 gp/95 gp/105 gp/107 gp/107 gp/108 gp/109 gp/110 gp/111 gp/113 apr:0
ap/82 gp/111 gp/119 gp/124 gp/126 gp/127 gp/128 gp/129 gp/129 gp/130 apr:0
ap/87 gp/107 gp/107 gp/108 gp/108 gp/110 gp/110 gp/110 gp/113 gp/113 apr:0
ap/84 gp/100 gp/112 gp/114 gp/114 gp/115 gp/115 gp/116 gp/118 gp/120 apr:0
ap/72 gp/92 gp/94 gp/101 gp/103 gp/104 gp/104 gp/107 gp/109 gp/110 apr:0
ap/68 gp/95 gp/109 gp/110 gp/110 gp/110 gp/112 gp/114 gp/115 gp/115 apr:0

Del.icio.us : genetic programming

首先是我的算法，因为传入的参数也比较少，所以能够做的很简单，就是根据当前的距离，尽量逼近对方的位置：

class simpleplayer:

def gonear(self,me,lastmove,others):
predict = []
for i in range(4):
if i==lastmove: continue
if i==0 and me[0]<>0:
predict.append(((me[0]-1-others[0][0])**2+(me[1]-others[0][1])**2,i))
elif i==1 and me[0]<>3:
predict.append(((me[0]+1-others[0][0])**2+(me[1]-others[0][1])**2,i))
elif i==2 and me[1]<>0:
predict.append(((me[0]-others[0][0])**2+(me[1]-1-others[0][1])**2,i))
elif i==3 and me[1]<>3:
predict.append(((me[0]-others[0][0])**2+(me[1]+1-others[0][1])**2,i))
return min(predict)[1]

def evaluate(self,board):
me = tuple(board[0:2])
lastmove = board[len(board)-1]
others = [tuple(board[x:x+2]) for x in range(2,len(board)-1,2)]
return self.gonear(me,lastmove,others)

然后是要对循环赛的程序做一些修改，达到这些目标：

1 希望能够看到每一轮战况的汇报，也就是说要看到AP和GP的输赢情况。

2 在下一轮中，AP保持不变，GP要进行进化

那么需要改变一下evolve函数函数：

def evolvewithap(ap,pc,popsize,rankfunction,maxgen=500,
mutationrate=0.1,breedingrate=0.4,pexp=0.7,pnew=0.05):
def selectindex(aprank):
while True:
i = int(log(random())/log(pexp))
if i<>aprank: return i

# create a lot
population = [randomtree(pc) for i in range(popsize)]
# put the ap
population.append(ap)

for i in range(maxgen):
scores = rankfunction(population)

# display the top 10
# if the ap is out of top 10, tournament break
aprank = -1
newpop = []
for i in range(len(scores)):
if isinstance(scores[i][1],simpleplayer):
aprank = i
if i<10:
print 'ap/%d ' % scores[i][0] ,
else:
break
elif i<10:
print 'gp/%d ' % scores[i][0] ,
newpop.append(scores[i][1])

if aprank > 50: break
print ' apr:%d' % aprank

# create the next generation
while len(newpop)<popsize:
if random()>pnew:
newpop.append(mutate(
crossover(scores[selectindex(aprank)][1],
scores[selectindex(aprank)][1],
probswap=breedingrate),
pc,
probchange=mutationrate))
else:
newpop.append(randomtree(pc))
# put the ap
newpop.append(ap)
population = newpop
# evolve over
scores[0][1].display()
return scores[0][1]

最后，进行测试：

import gp

gp.evolvewithap(gp.simpleplayer(),5,100,gp.tournament,
mutationrate=0.2,breedingrate=0.1,pexp=0.7,pnew=0.1)

运行的一部分结果如下：

ap/100 gp/103 gp/104 gp/106 gp/108 gp/109 gp/112 gp/113 gp/114 gp/117 apr:0
gp/93 gp/94 gp/95 gp/96 gp/99 gp/100 gp/100 gp/100 gp/100 gp/104 apr:10
gp/94 gp/99 gp/99 gp/100 gp/100 gp/100 gp/102 ap/102 gp/109 gp/109 apr:7
gp/85 gp/86 gp/88 gp/91 ap/92 gp/92 gp/93 gp/93 gp/94 gp/96 apr:4
gp/90 gp/102 ap/104 gp/106 gp/108 gp/110 gp/111 gp/112 gp/113 gp/115 apr:2
gp/88 ap/93 gp/101 gp/101 gp/101 gp/104 gp/104 gp/113 gp/114 gp/114 apr:1
gp/92 gp/94 gp/96 ap/97 gp/100 gp/101 gp/106 gp/106 gp/108 gp/111 apr:3
gp/87 gp/92 gp/96 gp/98 gp/105 gp/108 gp/110 gp/112 gp/112 gp/115 apr:10
gp/89 ap/96 gp/101 gp/102 gp/104 gp/104 gp/105 gp/107 gp/107 gp/108 apr:1
gp/87 gp/95 gp/96 gp/101 ap/102 gp/102 gp/105 gp/105 gp/106 gp/107 apr:4
gp/86 gp/90 gp/93 gp/97 gp/101 gp/101 gp/105 gp/105 gp/105 gp/106 apr:13
gp/81 gp/82 gp/82 gp/83 gp/83 gp/85 gp/88 gp/93 gp/95 gp/99 apr:13
gp/85 gp/89 gp/90 ap/91 gp/96 gp/97 gp/97 gp/97 gp/99 gp/101 apr:3
gp/84 gp/85 gp/86 gp/90 gp/91 gp/93 gp/94 gp/94 gp/95 ap/98 apr:9

从结果来看……这个算法总体比遗传算法能强一些，不过偶尔也有跌出前十名的情况，还以为能把gp的程序训练的好一些，不过似乎在目前很基础的这些函数面前，能做到这个程度已经很不错的，下来如果要改进的话，需要在基础函数方面增加一些东西吧？

Del.icio.us : genetic programming