Esempio n. 1
0
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
Esempio n. 2
0
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
Esempio n. 3
0
def test_NonLinearDS_check():
    """Test NonLinearDS parameter checking.
    """
    
    kpcaP = KPCAParam()
    kpcaP._kPar = RBFParam()
    kpcaP._kPar._kCen = True
    kpcaP._kFun = rbfK
    
    nlds = NonLinearDS(5, kpcaP, False)
    assert nlds.check() is False
Esempio n. 4
0
def test_NonLinearDS_check():
    """Test NonLinearDS parameter checking.
    """

    kpcaP = KPCAParam()
    kpcaP._kPar = RBFParam()
    kpcaP._kPar._kCen = True
    kpcaP._kFun = rbfK

    nlds = NonLinearDS(5, kpcaP, False)
    assert nlds.check() is False
Esempio n. 5
0
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)
Esempio n. 6
0
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)
Esempio n. 7
0
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
Esempio n. 8
0
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)
Esempio n. 9
0
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)
Esempio n. 10
0
def main(argv=None):
    if argv is None:
        argv = sys.argv

    parser = OptionParser(add_help_option=False)

    parser.add_option("-s", dest="inFile")
    parser.add_option("-d", dest="dbFile")
    parser.add_option("-m", dest="models")
    parser.add_option("-v", dest="videos")
    parser.add_option("-c", dest="config")
    parser.add_option("-o", dest="mdFile")

    parser.add_option("-h", dest="doUsage", action="store_true", default=False)
    parser.add_option("-x", dest="verbose", action="store_true", default=False)
    options, args = parser.parse_args()

    if options.doUsage:
        usage()

    # read config file
    config = json.load(open(options.config))

    # get DS config settings
    dynType = config["dynType"]
    shiftMe = config["shiftMe"]
    numIter = config["numIter"]

    verbose = options.verbose

    # I/O configuration
    inFile = options.inFile
    dbFile = options.dbFile
    models = options.models
    videos = options.videos
    mdFile = options.mdFile

    # check if the required options are present
    if (inFile is None or dbFile is None or models is None or videos is None):
        dsinfo.warn('Options missing!')
        usage()

    inVideo, inVideoSize = dsutil.loadDataFromVideoFile(inFile)
    if verbose:
        dsinfo.info("Loaded source video with %d frames!" % inVideo.shape[1])

    (db, winSize, nStates, dynType) = loadDB(videos, models, dbFile)

    if verbose:
        dsinfo.info("#Templates: %d #States: %d, WinSize: %d, Shift: %d" %
                    (len(db), nStates, winSize, shiftMe))

    if dynType.__name__ == "LinearDS":
        # create online version of LinearDS
        ds = OnlineLinearDS(nStates, winSize, shiftMe, False, verbose)
    elif dynType.__name__ == "NonLinearDS":
        kpcaP = KPCAParam()

        # select kernel
        if config["kdtKern"] == "rbf":
            kpcaP._kPar = RBFParam()
            kpcaP._kFun = rbfK
        else:
            dsinfo.fail("Kernel %s not supported!" % kdtKern)
            return -1

        # configure kernel
        if config["kCenter"] == 1:
            kpcaP._kPar._kCen = True
        else:
            kpcaP._kPar._kCen = False

        # create online version of KDT
        ds = OnlineNonLinearDS(nStates, kpcaP, winSize, shiftMe, verbose)
    else:
        dsinfo.fail('System type %s not supported!' % options.dsType)
        return -1

    dList = []
    for f in range(inVideo.shape[1]):
        ds.update(inVideo[:, f])
        if ds.check() and ds.hasChanged():
            dists = np.zeros((len(db), ))
            for j, dbentry in enumerate(db):
                dists[j] = {
                    "LinearDS": dsdist.ldsMartinDistance,
                    "NonLinearDS": dsdist.nldsMartinDistance
                }[dynType.__name__](ds, dbentry["model"], numIter)
            dList.append(dists)

    # write distance matrix
    if not mdFile is None:
        np.savetxt(mdFile, np.asmatrix(dList), fmt='%.5f', delimiter=' ')
Esempio n. 11
0
def main(argv=None):
    if argv is None:
        argv = sys.argv

    parser = OptionParser(add_help_option=False)

    parser.add_option("-s", dest="inFile")
    parser.add_option("-d", dest="dbFile")
    parser.add_option("-m", dest="models")
    parser.add_option("-v", dest="videos")
    parser.add_option("-c", dest="config")
    parser.add_option("-o", dest="mdFile")

    parser.add_option("-h", dest="doUsage", action="store_true", default=False)
    parser.add_option("-x", dest="verbose", action="store_true", default=False)
    options, args = parser.parse_args()

    if options.doUsage:
        usage()

    # read config file
    config = json.load(open(options.config))

    # get DS config settings
    dynType = config["dynType"]
    shiftMe = config["shiftMe"]
    numIter = config["numIter"]

    verbose = options.verbose

    # I/O configuration
    inFile = options.inFile
    dbFile = options.dbFile
    models = options.models
    videos = options.videos
    mdFile = options.mdFile

    # check if the required options are present
    if inFile is None or dbFile is None or models is None or videos is None:
        dsinfo.warn("Options missing!")
        usage()

    inVideo, inVideoSize = dsutil.loadDataFromVideoFile(inFile)
    if verbose:
        dsinfo.info("Loaded source video with %d frames!" % inVideo.shape[1])

    (db, winSize, nStates, dynType) = loadDB(videos, models, dbFile)

    if verbose:
        dsinfo.info("#Templates: %d #States: %d, WinSize: %d, Shift: %d" % (len(db), nStates, winSize, shiftMe))

    if dynType.__name__ == "LinearDS":
        # create online version of LinearDS
        ds = OnlineLinearDS(nStates, winSize, shiftMe, False, verbose)
    elif dynType.__name__ == "NonLinearDS":
        kpcaP = KPCAParam()

        # select kernel
        if config["kdtKern"] == "rbf":
            kpcaP._kPar = RBFParam()
            kpcaP._kFun = rbfK
        else:
            dsinfo.fail("Kernel %s not supported!" % kdtKern)
            return -1

        # configure kernel
        if config["kCenter"] == 1:
            kpcaP._kPar._kCen = True
        else:
            kpcaP._kPar._kCen = False

        # create online version of KDT
        ds = OnlineNonLinearDS(nStates, kpcaP, winSize, shiftMe, verbose)
    else:
        dsinfo.fail("System type %s not supported!" % options.dsType)
        return -1

    dList = []
    for f in range(inVideo.shape[1]):
        ds.update(inVideo[:, f])
        if ds.check() and ds.hasChanged():
            dists = np.zeros((len(db),))
            for j, dbentry in enumerate(db):
                dists[j] = {"LinearDS": dsdist.ldsMartinDistance, "NonLinearDS": dsdist.nldsMartinDistance}[
                    dynType.__name__
                ](ds, dbentry["model"], numIter)
            dList.append(dists)

    # write distance matrix
    if not mdFile is None:
        np.savetxt(mdFile, np.asmatrix(dList), fmt="%.5f", delimiter=" ")