def getTrainData():
"""获取训练数据"""
dataFilePath = "../data/samples-data.data"
labelsFilePath = "../data/samples-data-labels.data"
X = io.getData(dataFilePath)
Y = io.getData(labelsFilePath)
return X, Y
def excute():
"""针对训练好的模型进行寻优"""
logger.info("{}-sarsaOptimization-excute-{}".format('*' * 25, '*' * 25))
# Env基本参数定义
dim = 5 # 决策变量维数
actionDim = 3 # 动作策略维度
lowBoundary = [-300, -300, -300, -300, -200] # 变量下界值
upBoundary = [300, 300, 100, 300, 200] # 变量上界值
# 获得代理模型
modelName = getModelName()[1]
modelPath = modelPathFormat.format(modelName) # quadraticRegression
agent = io.getData(modelPath)
MAX_STEP = 10000
checkLens = 1000 # 检测最优最大步数
initPos = [[300, 300, 300, 300, 200]] # 最原始的模型尺寸
# # 结果最优的代理模型路径
# QSavingPath = "../data/Q.model"
# 执行动作
Q = io.getData(QSavingPath)
for pos in initPos: # 选择不同的起点进行
logger.info("using initial position: {}".format(pos))
curPos = pos[:] # 深度复制
e = EnvExcutor(agent,
dim,
lowBoundary,
upBoundary,
initPost=curPos,
checkLens=checkLens)
action = QExcutor.epsilonGreedyExcutor(Q, e.presentState)
while (e.isEnd is False) and (e.step < MAX_STEP):
e.interact(action) # 计算当前动作的奖赏
state = e.presentState # 获得当前状态
newAction = QExcutor.epsilonGreedyExcutor(
Q, state) # 根据累积奖赏获得当前状态的下一个动作
action = newAction
var, value = e.getOptimalValue()
# 按日期为目录保存绘制的结果曲线
sarsaResultsSavingDir = "sarsaModelExcuteResults/{}".format(TODAY)
tool.mkdirs(sarsaResultsSavingDir)
e.saveValueSnapShot(
'{}/optimalValueRecord.jpg'.format(sarsaResultsSavingDir))
e.saveVarSnapShot('{}/varRecord.jpg'.format(sarsaResultsSavingDir))
# 打印结果
logger.info(
"end step: {}, best result appears in step: {}, variabl: {}, optimal value: {}"
.format(e.step, e.optimalStep, var, value))
def testModelMAE(X, y):
"""测试模型对已有训练数据的拟合能力"""
logger.info("{}-testModelMAE-{}".format('*'*25, '*'*25))
curveFit = io.getData(curveFitModelSavingPath)
pdt = curveFit.predict(X)
rmae = tool.computeMAE(y, pdt)
logger.info("quadratic regression, predict mae : {}".format(rmae))
def testMultiVar():
modelName = "ElasticNet"
modelPath = "../data/{}.model".format(modelName)
func = io.getData(modelPath)
featureSize = 18
populationSize = 500
upperLimit = [100 for _ in range(featureSize)]
lowerLimit = [-100 for _ in range(featureSize)]
chromosomeLength = 10
maxIter = 1000
pc = 0.6
pm = 0.01
threshedValue = 10
isMax = False
ga = GA.GA(func,
featureSize,
populationSize,
upperLimit,
lowerLimit,
chromosomeLength,
maxIter=maxIter,
pc=pc,
pm=pm,
isMax=isMax,
threshedValue=threshedValue)
ga.fit()
def testModelPdtRMAE():
"""使用所有数据进行训练，然后对训练数据进行预测"""
logger.info("{}-testModelPdtRMAE-{}".format('*' * 25, '*' * 25))
stackModel = io.getData(stackModelSavingPath)
X, Y = getTrainData()
pdtValue = stackModel.predict(X)
retMSE = tool.computeRMAE(Y, pdtValue)
logger.info("stacking model using all data, RMAE : {}".format(retMSE))
def testSingleModelRMAE():
"""使用所有数据进行训练，然后对训练数据进行预测"""
logger.info("{}-testSingleModelRMAE-{}".format('*' * 25, '*' * 25))
X, Y = getTrainData()
names, models = model.getModel()
for n in names:
m = io.getData(singleModelSaving.format(n))
pdtValue = m.predict(X)
retMSE = tool.computeRMAE(Y, pdtValue)
logger.info("model: {}, using all data, RMAE : {}".format(n, retMSE))
def getTrainData():
"""获取训练数据"""
X = io.getData(dataFilePath)
Y = io.getData(labelsFilePath)
return X, Y
def loadModel(self):
"""加载模型"""
modelPath = modelPathFormat.format(self.modelName)
model = io.getData(modelPath)
return model
def testRes():
X = np.array([[299.99, 299.99, 99.99, 299.99, -199.99]])
curveFit = io.getData(curveFitModelSavingPath)
pdt = curveFit.predict(X)
print(pdt)
def train():
"""单目标，多约束寻优问题"""
logger.info("{}-sarsaOptimization-train-{}".format('*'*25, '*'*25))
global globalOptimalValue, MAX_STEP, EPSILON
# Env基本参数定义
dim = 5 # 决策变量维数
actionDim = 3 # 动作策略维度
lowBoundary = [-300, -300, -300, -300, -200] # 变量下界值
upBoundary = [300, 300, 100, 300, 200] # 变量上界值
# 获得代理模型
modelName = getModelName()[1]
modelPath = modelPathFormat.format(modelName) # quadraticRegression
agent = io.getData(modelPath)
MAX_STEP = 5000
maxIter = 1000 # 最大迭代数
checkLens = 5000 # 检测最优最大步数
lmb = 1 # 奖赏值学习率
elta = 2
gamma = 0.8 # 检查最优值的最大步数学习率
preOptimalValueDistance = 0 # 上一次迭代中前后两次最优解之间的步数间隔
# EPSILON衰减率
preEPSILON = EPSILON # 保存EPSILON值
eDescend = 0.001 # EPSILON衰减率，1000步后EPSILON衰减到0.0135
# 初始化起点位置
splitPointCount = 2
initPos = gridMeshPoints(lowBoundary, upBoundary, splitPointCount)
initPos.append([300, 300, 300, 300, 200]) # 最原始的模型尺寸
# 打印当前运行参数信息
# logger.info("The global optimalValue is not enabled, without EPSILON change")
logger.info("The global optimalValue is enabled")
logger.info("using model: {}".format(modelName))
logger.info("dim: {}, actionDim: {}, lowBoundary: {}, upBoundary: {},\n\
maxIter: {}, init checkLens: {}, lmb: {}, splitPointCount: {}, pointsSize:{},\n\
EPSILON: {}, MAX_STEP: {}"
.format(dim, actionDim, lowBoundary, upBoundary,
maxIter, checkLens, lmb, splitPointCount, len(initPos),
EPSILON, MAX_STEP))
totalIter = len(initPos) * maxIter # 总迭代数
count = 1 # 记录迭代数
Q = QFunction(dim, actionDim, lowBoundary, upBoundary) # 初始化Q函数
logger.info("use a new QFunction")
# # 选择上次最佳模型进行初始化
# preOptimalModelPath = "../data/sarsaModel/p-0-iter-830-sarsa-2020-01-06.model"
# Q = io.getData(preOptimalModelPath)
# logger.info("initial QFunction is backup from: {}".format(preOptimalModelPath))
# 开始训练
globalBestValue = []
for index, pos in enumerate(initPos): # 选择不同的起点进行
logger.info("start training, using initial position: {}".format(pos))
resultForEachStep = [] # 记录每一步的结果
bestValue = [] # 记录最优结果
checkLensStore = [checkLens] # 记录收敛步长数
preCheckLens = checkLens
EPSILON = preEPSILON
for it in range(maxIter):
curPos = pos[:] # 深度复制
e = Env(agent, dim, lowBoundary, upBoundary, initPost=curPos, checkLens=checkLens, lmb=lmb)
action = QExcutor.epsilonGreedy(Q, e.presentState)
while (e.isEnd is False) and (e.step < MAX_STEP):
# logger.info("action: {}".format(action))
state = e.presentState
reward = e.interact(action) # 计算当前动作的奖赏
newState = e.presentState # 获得当前状态
newAction = QExcutor.epsilonGreedy(Q, newState) # 根据累积奖赏获得当前状态的下一个动作
Q.updateStateAndAction(state, action, newState, newAction, reward) # 更新状态和动作
action = newAction[:]
# # 更新收敛检查步数
# # checkLens *= elta
# checkLens = abs(int(preCheckLens + elta * checkLens * (e.optimalStep / e.step - gamma)))
# checkLensStore.append(checkLens)
preOptimalValueGapDistance = e.getOptimalValueGapDistance()
var, value = e.getOptimalValue()
if globalOptimalValue and value < globalOptimalValue:
globalOptimalValue = value
# 记录每个迭代的最佳值
if var and value:
resultForEachStep.append([it, var, value])
if not bestValue or value < bestValue[2]:
bestValue = [it, var, value, pos, index]
curOptimalModelPath = os.path.join(os.path.dirname(QSavingPath), "p-{}-iter-{}-{}".format(index, it, os.path.basename(QSavingPath)))
io.saveData(Q, curOptimalModelPath)
# 按日期为目录保存绘制的结果曲线
e.saveValueSnapShot('{}/optimalValueRecord-P-{}-iter-{}.jpg'.format(sarsaResultsSavingDir, index, it))
e.saveVarSnapShot('{}/varRecord-P-{}-iter-{}.jpg'.format(sarsaResultsSavingDir, index, it))
e.saveRewardSnapShot('{}/rewardRecord-P-{}-iter-{}.jpg'.format(sarsaResultsSavingDir, index, it))
# 预估剩余运行时间
curTime = datetime.datetime.now()
curRunTime = curTime - startTime
meanIterRunTime = curRunTime / count
estimateTime = (totalIter - count) * meanIterRunTime
count += 1 # 迭代计数加1
# 更新EPSILON值
# EPSILON = (1 - eDescend) * EPSILON
# 打印当前变动参数，当前最佳值，预估仍需要运行时间的时间
logger.info("iter: {}, end step: {}, best value appears in step: {},\n\
optimal var: {}, optimal value: {},\n\
next checkLens: {}, preOptimalValueGapDistance: {},\n\
cur best value appears in iter: {},\n\
cur best optimal var:{}, cur best optimal value: {},\n\
cur EPSILON: {},\n\
still need to run: {}"
.format(it, e.step, e.optimalStep,
var, value,
checkLens, preOptimalValueGapDistance,
bestValue[0],
bestValue[1], bestValue[2],
EPSILON,
str(estimateTime)))
# 保存收敛步数曲线图
# saveProfileOfCheckLens(checkLensStore, '{}/checkLens-{}.jpg'.format(sarsaResultsSavingDir, index))
# 保存每个迭代结果曲线图以及当前最优解曲线图
saveProfileOfResults(resultForEachStep, '{}/result-{}.jpg'.format(sarsaResultsSavingDir, index))
# 打印使用当前初始起点的最优解
logger.info("p: {}, based on cur initial position, best value appears in iter: {}, var: {}, bestValue : {}"\
.format(index, bestValue[0], bestValue[1], bestValue[2]))
if not globalBestValue or globalBestValue[2] > bestValue[2]:
globalBestValue = bestValue
io.saveData(Q, QSavingPath) # 保存最终模型文件
logger.info("global best value: {}".format(globalBestValue))
endTime = datetime.datetime.now()
logger.info("run time: {}".format(str(endTime - startTime)))
def test():
dataSavePath = "../../data/samples-data.data"
X = io.getData(dataSavePath)
print(X)
