def session_factory(options='',output_buffer_size=8096):
    system = platform.system()
    path = None
    if (system == 'Linux') or (system == 'Darwin'):
        # find the MATLAB-root path:
        locations = os.environ.get("PATH").split(os.pathsep)
        for location in locations:
            candidate = os.path.join(location, 'matlab')
            if os.path.isfile(candidate):
                path = candidate
                break
        executable = os.path.realpath(path)
        basedir = os.path.dirname(os.path.dirname(executable))
        exec_and_options = " ".join([executable,options])
        session = MatlabSession(basedir,exec_and_options,output_buffer_size)
    elif system =='Windows':
        locations = os.environ.get("PATH").split(os.pathsep)
        for location in locations:
            candidate = os.path.join(location, 'matlab.exe')
            if os.path.isfile(candidate):
                path = candidate
                break
        executable = os.path.realpath(path)
        basedir = os.path.dirname(os.path.dirname(executable))
        session = MatlabSession(path=basedir,bufsize=output_buffer_size)

    else:
        raise NotSupportedException(
                'Not supported on the {platform}-platform'.format(
                        platform=system))
    return session
示例#2
0
    def readConstantly(self):
        if enableEyeCircuit:
            from pymatlab.matlab import MatlabSession
        import time
        initialized = 0
        if enableEyeCircuit:
            import os
            print("Opening MATLAB session...")
            self.session = MatlabSession('matlab -nojvm -nodisplay')
            print("Attempting to connect to DAQ...")
            self.session.run("cd " + os.path.join(os.getcwd(), "daq"))
            self.session.run("Init")  #Initializes DAQ and starts recording
            initialized = int(self.session.getvalue("Init_initialized"))
            if initialized == 0:
                print(
                    "DAQ Initialization failed. Ensure that the DAQ software is installed and try closing all open MATLAB Processes."
                )
                self.deactivate()
            else:
                print("Connected to DAQ")
                self.readyState.value = 1
                print("Calibrating Eye Circuit...")
                self.calibrate()
                self.session.run("oldVal = 0")

            while self.activeState():
                if enableEyeCircuit:
                    self.session.run(
                        "signal = monitor(Init_NI,Init_sampleRate,nMin,cLine,nMax,oldVal);"
                    )
                    self.session.run("oldVal = signal;")
                    self.direction.value = int(self.session.getvalue("signal"))
                    time.sleep(0.01)
                    self.count += 1
                    if self.count > 100:
                        self.session.run("refreshDevice(Init_NI);")
                        self.count = 0
        if enableEyeCircuit:
            print("Closing MATLAB Session...")
            if initialized == 1:
                self.session.run("Cleanup;")
            self.session.close()
            print("MATLAB Session Closed!")
示例#3
0
 def start(self,user,session):
     """ inits the session with matlab
     """
     self.user=user
     self.sessionId=session
     self.logger.debug("Starting matlab session %s",BCIConn.MATLAB_STR)
     self.session = MatlabSession(BCIConn.MATLAB_STR)
     self.logger.info("Matlab session started")
     self.session.putvalue('user',self.user)
     self.session.putvalue('session',self.sessionId)
     self.session.run(BCIConn.INIT)
     self.logger.debug("Matlab brainz object init with user %i and session %i",self.user,self.sessionId)
def matlabanovan(y,group,**args):
    from pymatlab.matlab import MatlabSession
    session = MatlabSession()
    session.close()
    session = MatlabSession('matlab -nojvm -nodisplay')
    session.PutValue('y',y)
    session.PutValue('group', group)
    session.PutValue('varargin' **args)
    session.run('anovan(y, group, varargin)')
    
示例#5
0
    def readConstantly(self):
        if enableEyeCircuit:
            from pymatlab.matlab import MatlabSession
        import time
        initialized = 0
        if enableEyeCircuit:
            import os
            print("Opening MATLAB session...")
            self.session = MatlabSession('matlab -nojvm -nodisplay')
            print("Attempting to connect to DAQ...")
            self.session.run("cd "+os.path.join(os.getcwd(),"daq"))
            self.session.run("Init") #Initializes DAQ and starts recording
            initialized = int(self.session.getvalue("Init_initialized"))
            if initialized == 0:
                print("DAQ Initialization failed. Ensure that the DAQ software is installed and try closing all open MATLAB Processes.")
                self.deactivate()
            else:
                print("Connected to DAQ")
                self.readyState.value = 1
                print("Calibrating Eye Circuit...")
                self.calibrate()
                self.session.run("oldVal = 0")

            while self.activeState():
                if enableEyeCircuit:
                    self.session.run("signal = monitor(Init_NI,Init_sampleRate,nMin,cLine,nMax,oldVal);")
                    self.session.run("oldVal = signal;")
                    self.direction.value = int(self.session.getvalue("signal"))
                    time.sleep(0.01)
                    self.count += 1
                    if self.count > 100:
                        self.session.run("refreshDevice(Init_NI);")
                        self.count = 0
        if enableEyeCircuit:
            print("Closing MATLAB Session...")
            if initialized == 1:
                self.session.run("Cleanup;")
            self.session.close()
            print("MATLAB Session Closed!")
def remote_session_factory(hostname,remote_path):
    system = platform.system()
    path = None
    if (system == 'Linux') or (system == 'Darwin'):
        locations = os.environ.get("PATH").split(os.pathsep)
        for location in locations:
            candidate = os.path.join(location, 'matlab')
            if os.path.isfile(candidate):
                path = candidate
                break
        executable = os.path.realpath(path)
        basedir = os.path.dirname(os.path.dirname(executable))
        session = MatlabSession(
            basedir,
            "ssh {host} '/bin/csh -c {full_path}'".format(
                    host=hostname,
                    full_path=remote_path)
            )
    else:
        raise NotSupportedException(
                'Not supported on the {platform}-platform'.format(
                        platform=system))
    return session
示例#7
0
 def _start_matlab(self):
     self.m = MatlabSession('/usr/local/MATLAB/R2011a/bin/matlab -nosplash -nodisplay')
     self.m.run("addpath(genpath('"+os.path.abspath(self.algopath)+"'))")
示例#8
0
class Whisperer(object):

    savepath = SAVEPATH
    algopath = ALGOPATH

    def _start_matlab(self):
        self.m = MatlabSession('/usr/local/MATLAB/R2011a/bin/matlab -nosplash -nodisplay')
        self.m.run("addpath(genpath('"+os.path.abspath(self.algopath)+"'))")

    def __init__(self,db,im=None):
        self.m = None
        self.db = db
        self.im = im

    def _put(self, name, value):
        self.m.putvalue(name, value)

    def _run(self, command):
        self.m.run(command)

    def _get(self, name):
        return self.m.getvalue(name)

    def _close_matlab(self):
        if self.m:
            self.m.close()
        self.m = None

    @matlab
    def create_titles_vector(self):
        db = self.db
        db_ratings = db(db.ratings).select(db.ratings.ALL, distinct=db.ratings.imovie).sort(lambda x: x.imovie)
        titles = None
        if self.im:
            titles = list()
            for x in db_ratings:
                movie = x.imovie
                titles.append(movie.title)
        if titles:
            self._run("titles = cell({},1)".format(len(titles)))
            for i, title in enumerate(titles):
                if title is None:
                    title = 'None'
                title = title.replace("'", "''")
                self._run("titles{{{0}}}='{1}'".format(i+1, title))
            self._run("save('"+os.path.join(self.savepath, 'titles')+"', 'titles')")

    @matlab
    def create_features_vector(self):
        db = self.db
        db_features = db(db.movies_features).select(db.movies_features.ALL, distinct=db.movies_features.feature).sort(lambda x: x.feature)
        features_vector = list()
        for x in db_features:
            features_vector.append(x.feature.name)
        self._run("features = cell({},1)".format(len(features_vector)))
        for i, feature in enumerate(features_vector):
            feature_escaped = feature.replace("'", "''")
            self._run("features{{{0}}}='{1}'".format(i+1, feature_escaped))
        self._run("save('"+os.path.join(self.savepath, 'features')+"', 'features')")


    @matlab
    def create_matlab_matrices(self, type=None, force=False, *args, **vars):
        c_icm = True
        c_urm = True
        urm_filepath = os.path.join(self.savepath, 'urm.mat')
        icm_filepath = os.path.join(self.savepath, 'icm.mat')
        try:
            urm_date = datetime.datetime.fromtimestamp(os.path.getctime(urm_filepath))
        except OSError:
            urm_date = None
        try:
            icm_date = datetime.datetime.fromtimestamp(os.path.getctime(icm_filepath))
        except OSError:
            icm_date = None
        if type == 'urm':
            c_icm = False
        elif type == 'icm':
            c_urm = False
        if c_urm:
            filepath = os.path.join(self.savepath, 'urm.mat')
            if not urm_date or force:
                users, movies, ratings, urm_dimensions = self._create_urm()
                self._put('urm_users', users)
                self._put('urm_movies', movies)
                self._put('urm_ratings', ratings)
                self._put('urm_dimensions', urm_dimensions)
                self._run("urm = sparse(urm_users, urm_movies, urm_ratings, urm_dimensions(1), urm_dimensions(2))")
                self._run("save('"+os.path.join(self.savepath, 'urm')+"', 'urm')")
                self._run("clear")
        if c_icm:
            filepath = os.path.join(self.savepath, 'icm.mat')
            if not icm_date or force:
                icm_items, icm_features, icm_occurrencies, icm_dimensions = self._create_icm()
                self._put('icm_items', icm_items)
                self._put('icm_features', icm_features)
                self._put('icm_occurrencies', icm_occurrencies)
                self._put('icm_dimensions', icm_dimensions)
                self._run("icm = sparse(icm_items, icm_features, icm_occurrencies, icm_dimensions(1), icm_dimensions(2))")
                self._run("save('"+os.path.join(self.savepath, 'icm')+"', 'icm')")
                self._run("clear")


    def _create_urm(self, users=None, items=None, ratings=None):
        """Return the user rating matrix"""
        db = self.db
        db_ratings = db(db.ratings).select(db.ratings.ALL, distinct=True)
        users = [float(x.iuser) for x in db_ratings]
        movies = [float(x.imovie) for x in db_ratings]
        ratings = [round(x.rating * 5, 0) for x in db_ratings]
        users = numpy.array(users)
        movies = numpy.array(movies)
        ratings = numpy.array(ratings)
        max_user = db.ratings.iuser.max()
        max_movies = db.ratings.imovie.max()
        dimensions = [float(db().select(max_user).first()[max_user]), float(db().select(max_movies).first()[max_movies])]
        dimensions = numpy.array(dimensions)

        return users, movies, ratings, dimensions


    def _create_icm(self, items=None, metadata=None):
        """Returns the item content matrix"""
        db = self.db
        if not items and not metadata:
            entries = db(db.movies_features).select(db.movies_features.ALL, distinct=True)

        items = [float(x.movie.id) for x in entries]
        features = [float(x.feature.id) for x in entries]
        occurrencies = [float(x.times) for x in entries]
        max_movies = db.movies_features.movie.max()
        max_features = db.movies_features.feature.max()
        dimensions = numpy.array([float(db().select(max_movies).first()[max_movies]), float(db().select(max_features).first()[max_features])])
        return numpy.array(items), numpy.array(features), numpy.array(occurrencies), dimensions

    def create_userprofile(self, user):
        db = self.db
        entries = db(db.ratings.iuser==user).select(db.ratings.ALL, cacheable=True)
        ratings = [round(x.rating * 5, 0) for x in entries]
        movies = [float(x.imovie) for x in entries]
        max_movies = db.ratings.imovie.max()
        dimension = [float(db().select(max_movies).first()[max_movies])]

        # up = numpy.zeros((1,self.db.query(func.max(Item.id)).one()[0]))
        # for r in ratings:
        #     up[0][r.item.id-1] = r.rating
        return numpy.array(ratings), numpy.array(movies), numpy.array(dimension)

    @matlab
    def _create_model(self, alg, param=None, *args, **kwargs):
        self._run("load('"+os.path.join(self.savepath, 'urm.mat')+"')")
        self._run("load('"+os.path.join(self.savepath, 'icm.mat')+"')")
        self._run("param = struct()")
        if param:
            for k,v in param.iteritems():
                self._run("param."+str(k)+" = "+str(v))
        self._run("["+alg+"_model] = createModel_"+alg+"(urm, icm, param)")
        self._run("save('"+os.path.join(self.savepath, alg+'_model')+"', '"+alg+"_model')")

    def create_model(self, algname='AsySVD'):
        """Create a model and saves it the ALGORITHMS/saved directory"""
        #function [model] = createModel_ALGORITHM_NAME(URM,ICM,param)
        db = self.db
        alg = self._get_model_name(algname)
        self.create_matlab_matrices(force=True)
        self._create_model(alg)


    @matlab
    def _get_rec(self, algname, user, **param):
        """Return a recommendation using the matlab engine"""
        #function [recomList] = onLineRecom_ALGORITHM_NAME (userProfile, model,param)
        ratings, movies, dimension = self.create_userprofile(user)
        alg = self._get_model_name(algname)
        self._put('ratings', ratings)
        self._put('movies', movies)
        self._put('dimension', dimension)
        self._run("up = sparse(1, movies, ratings, 1, dimension(1))")
        self._run("param = struct()")
        for k,v in param.iteritems():
            self._run("param."+str(k)+" = "+str(v))
        self._run("load('"+os.path.join(self.savepath, alg+'_model')+"', '"+alg+"_model')")
        self._run("[rec] = onLineRecom_"+algname+"(up, "+alg+"_model, param)")
        return self._get("rec")

    def get_rec(self, algname, user, max=10, **param):
        """Wrapper aroung the real recommendation getter to set parameters"""
        if algname == 'AsySVD':
            param = dict(param, userToTest=user)

        rec = self._get_rec(algname, user, **param)
        rec = numpy.squeeze(rec)
        indexes = bottleneck.argpartsort(rec, rec.size-max, axis=0)[-max:]
        rec = [(rec[index], index) for index in indexes]
        rec.sort(reverse=True)
        return rec

    @classmethod
    def get_algnames(self):
        """Return a list of algorithms in the system"""
        algs = list()
        for root, dirs, files in os.walk(self.algopath):
            for f in files:
                if f.startswith('onLineRecom'):
                    algs.append(f[12:-2])
        algs.sort()
        return algs

    @classmethod
    def _get_model_name(self, algname=None):
        for root, dirs, files in os.walk(self.algopath):
            for f in files:
                if f.startswith('onLineRecom'):
                    if f[12:-2] == algname:
                        for mf in files:
                            if mf.startswith('createModel'):
                                return mf[12:-2]

        return None


    @classmethod
    def get_models_info(self):
        """Return a dict of algorithms in which there is a model created and the time the model was created"""
        algnames = self.get_algnames()
        algs = dict()
        for root, dirs, files in os.walk(self.savepath):
            for f in files:
                for algname in algnames:
                    if f[:-10] in self._get_model_name(algname) and f[:-10]!='':
                        algo =f[:-10]
                        path = os.path.join(root, f)
                        algs[algname] = datetime.datetime.fromtimestamp(os.path.getmtime(path))
        return algs

    @classmethod
    def get_matrices_info(cls):
        matrices = dict()
        for matrice in ALL_MATRICES:
            try:
                matrices[matrice] = datetime.datetime.fromtimestamp(os.path.getmtime(os.path.join(cls.savepath, matrice+'.mat')))
            except:
                matrices[matrice] = None
        return matrices

    @classmethod
    def get_matrices_path(cls):
        matrices = dict()
        for matrice in ALL_MATRICES:
            try:
                matrices[matrice] = os.path.join(cls.savepath, matrice+'.mat')
            except:
                matrices[matrice] = None
        return matrices

    @classmethod
    def delete_matrice(cls, matrice):
        matrices_path = cls.get_matrices_path()
        os.remove(matrices_path[matrice])
示例#9
0
	def _start_matlab(self):
		self.m = MatlabSession('matlab -nosplash -nodisplay')
		self.m.run("addpath(genpath('"+os.path.abspath(self.algopath)+"'))")
示例#10
0
class Whisperer(object):
	
	savepath = config.SAVEPATH
	algopath = config.ALGOPATH
	
	def _start_matlab(self):
		self.m = MatlabSession('matlab -nosplash -nodisplay')
		self.m.run("addpath(genpath('"+os.path.abspath(self.algopath)+"'))")
		
	def __init__(self):
		self.m = None
		self.db = Session()
	
	def _put(self, name, value):
		self.m.putvalue(name, value)
	
	def _run(self, command):
		self.m.run(command)
		
	def _get(self, name):
		return self.m.getvalue(name)
	
	def _close_matlab(self):
		if self.m:
			self.m.close()
		self.m = None
		
	def create_urm(self, users=None, items=None, ratings=None):
		"""Return the user rating matrix"""
		if not users:
			users = self.db.query(User).all()
		if not items:
			items = self.db.query(Item).all()
		if not ratings:
			ratings = self.db.query(Rating).all()
		
		urm = numpy.zeros((self.db.query(func.max(User.id)).one()[0],self.db.query(func.max(Item.id)).one()[0]))
		for r in ratings:
			urm[r.user_id-1][r.item_id-1] = r.rating
		return urm
		
	def create_icm(self, items=None, metadatas=None):
		"""Returns the item content matrix"""
		if not items:
			items = self.db.query(Item).all()
		if not metadatas:
			metadatas = self.db.query(Metadata).all()
		
		icm = numpy.zeros((self.db.query(func.max(Metadata.id)).one()[0],self.db.query(func.max(Item.id)).one()[0]))
		for i in items:
			for m in i.metadatas:
				icm[m.id-1][i.id-1] = 1
		return icm
		
	def create_userprofile(self, user, items=None):
		if not items:
			items = self.db.query(Item).all()
		
		ratings = self.db.query(Rating).all()
		up = numpy.zeros((1,self.db.query(func.max(Item.id)).one()[0]))
		for r in ratings:
			up[0][r.item.id-1] = r.rating
		return up
	
	@matlab
	def create_model(self, algname, urm=None, icm=None):
		"""Create a model and saves it the ALGORITHMS/saved directory"""
		#function [model] = createModel_ALGORITHM_NAME(URM,ICM,param)
		if not urm:
			urm = self.create_urm()
		if not icm:
			icm = self.create_icm()
		alg = self._get_model_name(algname)
		self._put('urm', urm)
		self._put('icm', icm)
		self._run("["+alg+"_model] = createModel_"+alg+"(urm, icm)")
		self._run("save('"+os.path.join(self.savepath, alg+'_model')+"', '"+alg+"_model')")
	
	@matlab		
	def _get_rec(self, algname, user, **param):
		"""Return a recommendation using the matlab engine"""
		#function [recomList] = onLineRecom_ALGORITHM_NAME (userProfile, model,param)
		up = self.create_userprofile(user)
		alg = self._get_model_name(algname)
		self._put('up', up)
		self._run("param = struct()")
		for k,v in param.iteritems():
			self._run("param."+str(k)+" = "+str(v))
		self._run("load('"+os.path.join(self.savepath, alg+'_model')+"', '"+alg+"_model')")
		self._run("[rec] = onLineRecom_"+algname+"(up, "+alg+"_model, param)")
		return self._get("rec")
	
	def get_rec(self, algname, user, **param):
		"""Wrapper aroung the real recommendation getter to set parameters"""
		if algname == 'AsySVD':
			param = dict(param, userToTest=user.id)
		
		return self._get_rec(algname, user, **param)
	
	@classmethod	
	def get_algnames(self):
		"""Return a list of algorithms in the system"""
		algs = list()
		for root, dirs, files in os.walk(self.algopath):
			for f in files:
				if f.startswith('onLineRecom'):
					algs.append(f[12:-2])
		algs.sort()
		return algs
		
	@classmethod
	def _get_model_name(self, algname=None):
		for root, dirs, files in os.walk(self.algopath):
			for f in files:
				if f.startswith('onLineRecom'):
					if f[12:-2] == algname:
						for mf in files:
							if mf.startswith('createModel'):
								return mf[12:-2]
					
		return None
		
	
	@classmethod
	def get_models_info(self):
		"""Return a dict of algorithms in which there is a model created and the time the model was created"""
		algnames = self.get_algnames()
		algs = dict()
		for root, dirs, files in os.walk(self.savepath):
			for f in files:
				for algname in algnames:
					if f[:-10] in self._get_model_name(algname):
						algo =f[:-10]
						path = os.path.join(root, f)
						algs[algname] = datetime.datetime.fromtimestamp(os.path.getmtime(path))
		return algs
	
	@matlab
	def load_urm(self):
		self._run("load('urmFull.mat')")
		self._run("A=full(urm)")
		urm = self._get("A")
		#force matlab to close and free memory
		self._close_matlab()
		print 'Out of matlab!'
		for (row,col),value in numpy.ndenumerate(urm):
			print 'processing rating %i for user %i and item %i' % (value, row, col)
			if value is not 0:
				self.db.add(Rating(user_id=row+1, item_id=col+1, rating=value))
				self.db.flush()	
				self.db.commit()
		#for i,row in enumerate(urm):
		#	print 'processing row: %s' % (i)
		#	self.db.add(User(name="netflix%s" % (i)))
		#	self.db.flush()	
		#urm[r.user_id-1][r.item_id-1]
	
	@matlab
	def load_titles(self, filename='/tmp/movie_titles.txt'):
		self._run("load('titles.mat')")
		titles = self._get('titles')
		l = list()
		for row in titles:
			l.append(''.join(row).rstrip())
		f = open(filename, 'w')
		for item in l:
			f.write("%s\n" % item)
		f.close()
		return l
		
	def do_something(self):
		print 'URM'
		print self.create_urm()
		print 'ICM'
		print self.create_icm()
		print 'run AsySVD'
		#print self.create_model('random')
		#print self.create_model('cosineIIknn')
		#print 'get rec'
		print self.get_rec('random', self.db.query(User).filter(User.id==9).first())
示例#11
0
 def _start_matlab(self):
     self.m = MatlabSession(
         '/usr/local/MATLAB/R2011a/bin/matlab -nosplash -nodisplay')
     self.m.run("addpath(genpath('" + os.path.abspath(self.algopath) +
                "'))")
示例#12
0
class Whisperer(object):

    savepath = SAVEPATH
    algopath = ALGOPATH

    def _start_matlab(self):
        self.m = MatlabSession(
            '/usr/local/MATLAB/R2011a/bin/matlab -nosplash -nodisplay')
        self.m.run("addpath(genpath('" + os.path.abspath(self.algopath) +
                   "'))")

    def __init__(self, db, im=None):
        self.m = None
        self.db = db
        self.im = im

    def _put(self, name, value):
        self.m.putvalue(name, value)

    def _run(self, command):
        self.m.run(command)

    def _get(self, name):
        return self.m.getvalue(name)

    def _close_matlab(self):
        if self.m:
            self.m.close()
        self.m = None

    @matlab
    def create_titles_vector(self):
        db = self.db
        db_ratings = db(db.ratings).select(
            db.ratings.ALL,
            distinct=db.ratings.imovie).sort(lambda x: x.imovie)
        titles = None
        if self.im:
            titles = list()
            for x in db_ratings:
                movie = x.imovie
                titles.append(movie.title)
        if titles:
            self._run("titles = cell({},1)".format(len(titles)))
            for i, title in enumerate(titles):
                if title is None:
                    title = 'None'
                title = title.replace("'", "''")
                self._run("titles{{{0}}}='{1}'".format(i + 1, title))
            self._run("save('" + os.path.join(self.savepath, 'titles') +
                      "', 'titles')")

    @matlab
    def create_features_vector(self):
        db = self.db
        db_features = db(db.movies_features).select(
            db.movies_features.ALL,
            distinct=db.movies_features.feature).sort(lambda x: x.feature)
        features_vector = list()
        for x in db_features:
            features_vector.append(x.feature.name)
        self._run("features = cell({},1)".format(len(features_vector)))
        for i, feature in enumerate(features_vector):
            feature_escaped = feature.replace("'", "''")
            self._run("features{{{0}}}='{1}'".format(i + 1, feature_escaped))
        self._run("save('" + os.path.join(self.savepath, 'features') +
                  "', 'features')")

    @matlab
    def create_matlab_matrices(self, type=None, force=False, *args, **vars):
        c_icm = True
        c_urm = True
        urm_filepath = os.path.join(self.savepath, 'urm.mat')
        icm_filepath = os.path.join(self.savepath, 'icm.mat')
        try:
            urm_date = datetime.datetime.fromtimestamp(
                os.path.getctime(urm_filepath))
        except OSError:
            urm_date = None
        try:
            icm_date = datetime.datetime.fromtimestamp(
                os.path.getctime(icm_filepath))
        except OSError:
            icm_date = None
        if type == 'urm':
            c_icm = False
        elif type == 'icm':
            c_urm = False
        if c_urm:
            filepath = os.path.join(self.savepath, 'urm.mat')
            if not urm_date or force:
                users, movies, ratings, urm_dimensions = self._create_urm()
                self._put('urm_users', users)
                self._put('urm_movies', movies)
                self._put('urm_ratings', ratings)
                self._put('urm_dimensions', urm_dimensions)
                self._run(
                    "urm = sparse(urm_users, urm_movies, urm_ratings, urm_dimensions(1), urm_dimensions(2))"
                )
                self._run("save('" + os.path.join(self.savepath, 'urm') +
                          "', 'urm')")
                self._run("clear")
        if c_icm:
            filepath = os.path.join(self.savepath, 'icm.mat')
            if not icm_date or force:
                icm_items, icm_features, icm_occurrencies, icm_dimensions = self._create_icm(
                )
                self._put('icm_items', icm_items)
                self._put('icm_features', icm_features)
                self._put('icm_occurrencies', icm_occurrencies)
                self._put('icm_dimensions', icm_dimensions)
                self._run(
                    "icm = sparse(icm_items, icm_features, icm_occurrencies, icm_dimensions(1), icm_dimensions(2))"
                )
                self._run("save('" + os.path.join(self.savepath, 'icm') +
                          "', 'icm')")
                self._run("clear")

    def _create_urm(self, users=None, items=None, ratings=None):
        """Return the user rating matrix"""
        db = self.db
        db_ratings = db(db.ratings).select(db.ratings.ALL, distinct=True)
        users = [float(x.iuser) for x in db_ratings]
        movies = [float(x.imovie) for x in db_ratings]
        ratings = [round(x.rating * 5, 0) for x in db_ratings]
        users = numpy.array(users)
        movies = numpy.array(movies)
        ratings = numpy.array(ratings)
        max_user = db.ratings.iuser.max()
        max_movies = db.ratings.imovie.max()
        dimensions = [
            float(db().select(max_user).first()[max_user]),
            float(db().select(max_movies).first()[max_movies])
        ]
        dimensions = numpy.array(dimensions)

        return users, movies, ratings, dimensions

    def _create_icm(self, items=None, metadata=None):
        """Returns the item content matrix"""
        db = self.db
        if not items and not metadata:
            entries = db(db.movies_features).select(db.movies_features.ALL,
                                                    distinct=True)

        items = [float(x.movie.id) for x in entries]
        features = [float(x.feature.id) for x in entries]
        occurrencies = [float(x.times) for x in entries]
        max_movies = db.movies_features.movie.max()
        max_features = db.movies_features.feature.max()
        dimensions = numpy.array([
            float(db().select(max_movies).first()[max_movies]),
            float(db().select(max_features).first()[max_features])
        ])
        return numpy.array(items), numpy.array(features), numpy.array(
            occurrencies), dimensions

    def create_userprofile(self, user):
        db = self.db
        entries = db(db.ratings.iuser == user).select(db.ratings.ALL,
                                                      cacheable=True)
        ratings = [round(x.rating * 5, 0) for x in entries]
        movies = [float(x.imovie) for x in entries]
        max_movies = db.ratings.imovie.max()
        dimension = [float(db().select(max_movies).first()[max_movies])]

        # up = numpy.zeros((1,self.db.query(func.max(Item.id)).one()[0]))
        # for r in ratings:
        #     up[0][r.item.id-1] = r.rating
        return numpy.array(ratings), numpy.array(movies), numpy.array(
            dimension)

    @matlab
    def _create_model(self, alg, param=None, *args, **kwargs):
        self._run("load('" + os.path.join(self.savepath, 'urm.mat') + "')")
        self._run("load('" + os.path.join(self.savepath, 'icm.mat') + "')")
        self._run("param = struct()")
        if param:
            for k, v in param.iteritems():
                self._run("param." + str(k) + " = " + str(v))
        self._run("[" + alg + "_model] = createModel_" + alg +
                  "(urm, icm, param)")
        self._run("save('" + os.path.join(self.savepath, alg + '_model') +
                  "', '" + alg + "_model')")

    def create_model(self, algname='AsySVD'):
        """Create a model and saves it the ALGORITHMS/saved directory"""
        #function [model] = createModel_ALGORITHM_NAME(URM,ICM,param)
        db = self.db
        alg = self._get_model_name(algname)
        self.create_matlab_matrices(force=True)
        self._create_model(alg)

    @matlab
    def _get_rec(self, algname, user, **param):
        """Return a recommendation using the matlab engine"""
        #function [recomList] = onLineRecom_ALGORITHM_NAME (userProfile, model,param)
        ratings, movies, dimension = self.create_userprofile(user)
        alg = self._get_model_name(algname)
        self._put('ratings', ratings)
        self._put('movies', movies)
        self._put('dimension', dimension)
        self._run("up = sparse(1, movies, ratings, 1, dimension(1))")
        self._run("param = struct()")
        for k, v in param.iteritems():
            self._run("param." + str(k) + " = " + str(v))
        self._run("load('" + os.path.join(self.savepath, alg + '_model') +
                  "', '" + alg + "_model')")
        self._run("[rec] = onLineRecom_" + algname + "(up, " + alg +
                  "_model, param)")
        return self._get("rec")

    def get_rec(self, algname, user, max=10, **param):
        """Wrapper aroung the real recommendation getter to set parameters"""
        if algname == 'AsySVD':
            param = dict(param, userToTest=user)

        rec = self._get_rec(algname, user, **param)
        rec = numpy.squeeze(rec)
        indexes = bottleneck.argpartsort(rec, rec.size - max, axis=0)[-max:]
        rec = [(rec[index], index) for index in indexes]
        rec.sort(reverse=True)
        return rec

    @classmethod
    def get_algnames(self):
        """Return a list of algorithms in the system"""
        algs = list()
        for root, dirs, files in os.walk(self.algopath):
            for f in files:
                if f.startswith('onLineRecom'):
                    algs.append(f[12:-2])
        algs.sort()
        return algs

    @classmethod
    def _get_model_name(self, algname=None):
        for root, dirs, files in os.walk(self.algopath):
            for f in files:
                if f.startswith('onLineRecom'):
                    if f[12:-2] == algname:
                        for mf in files:
                            if mf.startswith('createModel'):
                                return mf[12:-2]

        return None

    @classmethod
    def get_models_info(self):
        """Return a dict of algorithms in which there is a model created and the time the model was created"""
        algnames = self.get_algnames()
        algs = dict()
        for root, dirs, files in os.walk(self.savepath):
            for f in files:
                for algname in algnames:
                    if f[:-10] in self._get_model_name(
                            algname) and f[:-10] != '':
                        algo = f[:-10]
                        path = os.path.join(root, f)
                        algs[algname] = datetime.datetime.fromtimestamp(
                            os.path.getmtime(path))
        return algs

    @classmethod
    def get_matrices_info(cls):
        matrices = dict()
        for matrice in ALL_MATRICES:
            try:
                matrices[matrice] = datetime.datetime.fromtimestamp(
                    os.path.getmtime(
                        os.path.join(cls.savepath, matrice + '.mat')))
            except:
                matrices[matrice] = None
        return matrices

    @classmethod
    def get_matrices_path(cls):
        matrices = dict()
        for matrice in ALL_MATRICES:
            try:
                matrices[matrice] = os.path.join(cls.savepath,
                                                 matrice + '.mat')
            except:
                matrices[matrice] = None
        return matrices

    @classmethod
    def delete_matrice(cls, matrice):
        matrices_path = cls.get_matrices_path()
        os.remove(matrices_path[matrice])
示例#13
0
def get_contextual_matlab(conf,Wsz):
    
    import platform
    if platform.node() != 'g6':
        dataPath = '/Users/aarslan/Brown/auto_context'
    else:
        dataPath = '/home/aarslan/prj/data/auto_context'

    print 'computing context features for windows size: ', str(Wsz)
    tic = time.time()
    session = MatlabSession()
    session.run('cd ', dataPath)
    session.putvalue('conf',conf)
    session.putvalue('Wsz',np.array([Wsz], dtype='float64'))
    session.run('B = ctxtFeat(conf, Wsz)')
    cf = session.getvalue('B')
    session.close()
    np.array(cf, dtype='uint8')
    print "Context feature for ", str(Wsz), " size windows took ", round(time.time() - tic,2), "seconds"
    return cf
示例#14
0
def get_contextual_matlab(conf, Wsz):

    import platform
    if platform.node() != 'g6':
        dataPath = '/Users/aarslan/Brown/auto_context'
    else:
        dataPath = '/home/aarslan/prj/data/auto_context'

    print 'computing context features for windows size: ', str(Wsz)
    tic = time.time()
    session = MatlabSession()
    session.run('cd ', dataPath)
    session.putvalue('conf', conf)
    session.putvalue('Wsz', np.array([Wsz], dtype='float64'))
    session.run('B = ctxtFeat(conf, Wsz)')
    cf = session.getvalue('B')
    session.close()
    np.array(cf, dtype='uint8')
    print "Context feature for ", str(Wsz), " size windows took ", round(
        time.time() - tic, 2), "seconds"
    return cf
示例#15
0
class BCIConn(object):
    """Connects wit matlab to process the signals and classification"""

    MATLAB_STR="matlab -nojvm -nodisplay -logfile ~/tmp/logmat.txt"
    INIT="brainz=Brainz(user,session);brainz.init();"
    START_TRIAL="brainz.startTrial()"
    ADD_DATA="c=brainz.addData(data)"
    END_TRIAL="brainz.endTrial()"


    def __init__(self):
        """@todo: to be defined """
        self.logger=logging.getLogger("logger")
        self.session=None
        self.lock=threading.Lock()
        self.onTrial=False

    def start(self,user,session):
        """ inits the session with matlab
        """
        self.user=user
        self.sessionId=session
        self.logger.debug("Starting matlab session %s",BCIConn.MATLAB_STR)
        self.session = MatlabSession(BCIConn.MATLAB_STR)
        self.logger.info("Matlab session started")
        self.session.putvalue('user',self.user)
        self.session.putvalue('session',self.sessionId)
        self.session.run(BCIConn.INIT)
        self.logger.debug("Matlab brainz object init with user %i and session %i",self.user,self.sessionId)

    def close(self  ):
        """Closes the matlab session
        """
        self.session.close()
        self.logger.info("Matlab session closed")

    def startTrial(self):
        """Sends the start trial signal to the matlab object
        """
        
        self.lock.acquire();
        self.logger.debug("Sending new trial")
        res=self.session.run(BCIConn.START_TRIAL)
        self.onTrial=True
        print "On trial %s"%self.onTrial
	if res!=None:
        	self.logger.error("Matlab complained %s"%res)

        self.lock.release();

    def endTrial(self):
        """Sends the start trial signal to the matlab object
        """
        self.onTrial=False
        self.lock.acquire();
        self.logger.debug("Finish trial")
        res=self.session.run(BCIConn.END_TRIAL)
	if res!=None:
        	self.logger.error("Matlab complained %s"%res)
        self.lock.release();

    def append(self, data):
        """sends a matrix of data to matlab to process it
        :data: 2-D matrix with the data
        :class: the output of the clasification or nil
        """
	self.logger.debug("Sending data to matlab")
        print "On trial %s"%self.onTrial
#        print "MATLAB %s"%threading.currentThread()
        if not self.onTrial:
                return -1
        #self.lock.acquire();
        time1=time.time()
        data=numpy.array(data,dtype=numpy.float64)
        self.session.putvalue('data',data)
        res=self.session.run(BCIConn.ADD_DATA)
        if res!=None:
                self.logger.error("Matlab complained %s"%res)

        c=self.session.getvalue('c')

        ##time.sleep(1)
        time2=time.time()
	self.logger.debug("done")
	#self.logger.debug("Data classified as %i",c)
        #self.lock.release();
        return int(c)