def step(self):
for x in self.params:
if (x.requiresGrad):
if x.grad is None: continue
state = self.state[x.gradFn.name]
if x.grad.shape != x.shape:
grad = x.grad.view().mean(0)
else:
grad = x.grad.view()
if "g2" in state:
state["g2"] = self.rho * state["g2"] + (1 -
self.rho) * grad**2
else:
state["g2"] = dim.zeros(grad.shape)
if not ("delta" in state):
state["delta"] = (1 - self.rho) * grad**2
else:
state["delta"] = self.rho * state["delta"] + (
1 - self.rho) * delta**2
part1 = state["delta"].sqrt() + self.eps
part2 = state["g2"].sqrt() + self.eps
delta = part1 / part2
x -= delta
def maxUnpool2d(inputs, indices, ks):
if (len(inputs.shape) != 4):
raise Exception("input({})不符合[miniBatch*inChannels*H*W]的形状要求".format(
inputs.shape))
indices = dim.vector(indices)
if (inputs.shape != indices.shape):
raise Exception("input({})与indices({})的形状不一致".format(
inputs.shape, indices.shape))
a = []
ks = int(ks)
for i, channel in enumerate(inputs):
a.append([])
for j, kernel in enumerate(channel):
a[i].append([])
h = kernel.shape[0]
w = kernel.shape[1]
q = []
for k in range(h):
p = []
for l in range(w):
factor = dim.zeros([ks, ks])
r = math.floor(indices[i, j, k, l] / ks)
c = math.floor(indices[i, j, k, l] % ks)
factor[r, c] = 1
p.append(kernel[k, l] * factor)
q.append(dim.concat(p, 1))
a[i][j] = dim.concat(q, 0)
rst = dim.vector(a)
return rst
def maxUnpool1d(inputs, indices, ks):
if (len(inputs.shape) != 3):
raise Exception("input({})不符合[miniBatch*inChannels*W]的形状要求".format(
inputs.shape))
print("maxUnpool1d indices:", indices)
indices = dim.vector(indices)
if (inputs.shape != indices.shape):
raise Exception("input({})与indices({})的形状不一致".format(
inputs.shape, indices.shape))
a = []
ks = int(ks)
for i, channel in enumerate(inputs):
a.append([])
for j, kernel in enumerate(channel):
a[i].append([])
p = []
w = kernel.size
for k in range(w):
factor = dim.zeros(ks)
r = math.floor(indices[i, j, k] % ks)
factor[r] = 1
p.append(kernel[k] * factor)
a[i][j] = dim.concat(p, 0)
rst = dim.vector(a)
return rst
def partGrad(self, partial, prevOp):
if (partial.type != "Variable"):
raise Exception("partial参数必须是Variable类型")
if (self.catch and self._grads.get(partial.name, None)):
return self._grads[partial.name]
if (prevOp is None): prevOp = Constant(dim.ones(self.eval().shape))
zeros = dim.zeros(self.left.eval().shape)
zeros.reshape(zeros.size)[self.args["indices"]] = 1
part1 = Constant(zeros)
part2 = dim.autograd.MulOperate.wrapper(part1, prevOp)
part3 = self.left.partGrad(partial, part2)
rst = part3
self._grads[partial.name] = rst
return rst
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")