コード例 #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
コード例 #2
0
ファイル: kdt.py プロジェクト: KitwareMedical/pydstk
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
コード例 #3
0
ファイル: dtdist.py プロジェクト: projectAfey/pydstk
def main(argv=None):
    if argv is None: 
        argv = sys.argv

    parser = OptionParser(add_help_option=False)
    parser.add_option("-s", dest="model1File")
    parser.add_option("-r", dest="model2File") 
    parser.add_option("-n", dest="iterations", type="int", default=20)
    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()
    
    with open(opt.model1File, 'r') as fid:
        dt1 = pickle.load(fid)
    with open(opt.model2File, 'r') as fid:
        dt2 = pickle.load(fid)

    martinD = dsdist.ldsMartinDistance(dt1, dt2, opt.iterations)
    dsinfo.info('D(%s,%s) = %.4f' % (opt.model1File, opt.model2File, martinD))
コード例 #4
0
ファイル: dtcluster.py プロジェクト: KitwareMedical/pydstk
def main(argv=None):
    if argv is None: 
        argv = sys.argv

    parser = OptionParser(add_help_option=False)
    parser.add_option("-i", dest="iListFile") 
    parser.add_option("-o", dest="oListFile")
    parser.add_option("-d", dest="dMatFile")
    parser.add_option("-b", dest="iBase")
    parser.add_option("-k", dest="kCenter", 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) 
    options, args = parser.parse_args()
    
    if options.shoHelp: 
        usage()
    
    iBase = options.iBase
    dMatFile = options.dMatFile
    iListFile = options.iListFile
    oListFile = options.oListFile
    kCenter = options.kCenter
    verbose = options.verbose

    assert kCenter > 0, "Oops (kCenter < 1) ..."
 
    iList = pickle.load(open(iListFile))
 
    if verbose:
        dsinfo.info("Loaded list with %d DT models!" % len(iList))
 
    # load DT's
    dts = []
    for dtFile in iList:
        dts.append(pickle.load(open(os.path.join(iBase, dtFile))))
    
    if verbose:
        dsinfo.info("Running DT clustering with %d clusters ..." % kCenter)
    
    D = None
    if not dMatFile is None:
        if os.path.exists(dMatFile):    
            if verbose:
                dsinfo.info("Try loading distance matrix %s!" % dMatFile)
            D = pickle.load(open(dMatFile))

    if D is None:
        if verbose:
            dsinfo.info("Computing pairwise distances ...")
        nDTs = len(dts)
        D = np.zeros((nDTs, nDTs))
        for i in range(nDTs):
            for j in range(nDTs):
                D[i,j] = ldsMartinDistance(dts[i], dts[j], 50)
    
    # run clustering
    (eData, ids) = LinearDS.cluster(D, kCenter, verbose)
    ids = list(ids)
    
    #write list of DT representatives
    oList = []
    for j, dtFile in enumerate(iList):
            if j in ids:
                oList.append(dtFile)
            else:
                oList.append("Dummy")
    pickle.dump(oList, open(oListFile, "w"))

    if verbose:
        dsinfo.info("Wrote list of representative DS's to %s!" % oListFile)

    if not dMatFile is None:
        if verbose:
            dsinfo.info("Writing distance matrix to %s!" % dMatFile)
        pickle.dump(D, open(dMatFile, "w"))
コード例 #5
0
ファイル: dtcluster.py プロジェクト: projectAfey/pydstk
def main(argv=None):
    if argv is None:
        argv = sys.argv

    parser = OptionParser(add_help_option=False)
    parser.add_option("-i", dest="iListFile")
    parser.add_option("-o", dest="oListFile")
    parser.add_option("-d", dest="dMatFile")
    parser.add_option("-b", dest="iBase")
    parser.add_option("-k", dest="kCenter", 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)
    options, args = parser.parse_args()

    if options.shoHelp:
        usage()

    iBase = options.iBase
    dMatFile = options.dMatFile
    iListFile = options.iListFile
    oListFile = options.oListFile
    kCenter = options.kCenter
    verbose = options.verbose

    assert kCenter > 0, "Oops (kCenter < 1) ..."

    iList = pickle.load(open(iListFile))

    if verbose:
        dsinfo.info("Loaded list with %d DT models!" % len(iList))

    # load DT's
    dts = []
    for dtFile in iList:
        dts.append(pickle.load(open(os.path.join(iBase, dtFile))))

    if verbose:
        dsinfo.info("Running DT clustering with %d clusters ..." % kCenter)

    D = None
    if not dMatFile is None:
        if os.path.exists(dMatFile):
            if verbose:
                dsinfo.info("Try loading distance matrix %s!" % dMatFile)
            D = pickle.load(open(dMatFile))

    if D is None:
        if verbose:
            dsinfo.info("Computing pairwise distances ...")
        nDTs = len(dts)
        D = np.zeros((nDTs, nDTs))
        for i in range(nDTs):
            for j in range(nDTs):
                D[i, j] = ldsMartinDistance(dts[i], dts[j], 50)

    # run clustering
    (eData, ids) = LinearDS.cluster(D, kCenter, verbose)
    ids = list(ids)

    #write list of DT representatives
    oList = []
    for j, dtFile in enumerate(iList):
        if j in ids:
            oList.append(dtFile)
        else:
            oList.append("Dummy")
    pickle.dump(oList, open(oListFile, "w"))

    if verbose:
        dsinfo.info("Wrote list of representative DS's to %s!" % oListFile)

    if not dMatFile is None:
        if verbose:
            dsinfo.info("Writing distance matrix to %s!" % dMatFile)
        pickle.dump(D, open(dMatFile, "w"))
コード例 #6
0
ファイル: dt.py プロジェクト: rkwitt/PyDSTK
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
コード例 #7
0
ファイル: detect.py プロジェクト: projectAfey/pydstk
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=' ')
コード例 #8
0
ファイル: system.py プロジェクト: rkwitt/PyDSTK
    def suboptimalSysID(self, Y):
        """Suboptimal system identification using SVD.
        
        Suboptimal system identification based on SVD, as proposed in the 
        original work of Doretto et al. [1]. 
        
        Parameters
        ----------
        Y : numpy array, shape = (N, D)
            Input data with D observations as N-dimensional column vectors.
        """
        
        nStates = self._nStates
        
        if self._verbose:
            dsinfo.info("using suboptimal SVD-based estimation!")

        (N, tau) = Y.shape
        Yavg = np.mean(Y, axis=1)
        Y = Y - Yavg[:,np.newaxis]
        
        if self._approx:
            if self._verbose:
                with Timer('randomized_svd'):
                    (U, S, V) = randomized_svd(Y, nStates)
            else:
                (U, S, V) = randomized_svd(Y, nStates)
        else:
            if self._verbose:
                with Timer('np.linalg.svd'):
                    (U, S, V) = np.linalg.svd(Y, full_matrices=0)
            else:
                (U, S, V) = np.linalg.svd(Y, full_matrices=0)
                
        Chat = U[:,0:nStates]
        Xhat = (np.diag(S)[0:nStates,0:nStates] * np.asmatrix(V[0:nStates,:]))
    
        initM0 = np.mean(Xhat[:,0], axis=1)
        initS0 = np.zeros((nStates, 1))

        pind = range(tau-1);

        phi1 = Xhat[:,pind]
        phi2 = Xhat[:,[i+1 for i in pind]]
        
        Ahat = phi2*np.linalg.pinv(phi1)
        Vhat = phi2-Ahat*phi1;
        Qhat = 1.0/Vhat.shape[1] * Vhat*Vhat.T 
         
        errorY = Y - Chat*Xhat
        Rhat = np.var(errorY.ravel())
        
        # save parameters
        self._initS0 = initS0
        self._initM0 = initM0
        self._Yavg = Yavg
        self._Ahat = Ahat
        self._Chat = Chat
        self._Xhat = Xhat
        self._Qhat = Qhat
        self._Rhat = Rhat
                
        if self.check():
            self._ready = True
コード例 #9
0
ファイル: detect.py プロジェクト: KitwareMedical/pydstk
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=" ")
コード例 #10
0
ファイル: system.py プロジェクト: projectAfey/pydstk
    def suboptimalSysID(self, Y):
        """Suboptimal system identification using SVD.

        Suboptimal system identification based on SVD, as proposed in the
        original work of Doretto et al. [1].

        Parameters
        ----------
        Y : numpy array, shape = (N, D)
            Input data with D observations as N-dimensional column vectors.
        """

        nStates = self._nStates

        if self._verbose:
            dsinfo.info("using suboptimal SVD-based estimation!")

        (N, tau) = Y.shape
        Yavg = np.mean(Y, axis=1)
        Y = Y - Yavg[:, np.newaxis]

        if self._approx:
            if self._verbose:
                with Timer('randomized_svd'):
                    (U, S, V) = randomized_svd(Y, nStates)
            else:
                (U, S, V) = randomized_svd(Y, nStates)
        else:
            if self._verbose:
                with Timer('np.linalg.svd'):
                    (U, S, V) = np.linalg.svd(Y, full_matrices=0)
            else:
                (U, S, V) = np.linalg.svd(Y, full_matrices=0)

        Chat = U[:, 0:nStates]
        Xhat = (np.diag(S)[0:nStates, 0:nStates] *
                np.asmatrix(V[0:nStates, :]))

        initM0 = np.mean(Xhat[:, 0], axis=1)
        initS0 = np.zeros((nStates, 1))

        pind = range(tau - 1)

        phi1 = Xhat[:, pind]
        phi2 = Xhat[:, [i + 1 for i in pind]]

        Ahat = phi2 * np.linalg.pinv(phi1)
        Vhat = phi2 - Ahat * phi1
        Qhat = 1.0 / Vhat.shape[1] * Vhat * Vhat.T

        errorY = Y - Chat * Xhat
        Rhat = np.var(errorY.ravel())

        # save parameters
        self._initS0 = initS0
        self._initM0 = initM0
        self._Yavg = Yavg
        self._Ahat = Ahat
        self._Chat = Chat
        self._Xhat = Xhat
        self._Qhat = Qhat
        self._Rhat = Rhat

        if self.check():
            self._ready = True
コード例 #11
0
ファイル: dt.py プロジェクト: projectAfey/pydstk
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