def test_ldsMartinDistance():
"""Test Martin distance computation for LDS's (5 states).
Config: 5 states (observation centering - default).
"""
fileA = os.path.join(TESTBASE, "data/data1.txt")
fileB = os.path.join(TESTBASE, "data/data2.txt")
# load data files
dataA, _ = loadDataFromASCIIFile(fileA)
dataB, _ = loadDataFromASCIIFile(fileB)
ldsA = LinearDS(5, False, False)
ldsB = LinearDS(5, False, False)
# estimate LDS's
ldsA.suboptimalSysID(dataA)
ldsB.suboptimalSysID(dataB)
# compute distances A<->A, A<->B
dAA = ldsMartinDistance(ldsA, ldsA, 20)
dAB = ldsMartinDistance(ldsA, ldsB, 20)
truth = np.genfromtxt(os.path.join(TESTBASE, "data/ldsMartinDistanceData1Data2.txt"))
np.testing.assert_almost_equal(dAB, truth, 2)
np.testing.assert_almost_equal(dAA, 0, 2)
def main(argv=None):
if argv is None:
argv = sys.argv
parser = OptionParser(add_help_option=False)
parser.add_option("-i", dest="iFile")
parser.add_option("-t", dest="iType")
parser.add_option("-o", dest="oFile")
parser.add_option("-n", dest="nStates", type="int", default=5)
parser.add_option("-h", dest="shoHelp", action="store_true", default=False)
parser.add_option("-v", dest="verbose", action="store_true", default=False)
opt, args = parser.parse_args()
if opt.shoHelp:
usage()
dataMat = None
dataSiz = None
try:
if opt.iType == 'vFile':
(dataMat, dataSiz) = dsutil.loadDataFromVideoFile(opt.iFile)
elif opt.iType == 'aFile':
(dataMat, dataSiz) = dsutil.loadDataFromASCIIFile(opt.iFile)
elif opt.iType == 'lFile':
(dataMat, dataSiz) = dsutil.loadDataFromIListFile(opt.iFile)
else:
dsinfo.fail("Unsupported file type : %s" % opt.iType)
return -1
# catch pyds exceptions
except ErrorDS as e:
msg.fail(e)
return -1
try:
kpcaP = KPCAParam()
kpcaP._kPar = RBFParam()
kpcaP._kPar._kCen = True
kpcaP._kFun = rbfK
kdt = NonLinearDS(opt.nStates, kpcaP, opt.verbose)
kdt.suboptimalSysID(dataMat)
if not opt.oFile is None:
if not kdt.check():
dsinfo.fail('cannot write invalid model!')
return -1
dsinfo.info('writing model to %s' % opt.oFile)
with open(opt.oFile, 'w') as fid:
pickle.dump(kdt, fid)
except ErrorDS as e:
dsinfo.fail(e)
return -1
def main(argv=None):
if argv is None:
argv = sys.argv
parser = OptionParser(add_help_option=False)
parser.add_option("-i", dest="iFile")
parser.add_option("-t", dest="iType")
parser.add_option("-o", dest="oFile")
parser.add_option("-n", dest="nStates", type="int", default=5)
parser.add_option("-h", dest="shoHelp", action="store_true", default=False)
parser.add_option("-v", dest="verbose", action="store_true", default=False)
opt, args = parser.parse_args()
if opt.shoHelp:
usage()
dataMat = None
dataSiz = None
try:
if opt.iType == 'vFile':
(dataMat, dataSiz) = dsutil.loadDataFromVideoFile(opt.iFile)
elif opt.iType == 'aFile':
(dataMat, dataSiz) = dsutil.loadDataFromASCIIFile(opt.iFile)
elif opt.iType == 'lFile':
(dataMat, dataSiz) = dsutil.loadDataFromIListFile(opt.iFile)
else:
dsinfo.fail("Unsupported file type : %s" % opt.iType)
return -1
# catch pyds exceptions
except ErrorDS as e:
msg.fail(e)
return -1
try:
kpcaP = KPCAParam()
kpcaP._kPar = RBFParam()
kpcaP._kPar._kCen = True
kpcaP._kFun = rbfK
kdt = NonLinearDS(opt.nStates, kpcaP, opt.verbose)
kdt.suboptimalSysID(dataMat)
if not opt.oFile is None:
if not kdt.check():
dsinfo.fail('cannot write invalid model!')
return -1
dsinfo.info('writing model to %s' % opt.oFile)
with open(opt.oFile, 'w') as fid:
pickle.dump(kdt, fid)
except ErrorDS as e:
dsinfo.fail(e)
return -1
def test_nldsMartinDistance():
"""Test Martin distance computation for NLDS's.
Config: 5 states, kernel centering
"""
fileA = os.path.join(TESTBASE, "data/data1.txt")
fileB = os.path.join(TESTBASE, "data/data2.txt")
# load data files
dataA, _ = loadDataFromASCIIFile(fileA)
dataB, _ = loadDataFromASCIIFile(fileB)
# configure kernels
kpcaPA = KPCAParam()
kpcaPA._kPar = RBFParam()
kpcaPA._kPar._kCen = True
kpcaPA._kFun = rbfK
kpcaPB = KPCAParam()
kpcaPB._kPar = RBFParam()
kpcaPB._kPar._kCen = True
kpcaPB._kFun = rbfK
nldsA = NonLinearDS(5, kpcaPA, False)
nldsB = NonLinearDS(5, kpcaPB, False)
# estimate NLDS's
nldsA.suboptimalSysID(dataA)
nldsB.suboptimalSysID(dataB)
# compute distances A<->A, A<->B
dAA = nldsMartinDistance(nldsA, nldsA, 20)
dAB = nldsMartinDistance(nldsA, nldsB, 20)
truth = np.genfromtxt(os.path.join(TESTBASE,
"data/nldsMartinDistanceData1Data2.txt" ))
np.testing.assert_almost_equal(dAA, 0, 2)
np.testing.assert_almost_equal(dAB, truth, 2)
def test_LinearDS_suboptimalSysID():
"""Test LinearDS system identification.
"""
dataFile = os.path.join(TESTBASE, "data/data1.txt")
data, _ = loadDataFromASCIIFile(dataFile)
lds = LinearDS(5, False, False)
lds.suboptimalSysID(data)
baseLDSFile = os.path.join(TESTBASE, "data/data1-dt-5c-center.pkl")
baseLDS = pickle.load(open(baseLDSFile))
_, err = LinearDS.stateSpaceMap(baseLDS, lds)
assert np.allclose(err, 0.0) == True
def test_LinearDS_suboptimalSysID():
"""Test LinearDS system identification.
"""
dataFile = os.path.join(TESTBASE, "data/data1.txt")
data, _ = loadDataFromASCIIFile(dataFile)
lds = LinearDS(5, False, False)
lds.suboptimalSysID(data)
baseLDSFile = os.path.join(TESTBASE, "data/data1-dt-5c-center.pkl")
baseLDS = pickle.load(open(baseLDSFile))
err = ldsMartinDistance(lds, baseLDS, N=20)
np.testing.assert_almost_equal(err, 0, 2)
def test_kpca():
dataFile = os.path.join(TESTBASE, "data/data1.txt")
data, _ = loadDataFromASCIIFile(dataFile)
kpcaP = KPCAParam()
kpcaP._kPar = RBFParam()
kpcaP._kPar._kCen = True
kpcaP._kFun = rbfK
X = kpca(data, 5, kpcaP)
baseKPCACoeffFile = os.path.join(TESTBASE, "data/data1-rbf-kpca-5c-center.txt")
baseKPCACoeff = np.genfromtxt(baseKPCACoeffFile, dtype=np.double)
# don't care about the sign
err = np.linalg.norm(np.abs(baseKPCACoeff) - np.abs(X), "fro")
np.testing.assert_almost_equal(err, 0, 2)
def test_kpca():
dataFile = os.path.join(TESTBASE, "data/data1.txt")
data, _ = loadDataFromASCIIFile(dataFile)
kpcaP = KPCAParam()
kpcaP._kPar = RBFParam()
kpcaP._kPar._kCen = True
kpcaP._kFun = rbfK
X = kpca(data, 5, kpcaP)
baseKPCACoeffFile = os.path.join(TESTBASE,
"data/data1-rbf-kpca-5c-center.txt")
baseKPCACoeff = np.genfromtxt(baseKPCACoeffFile, dtype=np.double)
# don't care about the sign
err = np.linalg.norm(np.abs(baseKPCACoeff) - np.abs(X), 'fro')
np.testing.assert_almost_equal(err, 0, 2)
def test_NonLinearDS_suboptimalSysID():
"""Test NonLinearDS system identification.
"""
dataFile = os.path.join(TESTBASE, "data/data1.txt")
data, _ = loadDataFromASCIIFile(dataFile)
kpcaP = KPCAParam()
kpcaP._kPar = RBFParam()
kpcaP._kPar._kCen = True
kpcaP._kFun = rbfK
nlds = NonLinearDS(5, kpcaP, False)
nlds.suboptimalSysID(data)
baseNLDSFile = os.path.join(TESTBASE, "data/data1-rbf-kdt-5c-center.pkl")
baseNLDS = pickle.load(open(baseNLDSFile))
err = NonLinearDS.naiveCompare(baseNLDS, nlds)
assert np.allclose(err, 0.0) == True
def test_NonLinearDS_suboptimalSysID():
"""Test NonLinearDS system identification.
"""
dataFile = os.path.join(TESTBASE, "data/data1.txt")
data, _ = loadDataFromASCIIFile(dataFile)
kpcaP = KPCAParam()
kpcaP._kPar = RBFParam()
kpcaP._kPar._kCen = True
kpcaP._kFun = rbfK
nlds = NonLinearDS(5, kpcaP, False)
nlds.suboptimalSysID(data)
baseNLDSFile = os.path.join(TESTBASE, "data/data1-rbf-kdt-5c-center.pkl")
baseNLDS = pickle.load(open(baseNLDSFile))
err = NonLinearDS.naiveCompare(baseNLDS, nlds)
np.testing.assert_almost_equal(err, 0, 2)
def main(argv=None):
if argv is None:
argv = sys.argv
parser = OptionParser(add_help_option=False)
parser.add_option("-p", dest="pFile")
parser.add_option("-i", dest="iFile")
parser.add_option("-t", dest="iType")
parser.add_option("-o", dest="oFile")
parser.add_option("-n", dest="nStates", type="int", default=+5)
parser.add_option("-m", dest="doMovie", type="int", default=-1)
parser.add_option("-a", dest="svdRand", action="store_true", default=False)
parser.add_option("-e", dest="doEstim", action="store_true", default=False)
parser.add_option("-s", dest="doSynth", action="store_true", default=False)
parser.add_option("-h", dest="shoHelp", action="store_true", default=False)
parser.add_option("-v", dest="verbose", action="store_true", default=False)
opt, args = parser.parse_args()
if opt.shoHelp:
usage()
dataMat = None
dataSiz = None
try:
if opt.iType == 'vFile':
(dataMat, dataSiz) = dsutil.loadDataFromVideoFile(opt.iFile)
elif opt.iType == 'aFile':
(dataMat, dataSiz) = dsutil.loadDataFromASCIIFile(opt.iFile)
elif opt.iType == 'lFile':
(dataMat, dataSiz) = dsutil.loadDataFromIListFile(opt.iFile)
else:
msg.fail("Unsupported file type : %s", opt.iType)
return -1
except Exception as e:
dsinfo.fail(e)
return -1
try:
# try loading the DT model
if not opt.pFile is None:
with open(opt.pFile) as fid:
dsinfo.info('trying to load model %s' % opt.pFile)
dt = pickle.load(fid)
# run estimation
if opt.doEstim:
if not opt.pFile is None:
dsinfo.fail('re-estimation attempt detected!')
return -1
dt = LinearDS(opt.nStates, approx=opt.svdRand, verbose=opt.verbose)
dt.suboptimalSysID(dataMat)
# synthesize output
if opt.doSynth:
dataSyn, _ = dt.synthesize(tau=50, mode='s')
# show a movie of the synthesis result
if opt.doMovie > 0:
if opt.doSynth:
dsutil.showMovie(dataSyn, dataSiz, fps=opt.doMovie)
# write DT model to file
if not opt.oFile is None:
dsinfo.info('writing model to %s' % opt.oFile)
with open(opt.oFile, 'w') as fid:
pickle.dump(dt, fid)
# catch pyds exceptions
except ErrorDS as e:
dsinfo.fail(e)
return -1
def main(argv=None):
if argv is None:
argv = sys.argv
parser = OptionParser(add_help_option=False)
parser.add_option("-p", dest="pFile")
parser.add_option("-i", dest="iFile")
parser.add_option("-t", dest="iType")
parser.add_option("-o", dest="oFile")
parser.add_option("-n", dest="nStates", type="int", default=+5)
parser.add_option("-m", dest="doMovie", type="int", default=-1)
parser.add_option("-a", dest="svdRand", action="store_true", default=False)
parser.add_option("-e", dest="doEstim", action="store_true", default=False)
parser.add_option("-s", dest="doSynth", action="store_true", default=False)
parser.add_option("-h", dest="shoHelp", action="store_true", default=False)
parser.add_option("-v", dest="verbose", action="store_true", default=False)
opt, args = parser.parse_args()
if opt.shoHelp:
usage()
dataMat = None
dataSiz = None
try:
if opt.iType == 'vFile':
(dataMat, dataSiz) = dsutil.loadDataFromVideoFile(opt.iFile)
elif opt.iType == 'aFile':
(dataMat, dataSiz) = dsutil.loadDataFromASCIIFile(opt.iFile)
elif opt.iType == 'lFile':
(dataMat, dataSiz) = dsutil.loadDataFromIListFile(opt.iFile)
elif opt.iType == 'mFile':
(dataMat, dataSiz) = dsutil.loadDataFromVolumeFile(opt.iFile)
else:
msg.fail("Unsupported file type : %s", opt.iType)
return -1
except Exception as e:
dsinfo.fail(e)
return -1
try:
# try loading the DT model
if not opt.pFile is None:
with open(opt.pFile) as fid:
dsinfo.info('trying to load model %s' % opt.pFile)
dt = pickle.load(fid)
# run estimation
if opt.doEstim:
if not opt.pFile is None:
dsinfo.fail('re-estimation attempt detected!')
return -1
dt = LinearDS(opt.nStates, approx=opt.svdRand, verbose=opt.verbose)
dt.suboptimalSysID(dataMat)
# synthesize output
if opt.doSynth:
dataSyn, _ = dt.synthesize(tau=50, mode='s')
# show a movie of the synthesis result
if opt.doMovie > 0:
if opt.doSynth:
dsutil.showMovie(dataSyn, dataSiz, fps=opt.doMovie)
# write DT model to file
if not opt.oFile is None:
dsinfo.info('writing model to %s' % opt.oFile)
with open(opt.oFile, 'w') as fid:
pickle.dump(dt, fid)
# catch pyds exceptions
except ErrorDS as e:
dsinfo.fail(e)
return -1
