class RacosOptimization:
def __init__(self, dim):
self.__Pop = [] # population set
self.__PosPop = [] # positive sample set
self.__Optimal = [] # the best sample so far
self.__NextPop = [] # the next population set
self.__region = [] # the region of model
self.__label = [] # the random label, if true random in this dimension
self.__SampleSize = 0 # the instance number of sampling in an iteration
self.__MaxIteration = 0 # the number of iterations
self.__Budget = 0 # budget of evaluation
self.__PositiveNum = 0 # the set size of PosPop
self.__RandProbability = 0 # the probability of sample in model
self.__UncertainBits = 0 # the dimension size that is sampled randomly
self.__OnlineSwitch = False
self.__dimension = dim
for i in range(dim.getSize()):
reg = []
reg.append(0)
reg.append(0)
self.__region.append(reg)
self.__label.append(True)
self.__ro = RandomOperator()
return
def OnlineTurnOn(self):
self.__OnlineSwitch = True
def OnlineTurnOff(self):
self.__OnlineSwitch = False
def Clear(self):
self.__Pop = []
self.__PosPop = []
self.__Optimal = []
self.__NextPop = []
return
# Parameters setting
def setParameters(self, ss, mt, pn, rp, ub):
self.__SampleSize = ss
if self.__OnlineSwitch is False:
self.__MaxIteration = mt
else:
self.__Budget = mt
self.__PositiveNum = pn
self.__RandProbability = rp
self.__UncertainBits = ub
return
# -------------------------------------------------------
# some test function
def ShowPop(self, fea):
print '----Pop----'
for i in range(self.__SampleSize):
if fea is True:
print self.__Pop[i].getFeatures(), ':', self.__Pop[i].getFitness()
else:
print 'fitness:', self.__Pop[i].getFitness()
return
def ShowNextPop(self, fea):
print '----NextPop----'
for i in range(self.__SampleSize):
if fea is True:
print self.__NextPop[i].getFeatures(), ':', self.__NextPop[i].getFitness()
else:
print 'fitness:', self.__NextPop[i].getFitness()
return
def ShowPosPop(self, fea):
print '----PosPop----'
for i in range(self.__PositiveNum):
if fea is True:
print self.__PosPop[i].getFeatures(), ':', self.__PosPop[i].getFitness()
else:
print 'fitness:', self.__PosPop[i].getFitness()
return
def ShowRegion(self):
print '----Region----'
for i in range(self.__dimension.getSize):
print 'dimension',i,'[', self.__region[i][0],',',self.__region[i][1],']'
return
def ShowLabel(self):
print self.__label
return
# test function end
# ----------------------------------------------------------------
# Return optimal
def getOptimal(self):
return self.__Optimal
# Generate an instance randomly
def RandomInstance(self, dim, region, label):
inst = Instance(dim)
for i in range(dim.getSize()):
if label[i] is True:
if dim.getType(i) is True:
inst.setFeature(i, self.__ro.getUniformDouble(region[i][0], region[i][1]))
else:
inst.setFeature(i, self.__ro.getUniformInteger(region[i][0], region[i][1]))
return inst
# generate an instance randomly
def PosRandomInstance(self, dim, region, label, pos):
ins = Instance(dim)
for i in range(dim.getSize()):
if label[i] is False:
if dim.getType(i) is True:
ins.setFeature(i, self.__ro.getUniformDouble(region[i][0], region[i][1]))
else:
ins.setFeature(i, self.__ro.getUniformInteger(region[i][0], region[i][1]))
else:
ins.setFeature(i, pos.getFeature(i))
return ins
# reset model
def ResetModel(self):
for i in range(self.__dimension.getSize()):
self.__region[i][0] = self.__dimension.getRegion(i)[0]
self.__region[i][1] = self.__dimension.getRegion(i)[1]
self.__label[i] = True
return
# If an instance exists in list which is as same as ins, return True
def InstanceInList(self, ins, list, end):
for i in range(len(list)):
if i == end:
break
if ins.Equal(list[i]) == True:
return True
return False
# Initialize Pop, PosPop and Optimal
def Initialize(self, func):
temp = []
# sample in original region under uniform distribution
self.ResetModel()
for i in range(self.__SampleSize+self.__PositiveNum):
ins = []
while(True):
ins = self.RandomInstance(self.__dimension, self.__region, self.__label)
if self.InstanceInList(ins, temp, i) is False:
break
ins.setFitness(func(ins.getFeatures()))
temp.append(ins)
# sorted by fitness
temp.sort(key=lambda instance: instance.getFitness())
# initialize PosPop and Pop
i = 0
while(i<self.__PositiveNum):
self.__PosPop.append(temp[i])
i += 1
while(i<self.__PositiveNum+self.__SampleSize):
self.__Pop.append(temp[i])
i += 1
# initialize optimal
self.__Optimal = self.__PosPop[0].CopyInstance()
return
# Generate model for sample next instance
def ContinueShrinkModel(self, ins):
ins_left = self.__SampleSize
while(ins_left > 0):
ChosenNeg = self.__ro.getUniformInteger(0, ins_left-1)
ChosenDim = self.__ro.getUniformInteger(0, self.__dimension.getSize()-1)
#shrinking
if (ins.getFeature(ChosenDim) < self.__Pop[ChosenNeg].getFeature(ChosenDim)):
btemp = self.__ro.getUniformDouble(ins.getFeature(ChosenDim), self.__Pop[ChosenNeg].getFeature(ChosenDim))
if(btemp < self.__region[ChosenDim][1]):
self.__region[ChosenDim][1] = btemp
i = 0
while(i < ins_left):
if self.__Pop[i].getFeature(ChosenDim) >= btemp:
ins_left = ins_left - 1
itemp = self.__Pop[i]
self.__Pop[i] = self.__Pop[ins_left]
self.__Pop[ins_left] = itemp
else:
i += 1
else:
btemp = self.__ro.getUniformDouble(self.__Pop[ChosenNeg].getFeature(ChosenDim), ins.getFeature(ChosenDim))
if (btemp > self.__region[ChosenDim][0]):
self.__region[ChosenDim][0] = btemp
i = 0
while(i < ins_left):
if self.__Pop[i].getFeature(ChosenDim) <= btemp:
ins_left = ins_left - 1
itemp = self.__Pop[i]
self.__Pop[i] = self.__Pop[ins_left]
self.__Pop[ins_left] = itemp
else:
i += 1
return
# Set uncertain bits
def setUncertainBits(self):
temp = []
for i in range(self.__dimension.getSize()):
temp.append(i)
for i in range(self.__UncertainBits):
index = self.__ro.getUniformInteger(0, self.__dimension.getSize()-i-1)
self.__label[temp[index]] = False
temp.remove(temp[index])
return
# Update PosPop list according to new Pop list generated latterly
def UpdatePosPop(self):
for i in range(self.__SampleSize):
j = 0
while(j<self.__PositiveNum):
if(self.__Pop[i].getFitness()<self.__PosPop[j].getFitness()):
break
else:
j += 1
if(j < self.__PositiveNum):
temp = self.__Pop[i]
self.__Pop[i] = self.__PosPop[self.__PositiveNum-1]
k = self.__PositiveNum-1
while(k > j):
self.__PosPop[k] = self.__PosPop[k-1]
k -= 1
self.__PosPop[j] = temp
return
def OnlineUpdate(self, ins):
j = 0
while (j < self.__PositiveNum):
if (ins.getFitness() < self.__PosPop[j].getFitness()):
break
else:
j += 1
if (j < self.__PositiveNum):
temp = ins
ins = self.__PosPop[self.__PositiveNum - 1]
k = self.__PositiveNum - 1
while (k > j):
self.__PosPop[k] = self.__PosPop[k - 1]
k -= 1
self.__PosPop[j] = temp
j = 0
while (j < self.__SampleSize):
if (ins.getFitness() < self.__Pop[j].getFitness()):
break
else:
j += 1
if (j < self.__SampleSize):
temp = ins
ins = self.__Pop[self.__SampleSize - 1]
k = self.__SampleSize - 1
while (k > j):
self.__Pop[k] = self.__Pop[k - 1]
k -= 1
self.__Pop[j] = temp
# Update Optimal
def UpdateOptimal(self):
if(self.__Optimal.getFitness() > self.__PosPop[0].getFitness()):
self.__Optimal = self.__PosPop[0].CopyInstance()
return
# If instances in Pop list are not in model, return True
def Distinguish(self):
for i in range(self.__SampleSize):
j = 0
while(j < self.__dimension.getSize()):
if (self.__Pop[i].getFeature(j) > self.__region[j][0]) and (self.__Pop[i].getFeature(j) < self.__region[j][1]):
j += 1
else:
break
if (j == self.__dimension.getSize()):
return False
return True
'''
Racos for continue optimization
param:
func: objective function name
ss: sample size
mt: max iteration size
pn: positive instance size
rp: the probability of sampling in model randomly
ub: uncertain bits
'''
def ContinueOpt(self, func, ss, mt, pn, rp, ub):
self.Clear()
self.setParameters(ss, mt, pn, rp, ub)
self.ResetModel()
self.Initialize(func)
if self.__OnlineSwitch is False:
# no online style
for itera in range(self.__MaxIteration-1):
self.__NextPop = []
for sam in range(self.__SampleSize):
while(True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(0, self.__PositiveNum-1)
Gsample = self.__ro.getUniformDouble(0, 1)
if(Gsample <= self.__RandProbability):
self.ContinueShrinkModel(self.__PosPop[ChosenPos])
self.setUncertainBits()
ins = self.PosRandomInstance(self.__dimension, self.__region, self.__label, self.__PosPop[ChosenPos])
if((self.InstanceInList(ins, self.__PosPop, self.__PositiveNum) is False) and (self.InstanceInList(ins, self.__NextPop, sam) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.__NextPop.append(ins)
self.__Pop = []
for i in range(self.__SampleSize):
self.__Pop.append(self.__NextPop[i])
self.UpdatePosPop()
self.UpdateOptimal()
else:
#Online style
BudCount = self.__SampleSize+self.__PositiveNum
while BudCount < self.__Budget:
# print BudCount, self.__Optimal.getFitness()
BudCount += 1
while (True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(0, self.__PositiveNum - 1)
Gsample = self.__ro.getUniformDouble(0, 1)
if (Gsample <= self.__RandProbability):
self.ContinueShrinkModel(self.__PosPop[ChosenPos])
self.setUncertainBits()
ins = self.PosRandomInstance(self.__dimension, self.__region, self.__label,
self.__PosPop[ChosenPos])
if ((self.InstanceInList(ins, self.__PosPop, self.__PositiveNum) is False) and (
self.InstanceInList(ins, self.__Pop, self.__SampleSize) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.OnlineUpdate(ins)
self.UpdateOptimal()
return
# Distinguish function for discrete optimization
def DiscreteDistinguish(self, ins, ChosenDim):
if len(ChosenDim) is 0:
return 0
for i in range(self.__SampleSize):
j = 0
while j < len(ChosenDim):
if ins.getFeature(ChosenDim[j]) != self.__Pop[i].getFeature(ChosenDim[j]):
break
j = j+1
if j == len(ChosenDim):
return 0
return 1
# PosRandomInstance function for discrete optimization
def PosRandomDiscreteInstance(self, PosIns, dim, label):
ins = Instance(dim)
for i in range(dim.getSize()):
if label[i] is True:
ins.setFeature(i, PosIns.getFeature(i))
else:
ins.setFeature(i, self.__ro.getUniformInteger(dim.getRegion(i)[0], dim.getRegion(i)[1]))
return ins
# ShringModel function for discrete
def DiscreteShrinkModel(self, ins, dim):
NonChosenDim = []
for i in range(dim.getSize()):
NonChosenDim.append(i)
ChosenDim = []
while self.DiscreteDistinguish(ins, ChosenDim) == 0:
tempDim = NonChosenDim[self.__ro.getUniformInteger(0, len(NonChosenDim)-1)]
ChosenDim.append(tempDim)
NonChosenDim.remove(tempDim)
while len(NonChosenDim) > self.__UncertainBits:
tempDim = NonChosenDim[self.__ro.getUniformInteger(0, len(NonChosenDim) - 1)]
ChosenDim.append(tempDim)
NonChosenDim.remove(tempDim)
return NonChosenDim
'''
RACOS for discrete optimization
param:
func: objective function name
ss: sample size
mt: max iteration size
pn: positive instance size
rp: the probability of sampling in model randomly
ub: uncertain bits
'''
def DiscreteOpt(self, func, ss, mt, pn, rp, ub):
self.Clear()
self.setParameters(ss, mt, pn, rp, ub)
self.ResetModel()
self.Initialize(func)
if self.__OnlineSwitch is False:
for itera in range(self.__MaxIteration - 1):
self.__NextPop = []
for sam in range(self.__SampleSize):
while (True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(0, self.__PositiveNum - 1)
Gsample = self.__ro.getUniformDouble(0, 1)
if (Gsample <= self.__RandProbability):
NonChosenDim = self.DiscreteShrinkModel(self.__PosPop[ChosenPos], self.__dimension)
for i in range(len(NonChosenDim)):
self.__label[NonChosenDim[i]] = False
ins = self.PosRandomDiscreteInstance(self.__PosPop[ChosenPos], self.__dimension, self.__label)
if ((self.InstanceInList(ins, self.__PosPop, self.__PositiveNum) is False) and (
self.InstanceInList(ins, self.__NextPop, sam) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.__NextPop.append(ins)
self.__Pop = []
for i in range(self.__SampleSize):
self.__Pop.append(self.__NextPop[i])
self.UpdatePosPop()
self.UpdateOptimal()
else:
BudCount = self.__SampleSize + self.__PositiveNum
while BudCount < self.__Budget:
print BudCount, self.__Optimal.getFitness()
BudCount += 1
while (True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(0, self.__PositiveNum - 1)
Gsample = self.__ro.getUniformDouble(0, 1)
if (Gsample <= self.__RandProbability):
NonChosenDim = self.DiscreteShrinkModel(self.__PosPop[ChosenPos], self.__dimension)
for i in range(len(NonChosenDim)):
self.__label[NonChosenDim[i]] = False
ins = self.PosRandomDiscreteInstance(self.__PosPop[ChosenPos], self.__dimension, self.__label)
if ((self.InstanceInList(ins, self.__PosPop, self.__PositiveNum) is False) and (
self.InstanceInList(ins, self.__Pop, self.__SampleSize) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.OnlineUpdate(ins)
self.UpdateOptimal()
return
# Distinguish function for mixed optimization
def MixDistinguish(self, ins):
for i in range(self.__SampleSize):
j = 0
while j < self.__dimension.getSize():
if self.__dimension.getType(j) is True:
if self.__Pop[i].getFeature(j) < self.__region[j][0] or self.__Pop[i].getFeature(j) > self.__region[j][1]:
break
else:
if self.__label[j] is False and ins.getFeature(j) != self.__Pop[i].getFeature(j):
break
j += 1
if j >= self.__dimension.getSize():
return False
return True
# PosRandomInstance for mixed optimization
def PosRandomMixInstance(self, PosIns, dim, regi, lab):
ins = Instance(dim)
for i in range(dim.getSize()):
if lab[i] is False:
ins.setFeature(i, PosIns.getFeature(i))
else:
if dim.getType(i) is True: #continue
ins.setFeature(i, self.__ro.getUniformDouble(regi[i][0], regi[i][1]))
else: #discrete
ins.setFeature(i, self.__ro.getUniformInteger(dim.getRegion(i)[0], dim.getRegion(i)[1]))
return ins
# ShrinkModel function for mixed optimization
def MixShrinkModel(self, ins):
ChosenDim = []
NonChosenDim = []
for i in range(self.__dimension.getSize()):
NonChosenDim.append(i)
count = 0
while self.MixDistinguish(ins) is False:
TempDim = NonChosenDim[self.__ro.getUniformInteger(0, len(NonChosenDim)-1)]
ChosenNeg = self.__ro.getUniformInteger(0, self.__SampleSize-1)
if self.__dimension.getType(TempDim) is True: #continue
if ins.getFeature(TempDim) < self.__Pop[ChosenNeg].getFeature(TempDim):
btemp = self.__ro.getUniformDouble(ins.getFeature(TempDim), self.__Pop[ChosenNeg].getFeature(TempDim))
if btemp < self.__region[TempDim][1]:
self.__region[TempDim][1] = btemp
else:
btemp = self.__ro.getUniformDouble(self.__Pop[ChosenNeg].getFeature(TempDim), ins.getFeature(TempDim))
if btemp > self.__region[TempDim][0]:
self.__region[TempDim][0] = btemp
else:
ChosenDim.append(TempDim)
NonChosenDim.remove(TempDim)
self.__label[TempDim] = False
count += 1
while len(NonChosenDim) > self.__UncertainBits:
TempDim = NonChosenDim[self.__ro.getUniformInteger(0, len(NonChosenDim) - 1)]
ChosenDim.append(TempDim)
NonChosenDim.remove(TempDim)
self.__label[TempDim] = False
return
'''
RACOS for mixed optimization
param:
func: objective function name
ss: sample size
mt: max iteration size
pn: positive instance size
rp: the probability of sampling in model randomly
ub: uncertain bits
'''
def MixOpt(self, func, ss, mt, pn, rp, ub):
self.Clear()
self.setParameters(ss, mt, pn, rp, ub)
self.ResetModel()
self.Initialize(func)
if self.__OnlineSwitch is False:
for itera in range(self.__MaxIteration - 1):
self.__NextPop = []
# self.ShowPosPop(True)
# self.ShowPop(True)
for sam in range(self.__SampleSize):
while (True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(0, self.__PositiveNum - 1)
Gsample = self.__ro.getUniformDouble(0, 1)
if (Gsample <= self.__RandProbability):
# print 'begin shrinking!'
self.MixShrinkModel(self.__PosPop[ChosenPos])
ins = self.PosRandomMixInstance(self.__PosPop[ChosenPos], self.__dimension, self.__region,
self.__label)
if ((self.InstanceInList(ins, self.__PosPop, self.__PositiveNum) is False) and (
self.InstanceInList(ins, self.__NextPop, sam) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.__NextPop.append(ins)
self.__Pop = []
for i in range(self.__SampleSize):
self.__Pop.append(self.__NextPop[i])
self.UpdatePosPop()
self.UpdateOptimal()
else:
#online style
BudCount = self.__SampleSize + self.__PositiveNum
while BudCount < self.__Budget:
print BudCount, self.__Optimal.getFitness()
BudCount += 1
while (True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(0, self.__PositiveNum - 1)
Gsample = self.__ro.getUniformDouble(0, 1)
if (Gsample <= self.__RandProbability):
# print 'begin shrinking!'
self.MixShrinkModel(self.__PosPop[ChosenPos])
ins = self.PosRandomMixInstance(self.__PosPop[ChosenPos], self.__dimension, self.__region,
self.__label)
if ((self.InstanceInList(ins, self.__PosPop, self.__PositiveNum) is False) and (
self.InstanceInList(ins, self.__Pop, self.__SampleSize) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.OnlineUpdate(ins)
self.UpdateOptimal()
return
class RacosOptimization:
def __init__(self, dim):
self.__Pop = [] # population set
self.__PosPop = [] # positive sample set
self.__Optimal = [] # the best sample so far
self.__NextPop = [] # the next population set
self.__region = [] # the region of model
self.__label = [] # the random label, if true random in this dimension
self.__SampleSize = 0 # the instance number of sampling in an iteration
self.__MaxIteration = 0 # the number of iterations
self.__Budget = 0 # budget of evaluation
self.__PositiveNum = 0 # the set size of PosPop
self.__RandProbability = 0 # the probability of sample in model
self.__UncertainBits = 0 # the dimension size that is sampled randomly
self.__OnlineSwitch = False
self.__dimension = dim
for i in range(dim.getSize()):
reg = []
reg.append(0)
reg.append(0)
self.__region.append(reg)
self.__label.append(True)
self.__ro = RandomOperator()
return
def OnlineTurnOn(self):
self.__OnlineSwitch = True
def OnlineTurnOff(self):
self.__OnlineSwitch = False
def Clear(self):
self.__Pop = []
self.__PosPop = []
self.__Optimal = []
self.__NextPop = []
return
# Parameters setting
def setParameters(self, ss, mt, pn, rp, ub):
self.__SampleSize = ss
if self.__OnlineSwitch is False:
self.__MaxIteration = mt
else:
self.__Budget = mt
self.__PositiveNum = pn
self.__RandProbability = rp
self.__UncertainBits = ub
return
# -------------------------------------------------------
# some test function
def ShowPop(self, fea):
print '----Pop----'
for i in range(self.__SampleSize):
if fea is True:
print self.__Pop[i].getFeatures(
), ':', self.__Pop[i].getFitness()
else:
print 'fitness:', self.__Pop[i].getFitness()
return
def ShowNextPop(self, fea):
print '----NextPop----'
for i in range(self.__SampleSize):
if fea is True:
print self.__NextPop[i].getFeatures(
), ':', self.__NextPop[i].getFitness()
else:
print 'fitness:', self.__NextPop[i].getFitness()
return
def ShowPosPop(self, fea):
print '----PosPop----'
for i in range(self.__PositiveNum):
if fea is True:
print self.__PosPop[i].getFeatures(
), ':', self.__PosPop[i].getFitness()
else:
print 'fitness:', self.__PosPop[i].getFitness()
return
def ShowRegion(self):
print '----Region----'
for i in range(self.__dimension.getSize):
print 'dimension', i, '[', self.__region[i][0], ',', self.__region[
i][1], ']'
return
def ShowLabel(self):
print self.__label
return
# test function end
# ----------------------------------------------------------------
# Return optimal
def getOptimal(self):
return self.__Optimal
# Generate an instance randomly
def RandomInstance(self, dim, region, label):
inst = Instance(dim)
for i in range(dim.getSize()):
if label[i] is True:
if dim.getType(i) is True:
inst.setFeature(
i,
self.__ro.getUniformDouble(region[i][0], region[i][1]))
else:
inst.setFeature(
i,
self.__ro.getUniformInteger(region[i][0],
region[i][1]))
return inst
# generate an instance randomly
def PosRandomInstance(self, dim, region, label, pos):
ins = Instance(dim)
for i in range(dim.getSize()):
if label[i] is False:
if dim.getType(i) is True:
ins.setFeature(
i,
self.__ro.getUniformDouble(region[i][0], region[i][1]))
else:
ins.setFeature(
i,
self.__ro.getUniformInteger(region[i][0],
region[i][1]))
else:
ins.setFeature(i, pos.getFeature(i))
return ins
# reset model
def ResetModel(self):
for i in range(self.__dimension.getSize()):
self.__region[i][0] = self.__dimension.getRegion(i)[0]
self.__region[i][1] = self.__dimension.getRegion(i)[1]
self.__label[i] = True
return
# If an instance exists in list which is as same as ins, return True
def InstanceInList(self, ins, list, end):
for i in range(len(list)):
if i == end:
break
if ins.Equal(list[i]) == True:
return True
return False
# Initialize Pop, PosPop and Optimal
def Initialize(self, func):
temp = []
# sample in original region under uniform distribution
self.ResetModel()
for i in range(self.__SampleSize + self.__PositiveNum):
ins = []
while (True):
ins = self.RandomInstance(self.__dimension, self.__region,
self.__label)
if self.InstanceInList(ins, temp, i) is False:
break
ins.setFitness(func(ins.getFeatures()))
temp.append(ins)
# sorted by fitness
temp.sort(key=lambda instance: instance.getFitness())
# initialize PosPop and Pop
i = 0
while (i < self.__PositiveNum):
self.__PosPop.append(temp[i])
i += 1
while (i < self.__PositiveNum + self.__SampleSize):
self.__Pop.append(temp[i])
i += 1
# initialize optimal
self.__Optimal = self.__PosPop[0].CopyInstance()
return
# Generate model for sample next instance
def ContinueShrinkModel(self, ins):
ins_left = self.__SampleSize
while (ins_left > 0):
ChosenNeg = self.__ro.getUniformInteger(0, ins_left - 1)
ChosenDim = self.__ro.getUniformInteger(
0,
self.__dimension.getSize() - 1)
#shrinking
if (ins.getFeature(ChosenDim) <
self.__Pop[ChosenNeg].getFeature(ChosenDim)):
btemp = self.__ro.getUniformDouble(
ins.getFeature(ChosenDim),
self.__Pop[ChosenNeg].getFeature(ChosenDim))
if (btemp < self.__region[ChosenDim][1]):
self.__region[ChosenDim][1] = btemp
i = 0
while (i < ins_left):
if self.__Pop[i].getFeature(ChosenDim) >= btemp:
ins_left = ins_left - 1
itemp = self.__Pop[i]
self.__Pop[i] = self.__Pop[ins_left]
self.__Pop[ins_left] = itemp
else:
i += 1
else:
btemp = self.__ro.getUniformDouble(
self.__Pop[ChosenNeg].getFeature(ChosenDim),
ins.getFeature(ChosenDim))
if (btemp > self.__region[ChosenDim][0]):
self.__region[ChosenDim][0] = btemp
i = 0
while (i < ins_left):
if self.__Pop[i].getFeature(ChosenDim) <= btemp:
ins_left = ins_left - 1
itemp = self.__Pop[i]
self.__Pop[i] = self.__Pop[ins_left]
self.__Pop[ins_left] = itemp
else:
i += 1
return
# Set uncertain bits
def setUncertainBits(self):
temp = []
for i in range(self.__dimension.getSize()):
temp.append(i)
for i in range(self.__UncertainBits):
index = self.__ro.getUniformInteger(
0,
self.__dimension.getSize() - i - 1)
self.__label[temp[index]] = False
temp.remove(temp[index])
return
# Update PosPop list according to new Pop list generated latterly
def UpdatePosPop(self):
for i in range(self.__SampleSize):
j = 0
while (j < self.__PositiveNum):
if (self.__Pop[i].getFitness() <
self.__PosPop[j].getFitness()):
break
else:
j += 1
if (j < self.__PositiveNum):
temp = self.__Pop[i]
self.__Pop[i] = self.__PosPop[self.__PositiveNum - 1]
k = self.__PositiveNum - 1
while (k > j):
self.__PosPop[k] = self.__PosPop[k - 1]
k -= 1
self.__PosPop[j] = temp
return
def OnlineUpdate(self, ins):
j = 0
while (j < self.__PositiveNum):
if (ins.getFitness() < self.__PosPop[j].getFitness()):
break
else:
j += 1
if (j < self.__PositiveNum):
temp = ins
ins = self.__PosPop[self.__PositiveNum - 1]
k = self.__PositiveNum - 1
while (k > j):
self.__PosPop[k] = self.__PosPop[k - 1]
k -= 1
self.__PosPop[j] = temp
j = 0
while (j < self.__SampleSize):
if (ins.getFitness() < self.__Pop[j].getFitness()):
break
else:
j += 1
if (j < self.__SampleSize):
temp = ins
ins = self.__Pop[self.__SampleSize - 1]
k = self.__SampleSize - 1
while (k > j):
self.__Pop[k] = self.__Pop[k - 1]
k -= 1
self.__Pop[j] = temp
# Update Optimal
def UpdateOptimal(self):
if (self.__Optimal.getFitness() > self.__PosPop[0].getFitness()):
self.__Optimal = self.__PosPop[0].CopyInstance()
return
# If instances in Pop list are not in model, return True
def Distinguish(self):
for i in range(self.__SampleSize):
j = 0
while (j < self.__dimension.getSize()):
if (self.__Pop[i].getFeature(j) > self.__region[j][0]) and (
self.__Pop[i].getFeature(j) < self.__region[j][1]):
j += 1
else:
break
if (j == self.__dimension.getSize()):
return False
return True
'''
Racos for continue optimization
param:
func: objective function name
ss: sample size
mt: max iteration size
pn: positive instance size
rp: the probability of sampling in model randomly
ub: uncertain bits
'''
def ContinueOpt(self, func, ss, mt, pn, rp, ub):
self.Clear()
self.setParameters(ss, mt, pn, rp, ub)
self.ResetModel()
self.Initialize(func)
if self.__OnlineSwitch is False:
# no online style
for itera in range(self.__MaxIteration - 1):
self.__NextPop = []
for sam in range(self.__SampleSize):
while (True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(
0, self.__PositiveNum - 1)
Gsample = self.__ro.getUniformDouble(0, 1)
if (Gsample <= self.__RandProbability):
self.ContinueShrinkModel(self.__PosPop[ChosenPos])
self.setUncertainBits()
ins = self.PosRandomInstance(self.__dimension,
self.__region,
self.__label,
self.__PosPop[ChosenPos])
if ((self.InstanceInList(ins, self.__PosPop,
self.__PositiveNum) is False)
and (self.InstanceInList(
ins, self.__NextPop, sam) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.__NextPop.append(ins)
self.__Pop = []
for i in range(self.__SampleSize):
self.__Pop.append(self.__NextPop[i])
self.UpdatePosPop()
self.UpdateOptimal()
else:
#Online style
BudCount = self.__SampleSize + self.__PositiveNum
while BudCount < self.__Budget:
# print BudCount, self.__Optimal.getFitness()
BudCount += 1
while (True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(
0, self.__PositiveNum - 1)
Gsample = self.__ro.getUniformDouble(0, 1)
if (Gsample <= self.__RandProbability):
self.ContinueShrinkModel(self.__PosPop[ChosenPos])
self.setUncertainBits()
ins = self.PosRandomInstance(self.__dimension,
self.__region, self.__label,
self.__PosPop[ChosenPos])
if ((self.InstanceInList(ins, self.__PosPop,
self.__PositiveNum) is False)
and (self.InstanceInList(
ins, self.__Pop, self.__SampleSize) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.OnlineUpdate(ins)
self.UpdateOptimal()
return
# Distinguish function for discrete optimization
def DiscreteDistinguish(self, ins, ChosenDim):
if len(ChosenDim) is 0:
return 0
for i in range(self.__SampleSize):
j = 0
while j < len(ChosenDim):
if ins.getFeature(ChosenDim[j]) != self.__Pop[i].getFeature(
ChosenDim[j]):
break
j = j + 1
if j == len(ChosenDim):
return 0
return 1
# PosRandomInstance function for discrete optimization
def PosRandomDiscreteInstance(self, PosIns, dim, label):
ins = Instance(dim)
for i in range(dim.getSize()):
if label[i] is True:
ins.setFeature(i, PosIns.getFeature(i))
else:
ins.setFeature(
i,
self.__ro.getUniformInteger(
dim.getRegion(i)[0],
dim.getRegion(i)[1]))
return ins
# ShringModel function for discrete
def DiscreteShrinkModel(self, ins, dim):
NonChosenDim = []
for i in range(dim.getSize()):
NonChosenDim.append(i)
ChosenDim = []
while self.DiscreteDistinguish(ins, ChosenDim) == 0:
tempDim = NonChosenDim[self.__ro.getUniformInteger(
0,
len(NonChosenDim) - 1)]
ChosenDim.append(tempDim)
NonChosenDim.remove(tempDim)
while len(NonChosenDim) > self.__UncertainBits:
tempDim = NonChosenDim[self.__ro.getUniformInteger(
0,
len(NonChosenDim) - 1)]
ChosenDim.append(tempDim)
NonChosenDim.remove(tempDim)
return NonChosenDim
'''
RACOS for discrete optimization
param:
func: objective function name
ss: sample size
mt: max iteration size
pn: positive instance size
rp: the probability of sampling in model randomly
ub: uncertain bits
'''
def DiscreteOpt(self, func, ss, mt, pn, rp, ub):
self.Clear()
self.setParameters(ss, mt, pn, rp, ub)
self.ResetModel()
self.Initialize(func)
if self.__OnlineSwitch is False:
for itera in range(self.__MaxIteration - 1):
self.__NextPop = []
for sam in range(self.__SampleSize):
while (True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(
0, self.__PositiveNum - 1)
Gsample = self.__ro.getUniformDouble(0, 1)
if (Gsample <= self.__RandProbability):
NonChosenDim = self.DiscreteShrinkModel(
self.__PosPop[ChosenPos], self.__dimension)
for i in range(len(NonChosenDim)):
self.__label[NonChosenDim[i]] = False
ins = self.PosRandomDiscreteInstance(
self.__PosPop[ChosenPos], self.__dimension,
self.__label)
if ((self.InstanceInList(ins, self.__PosPop,
self.__PositiveNum) is False)
and (self.InstanceInList(
ins, self.__NextPop, sam) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.__NextPop.append(ins)
self.__Pop = []
for i in range(self.__SampleSize):
self.__Pop.append(self.__NextPop[i])
self.UpdatePosPop()
self.UpdateOptimal()
else:
BudCount = self.__SampleSize + self.__PositiveNum
while BudCount < self.__Budget:
print BudCount, self.__Optimal.getFitness()
BudCount += 1
while (True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(
0, self.__PositiveNum - 1)
Gsample = self.__ro.getUniformDouble(0, 1)
if (Gsample <= self.__RandProbability):
NonChosenDim = self.DiscreteShrinkModel(
self.__PosPop[ChosenPos], self.__dimension)
for i in range(len(NonChosenDim)):
self.__label[NonChosenDim[i]] = False
ins = self.PosRandomDiscreteInstance(
self.__PosPop[ChosenPos], self.__dimension,
self.__label)
if ((self.InstanceInList(ins, self.__PosPop,
self.__PositiveNum) is False)
and (self.InstanceInList(
ins, self.__Pop, self.__SampleSize) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.OnlineUpdate(ins)
self.UpdateOptimal()
return
# Distinguish function for mixed optimization
def MixDistinguish(self, ins):
for i in range(self.__SampleSize):
j = 0
while j < self.__dimension.getSize():
if self.__dimension.getType(j) is True:
if self.__Pop[i].getFeature(j) < self.__region[j][
0] or self.__Pop[i].getFeature(
j) > self.__region[j][1]:
break
else:
if self.__label[j] is False and ins.getFeature(
j) != self.__Pop[i].getFeature(j):
break
j += 1
if j >= self.__dimension.getSize():
return False
return True
# PosRandomInstance for mixed optimization
def PosRandomMixInstance(self, PosIns, dim, regi, lab):
ins = Instance(dim)
for i in range(dim.getSize()):
if lab[i] is False:
ins.setFeature(i, PosIns.getFeature(i))
else:
if dim.getType(i) is True: #continue
ins.setFeature(
i, self.__ro.getUniformDouble(regi[i][0], regi[i][1]))
else: #discrete
ins.setFeature(
i,
self.__ro.getUniformInteger(
dim.getRegion(i)[0],
dim.getRegion(i)[1]))
return ins
# ShrinkModel function for mixed optimization
def MixShrinkModel(self, ins):
ChosenDim = []
NonChosenDim = []
for i in range(self.__dimension.getSize()):
NonChosenDim.append(i)
count = 0
while self.MixDistinguish(ins) is False:
TempDim = NonChosenDim[self.__ro.getUniformInteger(
0,
len(NonChosenDim) - 1)]
ChosenNeg = self.__ro.getUniformInteger(0, self.__SampleSize - 1)
if self.__dimension.getType(TempDim) is True: #continue
if ins.getFeature(TempDim) < self.__Pop[ChosenNeg].getFeature(
TempDim):
btemp = self.__ro.getUniformDouble(
ins.getFeature(TempDim),
self.__Pop[ChosenNeg].getFeature(TempDim))
if btemp < self.__region[TempDim][1]:
self.__region[TempDim][1] = btemp
else:
btemp = self.__ro.getUniformDouble(
self.__Pop[ChosenNeg].getFeature(TempDim),
ins.getFeature(TempDim))
if btemp > self.__region[TempDim][0]:
self.__region[TempDim][0] = btemp
else:
ChosenDim.append(TempDim)
NonChosenDim.remove(TempDim)
self.__label[TempDim] = False
count += 1
while len(NonChosenDim) > self.__UncertainBits:
TempDim = NonChosenDim[self.__ro.getUniformInteger(
0,
len(NonChosenDim) - 1)]
ChosenDim.append(TempDim)
NonChosenDim.remove(TempDim)
self.__label[TempDim] = False
return
'''
RACOS for mixed optimization
param:
func: objective function name
ss: sample size
mt: max iteration size
pn: positive instance size
rp: the probability of sampling in model randomly
ub: uncertain bits
'''
def MixOpt(self, func, ss, mt, pn, rp, ub):
self.Clear()
self.setParameters(ss, mt, pn, rp, ub)
self.ResetModel()
self.Initialize(func)
if self.__OnlineSwitch is False:
for itera in range(self.__MaxIteration - 1):
self.__NextPop = []
# self.ShowPosPop(True)
# self.ShowPop(True)
for sam in range(self.__SampleSize):
while (True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(
0, self.__PositiveNum - 1)
Gsample = self.__ro.getUniformDouble(0, 1)
if (Gsample <= self.__RandProbability):
# print 'begin shrinking!'
self.MixShrinkModel(self.__PosPop[ChosenPos])
ins = self.PosRandomMixInstance(
self.__PosPop[ChosenPos], self.__dimension,
self.__region, self.__label)
if ((self.InstanceInList(ins, self.__PosPop,
self.__PositiveNum) is False)
and (self.InstanceInList(
ins, self.__NextPop, sam) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.__NextPop.append(ins)
self.__Pop = []
for i in range(self.__SampleSize):
self.__Pop.append(self.__NextPop[i])
self.UpdatePosPop()
self.UpdateOptimal()
else:
#online style
BudCount = self.__SampleSize + self.__PositiveNum
while BudCount < self.__Budget:
print BudCount, self.__Optimal.getFitness()
BudCount += 1
while (True):
self.ResetModel()
ChosenPos = self.__ro.getUniformInteger(
0, self.__PositiveNum - 1)
Gsample = self.__ro.getUniformDouble(0, 1)
if (Gsample <= self.__RandProbability):
# print 'begin shrinking!'
self.MixShrinkModel(self.__PosPop[ChosenPos])
ins = self.PosRandomMixInstance(self.__PosPop[ChosenPos],
self.__dimension,
self.__region,
self.__label)
if ((self.InstanceInList(ins, self.__PosPop,
self.__PositiveNum) is False)
and (self.InstanceInList(
ins, self.__Pop, self.__SampleSize) is False)):
ins.setFitness(func(ins.getFeatures()))
break
self.OnlineUpdate(ins)
self.UpdateOptimal()
return
