def _test_matrix():
# A = numpy.mat([[1,2,3],[4,5,6]],numpy.float32)
# B = numpy.mat([[2,3],[4,5],[6,7]],numpy.float32)
# A = numpy.mat( numpy.array( numpy.random.random_sample((256,8192)), numpy.float32) )
# B = numpy.mat( numpy.array( numpy.random.random_sample((8192,256)), numpy.float32) )
# A = numpy.mat( numpy.array( numpy.random.random_sample((257,8191)), numpy.float32) )
# B = numpy.mat( numpy.array( numpy.random.random_sample((8191,257)), numpy.float32) )
A = numpy.mat(numpy.array(numpy.random.random_sample((256, 65536)), numpy.float32))
B = numpy.mat(numpy.array(numpy.random.random_sample((65536, 256)), numpy.float32))
# A = numpy.mat( numpy.array( numpy.random.random_sample((200,3000)), numpy.float32) )
# B = numpy.mat( numpy.array( numpy.random.random_sample((3000,3000,)), numpy.float32) )
# A = numpy.mat( numpy.array( numpy.random.random_sample((2048,2048)), numpy.float32) )
# B = numpy.mat( numpy.array( numpy.random.random_sample((2048,2048)), numpy.float32) )
# i = 3000
# A = numpy.mat( numpy.array( numpy.random.random_sample((i,i)), numpy.float32) )
# B = numpy.mat( numpy.array( numpy.random.random_sample((i,i)), numpy.float32) )
# A = numpy.mat([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]],numpy.float32)
# B = numpy.mat([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]],numpy.float32)
# print A
# print A*B
print "[pycublas] shapes: ", A.shape, "*", B.shape, "=", (A.shape[0], B.shape[1])
start = time.time()
C1 = (CUBLASMatrix(A) * CUBLASMatrix(B)).np_matrix()
t1 = time.time() - start
print "[pycublas] time (CUBLAS): %fs" % t1
start = time.time()
C2 = A * B
t2 = time.time() - start
print "[pycublas] time (numpy): %fs" % t2
print "[pycublas] speedup: %.1fX" % (t2 / t1)
print "[pycublas] error (average per cell):", numpy.abs(C1 - C2).sum() / C2.size
def test_rotate_inertia(self):
"""Are we obtaining the global inertia properly?"""
# Create parameters.
label = "seg1"
pos = np.array([[1], [2], [3]])
rot = inertia.rotate_space_123([pi / 2, pi / 2, pi / 2])
solids = [self.solidAB, self.solidBC, self.solidCD]
color = (1, 0, 0)
# Create the segment.
seg1 = seg.Segment(label, pos, rot, solids, color)
# This inertia matrix describes two 1kg point masses at (0, 2, 1) and
# (0, -2, -1) in the global reference frame, A.
seg1._rel_inertia = mat([[10.0, 0.0, 0.0], [0.0, 2.0, -4.0], [0.0, -4.0, 8.0]])
# If we want the inertia about a new reference frame, B, such that the
# two masses lie on the yb axis we can rotate about xa through the angle
# arctan(1/2). Note that this function returns R from va = R * vb.
seg1._rot_mat = inertia.rotate_space_123((arctan(1.0 / 2.0), 0.0, 0.0))
seg1.calc_properties()
I_b = seg1.inertia
expected_I_b = mat([[10.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 10.0]])
testing.assert_allclose(I_b, expected_I_b)
def test_main():
from numpy import mat
## Test FITELLIPSE - run through all possibilities
# Example
## 1) Linear fit, bookstein constraint
# Data points
x = mat("1 2 5 7 9 6 3 8; 7 6 8 7 5 7 2 4")
z, a, b, alpha = fitellipse(x, "linear")
## 2) Linear fit, Trace constraint
# Data points
x = mat("1 2 5 7 9 6 3 8; 7 6 8 7 5 7 2 4")
z, a, b, alpha = fitellipse(x, "linear", constraint="trace")
## 3) Nonlinear fit
# Data points
x = mat("1 2 5 7 9 6 3 8; 7 6 8 7 5 7 2 4")
z, a, b, alpha = fitellipse(x)
# Changing the tolerance, maxits
z, a, b, alpha = fitellipse(x, tol=1e-8, maxits=100)
"""
def all(X, axis = None):
"""
Test whether all elements along a given axis of sparse or dense matrix :param:`X` are nonzero.
:param X: Target matrix.
:type X: :class:`scipy.sparse` of format csr, csc, coo, bsr, dok, lil, dia or :class:`numpy.matrix`
:param axis: Specified axis along which nonzero test is performed. If :param:`axis` not specified, whole matrix is considered.
:type axis: `int`
"""
if sp.isspmatrix(X):
X = X.tocsr()
assert axis == 0 or axis == 1 or axis == None, "Incorrect axis number."
if axis is None:
return len(X.data) == X.shape[0] * X.shape[1]
res = [0 for _ in xrange(X.shape[1 - axis])]
def _caxis(now, row, col):
res[col] += 1
def _raxis(now, row, col):
res[row] += 1
check = _caxis if axis == 0 else _raxis
now = 0
for row in range(X.shape[0]):
upto = X.indptr[row+1]
while now < upto:
col = X.indices[now]
check(now, row, col)
now += 1
sol = [x == X.shape[0] if axis == 0 else x == X.shape[1] for x in res]
return np.mat(sol) if axis == 0 else np.mat(sol).T
else:
return X.all(axis)
def train(self, inp, out, training_weight=1.):
inp = np.mat(inp).T
out = np.mat(out).T
deriv = []
val = inp
vals = [val]
# forward calculation of activations and derivatives
for weight,bias in self.__weights:
val = weight*val
val += bias
deriv.append(self.__derivative(val))
vals.append(self.__activation(val))
deriv = iter(reversed(deriv))
weights = iter(reversed(self.__weights))
errs = []
errs.append(np.multiply(vals[-1]-out, next(deriv)))
# backwards propagation of errors
for (w,b),d in zip(weights, deriv):
errs.append(np.multiply(np.dot(w.T, errs[-1]), d))
weights = iter(self.__weights)
for (w,b),v,e in zip(\
self.__weights,\
vals, reversed(errs)):
e *= self.__learning_rate*training_weight
w -= e*v.T
b -= e
tmp = vals[-1]-out
return np.dot(tmp[0].T,tmp[0])*.5*training_weight
def testDigits(kTup=('rbf', 10)):
data, labels = loadImages('trainingDigits')
b, alphas = smo(data, labels, 200, 0.0001, 10000, kTup)
dataMat = np.mat(data)
labelMat = np.mat(labels).transpose()
svInd = np.nonzero(alphas.A > 0)[0]
sVs = dataMat[svInd]
labelSV = labelMat[svInd]
print "There are %d Support Vectors" % np.shape(sVs)[0]
m, n = np.shape(dataMat)
errorCount = 0
for i in xrange(m):
kernelEval = kernelTransform(sVs, dataMat[i, :], kTup)
predict = kernelEval.T * np.multiply(labelSV, alphas[svInd]) + b
if np.sign(predict) != np.sign(labels[i]):
errorCount += 1
print "The training error rate is %f " % (float(errorCount) / m)
data, labels = loadImages('testDigits')
dataMat = np.mat(data)
labelMat = np.mat(labels).transpose()
m, n = np.shape(dataMat)
errorCount = 0
for i in xrange(m):
kernelEval = kernelTransform(sVs, dataMat[i, :], kTup)
predict = kernelEval.T * np.multiply(labelSV, alphas[svInd]) + b
if np.sign(predict) != np.sign(labels[i]):
errorCount += 1
print "The test error rate is %f " % (float(errorCount) / m)
def _get_rotate_and_skew_transform(x1, y1, x2, y2, x3, y3):
"""
Retuen a transform that does
(x1, y1) -> (x1, y1)
(x2, y2) -> (x2, y2)
(x2, y1) -> (x3, y3)
It was intended to derive a skew transform that preserve the
lower-left corner (x1, y1) and top-right corner(x2,y2), but
change the the lower-right-corner(x2, y1) to a new position
(x3, y3).
"""
tr1 = mtransforms.Affine2D()
tr1.translate(-x1, -y1)
x2a, y2a = tr1.transform_point((x2, y2))
x3a, y3a = tr1.transform_point((x3, y3))
inv_mat = 1./(x2a*y3a-y2a*x3a) * np.mat([[y3a, -y2a],[-x3a, x2a]])
a, b = (inv_mat * np.mat([[x2a], [x2a]])).flat
c, d = (inv_mat * np.mat([[y2a], [0]])).flat
tr2 = mtransforms.Affine2D.from_values(a, c, b, d, 0, 0)
tr = (tr1 + tr2 + mtransforms.Affine2D().translate(x1, y1)).inverted().get_affine()
return tr
def __init__(self, X, regparam=1.0, number_of_clusters=2, kernel='LinearKernel', basis_vectors=None, Y = None, fixed_indices=None, callback=None, **kwargs):
kwargs['X'] = X
kwargs['kernel'] = kernel
if basis_vectors is not None:
kwargs['basis_vectors'] = basis_vectors
self.svdad = adapter.createSVDAdapter(**kwargs)
self.svals = np.mat(self.svdad.svals)
self.svecs = np.mat(self.svdad.rsvecs)
self.callbackfun = callback
self.regparam = regparam
self.constraint = 0
self.labelcount = number_of_clusters
self.size = X.shape[0]
#if self.labelcount == 2:
# self.oneclass = True
#else:
# self.oneclass = False
if Y is None:
self.classvec = np.zeros(self.size, np.int)
else:
self.classvec = Y
#self.size = self.classvec.shape[0]
self.Y = -np.ones((self.size, self.labelcount))
self.classcounts = np.zeros((self.labelcount), dtype = np.int32)
for i in range(self.size):
clazzind = self.classvec[i]
self.Y[i, clazzind] = 1
self.classcounts[clazzind] = self.classcounts[clazzind] + 1
self.fixedindices = []
if fixed_indices is not None:
self.fixedindices = fixed_indices
self.train()
def Y(self):
"""Return Z-parameter matrix"""
S = np.mat(self.S)
E = np.mat(np.eye(self.n, self.n))
Zref = self.z0 * E
Gref = 1 / np.sqrt(np.real(self.z0)) * E
return np.array(Gref**-1 * Zref**-1 * (S + E)**-1 * (E - S) * Gref)
def CA(self):
# return NPortZ(self).CA
z0 = self.z0
A = np.mat(self.A)
T = np.matrix([[np.sqrt(z0), -(A[0,1]+A[0,0]*z0)/np.sqrt(z0)],
[-1/np.sqrt(z0), -(A[1,1]+A[1,0]*z0)/np.sqrt(z0)]])
return np.array(T * np.mat(self.CS) * T.H)
def __mul__(self, a):
"""Cascade of two n-ports"""
selfA = np.mat(self.A)
aA = np.mat(a.A)
anport = NPortA(selfA * aA,
selfA * np.mat(a.CA) * selfA.H + self.CA )
return self.__class__(anport)
def Z(self):
"""Return Z-parameter matrix"""
S = np.mat(self.S).astype(float)
E = np.mat(np.eye(self.n, self.n))
Zref = self.z0 * E
Gref = 1 / np.sqrt(np.real(self.z0)) * E
return np.array(Gref.I * (E - S).I * (S + E) * Zref * Gref)
def smoP(dataMatIn, classLabels, C, toler, maxIter):
"""
完整的线性SMO算法
Parameters：
dataMatIn - 数据矩阵
classLabels - 数据标签
C - 松弛变量
toler - 容错率
maxIter - 最大迭代次数
Returns:
oS.b - SMO算法计算的b
oS.alphas - SMO算法计算的alphas
"""
oS = optStruct(np.mat(dataMatIn), np.mat(classLabels).transpose(), C, toler) #初始化数据结构
iter = 0 #初始化当前迭代次数
entireSet = True; alphaPairsChanged = 0
while (iter < maxIter) and ((alphaPairsChanged > 0) or (entireSet)): #遍历整个数据集都alpha也没有更新或者超过最大迭代次数,则退出循环
alphaPairsChanged = 0
if entireSet: #遍历整个数据集
for i in range(oS.m):
alphaPairsChanged += innerL(i,oS) #使用优化的SMO算法
print("全样本遍历:第%d次迭代 样本:%d, alpha优化次数:%d" % (iter,i,alphaPairsChanged))
iter += 1
else: #遍历非边界值
nonBoundIs = np.nonzero((oS.alphas.A > 0) * (oS.alphas.A < C))[0] #遍历不在边界0和C的alpha
for i in nonBoundIs:
alphaPairsChanged += innerL(i,oS)
print("非边界遍历:第%d次迭代 样本:%d, alpha优化次数:%d" % (iter,i,alphaPairsChanged))
iter += 1
if entireSet: #遍历一次后改为非边界遍历
entireSet = False
elif (alphaPairsChanged == 0): #如果alpha没有更新,计算全样本遍历
entireSet = True
print("迭代次数: %d" % iter)
return oS.b,oS.alphas #返回SMO算法计算的b和alphas
def cv_show( yEv, yEv_calc, disp = True, graph = True, grid_std = None):
# if the output is a vector and the original is a metrix,
# the output is translated to a matrix.
if len( np.shape(yEv_calc)) == 1:
yEv_calc = np.mat( yEv_calc).T
if len( np.shape(yEv)) == 1:
yEv = np.mat( yEv).T
r_sqr, RMSE = jchem.estimate_accuracy( yEv, yEv_calc, disp = disp)
if graph:
#plt.scatter( yEv.tolist(), yEv_calc.tolist())
plt.figure()
ms_sz = max(min( 4000 / yEv.shape[0], 8), 1)
plt.plot( yEv.tolist(), yEv_calc.tolist(), '.', ms = ms_sz) # Change ms
ax = plt.gca()
lims = [
np.min([ax.get_xlim(), ax.get_ylim()]), # min of both axes
np.max([ax.get_xlim(), ax.get_ylim()]), # max of both axes
]
# now plot both limits against eachother
#ax.plot(lims, lims, 'k-', alpha=0.75, zorder=0)
ax.plot(lims, lims, '-', color = 'pink')
plt.xlabel('Experiment')
plt.ylabel('Prediction')
if grid_std:
plt.title( '($r^2$, std) = ({0:.2e}, {1:.2e}), RMSE = {2:.2e}'.format( r_sqr, grid_std, RMSE))
else:
plt.title( '$r^2$ = {0:.2e}, RMSE = {1:.2e}'.format( r_sqr, RMSE))
plt.show()
return r_sqr, RMSE
def _determine_karray(equivalent_sizes, appended_sizes,
max_equivalent_size,
total_appended_size):
n = len(equivalent_sizes)
import numpy as np
A = np.mat(np.zeros((n+1, n+1), dtype="d"))
B = np.zeros((n+1), dtype="d")
# AxK = B
# populated A
for i, (r, a) in enumerate(equivalent_sizes):
A[i, i] = r
A[i, -1] = -1
B[i] = -a
A[-1, :-1] = [r for r, a in appended_sizes]
B[-1] = total_appended_size - sum([a for rs, a in appended_sizes])
karray_H = (A.I*np.mat(B).T).A1
karray = karray_H[:-1]
H = karray_H[-1]
if H > max_equivalent_size:
karray = ((max_equivalent_size -
np.array([a for r, a in equivalent_sizes]))
/ np.array([r for r, a in equivalent_sizes]))
return karray
def releaseK(self,Kl,rel):
"""Return a modified stiffness matrix to account for a moment release
at one of the ends. Kl is the original matrix, dx, dy are projections of the
member, and 'rel' is 2 or 5 to identify the local dof # of the released dof.
Both KL and KG are returned if the transformation matrix, T, is provided"""
L = self.L
if rel == 2:
if Kl[5,5] == 0.: # is other end also pinned?
em = np.mat([1.,0.]).T # corrective end moments, far end pinned
else:
em = np.mat([1.,0.5]).T # corrective end moments, far end fixed
elif rel == 5:
if Kl[2,2] == 0.:
em = np.mat([0.,1.]).T
else:
em = np.mat([0.5,1.]).T
else:
raise ValueError("Invalid release #: {}".format(rel))
Tf = np.mat([[0.,0.],[1./L,1./L],[1.,0.],[0.,0.],[-1./L,-1./L],[0.,1.]])
M = Tf*em
K = Kl.copy()
K[:,1] -= M*K[rel,1] # col 1 - forces for unit vertical displacment at j-end
K[:,2] -= M*K[rel,2] # col 2 - forces for unit rotation at j-end
K[:,4] -= M*K[rel,4] # col 4 - forces for unit vertical displacment at k-end
K[:,5] -= M*K[rel,5] # col 5 - forces for unit rotation at k-end
return K
def test_lsim_double_integrator(self):
# Note: scipy.signal.lsim fails if A is not invertible
A = np.mat("0. 1.;0. 0.")
B = np.mat("0.; 1.")
C = np.mat("1. 0.")
D = 0.
sys = StateSpace(A, B, C, D)
def check(u, x0, xtrue):
_t, yout, xout = forced_response(sys, t, u, x0)
np.testing.assert_array_almost_equal(xout, xtrue, decimal=6)
ytrue = np.squeeze(np.asarray(C.dot(xtrue)))
np.testing.assert_array_almost_equal(yout, ytrue, decimal=6)
# test with zero input
npts = 10
t = np.linspace(0, 1, npts)
u = np.zeros_like(t)
x0 = np.array([2., 3.])
xtrue = np.zeros((2, npts))
xtrue[0, :] = x0[0] + t * x0[1]
xtrue[1, :] = x0[1]
check(u, x0, xtrue)
# test with step input
u = np.ones_like(t)
xtrue = np.array([0.5 * t**2, t])
x0 = np.array([0., 0.])
check(u, x0, xtrue)
# test with linear input
u = t
xtrue = np.array([1./6. * t**3, 0.5 * t**2])
check(u, x0, xtrue)
def setUp(self):
self.a = np.array([[1,2,3],[4,0,5]])
self.space_s = Space(SparseMatrix(np.mat(self.a)),
["a", "b"], ["f1","f2", "f3"])
self.space_d = Space(DenseMatrix(np.mat(self.a)),
["a", "b"], ["f1","f2", "f3"])
def test_train2(self):
dim_ = 2
dim_1 = 3
dim_2 = 5
for dim in [dim_1 + dim_2, dim_1 + dim_2 + 2]:
expected_a = np.mat(np.random.random((dim_,dim_1)))
expected_b = np.mat(np.random.random((dim_,dim_2)))
m1 = np.mat(np.random.random((dim,dim_1)))
m2 = np.mat(np.random.random((dim,dim_2)))
ph = np.mat(expected_a*m1.T + expected_b*m2.T)
comp_model = FullAdditive(learner=LstsqRegressionLearner(intercept=False))
comp_model._train(DenseMatrix(m1),DenseMatrix(m2),
DenseMatrix(ph).transpose())
np.testing.assert_array_almost_equal(comp_model._mat_a_t.transpose().mat,
expected_a, 10)
np.testing.assert_array_almost_equal(comp_model._mat_b_t.transpose().mat,
expected_b, 10)
for dim in [dim_1 + dim_2 + 6, dim_1 + dim_2 + 20]:
expected_a = np.mat(np.random.random((dim_,dim_1)))
expected_b = np.mat(np.random.random((dim_,dim_2)))
m1 = np.mat(np.random.random((dim,dim_1)))
m2 = np.mat(np.random.random((dim,dim_2)))
ph = np.mat(expected_a*m1.T + expected_b*m2.T)
comp_model = FullAdditive(learner=LstsqRegressionLearner(intercept=True))
comp_model._train(DenseMatrix(m1),DenseMatrix(m2),
DenseMatrix(ph).transpose())
np.testing.assert_array_almost_equal(comp_model._mat_a_t.transpose().mat,
expected_a, 10)
np.testing.assert_array_almost_equal(comp_model._mat_b_t[:-1,:].transpose().mat,
expected_b, 10)
def test_top_feat_selection(self):
test_cases = [(self.a, np.mat([[3,1],[5,4]]), [2,0], 2),
(self.a, np.mat([[3],[5]]), [2], 1),
(self.a, np.mat([[3,1,2],[5,4,0]]), [2,0,1], 6),
]
for in_mat, expected_mat, expected_perm, no_cols in test_cases:
fs = TopFeatureSelection(no_cols)
out_mat, perm = fs.apply(DenseMatrix(in_mat))
np.testing.assert_array_equal(out_mat.mat, expected_mat)
self.assertListEqual(perm, expected_perm)
out_mat, perm = fs.apply(SparseMatrix(in_mat))
np.testing.assert_array_equal(out_mat.mat.todense(), expected_mat)
self.assertListEqual(perm, expected_perm)
fs = TopFeatureSelection(no_cols, criterion="length")
out_mat, perm = fs.apply(DenseMatrix(in_mat))
np.testing.assert_array_equal(out_mat.mat, expected_mat)
self.assertListEqual(perm, expected_perm)
out_mat, perm = fs.apply(SparseMatrix(in_mat))
np.testing.assert_array_equal(out_mat.mat.todense(), expected_mat)
self.assertListEqual(perm, expected_perm)
self.assertRaises(ValueError, TopFeatureSelection, 0)
self.assertRaises(ValueError, TopFeatureSelection, 2, criterion="something")
def main():
image0 = cv.LoadImage('pic1.jpg')
image1 = cv.LoadImage('pic2.jpg')
buff = cv.LoadImage('buff.jpg')
buff2 = cv.LoadImage('buff.jpg')
#image[ y, x , rgb ]
features0 = numpy.mat([[1771,1111],[2073.5,1056],[1963.5,1259.5],[1732.5,1435.5],[2095.5,1347.5],
[1908.5,1468.5],[1941.5,1666.5],[1210,1705],[2156,1551],[1534.5,2040.5],
[1952.5,1941.5],[1837,418],[1930.5,1100],[1611.5,1133],[2194.5,1039.5],
[1848,797.5],[2101,775.5],[1545.5,1408],[2167,1303.5]])
features1 = numpy.mat([[1738,1111],[2117.5,1094.5],[1936,1309],[1710.5,1457.5],[2161.5,1430],
[1919.5,1512.5],[1925,1732.5],[1342,1633.5],[2420,1650],[1644.5,2029.5],
[2128.5,2035],[1941.5,374],[1936,1122],[1578.5,1111],[2288,1089],[1798.5,786.5],
[2095.5,803],[1540,1391.5],[2293.5,1364]])
fund = fundamental(features0, features1)
H1, H2 = H1H2Calc(fund)
prewarp1, prewarp2 = WarpImages(image0, image1, H1, H2, buff, buff2)
features0, features1 = formatForFund(features0, features1)
warpFeatures0 = WarpFeatures(features0.T, H1)
warpFeatures1 = WarpFeatures(features1.T, H2)
#Transition(prewarp1, prewarp2, warpFeatures0, warpFeatures1, features0, features1)
cv.NamedWindow('display')
## cv.NamedWindow('prewarp1')
## cv.NamedWindow('prewarp2')
## cv.ShowImage('prewarp1', prewarp1)
## cv.WaitKey(0)
## cv.ShowImage('prewarp2', prewarp2)
## cv.WaitKey(0)
Linear(prewarp1, prewarp2, H1, H2, buff)#, writer)
def ball_filter6(dt,R=1., Q = 0.1):
f1 = KalmanFilter(dim=6)
g = 10
f1.F = np.mat ([[1., dt, dt**2, 0, 0, 0],
[0, 1., dt, 0, 0, 0],
[0, 0, 1., 0, 0, 0],
[0, 0, 0., 1., dt, -0.5*dt*dt*g],
[0, 0, 0, 0, 1., -g*dt],
[0, 0, 0, 0, 0., 1.]])
f1.H = np.mat([[1,0,0,0,0,0],
[0,0,0,0,0,0],
[0,0,0,0,0,0],
[0,0,0,1,0,0],
[0,0,0,0,0,0],
[0,0,0,0,0,0]])
f1.R = np.mat(np.eye(6)) * R
f1.Q = np.zeros((6,6))
f1.Q[2,2] = Q
f1.Q[5,5] = Q
f1.x = np.mat([0, 0 , 0, 0, 0, 0]).T
f1.P = np.eye(6) * 50.
f1.B = 0.
f1.u = 0
return f1
def buildStump(self,dataArr,classLabels,D): # D is a vector of the data's weight
dataMatrix = np.mat(dataArr)
labelMat = np.mat(classLabels).T
m,n = np.shape(dataMatrix)
numSteps = 10.0
bestStump = {}
bestClassEst = np.mat(np.zeros((m,1)))
minError = np.inf
for i in range(n):
rangeMin = dataMatrix[:,i].min()
rangeMax = dataMatrix[:,i].max()
stepSize = (rangeMax - rangeMin)/numSteps
for j in range(-1,int(numSteps) + 1):
for inequal in ['lt','gt']:
thresholdVal = (rangeMin + float(j) * stepSize)
predictedVals = self.stumpDecisionTree(dataMatrix,i,thresholdVal,inequal)
# print("Predict value:" , predictedVals.T)
errArr = np.mat(np.ones((m,1)))
errArr[predictedVals == labelMat] = 0 # set 0 to the vector which is classified correctly
# print(predictedVals.T," ",labelMat.T)
weightedError = D.T * errArr
# print("split: dim %d, threshold value %.2f ,threshold inequal: %s, the weighted error is %.3f" %(i,thresholdVal,inequal,weightedError))
if weightedError < minError:
minError = weightedError
bestClassEst = predictedVals.copy()
bestStump['dimension'] = i
bestStump['inequal'] = inequal
bestStump['threshold'] = thresholdVal
return bestStump,minError,bestClassEst
def run(V = None, V1 = None):
"""
Run examples.
:param V: Target matrix to estimate.
:type V: :class:`numpy.matrix`
:param V1: (Second) Target matrix to estimate used in multiple NMF (e. g. SNMNMF).
:type V1: :class:`numpy.matrix`
"""
if V == None or V1 == None:
prng = np.random.RandomState(42)
# construct target matrix
V = abs(np.mat(prng.normal(loc = 0.0, scale = 1.0, size = (20, 30))))
V1 = abs(np.mat(prng.normal(loc = 0.0, scale = 1.0, size = (20, 25))))
run_snmnmf(V, V1)
run_bd(V)
run_bmf(V)
run_icm(V)
run_lfnmf(V)
run_lsnmf(V)
run_nmf(V)
run_nsnmf(V)
run_pmf(V)
run_psmf(V)
run_snmf(V)
def r_t_mat_anallo(an1, an2):
""" Returns R12, T12, R21, T21 at an interface between thin films.
R12 is the reflection matrix from Anallo 1 off Anallo 2
The sign of elements in T12 and T21 is fixed to be positive,
in the eyes of `numpy.sign`
"""
if len(an1.k_z) != len(an2.k_z):
raise ValueError, "Need the same number of plane waves in \
Anallos %(an1)s and %(an2)s" % {'an1' : an1, 'an2' : an2}
Z1 = an1.Z()
Z2 = an2.Z()
R12 = np.mat(np.diag((Z2 - Z1)/(Z2 + Z1)))
# N.B. there is potentially a branch choice problem here, stemming
# from the normalisation to unit flux.
# We normalise each field amplitude by
# $chi^{\pm 1/2} = sqrt(k_z/k)^{\pm 1} = sqrt(Z/Zc)^{\pm 1}$
# The choice of branch in those square roots must be the same as the
# choice in the related square roots that we are about to take:
T12 = np.mat(np.diag(2.*sqrt(Z2)*sqrt(Z1)/(Z2+Z1)))
R21 = -R12
T21 = T12
return R12, T12, R21, T21
def test_rotate_inertia():
"""Are we obtaining the global inertia properly?"""
density = 1.5
height = 4
height_vec = array([[0], [0], [height]])
# One thickness is 0.
r0 = 5; t0 = 0; r1 = 2; t1 = 2;
stad1 = Stadium('Ls1: umbilicus', 'thicknessradius', t0, r0)
stad2 = Stadium('Lb1: mid-arm', 'thicknessradius', t1, r1)
solidA = StadiumSolid('solid', density, stad1, stad2, height)
# This inertia matrix describes two 1kg point masses at (0, 2, 1) and
# (0, -2, -1) in the global reference frame, A.
solidA._rel_inertia = mat([[10.0, 0.0, 0.0],
[0.0, 2.0, -4.0],
[0.0, -4.0, 8.0]])
# If we want the inertia about a new reference frame, B, such that the
# two masses lie on the yb axis we can rotate about xa through the angle
# arctan(1/2). Note that this function returns R from va = R * vb.
solidA._rot_mat = inertia.rotate_space_123((arctan(1.0 / 2.0), 0.0, 0.0))
solidA.calc_properties()
I_b = solidA.inertia
expected_I_b = mat([[10.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 10.0]])
testing.assert_allclose(I_b, expected_I_b)
def run_bd(V):
"""
Run Bayesian decomposition.
:param V: Target matrix to estimate.
:type V: :class:`numpy.matrix`
"""
rank = 10
model = nimfa.mf(V,
seed = "random_c",
rank = rank,
method = "bd",
max_iter = 12,
initialize_only = True,
alpha = np.mat(np.zeros((V.shape[0], rank))),
beta = np.mat(np.zeros((rank, V.shape[1]))),
theta = .0,
k = .0,
sigma = 1.,
skip = 100,
stride = 1,
n_w = np.mat(np.zeros((rank, 1))),
n_h = np.mat(np.zeros((rank, 1))),
n_sigma = False)
fit = nimfa.mf_run(model)
print_info(fit)
def adaBoostTrainDecisionStump(self,dataArr,classLabels,numInt=40):
weakDecisionStumpArr = []
m = np.shape(dataArr)[0]
weight = np.mat(np.ones((m,1))/m) # init the weight of the data.Normally, we set the initial weight is 1/n
aggressionClassEst = np.mat(np.zeros((m,1)))
for i in range(numInt): # classEst == class estimation
bestStump,error,classEst = self.buildStump(dataArr,classLabels,weight) # D is a vector of the data's weight
# print("D: ",weight.T)
alpha = float(0.5 * np.log((1.0 - error)/max(error , 1e-16))) # alpha is the weighted of the weak classifier
bestStump['alpha'] = alpha
weakDecisionStumpArr.append(bestStump)
exponent = np.multiply(-1* alpha * np.mat(classLabels).T , classEst) # calculte the exponent [- alpha * Y * Gm(X)]
print("classEst ：",classEst.T)
weight = np.multiply(weight,np.exp(exponent)) # update the weight of the data, w_m = e^[- alpha * Y * Gm(X)]
weight = weight/weight.sum() # D.sum() == Z_m (Normalized Factor) which makes sure the D_(m+1) can be a probability distribution
# give every estimated class vector (the classified result of the weak classifier) a weight
aggressionClassEst += alpha*classEst
print("aggression classEst: ",aggressionClassEst.T)
# aggressionClassError = np.multiply(np.sign(aggressionClassEst) != np.mat(classLabels).T, np.ones((m,1)))
# errorRate = aggressionClassError.sum()/m
errorRate = (np.sign(aggressionClassEst) != np.mat(classLabels).T).sum()/m # calculate the error classification
# errorRate = np.dot((np.sign(aggressionClassEst) != np.mat(classLabels).T).T,np.ones((m,1)))/m
print("total error: ",errorRate,"\n")
if errorRate == 0:
break
return weakDecisionStumpArr
def __init__(self,name,updateRateHz,messagingbus,sendmessagesto):
print "Instantiating Force & Moment Test Model ",name
# Call superclass constructor
Model.__init__(self,name,updateRateHz,messagingbus,sendmessagesto)
# Member variables ----------------------------------------------------
# Inputs
self.timeOn = 0.0
self.timeOff = 0.0
self.forceStationInput = mat('0.0;0.0;0.0')
self.momentStationInput = mat('0.0;0.0;0.0')
self.forceStation = mat('0.0;0.0;0.0')
self.momentStation = mat('0.0;0.0;0.0')
# Register Input Parameters -------------------------------------------
# Input Parameter Name, Member Variable Name, Example of Type)
self.registerInputParam('forceStation', 'forceStationInput', self.forceStationInput )
self.registerInputParam('momentStation', 'momentStationInput', self.momentStationInput)
self.registerInputParam('timeOn', 'timeOn', self.timeOn)
self.registerInputParam('timeOff', 'timeOff', self.timeOff)
def custom_convergence_check(x, dx, residuum, er, ea, eresiduum, vector_norm=lambda v: abs(v), debug=False):
all_check_results = []
if not hasattr(x, 'shape'):
x = numpy.mat(numpy.array(x))
dx = numpy.mat(numpy.array(dx))
residuum = numpy.mat(numpy.array(residuum))
if x.shape[0]:
if not debug:
ret = numpy.allclose(x, x + dx, rtol=er, atol=ea) and \
numpy.allclose(residuum, numpy.zeros(
residuum.shape), atol=eresiduum, rtol=0)
else:
for i in range(x.shape[0]):
if vector_norm(dx[i, 0]) < er * vector_norm(x[i, 0]) + ea and vector_norm(residuum[i, 0]) < eresiduum:
all_check_results.append(True)
else:
all_check_results.append(False)
if not all_check_results[-1]:
break
ret = not (False in all_check_results)
else:
# We get here when there's no variable to be checked. This is because there aren't variables
# of this type.
# Eg. the circuit has no voltage sources nor voltage defined elements. In this case, the actual check is done
# only by current_convergence_check, voltage_convergence_check always
# returns True.
ret = True
return ret, all_check_results
def __init__(self, feed_dict, full_analysis):
# initiate common vatiables
self.returns = feed_dict['input']
self.covar = self.returns.cov()
del feed_dict['input']
columns = []
self.inital_weights = []
for col in self.returns.columns:
name = col.split('_')[0]
self.inital_weights.append(get_quote_yahoo(name).marketCap)
columns.append(name)
self.inital_weights = np.array(self.inital_weights)
self.inital_weights = self.inital_weights / np.sum(self.inital_weights)
# save parameters in case replication is desired
self.Parameters = deepcopy(feed_dict)
objective, features, constraints, simulations, methods, tol, maxiter, disp = oc.unfeeder(
feed_dict)
try:
views = []
chg = []
for view in objective['target']:
chg.append(view[0] / 100)
views.append(view[1:])
views = np.array(views)
chg = np.array(chg)
except:
raise AttributeError(
'Black Litterman requires target views to be specified.')
# features
if 'benchmark' in features:
self.benchmark = features['benchmark']
else:
raise AttributeError('Black Litterman requires a benchmark.')
self.periodicity = _embed_periodicity(features['periodicity'])
if methods == 'arithmetic':
self.mean_returns = self.returns.mean() * self.periodicity
self.benchmark_mean = self.benchmark.mean() * self.periodicity
if methods == 'geometric':
self.mean_returns = _geomean(self.returns, self.periodicity)
self.benchmark_mean = _geomean(self.benchmark, self.periodicity)
if 'margin_int_rate' in features:
self.margin_rate = features['margin_int_rate']
else:
self.margin_rate = 0
if 'rf' in features:
self.rf = features['rf']
else:
self.rf = 0
# constraints
if 'min_weights' in constraints:
self.weight_bounds = tuple(
zip(constraints['min_weights'], constraints['max_weights']))
else:
self.weight_bounds = None
constraints = self.get_constraints(constraints)
# return computation
A = (self.benchmark_mean - self.rf) / (
(self.benchmark.std()**2) * self.periodicity)
pi = A * np.matmul(np.mat(self.covar * self.periodicity),
self.inital_weights)
omega = np.matmul(
np.matmul(views, np.mat(self.covar * self.periodicity)), views.T)
e1 = np.mat(
np.mat(self.covar * self.periodicity).I +
np.matmul(np.matmul(views.T,
np.mat(omega).I), views)).I
e2 = np.matmul(np.mat(self.covar * self.periodicity).I,
pi) + np.matmul(np.matmul(views.T,
np.mat(omega).I), chg).T
self.Expected_Returns = np.matmul(e1, e2)
# optimal portfolio
self.OptiParam = minimize(self.optimize_sharpe_ratio,
self.inital_weights,
method='SLSQP',
bounds=self.weight_bounds,
tol=tol,
constraints=constraints,
options={
'maxiter': maxiter,
'disp': disp
})
if not self.OptiParam['success']:
print('Warning!', self.OptiParam['message'])
tanw = self.OptiParam['x']
tanww = pd.DataFrame(tanw).T
tanww.columns = columns
tanr = self.weighted_annual_return(tanw)
margin = np.sum(np.abs(tanw)) - 1
tanra = tanr - self.rf - self.margin_rate * margin
tans = self.weighted_annual_stddev(tanw)
self.Optimal = {
'Weights': tanww,
'Return': tanr,
'AdjReturn': tanra,
'StdDev': tans,
'Sharpe': tanra / tans,
'Series': self.weighted_return(tanw)
}
# efficent frontier
if full_analysis == True:
analyze = np.linspace(max(self.Optimal['Return'] / 4, 0.0001),
min(self.Optimal['Return'] * 4, 0.5),
simulations)
efficent = []
eff = []
for ret in analyze:
e = self.optimize_efficent(ret, constraints, tol, maxiter,
disp)
we = e['x']
wew = pd.DataFrame(we).T
wew.columns = columns
margin = np.sum(np.abs(we)) - 1
re = self.weighted_annual_return(
we) - self.rf - self.margin_rate * margin
se = self.weighted_annual_stddev(we)
efficent.append({
'Weights': wew,
'Returns': re,
'StdDevs': se,
'Sharpe': re / se
})
eff.append(e)
self.EfficentParam = eff
self.EfficentFrontier = efficent
# close
self.ConstituentSharpe = self.get_sharpes(columns)
import numpy as np num = 100 a = np.mat(np.arange(1, num + 1)) b = np.transpose(a) c = a * b d = np.sum(a)**2 print c print d print d - c
for i in range(X.shape[0]):
for j in range(X.shape[1]):
for k in range(Y.shape[0]):
for m in range(Y.shape[2]):
R2[i, j, k, m] = sum(X[i, j, :] * Y[k, :, m])
print(np.array_equal(R, R2))
print('')
print('------------- Part 6 ---------------')
A = np.array([[1, 2, 3], [2, 2, 2], [3, 3, 3]])
B = np.array([[3, 2, 1], [1, 2, 3], [-1, -2, -3]])
R = A * B
print(R)
MA = np.mat(A)
MB = np.mat(B)
R = MA * MB
print(R)
print('')
print('------------ Part 7 ---------------')
A = np.array([[11, 12, 13], [21, 22, 23], [31, 32, 33]])
B = np.array([[11, 102, 13], [201, 22, 203], [31, 32, 303]])
print(np.array_equal(A, B))
print(np.array_equal(A, A))
print('')
print('------------- Part 8 --------------')
a = np.array([[True, True], [False, False]])
b = np.array([[True, False], [True, False]])
def ols_high_d_category(data_df, formula=None, robust=False, c_method='cgm', psdef=True, epsilon=1e-8, max_iter=1e6,
debug=False):
"""
:param data_df: Dataframe of relevant data
:type data_df: pd.DataFrame
:param formula: Formula takes the form of dependent_variable~continuous_variable|fixed_effect|clusters
:type formula: str
:param robust: bool value of whether to get a robust variance
:type robust: bool
:param c_method: method used to calculate multi-way clusters variance. Possible choices are:
- 'cgm'
- 'cgm2'
:type c_method: str
:param psdef:if True, replace negative eigenvalue of variance matrix with 0 (only in multi-way clusters variance)
:type psdef: bool
:param epsilon: tolerance of the demean process
:type epsilon: float
:param max_iter: max iteration of the demean process
:type max_iter: float
:param debug: If true then print all individual stage prints, defaults to false.
:type debug: bool
:return:params,df,bse,tvalues,pvalues,rsquared,rsquared_adj,fvalue,f_pvalue,variance_matrix,fittedvalues,resid,summary
Example
-------
y~x+x2|id+firm|id'
"""
total_start = time.time()
out_col, consist_col, category_col, cluster_col = formula_transform(formula)
consist_var = []
if len(category_col) == 0 or len(consist_col) == 0:
demeaned_df = data_df.copy()
const_consist = sm.add_constant(demeaned_df[consist_col])
consist_col = ['const'] + consist_col
demeaned_df['const'] = const_consist['const']
rank = 0
else:
for i in consist_col:
consist_var.append(i)
consist_var.append(out_col[0])
start = time.time()
demeaned_df = demean_dataframe(data_df, consist_var, category_col, epsilon, max_iter)
end = time.time()
start = time.process_time()
rank = cal_df(data_df, category_col)
end = time.process_time()
model = sm.OLS(demeaned_df[out_col], demeaned_df[consist_col])
result = model.fit()
demeaned_df['resid'] = result.resid
n = demeaned_df.shape[0]
k = len(consist_col)
f_result = OLSFixed()
f_result.out_col = out_col
f_result.consist_col = consist_col
f_result.category_col = category_col
f_result.data_df = data_df.copy()
f_result.demeaned_df = demeaned_df
f_result.params = result.params
f_result.df = result.df_resid - rank
# Now we need to update the standard errors of the OLS based on robust and clustering
if (len(cluster_col) == 0) & (robust is False):
std_error = result.bse * np.sqrt((n - k) / (n - k - rank))
covariance_matrix = result.normalized_cov_params * result.scale * result.df_resid / f_result.df
elif (len(cluster_col) == 0) & (robust is True):
covariance_matrix = robust_err(demeaned_df, consist_col, n, k, rank)
std_error = np.sqrt(np.diag(covariance_matrix))
else:
if category_col[0] == '0':
nested = False
else:
nested = is_nested(demeaned_df, category_col, cluster_col, consist_col)
covariance_matrix = clustered_error(demeaned_df, consist_col, cluster_col, n, k, rank, nested=nested,
c_method=c_method, psdef=psdef)
std_error = np.sqrt(np.diag(covariance_matrix))
f_result.bse = std_error
# print(f_result.bse)
f_result.variance_matrix = covariance_matrix
f_result.tvalues = f_result.params / f_result.bse
f_result.pvalues = pd.Series(2 * t.sf(np.abs(f_result.tvalues), f_result.df), index=list(result.params.index))
f_result.rsquared = result.rsquared
f_result.rsquared_adj = 1 - (len(data_df) - 1) / (result.df_resid - rank) * (1 - result.rsquared)
tmp1 = np.linalg.solve(f_result.variance_matrix, np.mat(f_result.params).T)
tmp2 = np.dot(np.mat(f_result.params), tmp1)
f_result.fvalue = tmp2[0, 0] / result.df_model
if len(cluster_col) > 0 and c_method == 'cgm':
f_result.f_pvalue = f.sf(f_result.fvalue, result.df_model,
min(min_clust(data_df, cluster_col) - 1, f_result.df))
f_result.f_df_proj = [result.df_model, (min(min_clust(data_df, cluster_col) - 1, f_result.df))]
else:
f_result.f_pvalue = f.sf(f_result.fvalue, result.df_model, f_result.df)
f_result.f_df_proj = [result.df_model, f_result.df]
# std err=diag( np.sqrt(result.normalized_cov_params*result.scale*result.df_resid/f_result.df) )
f_result.fittedvalues = result.fittedvalues
f_result.resid = result.resid
f_result.full_rsquared, f_result.full_rsquared_adj, f_result.full_fvalue, f_result.full_f_pvalue, f_result.f_df_full\
= cal_fullmodel(data_df, out_col, consist_col, rank, RSS=sum(result.resid ** 2))
f_result.nobs = result.nobs
f_result.yname = out_col
f_result.xname = consist_col
f_result.resid_std_err = np.sqrt(sum(result.resid ** 2) / (result.df_resid - rank))
if len(cluster_col) == 0:
f_result.cluster_method = 'no_cluster'
if robust:
f_result.Covariance_Type = 'robust'
else:
f_result.Covariance_Type = 'nonrobust'
else:
f_result.cluster_method = c_method
f_result.Covariance_Type = 'clustered'
end = time.time()
if debug:
print(f"Total {end - total_start}")
return f_result # , demeaned_df
def _sample_cze(self):
# Chinese Restaurant Precoss
for i in range(self._N):
old_r = self.c[i]
if old_r != -1:
if self.n[old_r] == 1:
del self.n[old_r]
del self.nu[old_r]
del self.kappa[old_r]
del self.phi[old_r]
else:
self.n[old_r] -= 1
like_ref, like_sym_s = [], []
classes = {}
_r = 0
x = self._X[i]
sent = self._Sent[i]
index = self._Index[i].astype(int)
like_dis = st.norm.pdf(x[:, 2], self.mu, np.sqrt(1. / self.lamda))
prob_dis = like_dis / like_dis.sum()
ang = np.arctan2(x[:, 1], x[:, 0])
like_sym_o = np.mat(self.psi[index][:, sent])
for r in self.n:
if r == self.new_class:
nu = self._init_nu()
kappa = self._init_kappa()
phi = self._init_phi() # concept word prob
pi = self.alpha
new_nu = copy.copy(nu)
new_kappa = copy.copy(kappa)
new_phi = copy.copy(phi)
else:
nu = self.nu[r]
phi = self.phi[r]
kappa = self.kappa[r]
pi = self.n[r]
like_ref.append(st.vonmises.pdf(ang, kappa, nu) * pi)
like_sym_s.append(phi[sent])
classes[_r] = r
_r += 1
R = len(classes)
K_n = len(x)
D_n = len(sent)
like_ref = np.array(like_ref) * prob_dis
prob_ref = like_ref / like_ref.sum()
like_sym_s = np.array(like_sym_s)
prob_sym_s = like_sym_s / like_sym_s.sum()
like_sym_o = np.array(like_sym_o)
prob_sym_o = like_sym_o / like_sym_o.sum()
# the joint probability between concept,referent,symbol, P_r,k * P_r,d * P_k,_d
like_rkd_d = np.array([[[[
prob_ref[r, k] * prob_sym_s[r, d] *
prob_sym_o[k, _d] if _d != d else 0 for _d in range(D_n)
] for d in range(D_n)] for k in range(K_n)] for r in range(R)])
prob_rkd_d = like_rkd_d / like_rkd_d.sum()
prob_rkd_d = prob_rkd_d.reshape(R * K_n * D_n * D_n)
C_rkd_d = rd.multinomial(1, prob_rkd_d).reshape((R, K_n, D_n, D_n))
# concept
new_r = classes[np.where(C_rkd_d == 1)[0][0]]
# reference
new_k = np.where(C_rkd_d == 1)[1][0]
# concept word
new_d_s = sent[np.where(C_rkd_d == 1)[2][0]]
# reference word
new_d_o = sent[np.where(C_rkd_d == 1)[3][0]]
self.c[i] = new_r
self.z[i] = new_k
self.e[i] = [new_d_s, new_d_o]
self.n[new_r] += 1
if new_r == self.new_class:
self.nu[self.new_class] = new_nu
self.kappa[self.new_class] = new_kappa
self.phi[self.new_class] = new_phi
j = 0
while True:
if not j in self.n:
self.n[j] = 0
self.new_class = j
break
j += 1
def getsymbol(modulationType):
"GETALPHABET Generate set of alphabet according to modulation type."
# Create basic mapping of signal symbols
if modulationType == '2pam':
symbolMap = np.mat('1, -1')
elif modulationType == '4pam':
symbolMap = np.mat('-3, -1, 1, 3')
elif modulationType == '8pam':
symbolMap = np.mat('-7, -5, -3, -1, 1, 3, 5, 7')
elif modulationType == '2psk':
symbolMap = np.mat('1j, -1j')
elif modulationType == '4psk':
symbolMap = np.mat('1, 1j, -1, -1j')
elif modulationType == '8psk':
symbolMap = np.mat('np.sqrt(2), 1+1j, np.sqrt(2)*1j, -1+1j,\
-np.sqrt(2), -1-1j, -np.sqrt(2)*1j, 1-1j')
elif modulationType == '4qam':
symbolMap = np.mat('1+1j, -1+1j, -1-1j, 1-1j')
elif modulationType == '16qam':
symbolMap = np.mat('3+3j, 3+1j, 3-1j, 3-3j, 1+3j, 1+1j, 1-1j, 1-3j,\
-1+3j, -1+1j, -1-1j, -1-3j, -3+3j, -3+1j, -3-1j, -3-3j')
elif modulationType == '64pam':
symbolMap = np.mat('1+1j, 3+1j, 1+3j, 3+3j, 7+1j, 5+1j, 7+3j,\
5+3j, 1+7j, 3+7j, 1+5j, 3+5j, 7+7j, 5+7j, 7+5j, 5+5j, 1-1j,\
1-3j, 3-1j, 3-3j, 1-7j, 1-5j, 3-7j, 3-5j, 7-1j, 7-3j, 5-1j,\
5-3j, 7-7j, 7-5j, 5-7j, 5-5j, -1+1j, -1+3j, -3+1j, -3+3j,\
-1+7j, -1+5j, -3+7j, -3+5j, -7+1j, -7+3j, -5+1j, -5+3j,\
-7+7j, -7+5j, -5+7j, -5+5j, -1-1j, -3-1j, -1-3j, -3-3j,\
-7-1j, -5-1j, -7-3j, -5-3j, -1-7j, -3-7j, -1-5j, -3-5j,\
-7-7j, -5-7j, -7-5j, -5-5j')
elif modulationType == '256qam':
symbolMap = np.mat('1+1j, 1+3j, 1+5j, 1+7j, 1+9j, 1+11j, 1+13j,\
1+15j, 1-1j, 1-3j, 1-5j, 1-7j, 1-9j, 1-11j, 1-13j, 1-15j,\
3+1j, 3+3j, 3+5j, 3+7j, 3+9j, 3+11j, 3+13j, 3+15j, 3-1j,\
3-3j, 3-5j, 3-7j, 3-9j, 3-11j, 3-13j, 3-15j, 5+1j, 5+3j,\
5+5j, 5+7j, 5+9j, 5+11j, 5+13j, 5+15j, 5-1j, 5-3j, 5-5j,\
5-7j, 5-9j, 5-11j, 5-13j, 5-15j, 7+1j, 7+3j, 7+5j, 7+7j,\
7+9j, 7+11j, 7+13j, 7+15j, 7-1j, 7-3j, 7-5j, 7-7j, 7-9j,\
7-11j, 7-13j, 7-15j, 9+1j, 9+3j, 9+5j, 9+7j, 9+9j, 9+11j,\
9+13j, 9+15j, 9-1j, 9-3j, 9-5j, 9-7j, 9-9j, 9-11j, 9-13j,\
9-15j, 11+1j, 11+3j, 11+5j, 11+7j, 11+9j, 11+11j, 11+13j,\
11+15j, 11-1j, 11-3j, 11-5j, 11-7j, 11-9j, 11-11j, 11-13j,\
11-15j, 13+1j, 13+3j, 13+5j, 13+7j, 13+9j, 13+11j, 13+13j,\
13+15j, 13-1j, 13-3j, 13-5j, 13-7j, 13-9j, 13-11j, 13-13j,\
13-15j, 15+1j, 15+3j, 15+5j, 15+7j, 15+9j, 15+11j, 15+13j,\
15+15j, 15-1j, 15-3j, 15-5j, 15-7j, 15-9j, 15-11j, 15-13j,\
15-15j, -1+1j, -1+3j, -1+5j, -1+7j, -1+9j, -1+11j, -1+13j,\
-1+15j, -1-1j, -1-3j, -1-5j, -1-7j, -1-9j, -1-11j, -1-13j,\
-1-15j, -3+1j, -3+3j, -3+5j, -3+7j, -3+9j, -3+11j, -3+13j,\
-3+15j, -3-1j, -3-3j, -3-5j, -3-7j, -3-9j, -3-11j, -3-13j,\
-3-15j, -5+1j, -5+3j, -5+5j, -5+7j, -5+9j, -5+11j, -5+13j,\
-5+15j, -5-1j, -5-3j, -5-5j, -5-7j, -5-9j, -5-11j, -5-13j,\
-5-15j, -7+1j, -7+3j, -7+5j, -7+7j, -7+9j, -7+11j, -7+13j,\
-7+15j, -7-1j, -7-3j, -7-5j, -7-7j, -7-9j, -7-11j, -7-13j,\
-7-15j, -9+1j, -9+3j, -9+5j, -9+7j, -9+9j, -9+11j, -9+13j,\
-9+15j, -9-1j, -9-3j, -9-5j, -9-7j, -9-9j, -9-11j, -9-13j,\
-9-15j, -11+1j, -11+3j, -11+5j, -11+7j, -11+9j, -11+11j,\
-11+13j, -11+15j, -11-1j, -11-3j, -11-5j, -11-7j, -11-9j,\
-11-11j, -11-13j, -11-15j, -13+1j, -13+3j, -13+5j, -13+7j,\
-13+9j, -13+11j, -13+13j, -13+15j, -13-1j, -13-3j, -13-5j,\
-13-7j, -13-9j, -13-11j, -13-13j, -13-15j, -15+1j, -15+3j,\
-15+5j, -15+7j, -15+9j, -15+11j, -15+13j, -15+15j, -15-1j,\
-15-3j, -15-5j, -15-7j, -15-9j, -15-11j, -15-13j, -15-15j')
symbolMap = symbolMap / np.sqrt(np.mean(np.power(np.abs(symbolMap), 2)))
return symbolMap
#!/usr/bin/python
import numpy
A = numpy.mat("3 4;5 6")
print "A\n", A
print "Determinant", numpy.linalg.det(A)
def test_index(self):
"""Test the get_coefficients function for index.
"""
size = (5, 4)
# Eye
key = (slice(0, 2, None), slice(0, 2, None))
x = create_var(size)
expr = index(x, (2, 2), key)
coeffs = get_coefficients(expr)
assert len(coeffs) == 1
id_, mat = coeffs[0]
self.assertEqual(id_, x.data)
self.assertEqual(mat.shape, (4, 20))
test_mat = np.mat(range(20)).T
self.assertItemsAlmostEqual((mat * test_mat).reshape((2, 2),
order='F'),
test_mat.reshape(size, order='F')[key])
# Eye with scalar mult.
key = (slice(0, 2, None), slice(0, 2, None))
x = create_var(size)
A = create_const(5, (1, 1))
expr = mul_expr(A, x, size)
expr = index(expr, (2, 2), key)
coeffs = get_coefficients(expr)
assert len(coeffs) == 1
id_, mat = coeffs[0]
test_mat = np.mat(range(20)).T
self.assertItemsAlmostEqual((mat * test_mat).reshape(
(2, 2), order='F'), 5 * test_mat.reshape(size, order='F')[key])
# Promoted
key = (slice(0, 2, None), slice(0, 2, None))
x = create_var((1, 1))
value = np.array(range(20)).reshape(size)
A = create_const(value, size)
prom_x = promote(x, (size[1], 1))
expr = mul_expr(A, diag_vec(prom_x), size)
expr = index(expr, (2, 2), key)
coeffs = get_coefficients(expr)
assert len(coeffs) == 1
id_, mat = coeffs[0]
self.assertEqual(mat.shape, (4, 1))
self.assertItemsAlmostEqual(mat, value[key])
# Normal
size = (5, 5)
key = (slice(0, 2, None), slice(0, 1, None))
x = create_var((5, 1))
A = create_const(np.ones(size), size)
expr = mul_expr(A, x, (5, 1))
expr = index(expr, (2, 1), key)
coeffs = get_coefficients(expr)
assert len(coeffs) == 1
id_, mat = coeffs[0]
self.assertEqual(mat.shape, (2, 5))
self.assertItemsAlmostEqual(mat.todense(), A.data[slice(0, 2, None)])
# Blocks
size = (5, 5)
key = (slice(0, 2, None), slice(0, 2, None))
x = create_var(size)
value = np.array(range(25)).reshape(size)
A = create_const(value, size)
expr = mul_expr(A, x, size)
expr = index(expr, (2, 2), key)
coeffs = get_coefficients(expr)
assert len(coeffs) == 1
id_, mat = coeffs[0]
self.assertEqual(mat.shape, (4, 25))
test_mat = np.mat(range(25)).T
self.assertItemsAlmostEqual(
(mat * test_mat).reshape((2, 2), order='F'),
(A.data * test_mat.reshape(size, order='F'))[key])
# Scalar constant
size = (1, 1)
A = create_const(5, size)
key = (slice(0, 1, None), slice(0, 1, None))
expr = index(A, (1, 1), key)
coeffs = get_coefficients(expr)
assert len(coeffs) == 1
id_, mat = coeffs[0]
self.assertEqual(intf.size(mat), (1, 1))
self.assertEqual(mat, 5)
# Dense constant
size = (5, 4)
key = (slice(0, 2, None), slice(0, 1, None))
value = np.array(range(20)).reshape(size)
A = create_const(value, size)
expr = index(A, (2, 1), key)
coeffs = get_coefficients(expr)
assert len(coeffs) == 1
id_, mat = coeffs[0]
self.assertEqual(mat.shape, (2, 1))
self.assertItemsAlmostEqual(mat, value[key])
# Sparse constant
size = (5, 5)
key = (slice(0, 2, None), slice(0, 1, None))
A = create_const(sp.eye(5), size)
expr = index(A, (2, 1), key)
coeffs = get_coefficients(expr)
assert len(coeffs) == 1
id_, mat = coeffs[0]
self.assertEqual(mat.shape, (2, 1))
self.assertItemsAlmostEqual(mat, sp.eye(5).todense()[key])
# Parameter
size = (5, 4)
key = (slice(0, 2, None), slice(0, 1, None))
param = Parameter(*size)
value = np.array(range(20)).reshape(size)
param.value = value
A = create_param(param, size)
expr = index(A, (2, 1), key)
coeffs = get_coefficients(expr)
assert len(coeffs) == 1
id_, mat = coeffs[0]
self.assertEqual(mat.shape, (2, 1))
self.assertItemsAlmostEqual(mat, param.value[key])
def Initial():
QFactorArr = 1
F = np.mat([[1, 0.1], [0, 1]])
H = np.mat([1, 0])
QReal = np.mat([[0.01, 0.1], [0.1, 1]])
R = 10
x0 = np.mat([[1], [1]])
N = 500
nMonte = 2
# F=np.mat(ast.literal_eval(str_F.get()))
# H=np.mat(ast.literal_eval(str_H.get()))
# QReal=np.mat(ast.literal_eval(str_Q.get()))
# R=ast.literal_eval(str_R.get())
# x0=np.mat(ast.literal_eval(str_x0.get()))
# N=ast.literal_eval(str_N.get())
nx = max(x0.shape)
Qfilter = QFactorArr * QReal
Rfilter = 1**2
x0filter = np.mat([[1], [1]])
P0filter = 1000 * np.mat(np.eye(nx))
Nopt = 12
# Qfilter=np.mat(ast.literal_eval(str_Qfilter.get()))
# Rfilter=ast.literal_eval(str_Rfilter.get())
# x0filter=np.mat(ast.literal_eval(str_x0filter.get()))
# P0filter=np.mat(ast.literal_eval(str_P0filter.get()))
# Nopt=ast.literal_eval(str_Nopt.get())
# unF=np.mat(ast.literal_eval(str_unF.get()))
# unQ=np.mat(ast.literal_eval(str_unQ.get()))
# start=ast.literal_eval(str_start.get())
# end=ast.literal_eval(str_end.get())
unFflag = chVarunF.get()
unQflag = chVarnoise.get()
print(unFflag, unQflag)
if unFflag or unQflag == 1:
start = 150
end = 300
if unFflag == 1 and unQflag == 0:
unF = np.mat([[1, 1], [0, 1]])
unQ = QReal
if unQflag == 1 and unFflag == 0:
unF = F
unQ = 50 * QReal
if unFflag == 0 and unQflag == 0:
start = 150
end = 300
unF = F
unQ = QReal
systemModel = SystemModel(F, H, QReal, R, x0, N)
filterModel = FilterModel(Qfilter, Rfilter, x0filter, P0filter, Nopt)
unsystemModel = unSystemModel(unF, unQ, start, end, unFflag, unQflag)
# nx = max(F.shape)
# ny = min(H.shape)
# xArr=np.mat(np.zeros((nx, N)))
# yArr=np.mat(np.zeros((ny, N)))
# for k in range(0,N):
# x = F * x + np.sqrt(QReal) * np.random.randn(nx, 1)
# y = H * x + np.sqrt(R) * np.random.randn()
# xArr[:, k] = x
# yArr[:, k] = y
return systemModel, filterModel, unsystemModel, nMonte
def Kalman(systemModel, filterModel, unsystemModel, smoothingFlag):
F = systemModel.F
H = systemModel.H
QFilter = filterModel.Qfilter
QReal = systemModel.QReal
R = systemModel.R
x = systemModel.x0
N = systemModel.N
nx = max(x.shape)
ny = min(H.shape)
Pplus = filterModel.P0filter
xhatplus = filterModel.x0filter
start_time = unsystemModel.start
end_time = unsystemModel.end
unF = unsystemModel.unF
unQ = unsystemModel.unQ
unFflag = unsystemModel.unFflag
unQflag = unsystemModel.unQflag
xArr = np.mat(np.zeros((nx, N)))
PplusArr = np.zeros((nx, nx, N))
PminusArr = np.zeros((nx, nx, N))
xhatminusArr = np.mat(np.zeros((nx, N)))
xhatplusArr = np.mat(np.zeros((nx, N)))
xhatplusError = np.mat(np.zeros((nx, N)))
PKalmanElements = np.mat(np.zeros((nx, N)))
JArr = np.zeros((nx, nx, N))
JInvArr = np.zeros((nx, nx, N))
KArr = np.mat(np.zeros((nx, N)))
yArr = np.mat(np.zeros((ny, N)))
FArr = np.zeros((nx, nx, N))
HArr = np.mat(np.zeros((N, nx)))
SArr = np.mat(np.zeros((ny, N)))
MeasResidual = np.mat(np.zeros((ny, N)))
Inx = np.mat(np.eye(nx))
# print(unF, unQ, start_time, end_time, unFflag, unQflag)
for k in range(0, N):
FArr[:, :, k] = F
HArr[k, :] = H
if 150 <= k and k <= 300:
x = unF * x + np.sqrt(np.mat([[0.01, 0.1], [0.1, 1]
])) * np.random.randn(nx, 1)
# if start_time<=k and k<=end_time:
# x = unF * x + np.sqrt(unQ) * np.random.randn(nx, 1)
else:
x = F * x + np.sqrt(QReal) * np.random.randn(nx, 1)
y = H * x + np.sqrt(R) * np.random.randn()
xArr[:, k] = x
yArr[:, k] = y
y = yArr[:, k]
#Kalman filter
Pminus = F * Pplus * F.T + QFilter
K = Pminus * H.T * (H * Pminus * H.T + R).I
xhatminus = F * xhatplus
xhatplus = xhatminus + K * (y - H * xhatminus)
Pplus = Pminus - K * H * Pminus
PminusArr[:, :, k] = Pminus
PplusArr[:, :, k] = Pplus
PKalmanElements[0, k] = Pplus[0, 0]
PKalmanElements[1, k] = Pplus[1, 1]
xhatminusArr[:, k] = xhatminus
xhatplusArr[:, k] = xhatplus
xhatplusError[:, k] = x - xhatplus
JArr[:, :, k] = Inx - K * H
JInvArr[:, :, k] = (Inx - K * H).I
KArr[:, k] = K
SArr[:, k] = H * Pminus * H.T + R
MeasResidual[:, k] = y - H * xhatminus
#Kalman smoother
xhatSmooth = xhatplus
PSmooth = Pplus
xhatSmoothArr = np.mat(np.zeros((nx, N)))
xhatSmoothError = np.mat(np.zeros((nx, N)))
xhatSmoothArr[:, N - 1] = xhatSmooth
xhatSmoothError[:, N - 1] = xArr[:, N - 1] - xhatSmooth
KSmootherArr = np.zeros((nx, nx, N - 1))
PSmootherElements = np.mat(np.zeros((nx, N)))
PSmootherElements[:, N - 1] = PKalmanElements[:, N - 1]
if smoothingFlag:
for k in range(N - 2, 0, -1):
K = PplusArr[:, :, k] * F.T * np.mat(PminusArr[:, :, k + 1]).I
PSmooth = PplusArr[:, :, k] - K * (PminusArr[:, :, k + 1] -
PSmooth) * K.T
xhatSmooth = xhatplusArr[:, k] + K * (xhatSmooth -
xhatminusArr[:, k + 1])
# Save data in arrays
xhatSmoothArr[:, k] = xhatSmooth
xhatSmoothError[:, k] = xArr[:, k] - xhatSmooth
KSmootherArr[:, :, k] = K
PSmootherElements[0, k] = PSmooth[0, 0]
PSmootherElements[1, k] = PSmooth[1, 1]
return xArr, yArr, xhatplusArr, xhatplusError, xhatSmoothError, PKalmanElements, PSmootherElements, MeasResidual, PminusArr
def savitzky_golay(y, window_size, order, deriv=0, rate=1):
r"""Smooth (and optionally differentiate) data with a Savitzky-Golay filter.
The Savitzky-Golay filter removes high frequency noise from data.
It has the advantage of preserving the original shape and
features of the signal better than other types of filtering
approaches, such as moving averages techniques.
Parameters
----------
y : array_like, shape (N,)
the values of the time history of the signal.
window_size : int
the length of the window. Must be an odd integer number.
order : int
the order of the polynomial used in the filtering.
Must be less then `window_size` - 1.
deriv: int
the order of the derivative to compute (default = 0 means only smoothing)
Returns
-------
ys : ndarray, shape (N)
the smoothed signal (or it's n-th derivative).
Notes
-----
The Savitzky-Golay is a type of low-pass filter, particularly
suited for smoothing noisy data. The main idea behind this
approach is to make for each point a least-square fit with a
polynomial of high order over a odd-sized window centered at
the point.
Examples
--------
t = np.linspace(-4, 4, 500)
y = np.exp( -t**2 ) + np.random.normal(0, 0.05, t.shape)
ysg = savitzky_golay(y, window_size=31, order=4)
import matplotlib.pyplot as plt
plt.plot(t, y, label='Noisy signal')
plt.plot(t, np.exp(-t**2), 'k', lw=1.5, label='Original signal')
plt.plot(t, ysg, 'r', label='Filtered signal')
plt.legend()
plt.show()
References
----------
.. [1] A. Savitzky, M. J. E. Golay, Smoothing and Differentiation of
Data by Simplified Least Squares Procedures. Analytical
Chemistry, 1964, 36 (8), pp 1627-1639.
.. [2] Numerical Recipes 3rd Edition: The Art of Scientific Computing
W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery
Cambridge University Press ISBN-13: 9780521880688
"""
try:
window_size = np.abs(np.int(window_size))
order = np.abs(np.int(order))
except ValueError as msg:
raise ValueError("window_size and order have to be of type int")
if window_size % 2 != 1 or window_size < 1:
raise TypeError("window_size size must be a positive odd number")
if window_size < order + 2:
raise TypeError("window_size is too small for the polynomials order")
order_range = range(order + 1)
half_window = (window_size - 1) // 2
# precompute coefficients
b = np.mat([[k ** i for i in order_range] for k in range(-half_window, half_window + 1)])
m = np.linalg.pinv(b).A[deriv] * rate ** deriv * factorial(deriv)
# pad the signal at the extremes with
# values taken from the signal itself
firstvals = y[0] - np.abs(y[1:half_window + 1][::-1] - y[0])
lastvals = y[-1] + np.abs(y[-half_window - 1:-1][::-1] - y[-1])
y = np.concatenate((firstvals, y, lastvals))
return np.convolve(m[::-1], y, mode='valid')
def UFIR(systemModel, filterModel, unsystemModel, smoothingFlag):
F = systemModel.F
H = systemModel.H
QReal = systemModel.QReal
R = systemModel.R
x = systemModel.x0
N = systemModel.N
nx = max(x.shape)
ny = min(H.shape)
nOpt = filterModel.Nopt
start_time = unsystemModel.start
end_time = unsystemModel.end
unF = unsystemModel.unF
unQ = unsystemModel.unQ
unFflag = unsystemModel.unFflag
unQflag = unsystemModel.unQflag
if smoothingFlag:
p = int(nOpt / 2 + 0.5)
iLowerLimit = max(nOpt + 1, nOpt + p - nx)
iUpperLimit = min(N - 1, N + nOpt - nx - 1)
NArr = np.arange(iLowerLimit, N - p, 1)
else:
p = 0
iLowerLimit = nOpt + 2 - nx
iUpperLimit = min(N - 1, N + nOpt - nx - 1)
NArr = np.arange(nOpt + 2 - nx, iUpperLimit + 1, 1)
xArr = np.mat(np.zeros((nx, N)))
xhatArr = np.mat(np.zeros((nx, N)))
xhatError = np.mat(np.zeros((nx, N)))
PElements = np.mat(np.zeros((nx, N)))
yArr = np.mat(np.zeros((ny, N)))
FArr = np.zeros((nx, nx, N))
HArr = np.mat(np.zeros((N, nx)))
MeasResidual = np.mat(np.zeros((ny, N)))
Inx = np.mat(np.eye(nx))
FExpMinusP = F.I**p
# print(unF, unQ, start_time, end_time, unFflag, unQflag)
for k in range(0, N):
FArr[:, :, k] = F
HArr[k, :] = H
if 150 <= k and k <= 300:
x = unF * x + np.sqrt(np.mat([[0.01, 0.1], [0.1, 1]
])) * np.random.randn(nx, 1)
# if start_time<=k and k<=end_time:
# x = unF * x + np.sqrt(unQ) * np.random.randn(nx, 1)
else:
x = F * x + np.sqrt(QReal) * np.random.randn(nx, 1)
y = H * x + np.sqrt(R) * np.random.randn()
xArr[:, k] = x
yArr[:, k] = y
Ysm = np.mat(np.zeros((1, nx * ny)))
FsmT = np.mat(np.zeros((nx, nx**2)))
HsmBar = np.mat(np.zeros((nx * ny, nx**2)))
for i in range(iLowerLimit, iUpperLimit + 1):
m = i - nOpt + 1
s = m + nx - 1
Yindex = nx * ny
for j in range(m, s + 1):
Ysm[Yindex - ny + 1 - 1:Yindex] = yArr[:, j - 1].T
Yindex = Yindex - ny
for j in range(1, nx + 1):
temp = Inx
for iii in range(j - 1, nx - 1):
temp = temp * FArr[:, :, s - iii - 1]
FsmT[:, (j - 1) * nx + 1 - 1:j * nx] = temp.T
for iii in range(s, m - 1, -1):
HsmBar[(s - iii) * ny + 1 - 1:(s - iii + 1) * ny,
(s - iii) * nx + 1 - 1:(s - iii + 1) * nx] = HArr[s, :]
Hsm = HsmBar * FsmT.T
alpha = Inx
if p >= nx:
for iii in range(1, p - nx):
alpha = alpha * FArr[:, :, s - p + iii - 1].I
else:
for iii in range(0, nx - 1 - p):
alpha = alpha * FArr[:, :, s - p - iii - 1]
xhat = alpha * (Hsm.T * Hsm).I * Hsm.T * Ysm.T
TempPord = Inx
for i1 in range(0, nx - 1):
TempPord = TempPord * FArr[:, :, s - i1 - 1]
G = TempPord * (Hsm.T * Hsm).I * TempPord.T
gamma = Inx
for i1 in range(0, p + 1):
gamma = gamma * FArr[:, :, i - nOpt + nx + 1 - i1 - 1]
for el in range(i - nOpt + nx + 1, i + 1):
G = (HArr[el - 1, :].T * HArr[el - 1, :] +
(FArr[:, :, el - 1] * G * np.mat(FArr[:, :, el - 1]).T).I).I
K = FArr[:, :, el - p - 1] * gamma.I * G * HArr[el - 1, :].T
xhat = FArr[:, :, el - p - 1] * xhat + K * (
yArr[:, el - 1] - HArr[el - 1, :] * gamma * xhat)
if el < i:
gamma = FArr[:, :, el + 1 - 1] * gamma * (np.mat(
FArr[:, :, el - p - 1]).I)
xhatArr[:, i - p - 1] = xhat
xhatError[:, i - p - 1] = xArr[:, i - p - 1] - xhat
Covariance = R * FExpMinusP * G * FExpMinusP.T
PElements[0, i - p - 1] = Covariance[0, 0]
PElements[1, i - p - 1] = Covariance[1, 1]
MeasResidual[:, i - p -
1] = yArr[:, i - p - 1] - HArr[i - p - 1, :] * xhat
return xArr, yArr, xhatArr, xhatError, PElements, NArr, MeasResidual
states_index_random = get_states_index_random()
index_7s, prob_normal_7s, directions_7s_01, max_p = cal_7directions_probability(
states_index_random, index_current=i)
# print("index_7s = ", index_7s)
# print("prob_normal_7s =", prob_normal_7s)
for j, index in enumerate(index_7s):
if 0 <= index <= 607:
state_transition_matrix[i, index] = np.array(
prob_normal_7s[j])
input_vector = np.zeros((1, 608))
start_index = 353
input_vector[0, start_index] = 1
B = state_transition_matrix
np.save("transition_matrix.npy", B)
step = 200
A = input_vector
print("\nAfter 200 iterations ......")
for i in tqdm(range(step)):
B = np.dot(np.mat(B), np.mat(B))
B /= np.max(B)
probility_distribution_608s = np.dot(np.mat(A), np.mat(B))
p_data = np.array(probility_distribution_608s)
p_data = np.reshape(p_data, (32, 19))
b = p_data * 255
img = cv2.merge([b, b, b])
print("\nPrior predictive distribution")
show_probility_img3D(img, title_name="Prior predictive distribution")
b: the bias of the SVM model, a float scalar.
'''
n, p = X.shape
#l: (lambda) = 1/ (n C), which is the weight of the L2 regularization term.
l = 1. / (n * C)
w, b = np.asmatrix(np.zeros((p, 1))), np.asmatrix(np.zeros(
(p, 0))) # initialize the weight vector as all zeros
for _ in xrange(n_epoch):
for i in xrange(n):
x = X[i].T # get the i-th instance in the dataset
y = float(Y[i])
#########################################
## INSERT YOUR CODE HERE
dL_dw, dL_db = gradient(x, y, w, b, l)
w = update_w(w, dL_dw, lr)
b = update_b(b, dL_db, lr)
#########################################
return w, b
x = np.mat('1,1;2,1;1,2')
y = np.mat('4;6;5')
w, b = train(x, y)
print w
print b
def __init__(self, arm_name='MTMR'):
self._num_rows = 6
self._num_cols = 7
self._jac_spa = np.zeros((self._num_rows, self._num_cols))
self._jac_bod = np.zeros((self._num_rows, self._num_cols))
self._new_data = 0
self._rate = rospy.Rate(500)
self._joint_state = JointState()
self._cart_state = JointState()
self._state_cmd = JointState()
self._wrench_cmd = np.zeros((6, 1))
self._joint_torques_cmd = np.zeros((7, 1))
self._jac_spa_sub = rospy.Subscriber('/dvrk/' + arm_name +
'/jacobian_spatial',
Float64MultiArray,
self.jac_spa_cb,
queue_size=1)
self._jac_bod_sub = rospy.Subscriber('/dvrk/' + arm_name +
'/jacobian_body',
Float64MultiArray,
self.jac_bod_cb,
queue_size=1)
self._js_sub = rospy.Subscriber('/dvrk/' + arm_name +
'/state_joint_current',
JointState,
self.js_cb,
queue_size=1)
self._cs_sub = rospy.Subscriber('/dvrk/' + arm_name +
'/position_cartesian_current',
PoseStamped,
self.cs_cb,
queue_size=1)
self._wrench_bod_sub = rospy.Subscriber('/ambf/' + arm_name +
'/set_wrench_body',
Wrench,
self.wrench_bod_cb,
queue_size=1)
self._torque_pub = rospy.Publisher('/dvrk/' + arm_name +
'/set_effort_joint',
JointState,
queue_size=5)
self._wd = WatchDog(0.1)
self.l4_o = np.identity(3)
self.l5_o = np.mat([[0, 0, -1], [0, 1, 0], [1, 0, 0]])
self.l6_o = np.mat([[0, 0, 1], [0, 1, 0], [-1, 0, 0]])
self.l7_o = np.mat([[1, 0, 0], [0, 0, -1], [0, 1, 0]])
self.Kp = 0.3
self.Kd = 0
theta = 0
self._rot_offset = np.mat([[+1.0, +0.0, +0.0],
[+0.0, +np.cos(theta), +np.sin(theta)],
[+0.0, -np.sin(theta), +np.cos(theta)]])
self._ee_rot = Rotation()
import sys
from numpy import mat, mean, power
# 分布式均值和方差计算的mapper
def read_input(file):
for line in file:
yield line.rstrip()
input = read_input(sys.stdin)
input = [float(line) for line in input]
numInputs = len(input)
input = mat(input)
sqInput = power(input, 2)
print("%d\t%f\t%f" % (numInputs, mean(input), mean(sqInput)))
print(sys.stderr, "report: still alive")
def sampleUniqueFeatures(self):
#pdb.set_trace()
#For each video
(N, K) = self.F.shape
#Most of the statistics are already coll
for sq in range(N):
(N, K) = self.F.shape
preComputedEta = {}
featCount = np.sum(self.F, axis=0)
vidCount = np.sum(self.F, axis=1)
uniqueL = []
for kk in range(K):
if featCount[0, kk] == 1 and self.F[sq, kk] == 1:
uniqueL.append(kk)
#First compute the old probability anyway
(i, j) = self.F[sq, :].nonzero()
j = np.asarray(j)[0]
TranNew = self.eta[sq][j, :][:, j]
StateNew = {}
StateNew['v'] = self.states['v'][0][j, :]
StateNew['l'] = self.states['l'][0][j, :]
preComputedEta[sq] = np.mat(
np.random.gamma(
np.ones((K, K)) * self.lamb + np.eye(K) * self.kappa))
for x in j:
for y in j:
preComputedEta[sq][x, y] = self.eta[sq][x, y]
oldProb = self.getFastHMMLikelihood(
StateNew, TranNew, sq,
self.obsPreComputedLikelihoods[sq][j, :])
if (len(uniqueL) == 0 or np.random.rand() > 0.5):
#Birth
#First choose data driven window length
vid = self.videos[sq]
if self.minW < len(vid):
leng = int(
np.random.uniform(self.minW,
min(self.maxW,
len(vid) - 1)))
else:
leng = int(
np.random.uniform(1, min(self.maxW,
len(vid) - 1)))
startP = int(np.random.uniform(0, len(vid) - leng - 1))
F = np.concatenate((self.F, np.zeros((self.F.shape[0], 1))),
axis=1)
F[sq, self.F.shape[1]] = 1
preComputedEta[sq] = np.mat(
np.random.gamma(
np.ones((K + 1, K + 1)) * self.lamb +
np.eye(K + 1) * self.kappa))
(i, j) = F[sq, :].nonzero()
j = np.asarray(j)[0]
for x in j[:-1]:
for y in j[:-1]:
preComputedEta[sq][x, y] = self.eta[sq][x, y]
TranNew = preComputedEta[sq][j, :][:, j]
#PopulateNew Row
self.obsPreComputedLikelihoods[sq] = np.concatenate(
(self.obsPreComputedLikelihoods[sq],
np.zeros((1, len(self.videos[sq])))),
axis=0)
#print self.states
ThetaNew = self.mlTheta(sq, startP, startP + leng + 1, F,
self.F.shape[1])
for x in range(self.F.shape[1]):
ThetaNew['v'][0][x, :] = self.states['v'][0][x, :]
ThetaNew['l'][0][x, :] = self.states['l'][0][x, :]
#print ThetaNew,self.obsPreComputedLikelihoods[sq].shape
for t in range(len(self.videos[sq])):
kk = K
self.obsPreComputedLikelihoods[sq][kk, t] = np.sum(
np.log([
ThetaNew['v'][0][kk, i] *
self.videos[sq][t]['obsV'][i] +
(1 - ThetaNew['v'][0][kk, i]) *
(1 - self.videos[sq][t]['obsV'][i])
for i in range(self.numVidObjs)
]))
self.obsPreComputedLikelihoods[sq][kk, t] += np.sum(
np.log([
ThetaNew['l'][0][kk, i] *
self.videos[sq][t]['obsL'][i] +
(1 - ThetaNew['l'][0][kk, i]) *
(1 - self.videos[sq][t]['obsL'][i])
for i in range(self.numLangObjs)
]))
newProb = self.getFastHMMLikelihood(
ThetaNew, TranNew, sq,
self.obsPreComputedLikelihoods[sq][j, :])
etaa = self.gamma * 1.0 / (1.0 + N - 1.0)
logPrNumFeat_Diff = np.log(etaa) + sp.special.gammaln(
F.shape[1] - 1) - sp.special.gammaln(F.shape[1])
#pdb.set_trace()
if np.exp(newProb - oldProb + logPrNumFeat_Diff - np.log(0.5) +
np.log(0.5 /
(len(uniqueL) + 1.0))) > np.random.rand():
self.F = F
self.states['v'][0] = np.concatenate(
(self.states['v'][0], ThetaNew['v'][0][-1, :]), axis=0)
self.states['l'][0] = np.concatenate(
(self.states['l'][0], ThetaNew['l'][0][-1, :]), axis=0)
self.eta[sq] = np.concatenate(
(self.eta[sq], preComputedEta[sq][:-1, -1]), axis=1)
self.eta[sq] = np.concatenate(
(self.eta[sq], preComputedEta[sq][-1, :]), axis=0)
#Update the next ones
L1 = range(len(self.videos))
L1.remove(sq)
for vi in L1:
self.eta[vi] = np.concatenate(
(self.eta[vi], np.zeros(
(self.eta[vi].shape[0], 1))),
axis=1)
self.eta[vi] = np.concatenate(
(self.eta[vi], np.zeros(
(1, self.eta[vi].shape[1]))),
axis=0)
self.obsPreComputedLikelihoods[vi] = np.concatenate(
(self.obsPreComputedLikelihoods[vi],
np.zeros((1, len(self.videos[vi])))),
axis=0)
for t in range(len(self.videos[vi])):
kk = K
self.obsPreComputedLikelihoods[vi][kk, t] = np.sum(
np.log([
self.states['v'][0][kk, i] *
self.videos[vi][t]['obsV'][i] +
(1 - self.states['v'][0][kk, i]) *
(1 - self.videos[vi][t]['obsV'][i])
for i in range(self.numVidObjs)
]))
self.obsPreComputedLikelihoods[vi][
kk, t] += np.sum(
np.log([
self.states['l'][0][kk, i] *
self.videos[vi][t]['obsL'][i] +
(1 - self.states['l'][0][kk, i]) *
(1 - self.videos[vi][t]['obsL'][i])
for i in range(self.numLangObjs)
]))
else:
self.obsPreComputedLikelihoods[sq] = np.delete(
self.obsPreComputedLikelihoods[sq], K, 0)
#print 'SPB',self.F.shape[1],self.states
#update eta,theta
elif (vidCount[sq, 0] > 1):
#Death
feat2kill = np.random.choice(uniqueL)
self.F[sq, feat2kill] = 0
(i, j) = self.F[sq, :].nonzero()
j = np.asarray(j)[0]
preComputedEta[sq] = np.mat(
np.random.gamma(
np.ones((K, K)) * self.lamb + np.eye(K) * self.kappa))
preComputedEta[sq][j, :][:, j] = self.eta[sq][j, :][:, j]
TranNew = preComputedEta[sq][j, :][:, j]
StateNew = {}
StateNew['v'] = [self.states['v'][0][j, :]]
StateNew['l'] = [self.states['l'][0][j, :]]
newProb = self.getFastHMMLikelihood(
StateNew, TranNew, sq,
self.obsPreComputedLikelihoods[sq][j, :])
etaa = self.gamma * 1.0 / (1.0 + N - 1.0)
logPrNumFeat_Diff = -np.log(etaa) - sp.special.gammaln(
self.F.shape[1] - 1) + sp.special.gammaln(self.F.shape[1])
if np.exp(newProb - oldProb + logPrNumFeat_Diff -
np.log(0.5 / len(uniqueL)) +
np.log(0.5)) > np.random.rand():
#accept
newF = self.F[:,
range(0, feat2kill) +
range(feat2kill + 1, self.F.shape[1])]
self.F = newF
self.states['v'][0] = np.delete(self.states['v'][0],
feat2kill, 0)
self.states['l'][0] = np.delete(self.states['l'][0],
feat2kill, 0)
#Update the next ones
L1 = range(len(self.videos))
#L1.remove(sq)
for vi in L1:
for xx in range(feat2kill + 1, self.eta[vi].shape[1]):
for yy in range(feat2kill + 1,
self.eta[vi].shape[1]):
self.eta[vi][xx - 1, yy - 1] = self.eta[vi][xx,
yy]
dim2kill = self.eta[vi].shape[1] - 1
self.eta[vi] = np.delete(self.eta[vi], dim2kill, 1)
self.eta[vi] = np.delete(self.eta[vi], dim2kill, 0)
self.obsPreComputedLikelihoods[vi] = np.delete(
self.obsPreComputedLikelihoods[vi], feat2kill, 0)
else:
self.F[sq, feat2kill] = 1
return 0
def get_detax(self, x):
uvcen = [331, 229]
kk = numpy.mat(uvcen).T - numpy.mat(x).T
return kk.reshape((1, 2)).tolist()
def initialize_v(n,k):
v=np.mat(np.zeros((n,k)))
for i in range(n):
for j in range(k):
v[i,j]=normalvariate(0,0.2)
return v
def sampleSharedFeats(self):
#pdb.set_trace()
#We only sample the columns who has more than one video to support it. In other words, we do not sample features unqiue to a specific video.
#First compute the number of occurences of each feature
featCount = np.sum(self.F, axis=0)
vidCount = np.sum(self.F, axis=1)
(N, K) = self.F.shape
#For computational efficiency we first cache all likelihoods and eta's
self.obsPreComputedLikelihoods = {}
preComputedEta = {}
for sq in range(N):
#Cache likelihoods
self.obsPreComputedLikelihoods[sq] = np.zeros(
(K, len(self.videos[sq])))
for t in range(len(self.videos[sq])):
for kk in range(K):
self.obsPreComputedLikelihoods[sq][kk, t] = np.sum(
np.log([
self.states['v'][0][kk, i] *
self.videos[sq][t]['obsV'][i] +
(1 - self.states['v'][0][kk, i]) *
(1 - self.videos[sq][t]['obsV'][i])
for i in range(self.numVidObjs)
]))
self.obsPreComputedLikelihoods[sq][kk, t] += np.sum(
np.log([
self.states['l'][0][kk, i] *
self.videos[sq][t]['obsL'][i] +
(1 - self.states['l'][0][kk, i]) *
(1 - self.videos[sq][t]['obsL'][i])
for i in range(self.numLangObjs)
]))
#Cache ETAs
preComputedEta[sq] = np.mat(
np.random.gamma(
np.ones((K, K)) * self.lamb + np.eye(K) * self.kappa))
(i, j) = self.F[sq, :].nonzero()
j = np.asarray(j)[0]
for x in j:
for y in j:
preComputedEta[sq][x, y] = self.eta[sq][x, y]
#pdb.set_trace()
for sq in range(N):
PrObsCur = 1
for ft in range(K):
if (vidCount[sq, 0] == 1) and (self.F[sq, ft] == 1):
continue
if (featCount[0, ft] == 1 and self.F[sq, ft] == 1):
continue
if PrObsCur == 1:
(i, j) = self.F[sq, :].nonzero()
j = np.asarray(j)[0]
TranNew = preComputedEta[sq][j, :][:, j]
StateNew = {}
StateNew['v'] = self.states['v'][0][j, :]
StateNew['l'] = self.states['l'][0][j, :]
PrObsCur = self.getFastHMMLikelihood(
StateNew, TranNew, sq,
self.obsPreComputedLikelihoods[sq][j, :])
#First decrement the feat count
featCount[0, ft] = featCount[0, ft] - self.F[sq, ft]
vidCount[sq, 0] = vidCount[sq, 0] - self.F[sq, ft]
if self.F[sq, ft] == 1:
PrPRatio = (N - featCount[0, ft]) / float(featCount[0, ft])
else:
PrPRatio = (featCount[0, ft]) / float(N - featCount[0, ft])
#Here we sample the F_ik by using the Eq.15 from Emily nFox et.al., JOINT MODELING OF MULTIPLE TIME SERIES VIA THE BETA PROCESS WITH APPLICATION TO MOTION CAPTURE SEGMENTATION
self.F[sq, ft] = 1 - self.F[sq, ft]
(i, j) = self.F[sq, :].nonzero()
j = np.asarray(j)[0]
TranNew = preComputedEta[sq][j, :][:, j]
StateNew = {}
StateNew['v'] = self.states['v'][0][j, :]
StateNew['l'] = self.states['l'][0][j, :]
PrObsNew = self.getFastHMMLikelihood(
StateNew, TranNew, sq,
self.obsPreComputedLikelihoods[sq][j, :])
if np.exp(PrObsNew - PrObsCur) * PrPRatio > np.random.rand():
PrObsCur = PrObsNew
if self.F[sq, ft] == 1:
for x in j:
self.eta[sq][x, ft] = preComputedEta[sq][x, ft]
self.eta[sq][ft, x] = preComputedEta[sq][ft, x]
else:
for x in j:
self.eta[sq][x, ft] = 0
self.eta[sq][ft, x] = 0
self.eta[sq][ft, ft] = 0
else:
self.F[sq, ft] = 1 - self.F[sq, ft]
featCount[0, ft] = featCount[0, ft] + self.F[sq, ft]
vidCount[sq, 0] = vidCount[sq, 0] + self.F[sq, ft]
return 0
def rot_z(q):
r = np.mat([[np.cos(q), -np.sin(q), 0], [np.sin(q),
np.cos(q), 0], [0, 0, 1]])
return r
image, label_pts = train_dataset.next_batch(1)
label_pts = label_pts[0]
image = [
cv2.resize(tmp, (128, 64), interpolation=cv2.INTER_LINEAR)
for tmp in image
]
c_val = sess.run(coffe,
feed_dict={
tensor_in: image,
gt_label_pts: label_pts
})
R = np.zeros([3, 3], np.float32)
R[0, 0] = c_val[0]
R[0, 1] = c_val[1]
R[0, 2] = c_val[2]
R[1, 1] = c_val[3]
R[1, 2] = c_val[4]
R[2, 1] = c_val[5]
R[2, 2] = 1
print(np.mat(R).I)
print(R)
print(c_val)
warp_image = cv2.warpPerspective(image[0],
R,
dsize=(image[0].shape[1],
image[0].shape[0]))
cv2.imwrite("src.jpg", image[0])
cv2.imwrite("ret.jpg", warp_image)
import numpy as np from numpy import linalg as la ''' C=np.array([1.75390 ,-0.51310, -0.00060]) Pt=np.array([-0.33130, 0.01060 , 0.00000]) v=C-Pt v=v/np.sqrt(np.sum(v**2)) ''' ###script that generates the rotation matrix that aligns a to b (a moves to align with b) a = np.mat([1, 1, 1]) b = np.mat([0, 0, 1]) a = a / np.sqrt(np.dot(a, a.T)) c = np.dot(a, b.T) v = np.cross(a, b)[0] s = np.sqrt(np.dot(v, v.T)) y = np.mat([[0, -v[2], v[1]], [v[2], 0, -v[0]], [-v[1], v[0], 0]]) Rot = np.mat(np.diag([1, 1, 1])) + y + np.dot(y, y) * (((1 - c) / s**2)[0, 0]) print(Rot, la.det(Rot)) print(np.dot(Rot, np.mat([1, 0, 0]).T), np.dot(Rot, np.mat([0, 1, 0]).T)) print(la.inv(Rot))
for i in range(m):
allItem+=1
if float(predict[i])<0.5 and classLabels[i]==1.0:
error+=1
elif float(predict[i])>=0.5 and classLabels[i]==-1.0:
error+=1
else:
continue
return float(error)/allItem
if __name__=="__main__":
print("----1.load data---")
dataTrain,labelTrain=loadDataSet("FM.txt")
print("----2.learning----")
w0,w,v=stocGradAscent(np.mat(dataTrain),labelTrain,3,5000,0.01)
predict_result=getPrediction(np.mat(dataTrain),w0,w,v)
print("----training error:----",(1-getAccuracy(predict_result,labelTrain)))
print("----3.save result----")
#save_model("weights",w0,w,v)
# coding:UTF-8
# '''
# Date:20160831
import numpy as np
from math import factorial
try:
window_size = np.abs(np.int(window_size))
order = np.abs(np.int(order))
except ValueError, msg:
raise ValueError("window_size and order have to be of type int")
if window_size % 2 != 1 or window_size < 1:
raise TypeError("window_size size must be a positive odd number")
if window_size < order + 2:
raise TypeError("window_size is too small for the polynomials order")
order_range = range(order + 1)
half_window = (window_size - 1) // 2
# precompute coefficients
b = np.mat([[k**i for i in order_range]
for k in range(-half_window, half_window + 1)])
m = np.linalg.pinv(b).A[deriv] * rate**deriv * factorial(deriv)
# pad the signal at the extremes with
# values taken from the signal itself
firstvals = y[0] - np.abs(y[1:half_window + 1][::-1] - y[0])
lastvals = y[-1] + np.abs(y[-half_window - 1:-1][::-1] - y[-1])
y = np.concatenate((firstvals, y, lastvals))
return np.convolve(m[::-1], y, mode='valid')
def read_options():
desc = """Questions and suggestions: [email protected]"""
global options
opt = optparse.OptionParser(
usage='Usage: %prog --ms=somename.MS <options>',
version='%prog version 1.0',
b = b + eta * labelMat[i]
# w = np.multiply(labelMat,alpha).T*dataMat
print (i,alpha[i])
flag = True
break
else:
flag = False
# w = (np.multiply(labelMat,alpha).T*dataMat).T
return alpha
if __name__=='__main__':
trainData,label,x_0,y_0,x_1,y_1,x_2,y_2 = generateData(1200)
m = np.shape(trainData)[0]
K = np.mat(np.zeros((m,m)))
#kernel matrix
for i in range(m):
K[:,i] = kernelTrans(np.mat(trainData), np.mat(trainData[i,:]), ('rbf',1))
alpha = trainModel(trainData,label,1,K)
plt.subplots_adjust(right=0.825)
ax=plt.gca()
plt.scatter(x_2, y_2, alpha=1,label = 'separated',)
plt.scatter(x_0, y_0, alpha=0.6,label = 'Positive',color='green')
plt.scatter(x_1, y_1, alpha=0.6,label = 'Negative',color='red') # 绘制散点图，透明度为0.6（这样颜色浅一点，比较好看）
def get_N_of_line(self, L1):
Ni = L1
Nj = 1 - L1
Nk = 0
N_of_line = np.mat([Ni, Nj, Nk]).T
return N_of_line
def init_grid(self):
'自动识别文件夹中三种数据文件，并以Pandas特征数据返回'
filename_point = './' + self.filename + '/E.n'
filename_element = './' + self.filename + '/E.e'
filename_boundary = './' + self.filename + '/E.s'
# 读取节点信息文件
number_of_triangle_point = pd.read_csv(filename_point,
header=None,
delim_whitespace=True,
nrows=1).iat[0, 0]
list_of_no_read = [
0, number_of_triangle_point + 1, number_of_triangle_point + 2
]
# 第一行与最后两行数据无需读取
# pd.read_csv参数参考http://www.cnblogs.com/datablog/p/6127000.html
self.point_of_global = pd.read_csv(
filename_point,
delim_whitespace=True,
names=["point NO", "x", "y", "boundary mark"],
skiprows=list_of_no_read)
# 读取单元信息文件
number_of_triangle_element = pd.read_csv(filename_element,
header=None,
delim_whitespace=True,
nrows=1).iat[0, 0]
list_of_no_read = [
0, number_of_triangle_element + 1, number_of_triangle_element + 2
]
self.element_of_global = pd.read_csv(
filename_element,
delim_whitespace=True,
names=[
"element number", "point i", "point j", "point k",
"neighbor ele i", "neighbor ele j", "neighbor ele k",
"boundary i", "boundary j", "boundary k"
],
skiprows=list_of_no_read)
# 读取边界信息文件
number_of_triangle_boundary = pd.read_csv(filename_boundary,
header=None,
delim_whitespace=True,
nrows=1).iat[0, 0]
list_of_no_read = [
0, number_of_triangle_boundary + 1, number_of_triangle_boundary + 2
]
self.boundary_of_global = pd.read_csv(filename_boundary,
delim_whitespace=True,
names=[
"boundary start",
"boundary end",
"left element",
"right element", "mark"
],
skiprows=list_of_no_read)
# 初始化总刚度矩阵 总载荷矩阵
self.Ae = np.mat(
np.tile([0.],
(number_of_triangle_point, number_of_triangle_point)))
self.f = np.mat(np.tile([0.], (number_of_triangle_point, 1)))
# Summary of the new catagory
concreteList['Strenght Catagory'].value_counts()
# Extract class names to python list,
# then encode with integers (dict)
classLabels = concreteList['Strenght Catagory']
classNames = sorted(set(classLabels))
classDict = dict(zip(classNames, range(5)))
# Compute values of N and M.
N = concreteList.shape[0]
M = concreteList.shape[1]
C = len(classNames)
# Extract vector y, convert to np matrix and transpose
y = np.mat([classDict[value] for value in classLabels]).T
X = np.array(concreteList.iloc[:, 0:-2])
# Data attributes to be plotted
i = 1
j = 6
# attribute names, and a title.
f = figure()
title('NanoNose data')
for c in range(C):
# select indices belonging to class c:
class_mask = y.A.ravel() == c
plot(X[class_mask, i], X[class_mask, j], 'o')
legend(classNames)
def get_area(self):
area_of_element = np.mat([[self.xi, self.yi, 1], [self.xj, self.yj, 1],
[self.xk, self.yk, 1]], )
self.area_of_element = np.linalg.det(area_of_element) / 2
