def sum_columns(m):
v = CuckooVector({})
for key,col in m.columns():
v.add(col)
return v
def with_replacement(X, Y, T):
x = CuckooVector({})
m = len(Y)
for t in range(T):
i = np.random.randint(m)
y = Y[i]
x.reset(X[i])
yield (x, y)
def power_iteration_mmt(m, iterations, v0):
v = CuckooVector({})
v.add(v0)
for i in range(iterations):
vp = CuckooVector({})
for c in m:
vp.add_scale(c, c.dot(v))
mu = vp.norm(2)
vp.scale(1.0/mu)
v = vp
return mu,v
def svm_primal_sgd(X, Y, lam, T):
w = CuckooVector({})
x = CuckooVector({})
m = len(Y)
for t in range(T):
step = 1 / (lam * (t+1))
i = np.random.randint(m)
y = Y[i]
x.reset(X[i])
w.scale(1 - step * lam)
if y * w.dot(x) < 1:
w.add_scale(x, step * y)
return w
def power_iteration(m, iterations, v0):
v = CuckooVector({})
v.add(v0)
for i in range(iterations):
v = m.mult_vec(v)
mu = v.norm(2)
v.scale(1.0/mu)
return mu,v
def pegasos(lam):
w = CuckooVector({})
wx = 0
t = 0
# while True:
# example = yield (w,wx)
# if example == None: break
# x,y = example
for xy in (yield (w, wx)):
x, y = xy
print(x)
print(y)
step = 1 / (lam * (t + 1))
w.scale(1 - step * lam)
wx = w.dot(x)
if y * wx < 1:
w.add_scale(x, step * y)
t = t + 1
def power_iteration_4(Y, X, U, S, iterations, v0):
v = CuckooVector({})
v.add(v0)
for i in range(iterations):
v1 = CuckooVector({})
for (x,y) in zip(X,Y):
v1.add_scale_dict(x, v.dot_dict(y))
v2 = CuckooVector({})
for (x,y) in zip(X,Y):
v2.add_scale_dict(y, v1.dot_dict(x))
for (u,s) in zip(U,S):
print(-s * u.dot(v))
v2.add_scale(u, -s * u.dot(v))
mu = v2.norm(2)
v2.scale(1.0/mu)
v = v2
return mu,v
def weightedError(w, Xt, Yt, thresh = 0):
xv = CuckooVector({})
return (1 + np.mean([(xv.reset(x) == None and np.sign(xv.dot(w) - thresh)*y) for (x,y) in zip(Xt,Yt)]))/2
sn = extract_ngrams(s, n, 1e-4)
X += sn
P += sn[:-n]
F += sn[n:]
pickle.dump((X,P,F), open(out_dir + 'xpf.pcl', 'wb', -1))
#(X,F,P) = pickle.load(open('xpf.pcl', 'rb'))
rnd = np.random
start = time.time()
# Form an initial vector for power iteration by taking a randomly
# weighted sum of training examples.
v0 = CuckooVector({})
for x in X:
v0.add_scale_dict(x, rnd.normal(0.0, 5.0))
U = []
Ud = []
S = []
# Compute 1000 singular vectors of future-past covariance
# by computing the eigen vectors of FP^TPF^T using power iteration
# with deflation.
for i in range(1000):
print(i)
mu,u = mat_utils.power_iteration_4(F, P, U, S, 10, v0)
S.append(mu)
U.append(u)
