def runThread(agent, numEpisodes, results, finished): exp = SimpleSimulation(numDevices=16, maxJobs=150, agentClass=agent, tasks=[HARD]) exp.scenario.setInterval(1) exp.setBatterySize(1e0) e = None try: for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode() results.put(["Agent %s" % agent.__name__, e, exp.getCurrentTime()]) except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment ̰:", exp.time) sys.exit(0) finished.put(True) # assert simulationResults.learningHistory is not None # histories.put(simulationResults.learningHistory) # print("\nsaving history", simulationResults.learningHistory, '\nr') print("forward", counters.NUM_FORWARD, "backward", counters.NUM_BACKWARD)
def runThread(agent, numEpisodes, results, finished): exp = SimpleSimulation(numDevices=2, maxJobs=maxjobs, agentClass=agent, tasks=[HARD], systemStateClass=minimalSystemState, scenarioTemplate=REGULAR_SCENARIO_ROUND_ROBIN, centralisedLearning=True, numEnergyLevels=numEnergyStates, trainClassification=True) # exp.scenario.setInterval(1) exp.sharedAgent.loadModel() exp.sharedAgent.setProductionMode() exp.setBatterySize(1e-1) exp.setFpgaIdleSleep(1e-3) e = None try: for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode(e) agentName = exp.devices[0].agent.__name__ result = [f"{agentName}", e, exp.numFinishedJobs] print(result) results.put(result) # results.put([f"{agentName}", e, exp.getCurrentTime()]) except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment :", exp.time) sys.exit(0) finished.put(True)
def threadRun(episodeNum, results, finished): exp = SimpleSimulation(numDevices=numDevices, maxJobs=100, tasks=[HARD], centralisedLearning=False) exp.setBatterySize(1e-1) exp.setFpgaIdleSleep(1e-3) for agent, device in zip( [lazyTableAgent, minimalTableAgent, minimalTableAgent], exp.devices): device.agent = agent(reconsiderBatches=False, systemState=exp.currentSystemState, owner=device, offPolicy=exp.offPolicy) device.agent.setDevices(exp.devices) print("set agent", agent, agent.__name__, device.agent, device.agent.__name__) print([device.agent.__name__ for device in exp.devices]) for e in range(int(episodeNum)): exp.simulateEpisode(e) for device in exp.devices: # print("putting results", device.agent.__name__, device.numJobsDone) # results.put(["Agent %s" % device.agent.__name__, e, device.currentTime.current]) results.put([ "Device %d Agent %s" % (device.index, device.agent.__name__), e, device.numJobsDone ]) sys.stdout.write("\rProgress: %.2f%%" % ((e + 1) / episodeNum * 100.)) finished.put(True)
def runThread(agent, numEpisodes, numDevices, taskOptions, results, finished): constants.CENTRALISED_LEARNING = False exp = SimpleSimulation(numDevices=numDevices, maxJobs=10, agentClass=agent, tasks=taskOptions, systemStateClass=targetedSystemState, reconsiderBatches=False, scenarioTemplate=RANDOM_SCENARIO_ROUND_ROBIN, centralisedLearning=False) exp.scenario.setInterval(1) exp.setFpgaIdleSleep(60) exp.setBatterySize(1e0) e = None try: for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode() times = np.zeros((len(taskOptions),)) for device in exp.devices: for t in range(len(taskOptions)): task = taskOptions[t] times[t] = device.fpga.getConfigTime(task) results.put(["Device %d %% time EASY" % device.index, e, times[0]/np.sum(times)]) # if times[1] == 0: # ratio = inf # else: # ratio = times[0] / times[1] # if ratio < 1 and ratio != 0: ratio = 1. / ratio # results.put(["Device %d EASY/HARD" % (device.index), e, ratio]) # print(e, "Device %d Task %s" % (device.index, task), e, device.getNumTasksDone(task)) except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment ̰:", exp.time) sys.exit(0) finished.put(True)
def runThread(jobInterval, fpgaSleepTime, numEpisodes, results, finished): exp = SimpleSimulation(numDevices=4, maxJobs=maxJobs) exp.setFpgaIdleSleep(fpgaSleepTime) exp.scenario.setInterval(jobInterval) print('interval', exp.scenario.timeInterval.mean) exp.setBatterySize(1e1) try: for i in range(numEpisodes): # exp.simulateTime(10) exp.simulateEpisode() results.put([ "FPGA Idle Sleep {} Interval {}".format( fpgaSleepTime, jobInterval), i, exp.getCurrentTime() ]) except: traceback.print_exc(file=sys.stdout) print( jobInterval, fpgaSleepTime, ) print("Error in experiment:", jobInterval, fpgaSleepTime, exp.getCurrentTime()) finished.put(True)
def runThread(agent, numEpisodes, results, finished): exp = SimpleSimulation(numDevices=16, maxJobs=150, agentClass=agent, tasks=[HARD]) exp.scenario.setInterval(1) exp.setBatterySize(1e0) e = None try: for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode() results.put([ "Agent %s" % agent.__name__, e, np.average([ device.totalSleepTime / device.currentTime.current for device in exp.devices ]) ]) except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment ̰:", exp.time) sys.exit(0) finished.put(True)
def run(results, finished): exp = SimpleSimulation(numDevices=numDevices, maxJobs=100, tasks=[HARD], centralisedLearning=False) exp.setBatterySize(1e0) # exp.setBatterySize(1e-5) # replace agents in devices # for dev in exp.devices: # print(dev.agent, dev.agent.model) for agent, device in zip([lazyTableAgent, minimalTableAgent, minimalTableAgent], exp.devices): device.agent = agent(systemState=exp.currentSystemState, owner=device, offPolicy=exp.offPolicy) device.agent.setDevices(exp.devices) print("set agent", agent, agent.__name__, device.agent, device.agent.__name__) # device.agent.reset() # device.reset() print([device.agent.__name__ for device in exp.devices]) for e in range(int(numEpisodes)): exp.simulateEpisode() for device in exp.devices: # print("putting results", device.agent.__name__, device.numJobsDone) # results.put(["Agent %s" % device.agent.__name__, e, device.currentTime.current]) results.put(["Device %d Agent %s" % (device.index, device.agent.__name__), e, device.numJobsDone]) 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)
def runThread(agent, numEpisodes, centralised, results, finished): exp = SimpleSimulation(numDevices=2, maxJobs=maxjobs, agentClass=agent, tasks=[HARD], systemStateClass=minimalSystemState, scenarioTemplate=REGULAR_SCENARIO_ROUND_ROBIN, centralisedLearning=centralised) # exp.scenario.setInterval(1) exp.setBatterySize(1e-1) exp.setFpgaIdleSleep(1e-3) e = None try: for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode(e) # results.put(["%s %s" % (exp.devices[0].agent.__name__, "Centralised" if centralised else "Decentralised"), e, exp.numFinishedJobs]) results.put([ "%s %s" % (exp.devices[0].agent.__name__, "Centralised" if centralised else "Decentralised"), e, exp.getCurrentTime() ]) except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment ̰:", exp.time) sys.exit(0) finished.put(True)
def runThread(agent, numEpisodes, results, finished, histories): exp = SimpleSimulation(numDevices=2, maxJobs=6, agentClass=agent) exp.setFpgaIdleSleep(5) exp.setBatterySize(1e0) try: for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode() results.put(["Duration %s" % exp.sharedAgent, e, exp.getCurrentTime()]) # results.put(["Episode reward %s" % exp.sharedAgent, e, exp.sharedAgent.episodeReward]) except: debug.printCache(200) traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment ̰:", exp.time) sys.exit(0) finished.put(True) assert simulationResults.learningHistory is not None histories.put(simulationResults.learningHistory) print("\nsaving history", simulationResults.learningHistory, '\nr') print("forward", counters.NUM_FORWARD, "backward", counters.NUM_BACKWARD) exp.sharedAgent.printModel()
def runThread(agent, numEpisodes, results, finished, histories): exp = SimpleSimulation(numDevices=1, maxJobs=3, agentClass=agent) exp.setFpgaIdleSleep(5) exp.setBatterySize(1e0) # sim.simulations.constants.FPGA_IDLE_SLEEP = 5 # sim.simulations.constants.OFFLOADING_POLICY = REINFORCEMENT_LEARNING # sim.simulations.constants.TOTAL_TIME = 1e3 try: for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode() results.put([ "Episode reward %s" % exp.sharedAgent, e, exp.sharedAgent.episodeReward ]) except: debug.printCache(200) traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment ̰:", exp.time) sys.exit(0) finished.put(True) assert simulationResults.learningHistory is not None histories.put(simulationResults.learningHistory) print("\nsaving history", simulationResults.learningHistory, '\nr') print("forward", counters.NUM_FORWARD, "backward", counters.NUM_BACKWARD) exp.sharedAgent.printModel()
def runThread(agent, numEpisodes, numDevices, taskOptions, results, finished): constants.CENTRALISED_LEARNING = False exp = SimpleSimulation(numDevices=numDevices, maxJobs=10, agentClass=agent, tasks=taskOptions, systemStateClass=targetedSystemState, reconsiderBatches=False, scenarioTemplate=RANDOM_SCENARIO_ROUND_ROBIN, centralisedLearning=False) exp.scenario.setInterval(1) exp.setFpgaIdleSleep(60) exp.setBatterySize(1e0) e = None try: for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode() for device in exp.devices: for task in taskOptions: results.put(["Device %d Task %d" % (device.index, task.identifier), e, device.getNumTasksDone(task)]) # print(e, "Device %d Task %s" % (device.index, task), e, device.getNumTasksDone(task)) except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment ̰:", exp.time) sys.exit(0) finished.put(True)
def runThread(agent, numEpisodes, results, finished, histories): exp = SimpleSimulation(numDevices=2, maxJobs=6, agentClass=agent, scenarioTemplate=RANDOM_SCENARIO_RANDOM) exp.setBatterySize(1e0) try: for e in range(int(numEpisodes / 2)): exp.simulateEpisode() results.put(["Agent %s" % agent.__name__, e, exp.numFinishedJobs]) exp.sharedAgent.setProductionMode(True) for e in range(int(numEpisodes / 2), int(numEpisodes)): exp.simulateEpisode() results.put(["Agent %s" % agent.__name__, e, exp.numFinishedJobs]) except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent) print("Error in experiment ̰:", exp.time) sys.exit(0) finished.put(True)
def runThread(numTrain, numTest, agent, maxJobs, results, finished): exp = None try: # pretrain exp = SimpleSimulation(numDevices=numDevices, maxJobs=maxJobs, agentClass=agent, tasks=[HARD], systemStateClass=extendedSystemState, jobInterval=1) exp.setBatterySize(1e-1) exp.setFpgaIdleSleep(1e-3) exp.simulateEpisodes(int(numTrain)) except: traceback.print_exc(file=sys.stdout) if exp is not None: print("Error in experiment:", maxJobs, exp.time) exp.sharedAgent.setProductionMode() for i in range(int(numTest)): exp.simulateEpisode(int(numTrain) + i) results.put([ "Agent %s" % exp.sharedAgent.__name__, maxJobs, exp.numFinishedJobs ]) # results.put(["", jobInterval, np.average([dev.numJobs for dev in exp.devices]) / exp.getCompletedJobs()]) finished.put(True)
def runThread(agent, numEpisodes, numDevices, taskOptions, interval, results, finished): constants.CENTRALISED_LEARNING = False exp = SimpleSimulation(numDevices=numDevices, maxJobs=50, agentClass=agent, tasks=taskOptions, systemStateClass=targetedSystemState, reconsiderBatches=False, scenarioTemplate=RANDOM_SCENARIO_ROUND_ROBIN, centralisedLearning=False) exp.scenario.setInterval(interval) exp.setFpgaIdleSleep(1e-3) exp.setBatterySize(1e-1) assert numEpisodes % 2 == 0 offset = 0 e = 0 reduced = False try: #pretrain # for e in range(0): # exp.simulateEpisode() debug.infoEnabled = False for i in range(2): for e in range(int(numEpisodes / 2)): exp.simulateEpisode(e) dol_ind_task, dol_task_ind = DOL(exp.devices, taskOptions) results.put( ["DOL %d devices" % numDevices, offset + e, dol_ind_task]) results.put([ "Jobs Completed %d devices" % numDevices, offset + e, exp.numFinishedJobs ]) # results.put(["Interval %.2f" % interval, e, dol_ind_task]) if not reduced: print() # remove half for i in range(int(numDevices / 2)): exp.removeDevice() reduced = True print("reduce to", exp.devices) offset = e finished.put("") except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment ̰:", exp.time) print(agent, numEpisodes, numDevices, taskOptions, interval, e, offset, reduced) sys.exit(0) finished.put(True)
def runThread(agent, numEpisodes, numDevices, taskOptions, interval, results, finished): constants.CENTRALISED_LEARNING = False exp = SimpleSimulation(numDevices=numDevices, maxJobs=10, agentClass=agent, tasks=taskOptions, systemStateClass=targetedSystemState, reconsiderBatches=False, scenarioTemplate=RANDOM_SCENARIO_ROUND_ROBIN, centralisedLearning=False) exp.scenario.setInterval(interval) exp.setFpgaIdleSleep(5) exp.setBatterySize(1e0) e = None try: #pretrain for e in range(0): exp.simulateEpisode() for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode() times = np.zeros((len(taskOptions),)) percentages = np.zeros((numDevices,)) for device in exp.devices: for t in range(len(taskOptions)): task = taskOptions[t] times[t] = device.fpga.getConfigTime(task) sum = np.sum(times) if sum > 0: perc = times[0] / sum else: perc = 0.5 if perc < 0.5: perc = 1. - perc percentages[device.index] = perc # results.put(["", np.average(percentages), exp.numFinishedJobs]) results.put(["Interval %.2f" % interval, np.average(percentages), exp.numFinishedJobs]) # for device in exp.devices: # device.agent.setProductionMode() # exp.simulateEpisode() finished.put("") # if times[1] == 0: # ratio = inf # else: # ratio = times[0] / times[1] # if ratio < 1 and ratio != 0: ratio = 1. / ratio # results.put(["Device %d EASY/HARD" % (device.index), e, ratio]) # print(e, "Device %d Task %s" % (device.index, task), e, device.getNumTasksDone(task)) except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment ̰:", exp.time) sys.exit(0) finished.put(True)
def runThread(id, agent, systemState, productionMode, offPolicy, numPhases, numEpisodes, results, finished): exp = SimpleSimulation(numDevices=4, maxJobs=maxjobs, agentClass=agent, tasks=[HARD], systemStateClass=systemState, scenarioTemplate=REGULAR_SCENARIO_ROUND_ROBIN, centralisedLearning=True, numEnergyLevels=numEnergyStates, trainClassification=True, offPolicy=offPolicy, allowExpansion=True) exp.setBatterySize(1e-1) exp.setFpgaIdleSleep(1e-3) exp.sharedAgent.loadModel() exp.sharedAgent.setProductionMode(productionMode) e = None overallEpisode = 0 try: for phase in range(numPhases): for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode(e) agentName = exp.devices[0].agent.__name__ result = [ f"{agentName} Production: {productionMode} OffPolicy: {offPolicy}", overallEpisode + e, exp.numFinishedJobs ] # print("result", result) results.put(result) # results.put([f"{agentName}", e, exp.getCurrentTime()]) # check if not the last one if phase < numPhases - 1: beforeStates = exp.currentSystemState.getUniqueStates() for i in range(5): exp.expandState("jobsInQueue") # print("\nexpand:", beforeStates, exp.currentSystemState.getUniqueStates()) # print() overallEpisode += numEpisodes except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e, offPolicy, productionMode) print("Error in experiment :", exp.time) sys.exit(0) finished.put(True)
def profileTarget(): debug.settings.enabled = False debug.settings.learnEnabled = False exp = Simulation(numDevices=2, systemStateClass=minimalSystemState, agentClass=minimalDeepAgent, centralisedLearning=True, offPolicy=True, trainClassification=False) exp.setBatterySize(1e-1) for i in range(1): exp.simulateEpisode(i)
def runThread(agent, numTicks, numDevices, results, finished, histories): exp = SimpleSimulation(numDevices=numDevices, scenarioTemplate=REGULAR_SCENARIO_RANDOM, jobInterval=10, agentClass=agent) exp.setBatterySize(1e4) exp.reset() timeOffsets = dict() previousTime = dict() currentEnergy = dict() for dev in exp.devices: timeOffsets[dev] = 0 currentEnergy[dev] = dev.energyLevel previousTime[dev] = 0 dev.latestPower = None i = None try: for i in range(numTicks): if exp.finished: for dev in exp.devices: timeOffsets[dev] += dev.currentTime.current exp.reset() # for i in range(): usages = exp.simulateTick() if usages == []: usages = [(0, 0), (0, 0)] for duration, power in usages: currentTime = previousTime[exp.latestDevice] + duration results.put([ "%s Power" % exp.latestDevice, previousTime[exp.latestDevice], power * 1e3 ]) previousTime[exp.latestDevice] = currentTime results.put( ["%s Power" % exp.latestDevice, currentTime, power * 1e3]) time.sleep(0.2) except: traceback.print_exc(file=sys.stdout) print(agent, i) print("Error in experiment ̰:", exp.time) debug.printCache(200) sys.exit(0) finished.put(True) # assert simulationResults.learningHistory is not None # histories.put(simulationResults.learningHistory) # print("\nsaving history", simulationResults.learningHistory, '\nr') print("forward", counters.NUM_FORWARD, "backward", counters.NUM_BACKWARD)
def runThread(id, agent, productionMode, offPolicy, numEpisodes, results, finished): startTime = datetime.now() exp = SimpleSimulation(numDevices=4, maxJobs=maxjobs, agentClass=agent, tasks=[HARD], systemStateClass=extendedSystemState, scenarioTemplate=REGULAR_SCENARIO_ROUND_ROBIN, centralisedLearning=True, numEnergyLevels=numEnergyStates, trainClassification=True, offPolicy=offPolicy) exp.sharedAgent.precache = True # exp.scenario.setInterval(1) exp.sharedAgent.loadModel() if productionMode: exp.sharedAgent.setProductionMode() exp.setBatterySize(1e-1) exp.setFpgaIdleSleep(1e-3) e = None try: for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode(e) agentName = exp.devices[0].agent.__name__ result = [ f"{agentName} PM: {productionMode} OP: {offPolicy}", e, exp.numFinishedJobs ] results.put(result) # result = [f"{agentName} PM: {productionMode} OP: {offPolicy} JOBS", e, exp.jobCounter] # results.put(result) except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment :", exp.time) sys.exit(0) finished.put(True) print( f"duration: {agent} PM {productionMode} OP {offPolicy}: {datetime.now() - startTime}" )
def runThread(agent, numEpisodes, results, finished): # constants.CENTRALISED_LEARNING = False exp = SimpleSimulation(numDevices=2, maxJobs=maxjobs, agentClass=agent, tasks=[HARD], systemStateClass=minimalSystemState, scenarioTemplate=REGULAR_SCENARIO_ROUND_ROBIN, reconsiderBatches=False, centralisedLearning=False) # exp.scenario.setInterval(1) exp.setFpgaIdleSleep(1e-3) exp.setBatterySize(1e-1) e = None try: for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode(e) results.put([ "Job %s" % exp.devices[0].agent.__name__, e, exp.numFinishedJobs ]) results.put([ "Duration %s" % exp.devices[0].agent.__name__, e, exp.getCurrentTime() ]) except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment ̰:", exp.time) sys.exit(0) finished.put(True) # assert simulationResults.learningHistory is not None # histories.put(simulationResults.learningHistory) # print("\nsaving history", simulationResults.learningHistory, '\nr') print("forward", counters.NUM_FORWARD, "backward", counters.NUM_BACKWARD) if exp.sharedAgent.__class__ == minimalTableAgent: plotting.plotModel(exp.sharedAgent, drawLabels=False)
def runThread(agent, numEpisodes, numDevices, taskOptions, interval, results, finished): constants.CENTRALISED_LEARNING = False exp = SimpleSimulation(numDevices=numDevices, maxJobs=10, agentClass=agent, tasks=taskOptions, systemStateClass=targetedSystemState, reconsiderBatches=False, scenarioTemplate=RANDOM_SCENARIO_ROUND_ROBIN, centralisedLearning=False) exp.scenario.setInterval(interval) exp.setFpgaIdleSleep(5) exp.setBatterySize(1e0) e = None try: #pretrain # for e in range(0): # exp.simulateEpisode() for e in range(numEpisodes): debug.infoEnabled = False exp.simulateEpisode() dol_ind_task, dol_task_ind = DOL(exp.devices, taskOptions) results.put(["DOL Devices %d" % numDevices, e, dol_ind_task]) results.put([ "Jobs Devices %d" % numDevices, e, exp.numFinishedJobs / 1000 ]) # results.put(["Interval %.2f" % interval, e, dol_ind_task]) finished.put("") except: debug.printCache() traceback.print_exc(file=sys.stdout) print(agent, e) print("Error in experiment ̰:", exp.time) sys.exit(0) finished.put(True)
def runThread(scenario, numEpisodes, results, finished): exp = SimpleSimulation(maxJobs=6, scenarioTemplate=scenario) exp.setBatterySize(1e0) e = -1 try: for e in range(numEpisodes): exp.simulateEpisode() results.put([str(scenario), e, exp.numFinishedJobs]) except: debug.printCache() traceback.print_exc(file=sys.stdout) print(scenario, e) print("Error in experiment ̰:", exp.time) sys.exit(0) try: finished.put(True) except: traceback.print_stack() print("forward", counters.NUM_FORWARD, "backward", counters.NUM_BACKWARD)
def threadRun(percentageMinimal, episodeNum, results, finished): exp = SimpleSimulation(numDevices=numDevices, maxJobs=50, tasks=[HARD], centralisedLearning=False, systemStateClass=minimalSystemState, scenarioTemplate=REGULAR_SCENARIO_ROUND_ROBIN) exp.scenario.setInterval(interval / numDevices) exp.setBatterySize(1e-1) exp.setFpgaIdleSleep(1e-3) numMinimal = int(numDevices * percentageMinimal) numRandom = numDevices - numMinimal agents = [minimalTableAgent] * numMinimal + [randomAgent] * numRandom for agent, device in zip(agents, exp.devices): device.agent = agent(reconsiderBatches=False, systemState=exp.currentSystemState, owner=device, offPolicy=exp.offPolicy) device.agent.setDevices(exp.devices) # print("set agent", agent, agent.__name__, device.agent, device.agent.__name__) for e in range(int(episodeNum)): exp.simulateEpisode(e) totalMinimalAgentJobs = 0 for i in range(numMinimal): dev = exp.devices[i] assert dev.agent.__class__ == minimalTableAgent totalMinimalAgentJobs += dev.numJobsDone results.put([ "%d %% Basic Agents" % (int(percentageMinimal * 100.)), e, totalMinimalAgentJobs / numMinimal ]) # sys.stdout.write("\rProgress: %.2f%%" % ((e+1)/episodeNum*100.)) finished.put(True)
def runThread(results, finished): exp = SimpleSimulation(numDevices=4, maxJobs=100, reconsiderBatches=False, systemStateClass=minimalSystemState, agentClass=minimalTableAgent) exp.setFpgaIdleSleep(1e-2) exp.setBatterySize(1e6) try: for i in range(numJobs): exp.simulateUntilJobDone() results.put( ["Loss", exp.completedJobs, exp.sharedAgent.latestLoss, False]) # results.put(["Reward", exp.completedJobs, exp.sharedAgent.latestReward, True]) # results.put(["Action", exp.completedJobs, exp.sharedAgent.latestAction, True]) # results.put(["MAE", exp.completedJobs, exp.sharedAgent.latestMAE, True]) # results.put(["MeanQ", exp.completedJobs, exp.sharedAgent.latestMeanQ, True]) except: traceback.print_exc(file=sys.stdout) sys.exit(0) print("Error in experiment:", exp.time) finished.put(True)
def runThread(jobInterval, fpgaSleepTime, numEpisodes, results, finished): exp = SimpleSimulation(numDevices=4) exp.scenario.setInterval(1) exp.setFpgaIdleSleep(fpgaSleepTime) exp.setBatterySize(1e1) try: for i in range(numEpisodes): # exp.simulateTime(10) exp.simulateEpisode() except: traceback.print_exc(file=sys.stdout) print( jobInterval, fpgaSleepTime, ) print("Error in experiment:", jobInterval, fpgaSleepTime, exp.getCurrentTime()) results.put([ "FPGA Idle Sleep {}".format(fpgaSleepTime), jobInterval, np.sum(exp.totalDevicesEnergy()) / exp.getNumDevices() ]) finished.put(True)
def singleThread(ID, depth, width, loss, epochs, results): # import tensorflow as tf # import tensorflow.config.gpu # tf.config.gpu.set_per_process_memory_growth(True) # tf.debugging.set_log_device_placement(True) # create deep agent for learning dqnExp = SimpleSimulation(numDevices=4, maxJobs=MAX_JOBS, agentClass=dqnAgent, tasks=[HARD], systemStateClass=systemStateClass, scenarioTemplate=REGULAR_SCENARIO_ROUND_ROBIN, centralisedLearning=True, numEnergyLevels=NUM_ENERGY_STATES, trainClassification=CLASSIFICATION) dqnExp.setBatterySize(1e-1) dqnExp.setFpgaIdleSleep(1e-3) # %% # train deep agent deepAgent = dqnExp.sharedAgent deepAgent.loss = loss deepAgent.createModel(depth, width) deepAgent.fit(trainingData, trainingTargetOneHot, epochs=epochs, split=0.0, class_weights=class_weights_dict) if CLASSIFICATION: output = deepAgent.model.evaluate(trainingData, trainingTargetOneHot, verbose=0) else: output = deepAgent.fullModel.evaluate( trainingData, trainingTargetOneHot.argmax(axis=1), verbose=0) predictions = deepAgent.model.predict_on_batch(trainingData) # print("evaluate: ", ID, output) if CLASSIFICATION: confusion = metrics.confusion_matrix(trainingTarget, predictions.argmax(axis=1)) else: # print(trainingTargetOneHot.argmax(axis=1)) onehot = np.eye( np.shape(trainingTargetOneHot)[1])[trainingTargetOneHot.argmax( axis=1)] # print(onehot) # print(deepAgent.fullModel.predict_on_batch(trainingData).argmax(axis=1)) confusion = metrics.confusion_matrix( trainingTargetOneHot.argmax(axis=1), deepAgent.fullModel.predict_on_batch(trainingData).argmax(axis=1)) # full estimate # print(deepAgent.model.predict_on_batch(trainingData)) # print(deepAgent.fullModel.predict_on_batch(trainingData)) # deepAgent.model.summary() # deepAgent.fullModel.summary() # print('done') deepAgent.saveModel(ID) result = (depth, width, loss, output[1], confusion, epochs, ID) # print(result) results.put(result)
systemStateClass = extendedSystemState # %% # create table agent for training data tableExp = SimpleSimulation(numDevices=4, maxJobs=MAX_JOBS, agentClass=minimalTableAgent, tasks=[HARD], systemStateClass=systemStateClass, scenarioTemplate=REGULAR_SCENARIO_ROUND_ROBIN, centralisedLearning=True, numEnergyLevels=NUM_ENERGY_STATES, trainClassification=CLASSIFICATION) tableExp.sharedAgent.loadModel() tableExp.setBatterySize(1e-1) tableExp.setFpgaIdleSleep(1e-3) # %% def chooseState(state, chosenJobs, chosenBatteryLevel): state = tableExp.sharedAgent.systemState maxJobs = state.maxJobs numBatteryLevels = state.singlesDiscrete['energyRemaining'] state.setField('jobsInQueue', chosenJobs / maxJobs) state.setField('energyRemaining', chosenBatteryLevel / numBatteryLevels) # %% # prepare training and testing data
from sim.learning.agent.localAgent import localAgent from sim.simulations.SimpleSimulation import SimpleSimulation if __name__ == "__main__": exp = SimpleSimulation(agentClass=localAgent) exp.setBatterySize(1e-1) # debug.settings.learnEnabled = True # debug.settings.enabled = True exp.simulateEpisode()
def runThread(numEpisodes, results, finished): dqnExp = SimpleSimulation(numDevices=2, maxJobs=maxjobs, agentClass=dqnAgent, tasks=[HARD], systemStateClass=minimalSystemState, scenarioTemplate=REGULAR_SCENARIO_ROUND_ROBIN, centralisedLearning=True, numEnergyLevels=numEnergyStates, trainClassification=False) # exp.scenario.setInterval(1) dqnExp.sharedAgent.loadModel() # dqnExp.sharedAgent.fullModel.summary() # dqnExp.sharedAgent.model.summary() dqnExp.sharedAgent.setProductionMode() dqnExp.setBatterySize(1e-1) dqnExp.setFpgaIdleSleep(1e-3) tableExp = SimpleSimulation(numDevices=2, maxJobs=maxjobs, agentClass=minimalTableAgent, tasks=[HARD], systemStateClass=minimalSystemState, scenarioTemplate=REGULAR_SCENARIO_ROUND_ROBIN, centralisedLearning=True, numEnergyLevels=numEnergyStates, trainClassification=True) # exp.scenario.setInterval(1) tableExp.sharedAgent.loadModel() tableExp.sharedAgent.setProductionMode() tableExp.setBatterySize(1e-1) tableExp.setFpgaIdleSleep(1e-3) print("states:", tableExp.sharedAgent.systemState.uniqueStates) duplicates = [] # iterate through possible states for i in range(tableExp.sharedAgent.systemState.uniqueStates): # set state in both experiments state = tableExp.sharedAgent.systemState.fromIndex(i) # table agentName = tableExp.sharedAgent.__name__ qvalues = tableExp.sharedAgent.predict(state) print(np.where(qvalues == np.max(qvalues))[0]) if np.where(qvalues == np.max(qvalues))[0].shape[0] > 1: duplicates.append(i) for j in range(tableExp.sharedAgent.numActions): result = [f"{agentName} {j}", i, qvalues[j]] results.put(result) # dqn agentName = dqnExp.sharedAgent.__name__ qvalues = dqnExp.sharedAgent.predict(dqnExp.sharedAgent.model, state.currentState) for j in range(dqnExp.sharedAgent.numActions): result = [f"{agentName} {j}", i, qvalues[j]] results.put(result) # results.put([f"{agentName}", e, exp.getCurrentTime()]) print("DUPLICATES", duplicates) # except: # debug.printCache() # traceback.print_exc(file=sys.stdout) # print(agent, e) # print("Error in experiment :", exp.time) # sys.exit(0) finished.put(True)
exp = SimpleSimulation(numDevices=4, maxJobs=5, reconsiderBatches=False, tasks=[HARD], agentClass=agent, centralisedLearning=True, systemStateClass=systemStateClass, scenarioTemplate=REGULAR_SCENARIO_ROUND_ROBIN, trainClassification=True, offPolicy=True) # exp.sharedAgent.createModel(2, 8) # exp.sharedAgent.loadModel() # exp.sharedAgent.setProductionMode() exp.scenario.setInterval(1) exp.setFpgaIdleSleep(1e-3) exp.setBatterySize(1e-2) # print("pretraining...") numrepeats = 1e5 if long else 1 for i in range( int(numrepeats) ): # change this to train longer (i'm using 1e3 to get a decent view) exp.simulateEpisode(i) # debug.learnOut('\n') # debug.learnOut('\n') # print("testing") localConstants.DEBUG_HISTORY = False # debug.settings.learnEnabled = True # debug.settings.enabled = True # debug.settings.infoEnabled = True