def __init__(self, cookie, pathname=None, seed=None, version=None, compatible=None): if cookie != bayesdb_open_cookie: raise ValueError('Do not construct BayesDB objects directly!') if pathname is None: pathname = ":memory:" self._sqlite3 = apsw.Connection(pathname) self.txn_depth = 0 self.metamodels = {} self.tracer = None self.sql_tracer = None self.cache = None self.temptable = 0 self.qid = 0 if seed is None: seed = struct.pack('<QQQQ', 0, 0, 0, 0) self._prng = weakprng.weakprng(seed) pyrseed = self._prng.weakrandom32() self._py_prng = random.Random(pyrseed) nprseed = [self._prng.weakrandom32() for _ in range(4)] self._np_prng = numpy.random.RandomState(nprseed) schema.bayesdb_install_schema(self._sqlite3, version=version, compatible=compatible) bqlfn.bayesdb_install_bql(self._sqlite3, self) # Cache an empty cursor for convenience. empty_cursor = self._sqlite3.cursor() empty_cursor.execute('') self._empty_cursor = bql.BayesDBCursor(self, empty_cursor)
def __init__(self, m, samplesize, rs): """ sizes is an array of hash dimensions. """ if not m: raise ValueError("Table size (m) and amount of hash functions (d)" " must be non-zero") self.n = 0 self.m = m self.samplesize = samplesize self.rs = rs self.mus = numpy.array([0.0] * m).reshape(self.m, 1) self.sigma = numpy.array([1.0] * self.m).reshape(self.m, 1) #print "sigma", self.sigma.shape self._i = 0 self._j = 0 print "mus", self.mus.shape #self.tables = numpy.matlib.zeros(shape=(m,samplesize)) #self.tables=numpy.random.normal(size=(m,samplesize)) # for _ in xrange(d): # table = array.array("d", (0.0 for _ in xrange(m))) # self.tables.append(table) #inizialize projection matrix rnd = random.Random() rnd.seed(datetime.now()) self.x = np.zeros(shape=(self.samplesize, self.m)) print "generating matrix of shape", self.samplesize, self.m for i in range(self.samplesize): numpy.random.seed(i + (self.rs * 10000)) #v = numpy.random.normal(0, 1, self.m) self.x[i, :self.m] = numpy.random.normal( 0, 1, self.m) # Now put in some data
def set_seed(n): """ DOCSTRING """ seed = n py_rng = random.Random(seed) np_rng = numpy.random.RandomState(seed) t_rng = theano.sandbox.rng_mrg.MRG_RandomStreams(seed)
def __init__(self, cookie, pathname=None, seed=None, version=None, compatible=None): if cookie != bayesdb_open_cookie: raise ValueError('Do not construct BayesDB objects directly!') if pathname is None: pathname = ":memory:" self.pathname = pathname self._sqlite3 = apsw.Connection(pathname) self._txn_depth = 0 # managed in txn.py self._cache = None # managed in txn.py self.metamodels = {} self.tracer = None self.sql_tracer = None self.temptable = 0 self.qid = 0 if seed is None: seed = struct.pack('<QQQQ', 0, 0, 0, 0) self._prng = weakprng.weakprng(seed) pyrseed = self._prng.weakrandom32() self._py_prng = random.Random(pyrseed) nprseed = [self._prng.weakrandom32() for _ in range(4)] self._np_prng = numpy.random.RandomState(nprseed) # Set up or check the permanent schema on disk. schema.bayesdb_install_schema(self, version=version, compatible=compatible) # Set up the in-memory BQL functions and virtual tables that # need not have storage on disk. bqlfn.bayesdb_install_bql(self._sqlite3, self) self._sqlite3.createmodule('bql_mutinf', bqlvtab.MutinfModule(self)) self._sqlite3.cursor().execute( 'create virtual table temp.bql_mutinf using bql_mutinf') # Cache an empty cursor for convenience. empty_cursor = self._sqlite3.cursor() empty_cursor.execute('') self._empty_cursor = bql.BayesDBCursor(self, empty_cursor)
def getQuery(self, butler): n = butler.algorithms.get(key='n') d = butler.algorithms.get(key='d') # If number of reported answers is small, generate random to avoid overfitting num_reported_answers = butler.algorithms.get( key='num_reported_answers') if num_reported_answers == None: num_reported_answers = 0 R = int(1 + d * numpy.log(n)) if num_reported_answers < R * n: # This generates the same shuffle every time this everytime # TODO: but this in utils and call this from other algorithms (they use # the same method). r = random.Random() r.seed(42) idxs = np.arange(n).repeat(R).tolist() r.shuffle(idxs) a = idxs[num_reported_answers] b = numpy.random.randint(n) while b == a: b = numpy.random.randint(n) c = numpy.random.randint(n) while c == a or c == b: c = numpy.random.randint(n) return [a, b, c] # generate an active query X = numpy.array(butler.algorithms.get(key='X')) # set maximum time allowed to search for a query t_max = 0.05 q, signed_score = utilsMDS.getRandomQuery(X) best_q = q best_score = abs(signed_score) t_start = time.time() while time.time() - t_start < t_max: q, signed_score = utilsMDS.getRandomQuery(X) if abs(signed_score) < best_score: best_q = q best_score = abs(signed_score) index_center = best_q[2] index_left = best_q[0] index_right = best_q[1] return [index_center, index_left, index_right]
def __init__(self, m, samplesize,rs): """ sizes is an array of hash dimensions. """ if not m: raise ValueError("Table size (m) and amount of hash functions (d)" " must be non-zero") self.n = 0 self.m=m self.samplesize=samplesize self.rs=rs self.mus=numpy.array([0.0] *m).reshape(self.m,1) self.sigma = numpy.array([1.0] * self.m).reshape(self.m, 1) #print "sigma", self.sigma.shape self._i=0 self._j=0 print "mus", self.mus.shape #self.tables = numpy.matlib.zeros(shape=(m,samplesize)) #self.tables=numpy.random.normal(size=(m,samplesize)) # for _ in xrange(d): # table = array.array("d", (0.0 for _ in xrange(m))) # self.tables.append(table) #inizialize projection matrix rnd = random.Random() rnd.seed(datetime.now()) #numpy.random.seed(self.rs * 10000) filename=''.join(rnd.choice(string.ascii_uppercase + string.digits) for _ in range(16)) #filename= "test" self.filename=filename+'.h5' self.h5file = tb.open_file(self.filename, mode='w', title="Random Projection Matrix") root = self.h5file.root self.x = self.h5file.create_carray(root, 'x', tb.Float64Atom(), shape=(self.samplesize, self.m)) print "generating matrix of shape", self.samplesize, self.m for i in range(self.samplesize): numpy.random.seed(i + (self.rs * 10000)) #v = numpy.random.normal(0, 1, self.m) self.x[i, :self.m] = numpy.random.normal(0, 1, self.m) # Now put in some data print "Random projection matrix saved on file", filename+'.h5'
""" DOCSTRING """ import numpy.random import random import theano.sandbox.rng_mrg np_rng = numpy.random.RandomState(seed) py_rng = random.Random(seed) seed = 42 t_rng = theano.sandbox.rng_mrg.MRG_RandomStreams(seed) def set_seed(n): """ DOCSTRING """ seed = n py_rng = random.Random(seed) np_rng = numpy.random.RandomState(seed) t_rng = theano.sandbox.rng_mrg.MRG_RandomStreams(seed)
def getQuery(self, butler): R = 10 n = butler.algorithms.get(key='n') num_reported_answers = butler.algorithms.get( key='num_reported_answers') if num_reported_answers == None: num_reported_answers = 0 butler.algorithms.set(key='num_reported_answers', value=0) if num_reported_answers < R * n: r = random.Random() r.seed(42) idxs = np.arange(n).repeat(R).tolist() r.shuffle(idxs) a = idxs[num_reported_answers] b = numpy.random.randint(n) while b == a: b = numpy.random.randint(n) c = numpy.random.randint(n) while c == a or c == b: c = numpy.random.randint(n) return [a, b, c] X = numpy.array(butler.algorithms.get(key='X')) tau = numpy.array(butler.algorithms.get(key='tau')) # set maximum time allowed to search for a query t_max = .05 best_q, best_score = utilsSTE.getRandomQuery(X) t_start = time.time() best_entropy = -1 * float('inf') while time.time() - t_start < t_max: q, score = utilsSTE.getRandomQuery(X) b, c, a = q p = 0 for i in range(n): p += utilsSTE.getSTETripletProbability(X[b], X[c], X[i]) * tau[a, i] taub = list(tau[a]) for i in range(n): taub[i] = taub[i] * utilsSTE.getSTETripletProbability( X[b], X[c], X[i]) taub = taub / sum(taub) tauc = list(tau[a]) for i in range(n): tauc[i] = tauc[i] * utilsSTE.getSTETripletProbability( X[c], X[b], X[i]) tauc = tauc / sum(tauc) entropy = -p * utilsSTE.getEntropy(taub) - ( 1 - p) * utilsSTE.getEntropy(tauc) if entropy > best_entropy: best_q = q best_entropy = entropy index_center = best_q[2] index_left = best_q[0] index_right = best_q[1] return [index_center, index_left, index_right]
def __init__(self, seed=None): self._generator = random.Random(seed) if (seed is not None) and ( seed is not False) else random