def test_mergeDataFrontNoSubmanager(self): dataManager = DataManager("manager") dataManager.addDataEntry("entry1", 2) data1 = dataManager.createDataObject([10, 10]) data1.setDataEntry("entry1", ..., np.ones((10, 2))) data2 = dataManager.createDataObject([5, 5]) data2.setDataEntry("entry1", ..., np.zeros((5, 2))) data1.mergeData(data2, True) self.assertEqual(data1.getNumElements("entry1"), 15) self.assertTrue((data1.getDataEntry("entry1", ...) == np.vstack( (np.zeros((5, 2)), np.ones((10, 2))))).all())
def test_nextAliases(self): dataManager = DataManager("manager", isTimeSeries=True) dataManager.addDataEntry("entry1", 1) dataManager.addDataEntry("entry2", 3) dataManager.addDataAlias("entries", [('entry1', ...), ('entry2', ...)]) data1 = dataManager.createDataObject([10]) dataMat = np.array(range(0, 11)) dataMat.resize(11, 1) dataMatNext = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) dataMatLast = np.array([0, 0, 1, 2, 3, 4, 5, 6, 7, 8]) dataMatNext.resize(10, 1) dataMatLast.resize(10, 1) data1.setDataEntry("allEntry1", ..., dataMat) nextEntry1 = data1.getDataEntry("nextEntry1", ...) allDataEntry1 = data1.getDataEntry("allEntry1", ...) lastEntry1 = data1.getDataEntry("lastEntry1", ...) self.assertTrue((nextEntry1 == dataMatNext).all()) self.assertTrue((allDataEntry1 == dataMat).all()) self.assertTrue((lastEntry1 == dataMatLast).all()) allDataEntries = data1.getDataEntry('allEntries', slice(0, 3)) allDataEntriesMat = np.array([[0, 0, 0, 0], [1, 0, 0, 0], [2, 0, 0, 0]]) self.assertTrue((allDataEntries == allDataEntriesMat).all())
def test_generator(self): dataManager = DataManager('values') dataManager.addDataEntry('X', 2) dataManager.addDataEntry('Y', 2) f = DummyMapping(dataManager) dataManager.addFeatureMapping(f) data = dataManager.createDataObject(10) # features mapping gets called every time now when we access data.Y data[...].X = np.random.normal(0, 1, (10, 2)) print('Features: ', data[...].Y) print('Features: ', data[...].Y) f.setLazyEvaluation(True) # mapping gets called only once print('Features: ', data[...].Y) print('Features: ', data[...].Y) print('Features: ', data[...].Y) # reset valid Tags data[...].Y_validFlag = np.vstack((np.ones( (5, 1), dtype=bool), np.zeros((5, 1), dtype=bool))) #Now mapping is only called for the last 5 elements print('Features: ', data[...].Y)
def test_dataSuffix(self): settings = SettingsManager.getDefaultSettings() settings.clean() dataManager = DataManager("manager") settings.pushSuffixStack('Agent1') dataManager.addDataEntry('parameters1', 1) dataManager.addDataEntry('parameters2', 1) dataManager.addDataAlias('parameters', [('parameters1', ...), ('parameters2', ...)]) self.assertTrue(dataManager.isDataEntry("parameters1Agent1")) self.assertFalse(dataManager.isDataEntry("parameters1")) data = dataManager.createDataObject(10) data.setDataEntry('parameters1Agent1', ..., np.ones((10, 1)) * 5) dummyManipulator = TestSuffixManipulator(dataManager) data[...] >> dummyManipulator.dummyFunction >> data self.assertTrue( np.all( data.getDataEntry("parameters2Agent1") == data.getDataEntry("parameters1Agent1") + 10)) self.assertTrue( np.all( data.getDataEntry("parametersAgent1") == np.hstack(( data.getDataEntry("parameters1Agent1"), data.getDataEntry("parameters2Agent1"))))) settings.popSuffixStack()
def test_reserveStorage(self): dataManager = DataManager('episodes') dataManager.addDataEntry('parameters', 5) dataManager.addDataEntry('contexts', 2) subDataManager = DataManager('steps') subDataManager.addDataEntry('states', 2) subDataManager.addDataEntry('actions', 2) dataManager.subDataManager = subDataManager data = dataManager.createDataObject([100, 20]) data.reserveStorage([20, 20]) self.assertEqual(data.dataStructure['contexts'].shape[0], 20) self.assertEqual(data.dataStructure['parameters'].shape[0], 20) for i in range(0, 20): self.assertEqual(data.dataStructure['steps'][i]['states'].shape[0], 20) self.assertEqual( data.dataStructure['steps'][i]['actions'].shape[0], 20) data.reserveStorage([50, 100]) self.assertEqual(data.dataStructure['contexts'].shape[0], 50) self.assertEqual(data.dataStructure['parameters'].shape[0], 50) for i in range(0, 50): self.assertEqual(data.dataStructure['steps'][i]['states'].shape[0], 100) self.assertEqual( data.dataStructure['steps'][i]['actions'].shape[0], 100) data.reserveStorage([50, 0]) self.assertEqual(data.dataStructure['contexts'].shape[0], 50) self.assertEqual(data.dataStructure['parameters'].shape[0], 50) for i in range(0, 50): self.assertEqual(data.dataStructure['steps'][i]['states'].shape[0], 0) self.assertEqual( data.dataStructure['steps'][i]['actions'].shape[0], 0) data.reserveStorage(15, ...) self.assertEqual(data.dataStructure['contexts'].shape[0], 50) self.assertEqual(data.dataStructure['parameters'].shape[0], 50) for i in range(0, 50): self.assertEqual(data.dataStructure['steps'][i]['states'].shape[0], 15) self.assertEqual( data.dataStructure['steps'][i]['actions'].shape[0], 15)
def testMappingData(self): dataManager = DataManager('values') dataManager.addDataEntry('X', 1) dataManager.addDataEntry('Y', 1) mapping = DummyMapping(dataManager) data = dataManager.createDataObject(10) data >> mapping self.assertTrue((data.getDataEntry('Y') == np.ones((10, 1))).all())
def test_mergeDataFront(self): dataManager = DataManager("manager") subDataManager = DataManager("subDataManager") dataManager.subDataManager = subDataManager dataManager.addDataEntry("entry1", 2) subDataManager.addDataEntry("entry2", 3) data1 = dataManager.createDataObject([10, 10]) data1.setDataEntry("entry1", ..., np.ones((10, 2))) data1.setDataEntry("entry2", ..., np.ones((100, 3))) data2 = dataManager.createDataObject([5, 5]) data2.setDataEntry("entry1", ..., np.zeros((5, 2))) data2.setDataEntry("entry2", ..., np.zeros((25, 3))) data1.mergeData(data2, True) self.assertEqual(data1.getNumElements("entry1"), 15) self.assertEqual(len(data1.dataStructure["subDataManager"]), 15) self.assertTrue((data1.getDataEntry("entry1", ...) == np.vstack( (np.zeros((5, 2)), np.ones((10, 2))))).all())
def testMatrixEntries(self): manager = DataManager('episodes') manager.addDataEntry('matrixEntry', (10, 10)) data = manager.createDataObject(5) data.setDataEntry('matrixEntry', slice(0, 2), np.ones((2, 10, 10))) testMatrix = np.zeros((5, 10, 10)) testMatrix[slice(0, 2)] = np.ones((2, 10, 10)) testMatrix = testMatrix - data.getDataEntry('matrixEntry') self.assertTrue((testMatrix == 0).all())
def test_getDataEntryDeepCopy(self): dataManager = DataManager('episodes') subDataManager = DataManager('steps') subSubDataManager = DataManager('subSteps') dataManager.subDataManager = subDataManager subDataManager.subDataManager = subSubDataManager dataManager.addDataEntry('parameters', 5) subDataManager.addDataEntry('states', 1) subSubDataManager.addDataEntry('subActions', 2, -10, 10) myData = dataManager.createDataObject([1, 1, 1]) # set the data for all subActions of all episodes, steps and subSteps myData.setDataEntry('subActions', [], np.ones((1, 2))) self.assertTrue((myData.dataStructure['steps'][0]['subSteps'][0] ['subActions'][0] == np.array([1, 1])).all()) data1 = myData.getDataEntry('subActions', []) data2 = myData.getDataEntry('subActions', [], True) data3 = myData.getDataEntry('subActions', [], False) data4 = myData.getDataEntry('subActions', [], False) self.assertTrue((data1 == data2).all()) self.assertTrue((data2 == data3).all()) self.assertTrue((data3 == data4).all()) data2[0, 1] = 7 # This should NOT have any impact on any other data self.assertTrue((data2 != data1).any()) self.assertTrue((data2 != data3).any()) self.assertTrue((data2 != data4).any()) data5 = myData.getDataEntry('subActions', []) data3[0, 0] = 8 # This MAY impact the data in the data structure, # but should not impact data1 or data2 self.assertTrue((data5 == data1).all()) self.assertTrue((data3 != data1).any()) self.assertTrue((data3 == data4).any()) myData.setDataEntry('subActions', [], data2) # still no impact on data1 self.assertTrue((data5 == data1).all()) self.assertTrue(((myData.getDataEntry('subActions', [])) == [1, 7]).all())
def test_setgetDataEntryLocalLayer(self): dataManager = DataManager('episodes') dataManager.addDataEntry('parameters', 5, -5, 5) myData = dataManager.createDataObject([10]) # set the data for the parameters of all episodes myData.setDataEntry(['parameters'], [], np.ones((10, 5))) myData.setDataEntry(['parameters'], [slice(0, 5)], np.ones((5, 5))) # the first episode should have different parameters myData.setDataEntry(['parameters'], [0], np.array([1, 2, 3, 4, 5])) self.assertTrue( (myData.dataStructure['parameters'][0] == np.array([1, 2, 3, 4, 5])).all()) self.assertTrue( (myData.dataStructure['parameters'][1] == np.array([1, 1, 1, 1, 1])).all()) self.assertTrue( (myData.dataStructure['parameters'][9] == np.array([1, 1, 1, 1, 1])).all()) # this should not change anything myData.setDataEntry(['parameters'], [], np.ones((10, 5))) myData.setDataEntry(['parameters'], [0], np.array([1, 2, 3, 4, 5])) self.assertTrue( (myData.dataStructure['parameters'][0] == np.array([1, 2, 3, 4, 5])).all()) self.assertTrue( (myData.dataStructure['parameters'][1] == np.array([1, 1, 1, 1, 1])).all()) self.assertTrue( (myData.dataStructure['parameters'][9] == np.array([1, 1, 1, 1, 1])).all()) # tests for getDataEntry self.assertTrue((myData.getDataEntry('parameters') == myData.dataStructure['parameters']).all()) self.assertTrue((myData.getDataEntry( 'parameters', ...) == myData.dataStructure['parameters']).all()) self.assertTrue((myData.getDataEntry('parameters')[4] == myData.dataStructure['parameters'][4]).all()) self.assertTrue((myData.getDataEntry( 'parameters', [4]) == myData.dataStructure['parameters'][4]).all())
def test_get_alias_data(self): dataManager = DataManager('episodes') dataManager.addDataEntry('parameters', 5) dataManager.addDataEntry('contexts', 5) dataManager.addDataAlias('parameterAlias', [('parameters', slice(0, 2))]) dataManager.addDataAlias('twoAlias', [('parameters', slice(0, 2)), ('contexts', slice(2, 5))]) myData = dataManager.createDataObject([10, 5, 1]) myData.dataStructure['parameters'] = np.ones((10, 5)) myData.dataStructure['contexts'] = np.ones((10, 5)) * 2 paramAlias = myData.dataStructure['parameterAlias'] paramAlias[:] = np.ones(2) * 3 paramAlias[0][1] = 10 myData.dataStructure['parameterAlias'] = paramAlias self.assertEqual(myData.dataStructure['parameters'][0][1], 10) self.assertEqual(myData.dataStructure['parameters'][0][2], 1) self.assertEqual(myData.dataStructure['parameters'][3][1], 3) self.assertEqual(myData.dataStructure['parameters'][5][3], 1) twoAlias = myData.dataStructure['twoAlias'] twoAlias[4] = np.ones(5) * 4 twoAlias[5] = np.ones(5) * 5 twoAlias[6] = np.ones(5) * 6 twoAlias[-1] = np.ones(5) * 9 myData.dataStructure['twoAlias'] = twoAlias self.assertEqual(myData.dataStructure['twoAlias'][0][3], 2) self.assertEqual(myData.dataStructure['twoAlias'][-1][3], 9) self.assertEqual(myData.dataStructure['twoAlias'][4][2], 4) self.assertEqual(myData.dataStructure['twoAlias'][5][2], 5) self.assertEqual(myData.dataStructure['parameters'][0][0], 3) self.assertEqual(myData.dataStructure['parameters'][0][1], 10) self.assertEqual(myData.dataStructure['parameters'][0][2], 1) self.assertEqual(myData.dataStructure['parameters'][4][2], 1) self.assertEqual(myData.dataStructure['parameters'][5][2], 1) self.assertEqual(myData.dataStructure['contexts'][1][3], 2) self.assertEqual(myData.dataStructure['contexts'][6][3], 6) self.assertEqual(myData.dataStructure['contexts'][-1][3], 9) self.assertEqual(myData.dataStructure['contexts'][4][0], 2) self.assertEqual(myData.dataStructure['contexts'][5][1], 2) self.assertEqual(myData.dataStructure['contexts'][4][2], 4) self.assertEqual(myData.dataStructure['contexts'][5][2], 5)
def testLinearGaussianMLLearner(self): dimInput = 3 dimOutput = 2 dataManager = DataManager('data') dataManager.addDataEntry('inputs', dimInput) dataManager.addDataEntry('outputs', dimOutput) dataManager.addDataEntry('weights', 1) numSamples = 1000000 data = dataManager.createDataObject([numSamples]) gaussianDist = GaussianLinearInFeatures(dataManager, ['inputs'], 'outputs', 'testFunction') gaussianDistLearner = LinearGaussianMLLearner(dataManager, gaussianDist) meanVec = normal(0, 1,(dimOutput,1)) betaVec = normal(0, 1, (dimOutput, dimInput)) covMat = normal(0, 1, (dimOutput, dimOutput)) covMat = np.dot(covMat.transpose(), covMat) gaussianDist.setCovariance(covMat) gaussianDist.setWeightsAndBias(betaVec, meanVec) inputVectors = normal(0, 1, (numSamples, dimInput)) outputVectors = gaussianDist.sampleFromDistribution(inputVectors) weights = uniform(0,1, (numSamples,1)) data.setDataEntry('inputs', [], inputVectors) data.setDataEntry('outputs', [], outputVectors) data.setDataEntry('weights', [], weights) gaussianDistLearner.setWeightName('weights') data >> gaussianDistLearner data >> gaussianDist >> data meanVecLearned = gaussianDist.getMean() betaVecLearned = gaussianDist.getBeta() covMatLearned = gaussianDist.getCovariance() self.assertTrue(np.sum(np.square(meanVec - meanVecLearned)) < 0.01) self.assertTrue(np.sum(np.square(betaVec - betaVecLearned)) < 0.01) self.assertTrue(np.sum(np.square(covMat - covMatLearned)) < 0.05)
def testSparseEntries(self): manager = DataManager('episodes') manager.addDataEntry('matrixEntry', 10, dataType=DataType.sparse) data = manager.createDataObject(5) sparseMatrix = csr_matrix((2, 10)) sparseMatrix[0, 4] = 4 sparseMatrix[1, 2] = 1 data.setDataEntry('matrixEntry', slice(0, 2), sparseMatrix) testMatrix = csr_matrix((5, 10)) testMatrix[slice(0, 2)] = sparseMatrix testMatrix = testMatrix - data.getDataEntry('matrixEntry') self.assertTrue(np.abs(testMatrix).sum() == 0)
def test_restrictedEntry(self): dataManager = DataManager("manager", isTimeSeries=False) dataManager.addDataEntry("entry1", 1) dataManager.addDataEntry("entry2", 3, isPeriodic=[True, False, True]) dataManager.addDataAlias("entries", [('entry1', ...), ('entry2', ...)]) data = dataManager.createDataObject(2) data.setDataEntry('entries', ..., np.array([[0, 8, 0, 2], [0, 2, 0, -8]])) entryRestricted = data.getDataEntry('entries_restricted') self.assertTrue( sum( sum( np.abs(entryRestricted - np.array([[0, 1, 0, 1], [0, 1, 0, -1]])))) < 0.001)
def test_getNumElementsForIndex(self): manager = DataUtil.createTestManager() data = manager.createDataObject([3, 4, 5]) self.assertEqual(data.getNumElementsForIndex(0), 3) self.assertEqual(data.getNumElementsForIndex(0, [...]), 3) self.assertEqual(data.getNumElementsForIndex(1), 12) self.assertEqual(data.getNumElementsForIndex(1, [...]), 12) self.assertEqual(data.getNumElementsForIndex(1, [..., ...]), 12) self.assertEqual(data.getNumElementsForIndex(1, [..., slice(0, 2)]), 6) self.assertEqual( data.getNumElementsForIndex(1, [slice(2, 3), slice(0, 2)]), 2) self.assertEqual(data.getNumElementsForIndex(2), 60) self.assertEqual( data.getNumElementsForIndex(2, ...), 60) # test implicit cast to array of second argument (deprecated) self.assertEqual(data.getNumElementsForIndex(2, [...]), 60) # this should be the standart way self.assertEqual(data.getNumElementsForIndex(2, [..., ...]), 60) self.assertEqual(data.getNumElementsForIndex(2, [..., ..., ...]), 60) self.assertEqual( data.getNumElementsForIndex(2, [..., ..., slice(0, 2)]), 24) self.assertEqual( data.getNumElementsForIndex( 2, [..., slice(1, 4), slice(0, 2)]), 18) self.assertEqual( data.getNumElementsForIndex( 2, [slice(0, 1), slice(2, 3), slice(0, 2)]), 2) dataManager = DataManager('episodes') subDataManager = DataManager('steps') dataManager.subDataManager = subDataManager dataManager.addDataEntry('parameters', 5) dataManager.addDataAlias('pAlias', [('parameters', ...)]) dataManager.addDataEntry('contexts', 2) data = dataManager.createDataObject([3, 4, 5]) self.assertEqual(data.getNumElementsForIndex(0), 3) self.assertEqual(data.getNumElementsForIndex(0, [...]), 3) self.assertEqual(data.getNumElementsForIndex(1), 12) self.assertEqual(data.getNumElementsForIndex(1, [...]), 12) self.assertEqual(data.getNumElementsForIndex(1, [..., ...]), 12) self.assertEqual(data.getNumElementsForIndex(1, [slice(2, 3)]), 4)
def test_setgetDataEntryRanges(self): dataManager = DataManager('episodes') dataManager.addDataEntry('parameters', 5) # implicit ranges ([-1 1]) dataManager.addDataEntry('temperature', 24, -20, 100) myData = dataManager.createDataObject([10, 5, 3]) # this should not raise any exception myData.setDataEntry(['parameters'], [], np.ones((10, 5))) myData.setDataEntry(['parameters'], [], -np.ones((10, 5))) myData.setDataEntry(['parameters'], [slice(0, 5)], 0.97 * np.ones( (5, 5))) myData.setDataEntry(['parameters'], [slice(0, 5)], -0.5 * np.ones( (5, 5))) myData.setDataEntry('temperature', [], -20 * np.ones((10, 24))) myData.setDataEntry('temperature', [], -19 * np.ones((10, 24))) myData.setDataEntry('temperature', [], 99 * np.ones((10, 24))) myData.setDataEntry('temperature', [], np.zeros((10, 24)))
def test_setDataEntryList(self): dataManager = DataManager('episodes') dataManager.addDataEntry('parameters', 5, -10, 10) dataManager.addDataEntry('contexts', 3, -10, 10) myData = dataManager.createDataObject([10]) # set the data for the parameters and context of all episodes myData.setDataEntry(['parameters'], [...], np.ones((10, 5))) myData.setDataEntry(['contexts'], [...], np.ones((10, 3))) myData.setDataEntryList( ['parameters', 'contexts'], [...], [np.zeros((10, 5)), np.zeros((10, 3))]) self.assertTrue((myData.getDataEntry('parameters', [...]) == np.zeros( (10, 5))).all()) self.assertTrue((myData.getDataEntry('contexts', [...]) == np.zeros( (10, 3))).all()) myData.setDataEntryList( [('parameters', ['contexts'])], [...], [np.hstack((np.ones((10, 5)), 2 * np.ones((10, 3))))]) self.assertTrue((myData.getDataEntry('parameters', [...]) == np.ones( (10, 5))).all()) self.assertTrue((myData.getDataEntry('contexts', [...]) == 2 * np.ones( (10, 3))).all()) myData.setDataEntryList([('parameters', ['contexts'])], [...], [6 * np.ones((10, 8))]) self.assertTrue((myData.getDataEntry('parameters', [...]) == 6 * np.ones( (10, 5))).all()) self.assertTrue((myData.getDataEntry('contexts', [...]) == 6 * np.ones( (3))).all()) myData.setDataEntryList([('parameters', ['contexts'])], [3], 7 * np.ones((1, 8))) self.assertTrue((myData.getDataEntry('parameters', [3]) == 7 * np.ones( (5))).all()) self.assertTrue((myData.getDataEntry('contexts', 3) == 7 * np.ones( (3))).all())
def test_getDataObject(self): dataManager = DataManager('episodes') subDataManager = DataManager('steps') subSubDataManager = DataManager('subSteps') dataManager.subDataManager = subDataManager subDataManager.subDataManager = subSubDataManager dataManager.addDataEntry('parameters', 5) dataManager.addDataEntry('contexts', 2) subDataManager.addDataEntry('states', 1) subDataManager.addDataEntry('actions', 2) subSubDataManager.addDataEntry('subStates', 1) subSubDataManager.addDataEntry('subActions', 2) myData = dataManager.createDataObject([10, 5, 1]) self.assertTrue(dataManager.finalized) self.assertEqual(len(myData.dataStructure['parameters']), 10) self.assertEqual(len(myData.dataStructure['contexts']), 10) self.assertEqual(len(myData.dataStructure['parameters'][0]), 5) self.assertEqual(len(myData.dataStructure['parameters'][9]), 5) self.assertEqual(len(myData.dataStructure['contexts'][0]), 2) self.assertEqual(len(myData.dataStructure['contexts'][9]), 2) self.assertEqual(len(myData.dataStructure['steps']), 10) self.assertEqual(len(myData.dataStructure['steps'][0]), 3) self.assertEqual(len(myData.dataStructure['steps'][0]['states']), 5) self.assertEqual(len(myData.dataStructure['steps'][0]['states'][0]), 1) self.assertEqual(len(myData.dataStructure['steps'][0]['actions']), 5) self.assertEqual(len(myData.dataStructure['steps'][0]['actions'][0]), 2) self.assertEqual(len(myData.dataStructure['steps'][0]['actions'][1]), 2) self.assertEqual(len(myData.dataStructure['steps'][0]['subSteps']), 5) self.assertEqual( len(myData.dataStructure['steps'][0]['subSteps'][0]['subActions']), 1) self.assertEqual( len(myData.dataStructure['steps'][0]['subSteps'][0]['subActions']), 1) self.assertEqual( len(myData.dataStructure['steps'][0]['subSteps'][0]['subActions'] [0]), 2)
def test_PeriodicEntry(self): dataManager = DataManager("manager", isTimeSeries=False) dataManager.addDataEntry("entry1", 1) dataManager.addDataEntry("entry2", 3, isPeriodic=[True, False, True]) dataManager.addDataAlias("entries", [('entry1', ...), ('entry2', ...)]) periodTest = dataManager.getPeriodicity('entries') self.assertTrue(periodTest == [False, True, False, True]) data = dataManager.createDataObject(2) data.setDataEntry('entries', ..., np.array([[0, 8, 0, 2], [0, 2, 0, -8]])) entryPeriodic = data.getDataEntry('entries_periodic') self.assertTrue( sum( sum( np.abs(entryPeriodic - np.array([[0, 1.71681469, 0, 2], [0, 2, 0, 4.56637061]])))) < 0.001)
def test_getDataEntryList(self): dataManager = DataManager('episodes') dataManager.addDataEntry('parameters', 5) dataManager.addDataEntry('contexts', 3) myData = dataManager.createDataObject([10]) # set the data for the parameters and context of all episodes myData.setDataEntry(['parameters'], [...], np.ones((10, 5))) myData.setDataEntry(['contexts'], [...], np.ones((10, 3))) result = myData.getDataEntryList(['parameters', 'contexts'], [...]) self.assertTrue(isinstance(result, list)) self.assertTrue((result[0] == np.ones((10, 5))).all()) self.assertTrue((result[1] == np.ones((10, 3))).all()) result = myData.getDataEntryList([('parameters', 'contexts')], [...]) self.assertEqual(len(result), 1) self.assertTrue((result[0] == np.ones((10, 8))).all())
def testDiagionalGaussian(self): num_cpu = 1 tf_config = tf.ConfigProto(inter_op_parallelism_threads=num_cpu, intra_op_parallelism_threads=num_cpu) session = tf.Session(config=tf_config) session.__enter__() dataManager = DataManager('data') dataManager.addDataEntry('states', 10) dataManager.addDataEntry('actions', 5) generatorMean = tfutils.continuous_MLP_generator([100, 100]) generatorLogStd = tfutils.diagional_log_std_generator() gaussian = DiagonalGaussian_Base(dataManager, ['states'], ['actions'], generatorMean, generatorLogStd) data = dataManager.createDataObject([10]) data[...].states = np.random.normal(0, 1, data[...].states.shape)
def test_getExpectation(self): dataManager = DataManager('values') dataManager.addDataEntry('X', 2) dataManager.addDataEntry('Y', 1) f = FunctionLinearInFeatures(dataManager, ['X'], ['Y'], None, None) X = np.array([[1, 1], [2, 1]]) f.bias = np.ones((1)) * 5 f.weights = np.array([ [2, 1], ]) Y = f.bias + np.dot(X, f.weights.transpose()) self.assertTrue((Y == f.computeOutput(inputFeatures=X)).all()) # Todo implement fromData? self.assertTrue((Y == f(X)).all()) data = dataManager.createDataObject(2) data.setDataEntry('X', ..., X) data[...] >> f self.assertTrue((Y == data.Y).all())
import numpy as np from pypost.mappings.Gaussian import LinearDiagonalGaussian num_cpu = 1 tf_config = tf.ConfigProto(inter_op_parallelism_threads=num_cpu, intra_op_parallelism_threads=num_cpu) session = tf.Session(config=tf_config) session.__enter__() dataManager = DataManager('data') dataManager.addDataEntry('states', 10) dataManager.addDataEntry('actions', 5) gaussian = LinearDiagonalGaussian(dataManager, ['states'], ['actions']) data = dataManager.createDataObject([10]) data[...].states = np.random.normal(0, 1, data[...].states.shape) # Sample from Gaussian and write back in data data[...] >> gaussian >= data # compute logLikelihood data[...] >= gaussian.logLike # Compute log likelihood gaussianOther = LinearDiagonalGaussian(dataManager, ['states'], ['actions']) # the param_* properties are created automatically by parsing the mean and logStd tensors. They can be set and read as normal numpy arrays gaussianOther.param_final_b = np.random.normal(0, 1, (5,)) gaussianOther.param_logstd = np.random.normal(0, 1, (5,))
def test_addDataEntry_after_finalize(self): dataManager = DataManager('episodes') myData = dataManager.createDataObject(10) self.assertRaises(RuntimeError, dataManager.addDataEntry, 'parameters', 5)
import numpy as np ''' In this example we are going to see how to use aliases. ''' # create data manager dataManager = DataManager('episodes') subDataManager = DataManagerTimeSeries('steps') subDataManager.addDataEntry('states', 2) subDataManager.addDataEntry('actions', 3, dataType=DataType.discrete) dataManager.subDataManager = subDataManager # create data object with 10 episodes data = dataManager.createDataObject(10) # fill episodes. we want to use a different number of timesteps for each episode for i in range(0, 10): numTimeSteps = i + 5 data.reserveStorage(numTimeSteps, [i]) print('Size of states matrix: ', data[i].states.shape) #fill in some dummy actions data[i].allStates = np.array( np.vstack( (range(0, numTimeSteps + 1), range(0, numTimeSteps + 1)))).transpose()
-3, 1, dropBoundarySamples=False) # now we only need to connect the data managers and finalize them dataManager.subDataManager = subDataManager # Initialization of the data # so far we have defined the structure of our data # now we want to create new data numTimeSteps = 1000 # here we create new data object with 1 episodes, 10000 steps # this method will also finalize the dataManager myData = dataManager.createDataObject([100, numTimeSteps]) # for time series, we have special aliases for accesing the next element, previous element and all elements # Fill all states with series allStates = np.zeros((numTimeSteps + 1, 5)) allStates[:, 0] = np.array(range(0, numTimeSteps + 1)).transpose() allStates[:, 1] = np.array(range(0, numTimeSteps + 1)).transpose() + 0.1 allStates[:, 2] = np.array(range(0, numTimeSteps + 1)).transpose() + 0.2 allStates[:, 3] = np.array(range(0, numTimeSteps + 1)).transpose() + 0.3 allStates[:, 4] = np.array(range(0, numTimeSteps + 1)).transpose() + 0.4 for i in range(0, 100): myData[i].allStates = allStates
def test_setgetDataEntry(self): dataManager = DataManager('episodes') subDataManager = DataManager('steps') subSubDataManager = DataManager('subSteps') dataManager.subDataManager = subDataManager subDataManager.subDataManager = subSubDataManager subSubDataManager.addDataEntry('subActions', 2, -10, 10) myData = dataManager.createDataObject([10, 5, 3]) # set the data for all subActions of all episodes, steps and subSteps myData.setDataEntry(['steps', 'subSteps', 'subActions'], [], np.ones((150, 2))) # all subActions in the 3rd subSteps of all steps of the 2nd episode # should have different parameters myData.setDataEntry(['steps', 'subSteps', 'subActions'], [1, ..., 2], np.array([[2, 1], [2, 2], [2, 3], [2, 4], [2, 5]])) self.assertTrue((myData.dataStructure['steps'][0]['subSteps'][0] ['subActions'][0] == np.array([1, 1])).all()) self.assertTrue((myData.dataStructure['steps'][1]['subSteps'][1] ['subActions'][1] == np.array([1, 1])).all()) self.assertTrue((myData.dataStructure['steps'][9]['subSteps'][4] ['subActions'][2] == np.array([1, 1])).all()) self.assertTrue((myData.dataStructure['steps'][1]['subSteps'][4] ['subActions'][1] == np.array([1, 1])).all()) self.assertTrue((myData.dataStructure['steps'][1]['subSteps'][0] ['subActions'][2] == np.array([2, 1])).all()) self.assertTrue((myData.dataStructure['steps'][1]['subSteps'][4] ['subActions'][2] == np.array([2, 5])).all()) # tests for getDataEntry self.assertTrue( (myData.getDataEntry(['steps', 'subSteps', 'subActions'], [0, 0]) == myData.dataStructure['steps'][0] ['subSteps'][0]['subActions']).all()) self.assertTrue( (myData.getDataEntry(['steps', 'subSteps', 'subActions'], 1) == np.array([[1, 1], [1, 1], [2, 1], [1, 1], [1, 1], [2, 2], [1, 1], [1, 1], [2, 3], [1, 1], [1, 1], [2, 4], [1, 1], [1, 1], [2, 5]])).all()) self.assertTrue( (myData.getDataEntry(['steps', 'subSteps', 'subActions'], [1, ..., 2]) == np.array([[2, 1], [2, 2], [2, 3], [2, 4], [2, 5]])).all()) self.assertTrue( (myData.getDataEntry(['steps', 'subSteps', 'subActions'], [1, 3, 2]) == np.array([[2, 4]])).all()) self.assertTrue( (myData.getDataEntry(['steps', 'subSteps', 'subActions'], [2, 3, 2]) == np.array([[1, 1]])).all()) # all subActions in every second subStep of all steps of the 2nd episode # should have different parameters myData.setDataEntry(['steps', 'subSteps', 'subActions'], [1, slice(0, 5, 2), 2], np.array([[3, 1], [3, 2], [3, 3]])) self.assertTrue( (myData.getDataEntry(['steps', 'subSteps', 'subActions'], 1) == np.array([[1, 1], [1, 1], [3, 1], [1, 1], [1, 1], [2, 2], [1, 1], [1, 1], [3, 2], [1, 1], [1, 1], [2, 4], [1, 1], [1, 1], [3, 3]])).all()) # all subActions in the first 3 subSteps of all steps of the 2nd episode # should have different parameters myData.setDataEntry(['steps', 'subSteps', 'subActions'], [1, slice(0, -2), 2], np.array([[4, 1], [4, 2], [4, 3]])) self.assertTrue( (myData.getDataEntry(['steps', 'subSteps', 'subActions'], 1) == np.array([[1, 1], [1, 1], [4, 1], [1, 1], [1, 1], [4, 2], [1, 1], [1, 1], [4, 3], [1, 1], [1, 1], [2, 4], [1, 1], [1, 1], [3, 3]])).all()) self.assertRaises(ValueError, myData.setDataEntry, ['steps', 'subSteps', 'subActions'], [1, 2, slice(0, 1)], np.array([[5, 1], [5, 2]])) self.assertRaises(ValueError, myData.setDataEntry, ['steps', 'subSteps', 'subActions'], [1, ..., 0], np.array([[5, 1], [5, 2], [5, 3]])) self.assertRaises(ValueError, myData.setDataEntry, ['steps', 'subSteps', 'subActions'], [1, slice(0, -2), 2], np.array([[5, 1], [5, 2]])) self.assertRaises(ValueError, myData.setDataEntry, ['steps', 'subSteps', 'subActions'], [1, slice(0, -2), 2], np.array([])) self.assertRaises(ValueError, myData.setDataEntry, ['steps', 'subSteps', 'subActions'], [1, slice(0, -2), 2], np.array([[5, 1], [5, 2], [5, 3], [5, 4]]))
def test_getDataEntryDimensions(self): dataManager = DataManager('episodes') subDataManager = DataManager('steps') subSubDataManager = DataManager('subSteps') dataManager.subDataManager = subDataManager subDataManager.subDataManager = subSubDataManager dataManager.addDataEntry('parameters', 5) subDataManager.addDataEntry('states', 1) subSubDataManager.addDataEntry('subStates', 1) subSubDataManager.addDataEntry('subActions', 2) myData = dataManager.createDataObject([10, 5, 3]) self.assertEqual(myData.getDataEntry(['parameters']).shape[0], 10) self.assertEqual( myData.getDataEntry(['parameters'], [...]).shape[0], 10) self.assertEqual(myData.getDataEntry(['parameters'], [1]).shape[0], 1) self.assertEqual( myData.getDataEntry(['steps', 'states'], [1]).shape[0], 5) self.assertEqual( myData.getDataEntry(['steps', 'states'], [3]).shape[0], 5) self.assertEqual( myData.getDataEntry(['steps', 'states'], [..., 1]).shape[0], 10) self.assertEqual( myData.getDataEntry(['steps', 'states'], [..., ...]).shape[0], 50) self.assertEqual(myData.getDataEntry(['steps', 'states']).shape[0], 50) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions'], [..., ..., ...]).shape[0], 150) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions']).shape[0], 150) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions'], [..., ..., 1]).shape[0], 50) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions'], [..., 1, ...]).shape[0], 30) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions'], [..., 1]).shape[0], 30) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions'], [..., 1, 1]).shape[0], 10) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions'], [1, ..., ...]).shape[0], 15) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions'], [1]).shape[0], 15) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions'], 1).shape[0], 15) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions'], [1, ..., 1]).shape[0], 5) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions'], [1, 1, ...]).shape[0], 3) self.assertEqual( myData.getDataEntry(['steps', 'subSteps', 'subActions'], [1, 1, 1]).shape[0], 1)
def test_addDataAlias_after_finalize(self): dataManager = DataManager('episodes') myData = dataManager.createDataObject([10]) self.assertRaises(RuntimeError, dataManager.addDataAlias, 'alias', [])
dataManager.addDataEntry('contexts', 5) # add an alias # parameterAlias points to the first two dimensions of parameters dataManager.addDataAlias('parameterAlias', [('parameters', slice(0, 2))]) # it's also possible to create an alias that points to another alias # 'aliasAlias' will now be the aquivalent to 'parameters' dataManager.addDataAlias('aliasAlias', [('parameterAlias', ...), ('contexts', slice(2, 5))]) dataManager.addDataAlias('parametersAliasVertical', [('parameters', slice(0, 2)), ('parameters', slice(2, 4))], useConcatVertical=True) # create the data object myData = dataManager.createDataObject([3]) # set the entries of the 'parameters' entry. This will also affect the alias # that points to 'parameters' parameters = myData[...].parameters parameters[:] = [1, 2, 3, 4, 5] myData[...].parameters = parameters # print all parameters print('initial parameters\n', parameters, '\n\n') # print all parameters again (using the alias) aliasAlias = myData[...].aliasAlias print('initial aliasAlias\n', aliasAlias, '\n\n') # update the parameters via the alias