集体智慧编程第十一章---用java编写(小部分)

<<集体智慧编程>>的第十一章是有关遗传编程的话题，书中提到本章将考查一种截然不同的问题解决方法。与先前遇到一个问题就选择一种算法的思路不同，我们将编写一个程序，尝试自动构造出解决某一问题的最佳程序。因而从本质上，我们将要构造的是一个能够构造算法的算法。

本章最后实现了一个能人机对战的AI，虽然比较粗糙，但还是觉得挺有趣，于是想自己实现一次里面的代码。书中代码是用python编写的，但是想试下用不同的语言实现同一个机器学习算法，举一反三，之前接触的机器学习算法都是用python，没试过java，于是打算用java编写一次。

此算法需要先构造一棵程序解析树。

相当于

def func(x,y)

if x > 3:

return y + 5

else:

return y - 2

书中的Python2代码:

from random import random,randint,choice
from copy import deepcopy
from math import log

class fwrapper:
  def __init__(self,function,childcount,name):
    self.function=function
    self.childcount=childcount
    self.name=name

class node:
  def __init__(self,fw,children):
    self.function=fw.function
    self.name=fw.name
    self.children=children

  def evaluate(self,inp):    
    results=[n.evaluate(inp) for n in self.children]
    return self.function(results)
  def display(self,indent=0):
    print ((' '*indent)+self.name)
    for c in self.children:
      c.display(indent+1)
    

class paramnode:
  def __init__(self,idx):
    self.idx=idx

  def evaluate(self,inp):
    return inp[self.idx]
  def display(self,indent=0):
    print ('%sp%d' % (' '*indent,self.idx))
    
    
class constnode:
  def __init__(self,v):
    self.v=v
  def evaluate(self,inp):
    return self.v
  def display(self,indent=0):
    print ('%s%d' % (' '*indent,self.v))
    

addw=fwrapper(lambda l:l[0]+l[1],2,'add')
subw=fwrapper(lambda l:l[0]-l[1],2,'subtract') 
mulw=fwrapper(lambda l:l[0]*l[1],2,'multiply')

def iffunc(l):
  if l[0]>0: return l[1]
  else: return l[2]
ifw=fwrapper(iffunc,3,'if')

def isgreater(l):
  if l[0]>l[1]: return 1
  else: return 0
gtw=fwrapper(isgreater,2,'isgreater')

flist=[addw,mulw,ifw,gtw,subw]

def exampletree():
  return node(ifw,[
                  node(gtw,[paramnode(0),constnode(3)]),
                  node(addw,[paramnode(1),constnode(5)]),
                  node(subw,[paramnode(1),constnode(2)]),
                  ]
              )

个别类的说明

fwrapper

一个封装类，对应于“函数型”节点上的函数。其成员变量包括了函数名称、函数本身，以及该函数接受的参数个数

node

对应于函数型节点（即带子节点的节点）。我们以一个fwrapper类对其进行初始化。当evaluate被调用时，我们会对各个子节点进行求值运算，然后再将函数本身应用于求得的结果

paramnode

这个类对应的节点只返回传递给程序的某个参数。其evaluate方法返回的是由idx指定的函数

constnode

返回常量值的节点。其evaluate方法返回该类初始化时所传入的值

程序运行代码结果:

>>>import gp

>>>exampletree = gp.exampletree()

>>>exampletree.evaluate([2,3])

1

>>>exampletree.evaluate([5,3])

8

>>>exampletree.display()

if

  isgreater

    p0

    3

  add

    p1

    5

  subtract

    p1

    2

java代码:

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;


public class Chapter11Test {
    private FWrapper addw ,subw ,mulw ,ifw , gtw ;
    private List<FWrapper> flist ;
    private static Chapter11Test obj = new Chapter11Test();

    int addfunc(List<Integer> l){
        return l.get(0)+l.get(1);
    }

    int subfunc(List<Integer> l){
        return l.get(0)-l.get(1);
    }

    int mulfunc(List<Integer> l){
        return l.get(0)*l.get(1);
    }

    int iffunc(List<Integer> l){
        if(l.get(0) > 0) return l.get(1);
        else return l.get(2);
    }

    int isgreater(List<Integer> l){
        if(l.get(0) > l.get(1)) return 1;
        else return 0;
    }

    private Node exampletree(){
        return new Node(ifw,new Object[]{
                new Node(gtw,new Object[]{new ParamNode(0),new ConstNode(3)}),
                new Node(addw,new Object[]{new ParamNode(1),new ConstNode(5)}),
                new Node(subw,new Object[]{new ParamNode(1),new ConstNode(2)})
        });
    }

    private void beginTest() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException {
        addw = new FWrapper(obj.getClass().getDeclaredMethod("addfunc",List.class), 2 ,"add");
        subw = new FWrapper(obj.getClass().getDeclaredMethod("subfunc",List.class), 2 ,"subtract");
        mulw = new FWrapper(obj.getClass().getDeclaredMethod("mulfunc",List.class), 2 ,"multiply");
        ifw = new FWrapper(obj.getClass().getDeclaredMethod("iffunc",List.class), 3 ,"if");
        gtw = new FWrapper(obj.getClass().getDeclaredMethod("isgreater",List.class), 2 ,"isgreater");
        flist = new ArrayList<>(Arrays.asList(addw,subw,mulw,ifw,gtw));
        Scanner reader = new Scanner(System.in);
        System.out.println("请输入参数X,Y :");
        int X = reader.nextInt();
        int Y = reader.nextInt();
        System.out.println("exampletree.evaluate(["+X+","+Y+"])");
        System.out.println(exampletree().evaluate(new int[]{X,Y}));
        System.out.println("exampletree.display()");
        exampletree().display(0);

    }


    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException {
        obj.beginTest();
    }


    class FWrapper{
        Method function;
        int childcount;
        String name;
        FWrapper(Method function,int childcount,String name){
            this.function = function;
            this.childcount = childcount;
            this.name = name;
        }
    }

    class Node{
        //private Method function;
        private FWrapper fw;
        private Object[] children;
        private String name;
        Node(FWrapper fw,Object[] children){
            this.fw = fw;
            this.name = fw.name;
            this.children = children;

        }

        public int evaluate(int[] inp) throws NoSuchMethodException, IllegalAccessException, ClassNotFoundException, InvocationTargetException {

            List<Integer> results = new ArrayList<>();
            for (int i = 0; i < children.length; i++) {
                int result = (Integer)children[i].getClass().getDeclaredMethod("evaluate",Class.forName("[I")).invoke(children[i],inp);
                results.add(result);
            }
            return (Integer)fw.function.invoke(obj,results);

        }

        public void display(int indent) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
            String indents="";
            for (int i = 0; i < indent; i++)
                indents+=" ";
            System.out.println(indents + name);
            for(Object c: children)
                c.getClass().getDeclaredMethod("display",int.class).invoke(c,indent+1);
        }
    }

    class ParamNode{
        private int idx;
        ParamNode(int idx){
            this.idx = idx;
        }

        public int evaluate(int[] inp){
            return inp[idx];
        }

        public void display(int indent){
            String indents="";
            for (int i = 0; i < indent; i++)
                indents+=" ";
            System.out.println(indents+"p"+idx);
        }
    }

    class ConstNode{
        private int v ;
        ConstNode(int v){
            this.v = v;
        }

        public int evaluate(int[] inp){
            return v;
        }

        public void display(int indent){
            String indents="";
            for (int i = 0; i < indent; i++)
                indents+=" ";
            System.out.println(indents+v);
        }
    }
}

java代码里的class和方法基本和python里的class和函数对应，这样写其实意义不大...代码比较烂，但是也从中学到一点java反射的知识，尤其是Method类的invoke。

运行结果也一样
请输入参数X,Y :
5
3
exampletree.evaluate([5,3])
8
exampletree.display()
if
 isgreater
  p0
  3
 add
  p1
  5
 subtract
  p1
  2


这次没有完整实现整章的算法，但以上的内容是本章后面的算法的基础。