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)
示例#2
0
from sim import debug
from sim.learning.action import BATCH
from sim.learning.agent.qTableAgent import qTableAgent
from sim.learning.state.minimalSystemState import minimalSystemState
from sim.simulations.SimpleSimulation import SimpleSimulation, NEW_JOB
from sim.learning.state.discretisedSystemState import discretisedSystemState
from sim.tasks.job import job
from sim.tasks.tasks import EASY

exp = SimpleSimulation(numDevices=1,
                       maxJobs=1,
                       agentClass=qTableAgent,
                       systemStateClass=minimalSystemState,
                       autoJobs=False)
print("original:")
exp.sharedAgent.possibleActions = [BATCH]
exp.sharedAgent.numActions = 1
exp.sharedAgent.model.table = np.random.standard_normal(
    exp.sharedAgent.model.table.shape)
exp.sharedAgent.printModel()

dev = exp.devices[0]

for i in range(3):
    print()
    exp.processQueuedTask(0, (NEW_JOB, dev))
    exp.simulateTick()

    print("state:", exp.currentSystemState.currentState, dev.batchLength(EASY))

exp.sharedAgent.printModel()