python 2.7 , Geneties Programmeren

Status
Niet open voor verdere reacties.

blua tigro

Gebruiker
Lid geworden
21 apr 2009
Berichten
48
dit is een poging tot GP in python 2.7

licentie :
je mag deze code gebruiken voor studie
je clamt deze code NIET als je eigen werk
opmerkingen | verbeteringen zijn welkom
meld trypo's aub

GP wat :
het berekenen van n formule uit n tabel of grafiek

GP hoe :
1 : schijf n array van formules [ GP.write() ]
2 : bereken uitvoer van formules [ GP.run() ]
3 : sorteer formules op fout uitvoer [ evaluate() ]
4 : beste formules maken kinderen [ GP.mix() ]
5 : somige kinderen worden gemuteerd [ GP.mutate() ]
6 : als generatie < max en beste.fout > gewenst dan ganaar 2

Code:
# bluatigro 28 nov 2017
# GP pytagoras.py

from GeneProg import *

# first create prorgams
GP.use( ADD )
GP.use( SUB )
GP.use( DIV )
GP.use( MUL )
GP.use( SQRT )
GP.intlist()
GP.setvarmax( 2 , 20 )
for i in xrange( len( program ) ) :
    program[ i ] = GP.write( 6 )

for generation in xrange( 10 ) :
    # let programs live and breed
    for i in xrange( len( program ) ) :
        # for al programs
        f = 0.0
        for a in xrange( -10 , 10 ) :
            for b in xrange( -10 , 10 ) : 
                GP.setvar( 'a' , a )
                GP.setvar( 'b' , b )
                uit = GP.run( program[ i ] ) # calc output
                if uit == 'error' : # if error in program
                    f += 1e10
                else :
                    wish = math.sqrt( a*a+b*b )
                    f += abs( wish - float( uit ) )
        fout[ i ] += f * f
    evaluate() # next generation

print '[ end calc pytagoras ]'
Code:
# bluatigro 28 nov 2017
# GP pi.py
from GeneProg import *

# first create prorgams
GP.use( ADD )
GP.use( SUB )
GP.use( DIV )
GP.use( MUL )
GP.use( SQRT )
GP.intlist()
for i in xrange( len( program ) ) :
    program[ i ] = GP.write( 6 )
print '[ calc pi ]'
for generation in xrange( 100 ) :
    # let programs live and breed
    for i in xrange( len( program ) ) :
        # for al programs
        uit = GP.run( program[ i ] ) # calc output
        if uit == 'error' : # if error in program
            fout[ i ] = 1e10
        else :
            fout[ i ] = abs( math.pi - float( uit ) )
    evaluate() # next generation

print '[ end calc pi ]'
Code:
# bluatigro 28 nov 2017
# GenetProg.py

import math , random

letters = 'abcdefgh'

def isnumber( x ) :
    try :
        dummy = float( x )
    except :
        return False
    return True
def isvar( x ) :
    return letters.find( x ) != -1 and len( x ) == 1
def isgene( x ) :
    return x[ 0 ] == '['

ADD = '[ + # # ]'
SUB = '[ - # # ]'
DIV = '[ / # # ]'
MUL = '[ * # # ]'
SQRT = '[ sqrt # # ]'

def rand( i ) :
    return random.randint( 0 , i )

class GeneProg() :

    def __init__( self ) :
        self.genes = list()
        self.nubermode = 0
        self.proglenmax = 400
        self.varmax = 0
        self.var = dict()
        for i in xrange( len( letters ) ) :
            self.var[ letters[ i ] ] = 0.0
             
    def run( self , prog ) :
        if prog == '' :
            return 'error'
        while prog.find( ']' ) != -1 :
            einde = prog.find( ']' )
            begin = einde
            while prog[ begin ] != '[' :
                begin -= 1
            part = prog[ begin : einde + 1 ]
            lst = part.split()
            function = lst[ 1 ]
            a = lst[ 2 ] 
            b = lst[ 3 ] 
            if isvar( a ) :
                a = self.var[ a ]
            elif isnumber( a ) :
                a = float( a )
            else :
                return 'error'
            if isvar( b ) :
                b = self.var[ b ]
            elif isnumber( b ) :
                b = float( b )
            else :
                return 'error'
            ab = 0.0
            try :
                if ( function == '+' ) :
                    ab = a + b
                elif ( function == '-' ) :
                    ab = a - b
                elif ( function == '/' ) :
                    ab = a / b  
                elif ( function == '*' ) :
                    ab = a * b
                elif ( function == 'sqrt' ) :
                    ab = math.sqrt( a )
                else :
                    return 'error'
            except :
                return 'error'
            prog = prog[ : begin ] + str( ab ) + prog[ einde + 1 : ]
        if prog[ 0 ] == '[' :
            prog = prog[ 1 : ]
        while prog[ 0 ] == ' ' :
            prog = prog[ 1 : ]
        return prog

    def use( self , gen ) :
        self.genes.append( gen )

    def intlist( self ) :
        for i in xrange( 31 ) :
            self.use( str( 2 ** i ) )
            self.use( str( -( 2 ** i ) ) )
        self.numbermode = 1

    def dbllist( self ) :
        for i in xrange( -31 , 31 ) :
            self.use( str( 2 ** i ) )
            self.use( str( -( 2 ** i ) ) )
        self.numbermode = 2

    def setvarmax( self , x , k ) :
        if x < 1 or x > len( letters ) - 1 :
            return
        for j in xrange( k ) :
            for i in xrange( x ) :
                self.use( letters[ i ] ) 
        self.varmax = x

    def setvar( self , no , x ) :
        p = letters.find( no )
        if p < 0 :
            return
        self.var[ no ] = x
        
    def write( self , hookmax ) :
        dice = rand( len( self.genes ) - 1 )
        while not isgene( self.genes[ dice ] ) :
            dice = rand( len( self.genes ) - 1 )
        seed = self.genes[ dice ]
        hook = 0
        while hook < hookmax and seed.find( '#' ) != -1 :
            p = seed.find( '#' )
            l = seed[ : p ]
            r = seed[ p + 1 : ]
            dice = rand( len( self.genes ) - 1 )
            gen = self.genes[ dice ]
            if isgene( gen ) :
                hook += 1
            seed = l + gen + r
        return self.lastsharp( seed )
        # return seed

    def lastsharp( self , seed ) :
        l = ''
        r = ''
        gen = ''
        while seed.find( '#' ) != -1 :
            p = seed.find( '#' )
            l = seed[ : p ]
            r = seed[ p + 1 : ]
            dice = rand( len( self.genes ) - 1 )
            gen = self.genes[ dice ]
            while isgene( gen ) :
                dice = rand( len( self.genes ) - 1 )
                gen = self.genes[ dice ]
            seed = l + gen + r
        return seed

    def growth( self , seed ) :
        dice = rand( len( self.genes ) - 1 )
        gen = self.genes[ dice ]
        while not isgene( gen ) :
            dice = rand( len( self.genes ) - 1 )
            gen = self.genes[ dice ]
        lst = seed.split()
        d = rand( len( lst ) - 1 )
        while not isvar( lst[ d ] ) and not isnumber( lst[ d ] ) :
            d = rand( len( lst ) - 1 )
        lst[ d ] = gen
        uit = ''
        for i in lst :
            uit += i + ' '
        return self.lastsharp( uit )

    def mix( self , proga , progb ) :
        lista = []
        if random.random() < .5 :
            proga , progb = progb , proga
        for i in xrange( len( proga ) - 1 ) :
            if proga[ i ] == '[' :
                lista.append( i )
        begina = lista[ rand( len( lista ) - 1 ) ]
        eindea = begina + 1
        fl = 0
        while fl >= 0 :
            eindea += 1
            if proga[ eindea ] == '[' :
                fl += 1
            if proga[ eindea ] == ']' :
                fl -= 1
        listb = []
        for i in xrange( len( progb ) - 1 ) :
            if progb[ i ] == '[' :
                listb.append( i )
        beginb = listb[ rand( len( listb ) - 1 ) ]
        eindeb = beginb + 1
        fl = 0
        while fl >= 0 :
            eindeb += 1
            if progb[ eindeb ] == '[' :
                fl += 1
            if progb[ eindeb ] == ']' :
                fl -= 1
        l = proga[ : begina ]
        m = progb[ beginb : eindeb + 1]
        r = proga[ eindea + 1 : ]
        if r == ']' :
            r = ''
        return l + m + r

    def mutate( self , prog ) :
        lst = prog.split()
        dice = rand( len( lst ) - 1 )
        while lst[ dice ] == '[' or lst[ dice ] == ']' :
            dice = rand( len( lst ) - 1 )
        atom = lst[ dice ]
        if isnumber( atom ) :
            if self.numbermode == 1 :
                f = float( atom )
                if random.random() < .5 :
                    f += 2 ** rand( 31 )
                else :
                    f -= 2 ** rand( 31 )
            else :
                f = float( atom ) 
                if random.random() < .5 :
                    f += 2 ** random.randint( -31 , 31 )
                else :
                    f -= 2 ** random.randint( -31 , 31 )
            atom = str( f )
            if self.varmax != 0 :
                if random.random() < .1 :
                    atom = letters[ rand( self.varmax ) ]
        elif isvar( atom ) :
            if random.random() < .9 :
                atom = letters[ rand( self.varmax ) ]
            else :
                if self.numbermode == 1 :
                    atom = 2 ** rand( 31 )
                else :
                    atom = 2 ** random.randint( -31 , 31 )
                atom = str( atom )
            
        else : # atom is operator
            dice2 = rand( len( self.genes ) - 1 )
            while not isgene( self.genes[ dice2 ] ) :
                dice2 = rand( len( self.genes ) - 1 )
            gen = self.genes[ dice2 ]
            l = gen.split()
            atom = l[ 1 ]

        lst[ dice ] = atom

        uit = ''
        for i in lst :
            uit += i + ' '
        if len( uit ) < self.proglenmax :
            if random.random() < .1 :
                uit = self.growth( uit )
        return uit

program = []
fout = []

for i in xrange( 2000 ) :
    program.append( '' )
    fout.append( 0.0 )
                 
GP = GeneProg()

def evaluate() :
    for high in xrange( 1 , len( program ) - 1 ) :
        for low in xrange( 0 , high - 1 ) :
            if fout[ high ] < fout[ low ] :
                program[ high ] , program[ low ] = program[ low ] , program[ high ]
                fout[ high ] , fout[ low ] = fout[ low ] , fout[ high ]
    print program[ 0 ]
    print fout[ 0 ]
    for i in xrange( 20 , len( program ) - 1 ) :
        proga = program[ random.randint( 0 , 20 ) ]
        progb = program[ random.randint( 0 , 20 ) ]
        program[ i ] = GP.mix( proga , progb )
        if random.random() < .1 :
            program[ i ] = GP.mutate( program[ i ] )
        fout[ i ] = 0.0
 
Ik was meer geïnteresseerd in resultaten dan in de code .... ;-).
 
Status
Niet open voor verdere reacties.
Steun Ons

Nieuwste berichten

Terug
Bovenaan Onderaan