Example #1
0
def createComparisonDataSeries(directory, romStringList, taskIDList, taskPrefixList, extensionList, baselineDirectory, summed = False, divided = True, resultsCollectionFunction = dataManipulation.getResultsFromTaskFile, taskSeparator = "^"):
    #romStringList, taskIDList and taskPrefixList must be of the same size
    if len(romStringList) != len(taskIDList) and len(taskIDList) != len(taskPrefixList):
        raise Exception("Lists are not of equal size cant parse data properly")

    counter = 0
    gameDict = {}
    minNumTasks = -1
    maxNumTasks = float('inf')
    gameTitle = romStringList[0].split(taskSeparator)[taskIDList[0]]

    for g in xrange(len(taskPrefixList)):
        gameDict[g] = {}

        
    for romString in romStringList:
        pathToArchs = (directory + "/" + romString)
        games = romString.split(taskSeparator)
        numTasksinRomString = len(games)

        if numTasksinRomString > minNumTasks:
            minNumTasks = numTasksinRomString
        if numTasksinRomString > maxNumTasks:
            maxNumTasks = numTasksinRomString

        for arch in extensionList:
            archDirectory = pathToArchs + "/" + arch
            taskID = taskIDList[counter]
            if summed:
                taskFile = "/averaged_task_" + str(taskID) + "_results_Summed.csv"
            else:
                taskFile = "/averaged_task_" + str(taskID) + "_results.csv"

            gameDict[counter][arch] = resultsCollectionFunction(archDirectory + "/" + taskFile)

            if divided:
                    gameDict[counter][arch][0] = dataManipulation.divideDataElementsByFactor(gameDict[counter][arch][0], numTasksinRomString)

                    if summed:
                        gameDict[counter][arch][1] = dataManipulation.divideDataElementsByFactor(gameDict[counter][arch][1], numTasksinRomString)

        counter += 1

    if summed:
        baselineFile = baselineDirectory + "/" + gameTitle + "/DQNNet/averaged_task_0_results_Summed.csv"
    else:
        baselineFile = baselineDirectory + "/" + gameTitle + "/DQNNet/averaged_task_0_results.csv"

    gameDict["baseline"] = resultsCollectionFunction(baselineFile)

    if divided:       
        numDataPointsToUse = int(len(gameDict["baseline"][0]) / (minNumTasks / 2))
        gameDict["baseline"][0] = gameDict["baseline"][0][0:numDataPointsToUse]
        gameDict["baseline"][1] = gameDict["baseline"][1][0:numDataPointsToUse]
        gameDict["baseline"][2] = gameDict["baseline"][2][0:numDataPointsToUse]



    taskDataSeriesList = []
    baselineDataSeries = DataSeries(gameDict["baseline"][0], gameDict["baseline"][1], gameDict["baseline"][2], gameTitle + "_Baseline")

    counter = 0
    plotcount = 1
    for romString in romStringList:
        for arch in extensionList:
            currentArchDataSeries = DataSeries(gameDict[counter][arch][0], gameDict[counter][arch][1], gameDict[counter][arch][2], taskPrefixList[counter] + "_" + arch)
            taskDataSeriesList.append(currentArchDataSeries)
        counter += 1

    taskDataSeriesList.append(baselineDataSeries)


    titleSuffix = ""
    if summed:
        titleSuffix = "_Summed"

    plotDataSeries(plotcount, taskDataSeriesList, gameTitle + "_" + ",".join(extensionList)+"_GameComparison", saveFigure = directory + "/" + gameTitle + titleSuffix + "_" + ",".join(extensionList)+"_GameComparison")
    plt.show()
Example #2
0
def createExperimentDataSeries(directory, baselineDirectory, romString, summed = True, divided = True, resultsCollectionFunction = dataManipulation.getResultsFromTaskFile,taskSeparator = "^"):
    pathToArchs = (directory + "/" + romString)
    games = romString.split(taskSeparator)
    numTasks = len(games)
    gameDict = {}
    archList = []

    for g in games:
        gameDict[g] = {}

    #load transfer part
    for arch in os.listdir(pathToArchs):
        if "." in arch:
            continue #Not a directory

        archList.append(arch)
        archDirectory = pathToArchs + "/" + arch

        for file in os.listdir(archDirectory):
            if "results" in file and ".csv" in file and ((not summed and "Summed" not in file) or (summed and "Summed" in file)):
                print archDirectory + "/" + file
                taskNum = int(file[file.index('task_') + 5 : file.index('_results')])
                currentGame = games[taskNum]
                gameDict[currentGame][arch] = resultsCollectionFunction(archDirectory + "/" + file)
                
                if divided:
                    gameDict[currentGame][arch][0] = dataManipulation.divideDataElementsByFactor(gameDict[currentGame][arch][0], numTasks)

                    if summed:
                        gameDict[currentGame][arch][1] = dataManipulation.divideDataElementsByFactor(gameDict[currentGame][arch][1], numTasks)
                
                # if summed:
                #     gameDict[currentGame][arch][1] = computeSummedData(gameDict[currentGame][arch][1])
                #     gameDict[currentGame][arch][2] = gameDict[currentGame][arch][2] ** 2
                #     gameDict[currentGame][arch][2] = computeSummedData(gameDict[currentGame][arch][2]) ** 0.5

    #load baselines
    count = 1
    for game in games:
        if summed:
            extensionToFile = "/DQNNet/averaged_task_0_results_Summed.csv"
        else:
            extensionToFile = "/DQNNet/averaged_task_0_results.csv"

        baselineFile = baselineDirectory + "/" + game + extensionToFile
        gameDict[game]["baseline"] = resultsCollectionFunction(baselineFile)

        if divided:       
            numDataPointsToUse = int(len(gameDict[game]["baseline"][0]) / (numTasks / 2))
            gameDict[game]["baseline"][0] = gameDict[game]["baseline"][0][0:numDataPointsToUse]
            gameDict[game]["baseline"][1] = gameDict[game]["baseline"][1][0:numDataPointsToUse]

            if gameDict[game]["baseline"][2] != None:
                gameDict[game]["baseline"][2] = gameDict[game]["baseline"][2][0:numDataPointsToUse]

        # if summed:
        #             gameDict[game]["baseline"][1] = computeSummedData(gameDict[game]["baseline"][1])
        #             gameDict[game]["baseline"][2] = gameDict[game]["baseline"][2] ** 2
        #             gameDict[game]["baseline"][2] = computeSummedData(gameDict[game]["baseline"][2]) ** 0.5

        graphSuffix = ""
        if summed:
            graphSuffix = "_Summed"

        taskDataSeriesList = []
        baselineDataSeries = DataSeries(gameDict[game]["baseline"][0], gameDict[game]["baseline"][1], gameDict[game]["baseline"][2], game + graphSuffix )

        for arch in archList:
            currentArchDataSeries = DataSeries(gameDict[game][arch][0], gameDict[game][arch][1], gameDict[game][arch][2], game + "_" + arch +graphSuffix )
            taskDataSeriesList.append(currentArchDataSeries)
        
        taskDataSeriesList.append(baselineDataSeries)

        plotDataSeries(count, taskDataSeriesList, romString + graphSuffix, saveFigure = pathToArchs + "/" + game + graphSuffix +"_Graph")
        count += 1
    plt.show()