def run(episodeNum):
episodeNum = int(episodeNum)
setupMultithreading()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
processes = []
for _ in range(localConstants.REPEATS):
for percentage in np.linspace(0.1, 1.0, num=10):
processes.append(
multiprocessing.Process(target=threadRun,
args=(percentage, episodeNum, results,
finished)))
results = executeMulti(processes,
results,
finished,
numResults=episodeNum * len(processes))
# plotting.plotMulti("Competing Agents", results=results, ylabel="Job #", xlabel="Episode #") # , save=True)
plotting.plotMultiWithErrors("Competing Agents",
results=results,
ylabel="Job #",
xlabel="Episode #") # , save=True)
def run():
print("starting experiment")
debug.settings.enabled = False
debug.settings.learnEnabled = False
debug.settings.infoEnabled = False
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
histories = multiprocessing.Queue()
numDevices = 2
numTicks = int(1e1)
agentsToTest = [minimalTableAgent] # , lazyAgent]
for agent in agentsToTest: # [minimalAgent, lazyAgent]:
for _ in range(localConstants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(agent, numTicks, numDevices,
results, finished, histories)))
results = executeMulti(processes,
results,
finished,
assembly=assembleResultsBasic,
numResults=localConstants.REPEATS * numTicks * 2)
plotting.plotMulti("Device Power",
results=results,
ylabel="Power (in mW)",
xlabel="Tick #") #, ylim=[0, 0.1]) # , save=True)
def run():
print("starting experiment")
processes = list()
# offloadingOptions = [True, False]
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
numEpisodes = int(1e2)
for jobInterval in np.arange(1, 1e1, 1):
for fpgaSleepTime in np.arange(0, 1e-0, 2.5e-1):
for _ in range(localConstants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(jobInterval, fpgaSleepTime,
numEpisodes, results,
finished)))
results = executeMulti(processes,
results,
finished,
numResults=numEpisodes * len(processes))
plotMultiWithErrors("Average Energy", results=results) # , save=True)
def run(numEpisodes):
print("starting experiment")
debug.enabled = False
debug.learnEnabled = False
debug.infoEnabled = False
debug.settings.fileOutput = False
localConstants.DEBUG_HISTORY = False
debug.settings.maxCache = int(1e4)
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
numEpisodes = int(numEpisodes)
print(ALL_SCENARIOS, localConstants.REPEATS)
for scenario in ALL_SCENARIOS:
for _ in range(localConstants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(scenario, numEpisodes, results,
finished)))
results = executeMulti(processes,
results,
finished,
numResults=len(processes) * numEpisodes)
plotting.plotMultiWithErrors("Number of Jobs",
results=results,
ylabel="Job #",
xlabel="Episode #") # , save=True)
def run():
print("starting experiment")
debug.enabled = False
processes = list()
# constants.MINIMUM_BATCH = 5
localConstants.REPEATS = 1
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
numtrain = 1e3
numtest = int(1e1)
for agent in [lazyTableAgent, minimalTableAgent]:
# for agent in [lazyTableAgent]:
# for maxJobs in np.linspace(2, 100, num=10):
# for maxJobs in [256]:
for maxJobs in np.logspace(0, 9, base=2, num=10):
for _ in range(localConstants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(numtrain, numtest, agent,
int(maxJobs), results,
finished)))
results = executeMulti(processes,
results,
finished,
numResults=len(processes) * numtest)
plotMultiWithErrors("Max Jobs in Queue",
results=results,
ylabel="Total Jobs",
xlabel="Max Queue") # , save=True)
def run(numEpisodes):
print("starting experiment")
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
localConstants.REPEATS = 16
numEpisodes = int(numEpisodes)
# , ]minimalTableAgent
systemState = extendedSystemState
# agentsToTest = [minimalTableAgent, randomAgent] # minimalTableAgent, , localAgent]
numPhases = int(3e1)
for agent, offPolicy in [(minimalDeepAgent, True), (minimalDeepAgent, False), (minimalTableAgent, False)]:
for production in [True, False]:
for pretrain in [True, False]:
for _ in range(localConstants.REPEATS):
for centralised in [True]:
# if not (not centralised and agent is randomAgent):
processes.append(multiprocessing.Process(target=runThread, args=(
len(processes), agent, systemState, production, offPolicy, pretrain, numPhases, numEpisodes, results, finished)))
results = executeMulti(processes, results, finished, numResults=len(
processes) * numPhases * numEpisodes, assembly=assembleResults, chooseBest=1.0)
plotting.plotMultiWithErrors("experiment6", title="experiment 6", results=results, ylabel="Job #", xlabel="Episode #") # , save=True)
def run(numEpisodes):
print("starting experiment")
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
localConstants.REPEATS = 128
# localConstants.REPEATS = 8
numEpisodes = int(numEpisodes)
# agentsToTest = [minimalTableAgent]
agentsToTest = [minimalTableAgent, lazyTableAgent,
randomAgent] # , localAgent]
for agent in agentsToTest: # [minimalAgent, lazyAgent]:
for _ in range(localConstants.REPEATS):
for centralised in [True, False]:
if not (not centralised and agent is randomAgent):
processes.append(
multiprocessing.Process(target=runThread,
args=(agent, numEpisodes,
centralised, results,
finished)))
results = executeMulti(processes,
results,
finished,
numResults=len(processes) * numEpisodes)
# plotting.plotMultiWithErrors("Number of Jobs", results=results, ylabel="Job #", xlabel="Episode #") # , save=True)
# plotting.plotMultiWithErrors("experiment1", title="experiment 1", results=results, ylabel="Job #", xlabel="Episode #") # , save=True)
plotting.plotMultiWithErrors("experiment1duration",
title="experiment 1 duration",
results=results,
ylabel="Lifetime",
xlabel="Episode #") # , save=True)
def run(numEpisodes):
print("starting experiment")
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
localConstants.REPEATS = 2
# localConstants.REPEATS = 8
numEpisodes = int(numEpisodes)
# agentsToTest = [minimalTableAgent]
agentsToTest = [dqnAgent] # minimalTableAgent, , localAgent]
for _ in range(localConstants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(numEpisodes, results, finished)))
results = executeMulti(processes,
results,
finished,
numResults=len(processes) * numEnergyStates * 3 *
(maxjobs + 1) * 2)
# plotting.plotMultiWithErrors("experiment1", title="experiment 1", results=results, ylabel="", xlabel="Episode #") # , save=True)
plotting.plotMultiWithErrors("experiment1",
title="experiment 1",
results=results,
ylabel="Q Value",
xlabel="State Index") # , save=True)
def run(numEpisodes):
print("starting experiment")
processes = list()
# sim.simulations.constants.MINIMUM_BATCH = 1e7
# offloadingOptions = [True, False]
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
# experiments = multiprocessing.Queue()
# REPEATS = 1
# localConstants.REPEATS = 10
numEpisodes = int(numEpisodes)
agentsToTest = [minimalTableAgent, lazyTableAgent,
randomAgent] # localAgent]
for agent in agentsToTest: # [minimalAgent, lazyAgent]:
for _ in range(localConstants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(agent, numEpisodes, results,
finished)))
results = executeMulti(processes,
results,
finished,
numResults=len(agentsToTest) * numEpisodes *
localConstants.REPEATS)
# plotting.plotMultiWithErrors("Number of Jobs", results=results, ylabel="Job #", xlabel="Episode #") # , save=True)
plotting.plotMulti("Sleep Time",
results=results,
ylabel="Time Asleep %",
xlabel="Episode #") # , save=True)
def run():
print("starting experiment")
debug.enabled = False
processes = list()
constants.MINIMUM_BATCH = 5
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
for jobInterval in np.arange(1, 1e2, 1e0):
for _ in range(localConstants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(SimpleSimulation(
numDevices=numDevices,
jobInterval=Gaussian(
jobInterval, 1),
agentClass=lazyAgent), jobInterval,
results, finished)))
results = executeMulti(processes, results, finished)
plotMultiWithErrors("Average Power vs Job Interval",
results=results,
ylabel="Average Device Power",
xlabel="Job Interval") # , save=True)
def run(numEpisodes):
print("starting experiment")
processes = list()
# sim.simulations.constants.MINIMUM_BATCH = 1e7
# offloadingOptions = [True, False]
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
# experiments = multiprocessing.Queue()
# REPEATS = 1
numDevices = 2
# localConstants.REPEATS = 10
numEpisodes = int(numEpisodes)
# agentsToTest = [minimalTableAgent] #, lazyTableAgent]
# tasks = [[EASY], [EASY, HARD]]
taskOptions = [EASY, HARD]
# taskOptions = [HARD, ALTERNATIVE]
for t in range(len(taskOptions)):
taskOptions[t].identifier = t
print("task", taskOptions[t], taskOptions[t].identifier)
# for agent in agentsToTest: # [minimalAgent, lazyAgent]:
for _ in range(localConstants.REPEATS):
# for taskOptions in tasks:
processes.append(multiprocessing.Process(target=runThread, args=(minimalTableAgent, numEpisodes, numDevices, taskOptions, results, finished)))
results = executeMulti(processes, results, finished, numResults=len(processes) * numEpisodes * numDevices, assembly=experiment.assembleResultsBasic)
# plotting.plotMultiWithErrors("Number of Jobs", results=results, ylabel="Job #", xlabel="Episode #") # , save=True)
plotting.plotMulti("Number of Jobs", results=results, ylabel="EASY/HARD", xlabel="Episode #") # , save=True)
def run(numEpisodes):
print("starting experiment")
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
localConstants.REPEATS = 1
# localConstants.REPEATS = 8
numEpisodes = int(numEpisodes)
agentsToTest = [minimalTableAgent]
# agentsToTest = [minimalTableAgent, lazyTableAgent, randomAgent] # , localAgent]
for agent in agentsToTest: # [minimalAgent, lazyAgent]:
# for _ in range(localConstants.REPEATS):
for centralised in [True]:
if not (not centralised and agent is randomAgent):
processes.append(
multiprocessing.Process(target=runThread,
args=(agent, numEpisodes,
centralised, results,
finished)))
results = executeMulti(processes,
results,
finished,
numResults=len(processes) * numEpisodes)
def run():
print("starting experiment")
processes = list()
# offloadingOptions = [True, False]
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
numEpisodes = int(1e1)
for jobInterval in [0.1, 1]: #, 10]: #np.arange(0.1, 1., 0.3):
for fpgaSleepTime in [1e-6, 1e-3, 2e-3,
1e-2]: #, 1]:# np.arange(0, 1e-0, 5e-1):
for _ in range(localConstants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(jobInterval, fpgaSleepTime,
numEpisodes, results,
finished)))
results = executeMulti(processes,
results,
finished,
numResults=numEpisodes * len(processes))
plotMultiWithErrors("Total Jobs Done", results=results) # , save=True)
def run():
print("starting experiment")
# sim.constants.TOTAL_TIME = 1e3
processes = list()
constants.MINIMUM_BATCH = 1e5
# offloadingOptions = [True, False]
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
histories = multiprocessing.Queue()
constants.REPEATS = 1
constants.MAX_JOBS = 5
# for jobLikelihood in np.arange(1e-3, 1e-2, 1e-3):
# for roundRobin in np.arange(1e0, 1e1, 2.5):
for _ in range(constants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(results, finished, histories)))
results = executeMulti(processes,
results,
finished,
numResults=numJobs * constants.REPEATS)
plotMultiWithErrors("BatchSize",
results=results,
ylabel="Loss",
xlabel="Job #") # , save=True)
def run(numEpisodes):
print("starting experiment")
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
localConstants.REPEATS = 64
numEpisodes = int(numEpisodes)
agentsToTest = [minimalTableAgent, minimalDeepAgent]
# agentsToTest = [(minimalTableAgent, False), (minimalDeepAgent, True), (minimalDeepAgent, False), ]
for agent in agentsToTest:
for pretrain in [True, False]:
for centralised in [True]:
for _ in range(localConstants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(len(processes), agent,
pretrain, numEpisodes,
results, finished)))
results = executeMulti(processes,
results,
finished,
numResults=len(processes) * numEpisodes,
assembly=assembleResults,
chooseBest=1.0)
plotting.plotMultiWithErrors("experiment7",
title="experiment 7",
results=results,
ylabel="Job #",
xlabel="Episode #") # , save=True)
def run(numEpisodes):
print("starting experiment")
processes = list()
# sim.simulations.constants.MINIMUM_BATCH = 1e7
# offloadingOptions = [True, False]
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
# experiments = multiprocessing.Queue()
# REPEATS = 1
# numDevices = 6
# localConstants.REPEATS = 10
numEpisodes = int(numEpisodes)
# agentsToTest = [minimalTableAgent] #, lazyTableAgent]
# tasks = [[EASY], [EASY, HARD]]
taskOptions = [EASY, HARD]
# taskOptions = [HARD, ALTERNATIVE]
for t in range(len(taskOptions)):
taskOptions[t].identifier = t
print("task", taskOptions[t], taskOptions[t].identifier)
# testIntervals = np.logspace(-4, 0, num=5)
# testIntervals = [1e0]
# for agent in agentsToTest: # [minimalAgent, lazyAgent]:
localConstants.REPEATS = 1
for _ in range(localConstants.REPEATS):
# for taskOptions in tasks:
# for interval in testIntervals:
# interval = testIntervals
for numDevices in [2, 12]:
processes.append(
multiprocessing.Process(target=runThread,
args=(regretfulTableAgent, numEpisodes,
numDevices, taskOptions, 1,
results, finished)))
results = executeMulti(processes,
results,
finished,
numResults=len(processes) * numEpisodes *
2) #, assembly=experiment.assembleResultsBasic)
# plotting.plotMultiWithErrors("Number of Jobs", results=results, ylabel="Job #", xlabel="Episode #") # , save=True)
localConstants.SAVE_GRAPH = True
plotting.plotMultiWithErrors("DOL",
results=results,
ylabel="DOL",
xlabel="Episode #")
def run():
print("starting experiment")
debug.enabled = False
processes = list()
# constants.MINIMUM_BATCH = 5
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
for jobInterval in np.logspace(-3, 1, num=5, base=10.):
for _ in range(localConstants.REPEATS):
print(SimpleSimulation())
processes.append(multiprocessing.Process(target=runThread, args=(jobInterval, results, finished)))
results = executeMulti(processes, results, finished)
plotMultiWithErrors("Job Interval", results=results, ylabel="Total Jobs", xlabel="Job Interval") # , save=True)
def run():
print ("starting experiment")
processes = list()
# offloadingOptions = [True, False]
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
REPEATS = 6
for jobInterval in np.arange(1e1, 1e2, 1e1):
# for fpgaPowerPlan in [sim.fpgaPowerPolicy.FPGA_STAYS_ON]: # , sim.constants.FPGA_IMMEDIATELY_OFF, sim.constants.FPGA_WAIT_OFF]:
for _ in range(REPEATS):
processes.append(multiprocessing.Process(target=runThread, args=(SimpleSimulation(maxJobs=5, numDevices=numDevices, jobInterval=jobInterval), jobInterval, results, finished)))
results = executeMulti(processes, results, finished)
plotMultiWithErrors("sleep time", results=results) # , save=True)
def run(numEpisodes):
print("starting experiment")
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
localConstants.REPEATS = 32
numEpisodes = int(numEpisodes)
# , ]minimalTableAgent
systemState = targetedSystemState
# tasks = [EASY, HARD, MEDIUM, ALTERNATIVE] # this works somewhat
tasks = [EASY, MEDIUM, HARD, ALTERNATIVE][::-1] # comm is too hard?
for t in range(len(tasks)):
tasks[t].identifier = t
print("task", tasks[t], tasks[t].identifier)
numPhases = len(tasks)
for agent, offPolicy in [
(minimalDeepAgent, True), (minimalTableAgent, True)
]: # (minimalDeepAgent, False),
for _ in range(localConstants.REPEATS):
for centralised in [True]:
# if not (not centralised and agent is randomAgent):
processes.append(
multiprocessing.Process(
target=runThread,
args=(len(processes), agent, systemState, offPolicy,
tasks, numPhases, numEpisodes, results,
finished)))
results = executeMulti(processes,
results,
finished,
numResults=len(processes) * numPhases * numEpisodes,
assembly=assembleResults,
chooseBest=0.5)
plotting.plotMultiWithErrors("experiment9",
title="experiment 9",
results=results,
ylabel="Job #",
xlabel="Episode #") # , save=True)
def run(numEpisodes):
print("starting experiment")
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
numEpisodes = int(numEpisodes)
taskOptions = [EASY, HARD]
for t in range(len(taskOptions)):
taskOptions[t].identifier = t
print("task", taskOptions[t], taskOptions[t].identifier)
# localConstants.REPEATS = 128
localConstants.REPEATS = 16
for _ in range(localConstants.REPEATS):
for numDevices in [4, 8, 12]: #, 6, 8, 10, 12]:
# for numDevices in [4, 12]:
processes.append(
multiprocessing.Process(target=runThread,
args=(minimalTableAgent, numEpisodes,
numDevices, taskOptions, 1,
results, finished)))
results = executeMulti(processes,
results,
finished,
numResults=len(processes) * numEpisodes *
2) #, assembly=experiment.assembleResultsBasic)
# plotting.plotMultiWithErrors("Number of Jobs", results=results, ylabel="Job #", xlabel="Episode #") # , save=True)
# plotting.plotMultiWithErrors("DOL", results=results, ylabel="DOL", xlabel="Episode #")
codes = ["Jobs Completed", "DOL"]
plotting.plotMultiSubplots("experiment4normalised",
results=results,
ylabel=["System Jobs #", "DOL"],
xlabel="Episode #",
subplotCodes=codes,
plotErrors=True)
def run(numEpisodesTrain, numEpisodesTest):
print("starting experiment")
processes = list()
# sim.simulations.constants.MINIMUM_BATCH = 1e7
# offloadingOptions = [True, False]
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
# experiments = multiprocessing.Queue()
# REPEATS = 1
maxDevices = 12
minDevices = 2
numDevices = np.linspace(start=minDevices, stop=maxDevices, num=int((maxDevices - minDevices) / 2))
# localConstants.REPEATS = 10
numEpisodesTrain, numEpisodesTest = int(numEpisodesTrain), int(numEpisodesTest)
# agentsToTest = [minimalTableAgent] #, lazyTableAgent]
# tasks = [[EASY], [EASY, HARD]]
taskOptions = [EASY, HARD]
# taskOptions = [HARD, ALTERNATIVE]
for t in range(len(taskOptions)):
taskOptions[t].identifier = t
print("task", taskOptions[t], taskOptions[t].identifier)
# testIntervals = np.logspace(-4, 0, num=5)
testIntervals = np.linspace(1e-2, 1, num=3)
for _ in range(localConstants.REPEATS):
for interval in testIntervals:
for devs in numDevices:
processes.append(multiprocessing.Process(target=runThread, args=(numEpisodesTrain, numEpisodesTest, devs, taskOptions, interval, results, finished)))
results = executeMulti(processes, results, finished, numResults=len(processes) * numEpisodesTest*2) #, assembly=experiment.assembleResultsBasic)
# plotting.plotMultiWithErrors("Number of Jobs", results=results, ylabel="Job #", xlabel="Episode #") # , save=True)
localConstants.SAVE_GRAPH = True
plotting.plotMultiWithErrors("DOL", results=results, ylabel="DOL", xlabel="Interval")
def run():
print("starting experiment")
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
REPEATS = 1
# for jobLikelihood in np.arange(1e-3, 1e-2, 1e-3):
# for roundRobin in np.arange(1e0, 1e1, 2.5):
for _ in range(REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(results, finished)))
results = executeMulti(processes,
results,
finished,
numResults=numJobs * REPEATS * 1)
plotMultiWithErrors("Learning Behaviour",
results=results,
ylabel="Normalised Quantities",
xlabel="Job #") # , save=True)
def run():
print("starting experiment")
debug.enabled = False
debug.learnEnabled = False
debug.infoEnabled = False
# debug.fileOutput = True
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
histories = multiprocessing.Queue()
REPEATS = 1
numEpisodes = int(1e2)
agentsToTest = [minimalTableAgent, lazyTableAgent]
for agent in agentsToTest: # [minimalAgent, lazyAgent]:
for _ in range(REPEATS):
processes.append(multiprocessing.Process(target=runThread, args=(agent, numEpisodes, results, finished, histories)))
results = executeMulti(processes, results, finished, numResults=len(agentsToTest) * numEpisodes * REPEATS)
plotting.plotMultiWithErrors("Episode duration", results=results, ylabel="Duration", xlabel="Episode #") # , save=True)
def run():
print("starting experiment")
debug.enabled = False
debug.learnEnabled = False
debug.infoEnabled = False
localConstants.DEBUG_HISTORY = False
processes = list()
# sim.simulations.constants.MINIMUM_BATCH = 1e7
# offloadingOptions = [True, False]
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
histories = multiprocessing.Queue()
# REPEATS = 1
# localConstants.REPEATS = 10
numEpisodes = int(1e2)
agentsToTest = [minimalTableAgent, lazyTableAgent]
for agent in agentsToTest: # [minimalAgent, lazyAgent]:
for _ in range(localConstants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(agent, numEpisodes, results,
finished, histories)))
results = executeMulti(processes,
results,
finished,
numResults=len(agentsToTest) * numEpisodes *
localConstants.REPEATS)
plotting.plotMultiWithErrors("Number of Jobs (with production mode)",
results=results,
ylabel="Job #",
xlabel="Episode #") # , save=True)
def run(numEpisodes):
print("starting experiment")
processes = list()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
localConstants.REPEATS = 4
numEpisodes = int(numEpisodes)
taskOptions = [EASY, HARD]
for t in range(len(taskOptions)):
taskOptions[t].identifier = t
print("task", taskOptions[t], taskOptions[t].identifier)
for _ in range(localConstants.REPEATS):
# for taskOptions in tasks:
# for interval in testIntervals:
for numDevices in [4, 8, 12]: #, 6, 8, 10, 12]:
processes.append(
multiprocessing.Process(target=runThread,
args=(regretfulDeepAgent, numEpisodes,
numDevices, taskOptions, 1,
results, finished)))
results = executeMulti(processes,
results,
finished,
numResults=len(processes) * numEpisodes * 2)
plotting.plotMultiWithErrors("experiment8",
results=results,
ylabel="DOL",
xlabel="Episode #",
logy=False)
def run():
print("starting experiment")
debug.enabled = False
debug.learnEnabled = False
debug.infoEnabled = False
processes = list()
# sim.simulations.constants.MINIMUM_BATCH = 1e7
# offloadingOptions = [True, False]
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
histories = multiprocessing.Queue()
# sim.simulations.constants.REPEATS = 1
# for jobLikelihood in np.arange(1e-3, 1e-2, 1e-3):
# for roundRobin in np.arange(1e0, 1e1, 2.5):
numEpisodes = int(1e4)
agentsToTest = [lazyTableAgent] # agentsToTest = [lazyAgent] #
for agent in agentsToTest: # [minimalAgent, lazyAgent]:
for _ in range(localConstants.REPEATS):
processes.append(
multiprocessing.Process(target=runThread,
args=(agent, numEpisodes, results,
finished, histories)))
results = executeMulti(processes,
results,
finished,
numResults=len(agentsToTest) * numEpisodes *
localConstants.REPEATS)
plotting.plotMultiWithErrors("Episode Rewards",
results=results,
ylabel="Reward",
xlabel="Episode #") # , save=True)
# print("end of episode!", exp.time)
results.put(["test", index, exp.episodeNumber])
finished.put(True)
# print("Experiment done!", exp.time)
if __name__ == '__main__':
print("testing simple simulation")
constants.NUM_DEVICES = 1
constants.DEFAULT_ELASTIC_NODE.BATTERY_SIZE = 1e1
constants.OFFLOADING_POLICY = REINFORCEMENT_LEARNING
debug.enabled = False
constants.DRAW_DEVICES = False
processes = []
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
# for i in range(multiprocessing.cpu_count()-1):
for i in range(100):
processes.append(
multiprocessing.Process(target=runThread,
args=(i, results, finished)))
results = executeMulti(processes, results, finished)
plotMultiWithErrors("StabilityTest", results=results)
# np.set_printoptions(threshold=sys.maxsize, suppress=True)
# sim.learning.offloadingDecision.sharedAgent.printModel()
sys.stdout.write("\rProgress: %.2f%%" % ((e+1)/numEpisodes*100.))
# for device in exp.devices:
# # device.agent.printModel()
# device.agent.setProductionMode()
# for device in exp.devices:
# device.agent.printModel()
finished.put(True)
if __name__ == "__main__":
setupMultithreading()
results = multiprocessing.Queue()
finished = multiprocessing.Queue()
results = executeMulti([multiprocessing.Process(target=run, args=(results, finished))], results, finished, numResults=numEpisodes * numDevices)
plotting.plotMulti("Competing Agents", results=results, ylabel="Job #", xlabel="Episode #") # , save=True)
# <Lazy Agent> Model
# energyRemaining = 0 jobsInQueue = 0 currentConfig = 0 [ 0.0015 0.0019 3.7539 ]
# energyRemaining = 0 jobsInQueue = 0 currentConfig = 1 [ 25.0000 25.0000 25.0000 ]
# energyRemaining = 0 jobsInQueue = 1 currentConfig = 0 [ -5.8986 0.0019 9.6867 ]
# energyRemaining = 0 jobsInQueue = 1 currentConfig = 1 [ 25.0000 25.0000 25.0000 ]
# energyRemaining = 0 jobsInQueue = 2 currentConfig = 0 [ -0.1022 0.0019 16.4031 ]
# energyRemaining = 0 jobsInQueue = 2 currentConfig = 1 [ 25.0000 25.0000 25.0000 ]
# energyRemaining = 0 jobsInQueue = 3 currentConfig = 0 [ 0.6967 25.0000 -10.7927 ]
# energyRemaining = 0 jobsInQueue = 3 currentConfig = 1 [ 25.0000 25.0000 25.0000 ]
