def main():
parser = dim.Parser(
description=
'The python version of the Dynamic Islands Model for OneMax problem.',
verbose='error')
parser.add_argument('--nislands',
'-N',
help='number of islands',
type=int,
default=4)
parser.add_argument('--popSize',
'-P',
help='size of population',
type=int,
default=100)
parser.add_argument('--chromSize',
'-n',
help='size of problem',
type=int,
default=1000)
parser.add_argument('--definedChromSize',
help='size of problem set to True',
type=int,
default=0)
parser.add_argument('--targetFitness',
'-T',
help='optimum to reach (0: disable)',
type=int)
parser.add_argument('--maxGen',
'-G',
help='maximum number of generation (0: disable)',
type=int,
default=0)
parser.add_argument('--alpha',
'-a',
help='the alpha parameter of the learning process',
type=float,
default=.2)
parser.add_argument('--alphaF',
'-A',
help='the alpha parameter of the learning process',
type=float,
default=.01)
parser.add_argument('--beta',
'-b',
help='the beta parameter of the learning process',
type=float,
default=.01)
parser.add_argument('--strategy',
'-S',
help='set a strategy of rewarding',
default=dim.Best)
parser.add_argument('--best',
'-B',
action='store_const',
const=dim.Best,
dest='strategy',
help='best strategy (see -S)')
parser.add_argument('--avg',
'-M',
action='store_const',
const=dim.Average,
dest='strategy',
help='average strategy (see -S)')
parser.add_argument('--stepTimer',
help='step of time used for printing results to files',
type=int,
default=0)
parser.add_argument(
'--seed',
help='set the seed value for the generator of pseudo-random numbers',
type=int,
default=0)
args = parser()
if args.seed:
dim.random.seed(args.seed)
print("seed:", args.seed)
N = args.nislands
P = args.popSize
n = args.chromSize
T = args.targetFitness
G = args.maxGen
# init = dim.Zerofy(n)
init = dim.Defined(n, args.definedChromSize)
init_matrix = dim.InitMatrix(N, 1 / N * 100)
__eval = OneMaxFullEval()
reward = args.strategy(args.alpha, args.beta)
updater = dim.Updater(reward)
memorizer = dim.Memorize()
matrix = init_matrix()
print(matrix)
pop_set = []
data_set = []
for i in range(N):
pop_set += [dim.Population(P, init)]
data_set += [dim.IslandData(i, N)]
evolvers = []
feedbackers = []
updaters = [updater] * N
memorizers = [memorizer] * N
migrators = []
checkpoints = []
for i in range(N):
pop = pop_set[i]
data = data_set[i]
data.proba = matrix[i].copy()
dim.apply(pop, __eval)
mon = None
if data.rank == 0:
mon = BitMutation(1, True)
else:
mon = DetBitFlip((data.rank - 1) * 2 + 1)
print(i, mon)
evolver = dim.Evolver(__eval, mon)
evolvers += [evolver]
feedbacker = dim.Feedbacker(pop_set, data_set, args.alphaF)
feedbackers += [feedbacker]
migrator = dim.Migrator(pop_set, data_set)
migrators += [migrator]
fit = dim.Fit(T if T else n)
cont = dim.Combined(fit)
checkpoint = dim.Checkpoint(cont)
checkpoints += [checkpoint]
if G:
maxgen = dim.MaxGen(G)
cont.add(maxgen)
monitor = dim.Print(out=open('result_monitor_%d' % data.rank, 'w'),
stepTimer=args.stepTimer)
monitor.addTo(checkpoint)
for stat in [
dim.IslandRank(),
dim.ElapsedTime(),
dim.ElapsedTimeBetweenGenerations(),
dim.Generation(),
dim.PopSize(),
dim.AverageFitness(),
dim.BestFitness(),
dim.BestOfBestFitness(pop_set, data_set),
dim.Probabilities(),
dim.CommingProbabilities(pop_set, data_set),
# dim.SumOfGoingProbabilities(),
# dim.SumOfCommingProbabilities(pop_set, data_set),
dim.Feedbacks(),
]:
stat.addTo(checkpoint)
monitor.add(stat)
for step in [evolvers, feedbackers, updaters, memorizers, migrators]:
for i in range(N):
step[i].firstCall(pop_set[i], data_set[i])
while True:
stop = False
for i in range(N):
if not checkpoints[i](pop_set[i], data_set[i]):
stop = True
break
if stop: break
for i in range(N):
evolvers[i](pop_set[i], data_set[i])
for i in range(N):
feedbackers[i].send(pop_set[i], data_set[i])
for i in range(N):
feedbackers[i].recv(pop_set[i], data_set[i])
for i in range(N):
updaters[i](pop_set[i], data_set[i])
for i in range(N):
memorizers[i](pop_set[i], data_set[i])
for i in range(N):
migrators[i].send(pop_set[i], data_set[i])
for i in range(N):
migrators[i].recv(pop_set[i], data_set[i])
for step in [evolvers, feedbackers, updaters, memorizers, migrators]:
for i in range(N):
step[i].lastCall(pop_set[i], data_set[i])
def main():
parser = dim.Parser(description='The python version of the Dynamic Islands Model for OneMax problem.', verbose='error')
parser.add_argument('--nislands', '-N', help='number of islands', type=int, default=4)
parser.add_argument('--popSize', '-P', help='size of population', type=int, default=100)
parser.add_argument('--chromSize', '-n', help='size of problem', type=int, default=1000)
parser.add_argument('--definedChromSize', help='size of problem set to True', type=int, default=0)
parser.add_argument('--targetFitness', '-T', help='optimum to reach (0: disable)', type=int)
parser.add_argument('--maxGen', '-G', help='maximum number of generation (0: disable)', type=int, default=0)
parser.add_argument('--alpha', '-a', help='the alpha parameter of the learning process', type=float, default=.2)
parser.add_argument('--alphaF', '-A', help='the alpha parameter of the learning process', type=float, default=.01)
parser.add_argument('--beta', '-b', help='the beta parameter of the learning process', type=float, default=.01)
parser.add_argument('--strategy', '-S', help='set a strategy of rewarding', default=dim.Best)
parser.add_argument('--best', '-B', action='store_const', const=dim.Best, dest='strategy', help='best strategy (see -S)')
parser.add_argument('--avg', '-M', action='store_const', const=dim.Average, dest='strategy', help='average strategy (see -S)')
parser.add_argument('--stepTimer', help='step of time used for printing results to files', type=int, default=0)
parser.add_argument('--seed', help='set the seed value for the generator of pseudo-random numbers', type=int, default=0)
args = parser()
if args.seed:
dim.random.seed(args.seed)
print("seed:", args.seed)
N = args.nislands
P = args.popSize
n = args.chromSize
T = args.targetFitness
G = args.maxGen
# init = dim.Zerofy(n)
init = dim.Defined(n,args.definedChromSize)
init_matrix = dim.InitMatrix(N,1/N*100)
__eval = OneMaxFullEval()
reward = args.strategy(args.alpha, args.beta)
updater = dim.Updater(reward)
memorizer = dim.Memorize()
matrix = init_matrix()
print(matrix)
pop_set = []
data_set = []
for i in range(N):
pop_set += [dim.Population(P,init)]
data_set += [dim.IslandData(i,N)]
evolvers = []
feedbackers = []
updaters = [updater]*N
memorizers = [memorizer]*N
migrators = []
checkpoints = []
for i in range(N):
pop = pop_set[i]
data = data_set[i]
data.proba = matrix[i].copy()
dim.apply(pop, __eval)
mon = None
if data.rank == 0:
mon = BitMutation(1, True)
else:
mon = DetBitFlip( (data.rank-1)*2+1 )
print(i, mon)
evolver = dim.Evolver(__eval, mon); evolvers += [evolver]
feedbacker = dim.Feedbacker(pop_set, data_set, args.alphaF); feedbackers += [feedbacker]
migrator = dim.Migrator(pop_set, data_set); migrators += [migrator]
fit = dim.Fit(T if T else n)
cont = dim.Combined(fit)
checkpoint = dim.Checkpoint(cont); checkpoints += [checkpoint]
if G:
maxgen = dim.MaxGen(G)
cont.add(maxgen)
monitor = dim.Print( out=open('result_monitor_%d' % data.rank, 'w'), stepTimer=args.stepTimer )
monitor.addTo(checkpoint)
for stat in [dim.IslandRank(),
dim.ElapsedTime(),
dim.ElapsedTimeBetweenGenerations(),
dim.Generation(),
dim.PopSize(),
dim.AverageFitness(),
dim.BestFitness(),
dim.BestOfBestFitness(pop_set, data_set),
dim.Probabilities(),
dim.CommingProbabilities(pop_set, data_set),
# dim.SumOfGoingProbabilities(),
# dim.SumOfCommingProbabilities(pop_set, data_set),
dim.Feedbacks(),
]:
stat.addTo(checkpoint)
monitor.add(stat)
for step in [evolvers, feedbackers, updaters, memorizers, migrators]:
for i in range(N):
step[i].firstCall(pop_set[i], data_set[i])
while True:
stop = False
for i in range(N):
if not checkpoints[i](pop_set[i], data_set[i]):
stop = True
break
if stop: break
for i in range(N): evolvers[i](pop_set[i], data_set[i])
for i in range(N): feedbackers[i].send(pop_set[i], data_set[i])
for i in range(N): feedbackers[i].recv(pop_set[i], data_set[i])
for i in range(N): updaters[i](pop_set[i], data_set[i])
for i in range(N): memorizers[i](pop_set[i], data_set[i])
for i in range(N): migrators[i].send(pop_set[i], data_set[i])
for i in range(N): migrators[i].recv(pop_set[i], data_set[i])
for step in [evolvers, feedbackers, updaters, memorizers, migrators]:
for i in range(N):
step[i].lastCall(pop_set[i], data_set[i])
def main():
parser = dim.Parser(description='The python version of the Dynamic Islands Model for OneMax problem.', verbose='error')
parser.add_argument('--nislands', '-N', help='number of islands', type=int, default=4)
parser.add_argument('--popSize', '-P', help='size of population', type=int, default=100)
parser.add_argument('--chromSize', '-n', help='size of problem', type=int, default=1000)
parser.add_argument('--definedChromSize', help='size of problem set to True', type=int, default=0)
parser.add_argument('--targetFitness', '-T', help='optimum to reach (0: disable)', type=int)
parser.add_argument('--maxGen', '-G', help='maximum number of generation (0: disable)', type=int, default=0)
parser.add_argument('--alpha', '-a', help='the alpha parameter of the learning process', type=float, default=.2)
parser.add_argument('--alphaF', '-A', help='the alpha parameter of the learning process', type=float, default=.01)
parser.add_argument('--beta', '-b', help='the beta parameter of the learning process', type=float, default=.01)
parser.add_argument('--strategy', '-S', help='set a strategy of rewarding', default=dim.Best)
parser.add_argument('--best', '-B', action='store_const', const=dim.Best, dest='strategy', help='best strategy (see -S)')
parser.add_argument('--avg', '-M', action='store_const', const=dim.Average, dest='strategy', help='average strategy (see -S)')
parser.add_argument('--stepTimer', help='step of time used for printing results to files', type=int, default=0)
parser.add_argument('--seed', help='set the seed value for the generator of pseudo-random numbers', type=int, default=0)
args = parser()
if args.seed:
dim.random.seed(args.seed)
print("seed:", args.seed)
N = args.nislands
P = args.popSize
n = args.chromSize
T = args.targetFitness
G = args.maxGen
# init = dim.ZerofyInit(n)
init = dim.DefinedInit(n,args.definedChromSize)
init_matrix = dim.InitMatrix(False,1/N)
__eval = OneMaxFullEval()
reward = args.strategy(args.alpha, args.beta)
updater = dim.Updater(reward)
memorizer = dim.Memorize()
matrix = dim.zeros( (N,N) )
init_matrix(matrix)
pop_set = []
data_set = []
for i in range(N):
pop_set += [dim.Population(P,init)]
data_set += [dim.IslandData(i,N)]
islands = []
for i in range(N):
pop = pop_set[i]
data = data_set[i]
data.proba = matrix[i].copy()
dim.apply(pop, __eval)
# mon = None
# if data.rank == 0:
# mon = BitMutation(1, True)
# else:
# mon = DetBitFlip( (data.rank-1)*2+1 )
# asso = [(BitMutation, 1, True),
# (DetBitFlip, 1),
# (DetBitFlip, 3),
# (DetBitFlip, 5),]
asso = [(DetBitFlip, 1),
(DetBitFlip, 3),
(DetBitFlip, 5),
(DetBitFlip, 7),]
assert len(asso) == args.nislands
mon = asso[data.rank][0](*asso[data.rank][1:])
print(i, mon)
evolver = dim.Evolver(__eval, mon)
feedbacker = dim.Feedbacker(pop_set, data_set, args.alphaF)
migrator = dim.Migrator(pop_set, data_set)
fit = dim.Fit(T if T else n)
cont = dim.Combined(fit)
checkpoint = dim.Checkpoint(cont)
if G:
maxgen = dim.MaxGen(G)
cont.add(maxgen)
monitor = dim.PrintMonitor( out=open('result_monitor_%d' % data.rank, 'w'), stepTimer=args.stepTimer )
monitor.addTo(checkpoint)
for stat in [dim.IslandRank(),
dim.ElapsedTime(),
dim.ElapsedTimeBetweenGenerations(),
dim.Generation(),
dim.PopSize(),
dim.AverageFitness(),
dim.BestFitness(),
dim.Probabilities(),
dim.CommingProbabilities(pop_set, data_set),
# dim.SumOfGoingProbabilities(),
# dim.SumOfCommingProbabilities(pop_set, data_set),
# dim.Feedbacks(),
]:
stat.addTo(checkpoint)
monitor.add(stat)
island = dim.Algo(evolver, feedbacker, updater, memorizer,
migrator, checkpoint, pop_set, data_set)
t = dim.Thread(target=island, args=[pop,data])
islands += [t]
for island in islands:
island.start()
try:
for island in islands:
island.join()
except KeyboardInterrupt as e:
print("Interrupted by user")
def main():
parser = dim.Parser(
description=
'The python version of the Dynamic Islands Model for OneMax problem.',
verbose='error')
parser.add_argument('--nislands',
'-N',
help='number of islands',
type=int,
default=4)
parser.add_argument('--popSize',
'-P',
help='size of population',
type=int,
default=100)
parser.add_argument('--chromSize',
'-n',
help='size of problem',
type=int,
default=1000)
parser.add_argument('--definedChromSize',
help='size of problem set to True',
type=int,
default=0)
parser.add_argument('--targetFitness',
'-T',
help='optimum to reach (0: disable)',
type=int)
parser.add_argument('--maxGen',
'-G',
help='maximum number of generation (0: disable)',
type=int,
default=0)
parser.add_argument('--alpha',
'-a',
help='the alpha parameter of the learning process',
type=float,
default=.2)
parser.add_argument('--alphaF',
'-A',
help='the alpha parameter of the learning process',
type=float,
default=.01)
parser.add_argument('--beta',
'-b',
help='the beta parameter of the learning process',
type=float,
default=.01)
parser.add_argument('--strategy',
'-S',
help='set a strategy of rewarding',
default=dim.Best)
parser.add_argument('--best',
'-B',
action='store_const',
const=dim.Best,
dest='strategy',
help='best strategy (see -S)')
parser.add_argument('--avg',
'-M',
action='store_const',
const=dim.Average,
dest='strategy',
help='average strategy (see -S)')
parser.add_argument('--stepTimer',
help='step of time used for printing results to files',
type=int,
default=0)
parser.add_argument(
'--seed',
help='set the seed value for the generator of pseudo-random numbers',
type=int,
default=0)
args = parser()
if args.seed:
dim.random.seed(args.seed)
print("seed:", args.seed)
N = args.nislands
P = args.popSize
n = args.chromSize
T = args.targetFitness
G = args.maxGen
# init = dim.ZerofyInit(n)
init = dim.DefinedInit(n, args.definedChromSize)
init_matrix = dim.InitMatrix(False, 1 / N)
__eval = OneMaxFullEval()
reward = args.strategy(args.alpha, args.beta)
updater = dim.Updater(reward)
memorizer = dim.Memorize()
matrix = dim.zeros((N, N))
init_matrix(matrix)
pop_set = []
data_set = []
for i in range(N):
pop_set += [dim.Population(P, init)]
data_set += [dim.IslandData(i, N)]
islands = []
for i in range(N):
pop = pop_set[i]
data = data_set[i]
data.proba = matrix[i].copy()
dim.apply(pop, __eval)
# mon = None
# if data.rank == 0:
# mon = BitMutation(1, True)
# else:
# mon = DetBitFlip( (data.rank-1)*2+1 )
# asso = [(BitMutation, 1, True),
# (DetBitFlip, 1),
# (DetBitFlip, 3),
# (DetBitFlip, 5),]
asso = [
(DetBitFlip, 1),
(DetBitFlip, 3),
(DetBitFlip, 5),
(DetBitFlip, 7),
]
assert len(asso) == args.nislands
mon = asso[data.rank][0](*asso[data.rank][1:])
print(i, mon)
evolver = dim.Evolver(__eval, mon)
feedbacker = dim.Feedbacker(pop_set, data_set, args.alphaF)
migrator = dim.Migrator(pop_set, data_set)
fit = dim.Fit(T if T else n)
cont = dim.Combined(fit)
checkpoint = dim.Checkpoint(cont)
if G:
maxgen = dim.MaxGen(G)
cont.add(maxgen)
monitor = dim.PrintMonitor(out=open('result_monitor_%d' % data.rank,
'w'),
stepTimer=args.stepTimer)
monitor.addTo(checkpoint)
for stat in [
dim.IslandRank(),
dim.ElapsedTime(),
dim.ElapsedTimeBetweenGenerations(),
dim.Generation(),
dim.PopSize(),
dim.AverageFitness(),
dim.BestFitness(),
dim.Probabilities(),
dim.CommingProbabilities(pop_set, data_set),
# dim.SumOfGoingProbabilities(),
# dim.SumOfCommingProbabilities(pop_set, data_set),
# dim.Feedbacks(),
]:
stat.addTo(checkpoint)
monitor.add(stat)
island = dim.Algo(evolver, feedbacker, updater, memorizer, migrator,
checkpoint, pop_set, data_set)
t = dim.Thread(target=island, args=[pop, data])
islands += [t]
for island in islands:
island.start()
try:
for island in islands:
island.join()
except KeyboardInterrupt as e:
print("Interrupted by user")
