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
