platz/libs/ga.py

"""
Enthaelt alle Datenstrukturen um die einen genetischen Algorithmus darzustellen

"""
from random import *
from itertools import chain
from string import split
from copy import deepcopy
import ConfigParser, os


__author__ = "Michael Stangl"
__version__ = "$Revision: $"
__date__ = "$Date: $"
__copyright__ = "Copyright (c) 2005 Michael Stangl"
__license__ = "Python"

class Loesung:
	"""ein einfaches Loesungsobjekt. Taugt um es als Superklasse zu ueberladen"""
	def __init__(self, *Argumente, **keywords):
		self.Id = -1 * randint(1,100)
		self.value = self.Id
		print " initialisiere Loesung " + repr(self.Id)
	def mutieren(self):
		print " mutiere Loesung " + repr(self.Id)
		self.Id = -1 * randint(1,100)
		self.value = self.Id
		return self
	def kreuzen(self,obj):
		print " kreuze Loesung " + repr(self.Id)
	def laden(self):
		print " lade Loesung " + repr(self.Id)
	def speichern(self):
		print " speichere Loesung " + repr(self.Id)
	def __repr__(self):
		return ' L '+ repr(self.Id) 
	def __cmp__(self,other):
		if   self.value < other.value: 	return -1
		elif self.value == other.value: return 0
		else: 							return 1

class Zyklus:
	"""Definiert wie ein Zyklus ablaufen soll:
	
		wann sollen Objekte generiert, gekreuzt, mutiert und selektiert werden
		wieviele sind davon jeweils betroffen
	"""
	def __init__(self, 	Name='default', 
						Abfolge='e,m,s', 
						Anzahl='10,10,10'):
		self.Name = Name
		self.Abfolge = split(Abfolge, ',')
		self.Anzahl  = split(Anzahl,',')
	def __repr__(self):
		return( "Zyklus: %s\n"
				" Zyklusabfolge: %s\n"
				" Anzahl       : %s\n"
		% ( self.Name, 
			self.Abfolge, 
			self.Anzahl ) )
	def laden(self, FileName, ZyklusName):
		config = ConfigParser.ConfigParser()
		ZyklusPath= os.path.split( FileName ) 
		ZyklusPath= os.path.join( FileName ) 
		config.read( ZyklusPath )
		self.Name = ZyklusName
		Abfolge = eval( config.get( ZyklusName, 'Abfolge' ))
		Anzahl  = eval( config.get( ZyklusName, 'Anzahl' ))
		self.Abfolge = Abfolge.split(',')
		self.Anzahl = Anzahl.split(',')
		pass

class Farm:
	"""enthaelt und pflegt Loesungsobjekte, kreuzt, mutiert, selektiert sie"""
	def __init__(self, Zyklus, Klasse, *Arguments, **keywords):
		"""initialisiere die Farm
	
		mit einem definerten Zyklus fuer die Zucht und dem gewunschten zu Zuchtobjekt
		"""
		self.Position = 0
		self.Pool = []
		self.PoolNeu = []
		self.Zyklus = Zyklus
		self.Klasse = Klasse
		for Aktion, Zahl in zip(Zyklus.Abfolge,Zyklus.Anzahl):
			#print 'Aktion:',Aktion
			#print 'Zahl:',Zahl
			self.Position = self.Position + 1
			if   Aktion == 'e':
				self.LoesungenErzeugen(int(Zahl), Klasse, *Arguments, **keywords)
			elif Aktion == 'm':
				self.LoesungenMutieren(int(Zahl))
			elif Aktion == 's':
				self.LoesungenAuswaehlen(int(Zahl))
			elif Aktion == 'S':
				self.LoesungenZufaelligAuswaehlen(int(Zahl))
			elif Aktion == 'j':
				self.LoesungenBehalten()
			elif Aktion == 'z':
				self.NeueGeneration()
			else:
				pass
	def LoesungenErzeugen(self, N, Klasse, *Arguments, **keywords):
		""" Erzeuge Loesungen"""
		for i in xrange(N):
			L = Klasse( *Arguments, **keywords )
			self.Pool.append(L)
		#print repr(len(self.Pool)) + ' Loesungsobjekte erzeugt'
	def LoesungenKreuzen(self,N):
		"""mache aus zwei Loesungen eine neue"""
		#print "+ Loesungen kreuzen"
		for i in xrange(N):
			self.Pool.append(self.Pool[i].kreuzen())
	def LoesungenMutieren(self, N):
		"""veraendere die Loesung, so dass sie hoffentlich besser wird"""
		print "+ Loesungen mutieren: ", N
		for n in xrange(N):
			#print " -"+repr(n+1)+" mal"
			for L in chain(self.Pool):
				O = deepcopy(L)
				self.PoolNeu.append(O.mutieren())
		#print self
	def LoesungenBehalten(self):
		"""Behalte alle Eltern aus dem alten Pool"""
		print "+ alten Loesungspool behalten"
		self.PoolNeu = self.PoolNeu + self.Pool
		#print self
	def NeueGeneration(self):
		"""Loesche alle bisherigen Eltern und mache einen neuen Zyklus"""
		print "+ Neue Generation erzeugen"
		self.Pool = self.PoolNeu
		self.PoolNeu = []
		#print self
		#print "---------------"
	def LoesungenAuswaehlen(self, N):
		"""Selektiere die besten Loesungen"""
		print "+ die besten -", repr(N) +" - Loesungen auswaehlen -"
		for i in xrange(N):
			L = max(self.Pool)
			self.PoolNeu.append(L)
			self.Pool.remove(L)
		#print self
	def LoesungenZufaelligAuswaehlen(self, N):
		"""Selektiere zufaellig Loesungen"""
		print "+ zufaellig auswaehlen -"+ repr(N) + "-"
		for i in xrange(N):
			self.PoolNeu.append(choice(self.Pool))
		#print self
	def __repr__(self):
		"""Drucke die Farm am Bildschirm aus"""
		return( " gewaehlte Objekte (%d): %s\n"
				" Elternobjekte (%d)    : %s\n"
		% ( len(self.PoolNeu),  self.PoolNeu, 
			len(self.Pool), self.Pool))
	def laden(self):
		print "+ laden"
	def speichern(self):
		print "+ speichern"
	def Bester(self):
	 	return  max(self.Pool)


if __name__ == '__main__':
	print "\n-- Erzeuge Zyklus:"
	#Z = Zyklus( Name='Easy', 
				#Abfolge='e,s,+,m,j,S,+',
				#Anzahl='10,5,x,2,x,5,x'
				#)
	Z = Zyklus( Name='Easy', 
				Abfolge='e,'+'s,z,m,j,z,'*3+'s', 
				Anzahl='10,'+'5,x,2,x,x,'*3+'1' 
				)
	print Z

	print "\n-- Erzeuge Loesungen:"
	L1 = Loesung()
	L2 = Loesung()
	L3 = Loesung()
	print L1, L2, L3
	print 'L1 > L2 =', L1 > L2
	print 'L2 > L3 =', L2 > L3
	print 'L1 > L3 =', L1 > L3

	A=2
	B=3

	print "\n-- Erzeuge Farm:"
	F1 = Farm( Z, Loesung, Arg1=A, Arg2=B, Arg3=L1 )
	print F1

else:
	pass