def PCA_transform(train_feature, test_feature, mat_file_path):
""" Unsupervised dimension reduction
Note: 由于scikit-learn中PCA无法针对目前的训练集进行PCA分解，所以这里采用matlab的分解结果
"""
#import ipdb; ipdb.set_trace()
print 'PCA fitting...'
"""
from sklearn.decomposition import PCA
pca = PCA(n_components, whiten=False).fit(model_train_data)
print 'PCA transformation...'
model_train_data2 = pca.transform(model_train_data)
model_test_data2 = pca.transform(model_test_data)
test_data2 = pca.transform(test_data)
"""
# 读入mat文件
import scipy.io
mat_dict = scipy.io.loadmat(mat_file_path)
W = np.asmatrix(mat_dict['COEFF'])
# train_feature_transformed 包含所有的训练数据
#train_feature_transformed = np.asmatrix(mat_dict['train']) # 已经转换好的
#test_feature_transformed = np.asmatrix(mat_dict['test'])
train_feature_transformed = np.asmatrix(train_feature) * W # or this one
test_feature_transformed = np.asmatrix(test_feature) * W
return np.array(train_feature_transformed), np.array(test_feature_transformed)
def noRidgeGradientDescentWhole(train,alpha):
train = np.asmatrix(train)
train_x = train[0:, 0 : -1]
train_y = train[0:, -1]
train_m, train_n = train_x.shape
w_c = [0]*train_n
w_c = np.asmatrix(w_c).T
train_err_list = []
for j in range(1,100000):
a_c = 1.0 / (j+ 1)
gradient = 1.0/train_m *((train_x.T * train_x) * w_c - train_x.T * train_y)
w_n = w_c - alpha*a_c* gradient
mm = w_n - w_c
sum_m = np.sum(np.square(mm))
sqrt = sum_m ** 0.5
w_c = w_n
train_err = ((train_y - train_x * w_c).T * (train_y - train_x * w_c))/2.0/train_m
# + lamb/2.0/train_m * w_c.T*w_c
train_err = np.asarray(train_err)[0][0]
train_err_list.append(train_err)
if j % 100 == 0:
print "try " + str(j) +"times"
# print "gradient"+ str(gradient)
# print sqrt,'sqrt'
if sqrt < 0.2:
wo = w_c
train_err_last = train_err
break
# print train_err_last,'training err on the whole data set'
return wo,train_err_list,train_err_last
def sum(self, axis=None):
"""Sum the matrix over the given axis. If the axis is None, sum
over both rows and columns, returning a scalar.
"""
# We use multiplication by an array of ones to achieve this.
# For some sparse matrix formats more efficient methods are
# possible -- these should override this function.
m, n = self.shape
# Mimic numpy's casting.
if np.issubdtype(self.dtype, np.float_):
res_dtype = np.float_
elif (np.issubdtype(self.dtype, np.int_) or
np.issubdtype(self.dtype, np.bool_)):
res_dtype = np.int_
elif np.issubdtype(self.dtype, np.complex_):
res_dtype = np.complex_
else:
res_dtype = self.dtype
if axis is None:
# sum over rows and columns
return (self * np.asmatrix(np.ones((n, 1), dtype=res_dtype))).sum()
if axis < 0:
axis += 2
if axis == 0:
# sum over columns
return np.asmatrix(np.ones((1, m), dtype=res_dtype)) * self
elif axis == 1:
# sum over rows
return self * np.asmatrix(np.ones((n, 1), dtype=res_dtype))
else:
raise ValueError("axis out of bounds")
def init_random( self, scale = 1.0 ):
"""
Randomly initialise the biases and weights
"""
self.b = numpy.asmatrix( numpy.random.normal( loc = 0.0, scale = scale, size = self.H ) )
self.c = numpy.asmatrix( numpy.random.normal( loc = 0.0, scale = scale, size = self.V ) )
self.W = numpy.asmatrix( numpy.random.normal( loc = 0.0, scale = scale, size = (self.H, self.V) ) )
def test_arclength_half_circle():
""" Here we define the tests for the lenght computer of our ArcLengthParametrizer, we try it with a half a
circle and a fan.
We test it both in 2d and 3d."""
# Number of interpolation points minus one
n = 5
toll = 1.e-6
points = np.linspace(0, 1, (n+1) )
R = 1
P = 1
control_points_2d = np.asmatrix(np.zeros([n+1,2]))#[np.array([R*np.cos(5*i * np.pi / (n + 1)), R*np.sin(5*i * np.pi / (n + 1)), P * i]) for i in range(0, n+1)]
control_points_2d[:,0] = np.transpose(np.matrix([R*np.cos(1 * i * np.pi / (n + 1))for i in range(n+1)]))
control_points_2d[:,1] = np.transpose(np.matrix([R*np.sin(1 * i * np.pi / (n + 1))for i in range(n+1)]))
control_points_3d = np.asmatrix(np.zeros([n+1,3]))#[np.array([R*np.cos(5*i * np.pi / (n + 1)), R*np.sin(5*i * np.pi / (n + 1)), P * i]) for i in range(0, n+1)]
control_points_3d[:,0] = np.transpose(np.matrix([R*np.cos(1 * i * np.pi / (n + 1))for i in range(n+1)]))
control_points_3d[:,1] = np.transpose(np.matrix([R*np.sin(1 * i * np.pi / (n + 1))for i in range(n+1)]))
control_points_3d[:,2] = np.transpose(np.matrix([P*i for i in range(n+1)]))
vsl = AffineVectorSpace(UniformLagrangeVectorSpace(n+1),0,1)
dummy_arky_2d = ArcLengthParametrizer(vsl, control_points_2d)
dummy_arky_3d = ArcLengthParametrizer(vsl, control_points_3d)
length2d = dummy_arky_2d.compute_arclength()[-1,1]
length3d = dummy_arky_3d.compute_arclength()[-1,1]
# print (length2d)
# print (n * np.sqrt(2))
l2 = np.pi * R
l3 = 2 * np.pi * np.sqrt(R * R + (P / (2 * np.pi)) * (P / (2 * np.pi)))
print (length2d, l2)
print (length3d, l3)
assert (length2d - l2) < toll
assert (length3d - l3) < toll
def solve(self, xk, iteraciones):
bk_matrix = self.Identity(numpy.size(xk))
#xk=numpy.transpose(numpy.asmatrix(xk))
xk1 = xk[:]
def f(xk):
a=xk[0]*xk[0]
return a
self.function= f
for x in range(iteraciones):
#gxk = self.Gradiente(xk)
gxk = scipy.optimize.approx_fprime(xk,self.function,0.01)
gxkt=numpy.transpose(numpy.asmatrix(gxk))
dk_vector = - bk_matrix * gxkt
def deriv(punto):
return scipy.optimize.approx_fprime(xk,self.function,0.01)
tupla = scipy.optimize.line_search(self.function,deriv,numpy.transpose(numpy.asmatrix(xk)),dk_vector,numpy.asmatrix(gxk))
ak=tupla[0]
#ak, _, _ = scipy.optimize.line_search(self.function, xk, dk_vector, gxk, self.function(xk))
#ak, fevals, gfevals = scipy.optimize.line_search(self.function, None, self.xk_vector, self.dk_vector, gxk)
dkvec=numpy.array(numpy.transpose(dk_vector))
vec0=dkvec[0]
xk1 = xk + ak * vec0
xk = numpy.array(xk1)
return xk1
def handle_monocular(self, msg):
(image, camera) = msg
gray = self.mkgray(image)
C = self.image_corners(gray)
if C:
linearity_rms = self.mc.linear_error(C, self.board)
# Add in reprojection check
image_points = C
object_points = self.mc.mk_object_points([self.board], use_board_size=True)[0]
dist_coeffs = numpy.zeros((4, 1))
camera_matrix = numpy.array( [ [ camera.P[0], camera.P[1], camera.P[2] ],
[ camera.P[4], camera.P[5], camera.P[6] ],
[ camera.P[8], camera.P[9], camera.P[10] ] ] )
ok, rot, trans = cv2.solvePnP(object_points, image_points, camera_matrix, dist_coeffs)
# Convert rotation into a 3x3 Rotation Matrix
rot3x3, _ = cv2.Rodrigues(rot)
# Reproject model points into image
object_points_world = numpy.asmatrix(rot3x3) * (numpy.asmatrix(object_points.squeeze().T) + numpy.asmatrix(trans))
reprojected_h = camera_matrix * object_points_world
reprojected = (reprojected_h[0:2, :] / reprojected_h[2, :])
reprojection_errors = image_points.squeeze().T - reprojected.T
reprojection_rms = numpy.sqrt(numpy.sum(numpy.array(reprojection_errors) ** 2) / numpy.product(reprojection_errors.shape))
# Print the results
print("Linearity RMS Error: %.3f Pixels Reprojection RMS Error: %.3f Pixels" % (linearity_rms, reprojection_rms))
else:
print('no chessboard')
def L(self, alpha, Q):
a = alpha.reshape((len(alpha), 1))
a = np.asmatrix(a)
c = np.ones_like(a)
c = np.asmatrix(c)
a_T = a.getT()
return 0.5*((a_T*Q)*a) - c.getT()*a
def weights(self, X, Y, res):
alphas = res.x
#get weights from valid support vectors - probably should check the math here?
w1 = 0.0
w2 = 0.0
sv_indexes = []
for i in range(0, len(alphas)):
if alphas[i] > 1.0e-03:
w1 += alphas[i] * Y[i] * X[i][0]
w2 += alphas[i] * Y[i] * X[i][1]
self.sv_count += 1.0
sv_indexes.append(i)
W = [w1, w2]
self.W = W
#solve for b, or w0, using any SV
Wm = np.asmatrix(W)
try:
n = sv_indexes[0]
except IndexError:
self.no_svs += 1
return self.fit(X, Y)
xn = np.asmatrix(X[n])
xn = xn.getT()
self.b = (1/Y[n]) - Wm*xn
def mulliken(self):
"""
perform a mulliken population analysis
"""
if self.overlap is not None:
Smat_ao = np.asmatrix(self.overlap)
else:
raise Exception('mulliken analysis is missing the overlap matrix')
population = {}
for kind, mo in self.mo.items():
population[kind] = np.zeros(len(self.basis_set.center_charges))
Cmat = np.asmatrix(mo.coefficients)
D = Cmat * np.diag(mo.occupations) * Cmat.T
DS = np.multiply(D, Smat_ao)
for i, (ao, basis_id) in enumerate(zip(np.asarray(DS), mo.basis_ids)):
pop = np.sum(ao)
cgto_tuple = mo.basis_set.contracted_ids[basis_id]
center_id, l, n, m = cgto_tuple
population[kind][center_id-1] += pop
if self.unrestricted:
population_total = population['alpha'] + population['beta']
else:
population_total = population['restricted']
mulliken_charges = self.basis_set.center_charges - population_total
return mulliken_charges
def fit(self, bags, y):
"""
@param bags : a sequence of n bags; each bag is an m-by-k array-like
object containing m instances with k features
@param y : an array-like object of length n containing -1/+1 labels
"""
self._bags = [np.asmatrix(bag) for bag in bags]
y = np.asmatrix(y).reshape((-1, 1))
bs = BagSplitter(self._bags, y)
if self.verbose:
print 'Training initial sMIL classifier for sbMIL...'
initial_classifier = sMIL(kernel=self.kernel, C=self.C, p=self.p, gamma=self.gamma,
scale_C=self.scale_C, verbose=self.verbose,
sv_cutoff=self.sv_cutoff)
initial_classifier.fit(bags, y)
if self.verbose:
print 'Computing initial instance labels for sbMIL...'
f_pos = initial_classifier.predict(bs.pos_inst_as_bags)
# Select nth largest value as cutoff for positive instances
n = int(round(bs.L_p * self.eta))
n = min(bs.L_p, n)
n = max(bs.X_p, n)
f_cutoff = sorted((float(f) for f in f_pos), reverse=True)[n - 1]
# Label all except for n largest as -1
pos_labels = -np.matrix(np.ones((bs.L_p, 1)))
pos_labels[np.nonzero(f_pos >= f_cutoff)] = 1.0
# Train on all instances
if self.verbose:
print 'Retraining with top %d%% as positive...' % int(100 * self.eta)
all_labels = np.vstack([-np.ones((bs.L_n, 1)), pos_labels])
super(SIL, self).fit(bs.instances, all_labels)
def test_probabilities(self): grbm = GaussianRBM(7, 13) grbm.W = np.asmatrix(np.random.randn(grbm.X.shape[0], grbm.Y.shape[0])) grbm.b = np.asmatrix(np.random.rand(grbm.X.shape[0], 1)) grbm.c = np.asmatrix(np.random.randn(grbm.Y.shape[0], 1)) grbm.sigma = np.random.rand() * 0.5 + 0.5 grbm.sigma = 1. examples_vis = np.asmatrix(np.random.randn(grbm.X.shape[0], 1000) * 2.) examples_hid = np.matrix(np.random.rand(grbm.Y.shape[0], 100) < 0.5) states_hid = utils.binary_numbers(grbm.Y.shape[0]) # check that conditional probabilities are normalized logprobs = grbm._clogprob_hid_vis(examples_vis, states_hid, all_pairs=True) self.assertTrue(np.all(utils.logsumexp(logprobs, 1) < 1E-8)) # test for consistency logprobs1 = grbm._ulogprob(examples_vis, examples_hid, all_pairs=True) logprobs2 = grbm._clogprob_vis_hid(examples_vis, examples_hid, all_pairs=True) \ + grbm._ulogprob_hid(examples_hid) logprobs3 = grbm._clogprob_hid_vis(examples_vis, examples_hid, all_pairs=True) \ + grbm._ulogprob_vis(examples_vis).T self.assertTrue(np.all(np.abs(logprobs1 - logprobs2) < 1E-10)) self.assertTrue(np.all(np.abs(logprobs1 - logprobs3) < 1E-3))
def elop(X, Y, op):
"""
Compute element-wise operation of matrix :param:`X` and matrix :param:`Y`.
:param X: First input matrix.
:type X: :class:`scipy.sparse` of format csr, csc, coo, bsr, dok, lil, dia or :class:`numpy.matrix`
:param Y: Second input matrix.
:type Y: :class:`scipy.sparse` of format csr, csc, coo, bsr, dok, lil, dia or :class:`numpy.matrix`
:param op: Operation to be performed.
:type op: `func`
"""
try:
zp1 = op(0, 1) if sp.isspmatrix(X) else op(1, 0)
zp2 = op(0, 0)
zp = zp1 != 0 or zp2 != 0
except:
zp = 0
if sp.isspmatrix(X) or sp.isspmatrix(Y):
return _op_spmatrix(X, Y, op) if not zp else _op_matrix(X, Y, op)
else:
try:
X[X == 0] = np.finfo(X.dtype).eps
Y[Y == 0] = np.finfo(Y.dtype).eps
except ValueError:
return op(np.asmatrix(X), np.asmatrix(Y))
return op(np.asmatrix(X), np.asmatrix(Y))
def _alpha_cal(self,observations):
# Calculate alpha matrix and return it
num_states = self.em_prob.shape[0]
total_stages = len(observations)
# Initialize values
ob_ind = self.obs_map[ observations[0] ]
alpha = np.asmatrix(np.zeros((num_states,total_stages)))
c_scale = np.asmatrix(np.zeros((total_stages,1)))
# Handle alpha base case
alpha[:,0] = np.multiply ( np.transpose(self.em_prob[:,ob_ind]) , self.start_prob ).transpose()
# store scaling factors, scale alpha
c_scale[0,0] = 1/np.sum(alpha[:,0])
alpha[:,0] = alpha[:,0] * c_scale[0]
# Iteratively calculate alpha(t) for all 't'
for curr_t in range(1,total_stages):
ob_ind = self.obs_map[observations[curr_t]]
alpha[:,curr_t] = np.dot( alpha[:,curr_t-1].transpose() , self.trans_prob).transpose()
alpha[:,curr_t] = np.multiply( alpha[:,curr_t].transpose() , np.transpose( self.em_prob[:,ob_ind] )).transpose()
# Store scaling factors, scale alpha
c_scale[curr_t] = 1/np.sum(alpha[:,curr_t])
alpha[:,curr_t] = alpha[:,curr_t] * c_scale[curr_t]
# return the computed alpha
return (alpha,c_scale)
def _randomize():
# Generate random transition,start and emission probabilities
# Store observations and states
num_obs = len(self.observations)
num_states = len(states)
# Generate a random list with sum of numbers = 1
a = np.random.random(num_states)
a /= a.sum()
# Initialize start_prob
self.start_prob = a
# Initialize transition matrix
# Fill each row with a list that sums upto 1
self.trans_prob = np.asmatrix(np.zeros((num_states,num_states)))
for i in range(num_states):
a = np.random.random(num_states)
a /= a.sum()
self.trans_prob[i,:] = a
# Initialize emission matrix
# Fill each row with a list that sums upto 1
self.em_prob = np.asmatrix(np.zeros((num_states,num_obs)))
for i in range(num_states):
a = np.random.random(num_obs)
a /= a.sum()
self.em_prob[i,:] = a
return self.start_prob, self.trans_prob, self.em_prob
def calculate_transform_error(R, t, positions_1, positions_2):
#TODO: Incorporate Bayes rule:
# prob of R given point_correspondances =
# prob of pts given R (if R is large, points are likely on one side of image?)*
# prob of R (large R is more unlikely than small R for keypoints) /
# prob of points (proportional to match strengh, inversely prop to distance)
#add error to R if it is very oblique
#(since large angles of R are unlikely)
[axis, theta] = get_axis_angle(R)
angle_likelihood = theta**2
cum_error = 0
num_points = positions_1.shape[0]
for i in range(num_points):
pt_1 = np.asmatrix(positions_1[i, :])
pt_2 = np.asmatrix(positions_2[i, :])
pt_1 = pt_1.transpose()
pt_2 = pt_2.transpose()
transformed_pt_1 = (np.dot(R, pt_1)) + t
cum_error += np.linalg.norm((transformed_pt_1 - pt_2))**2
return cum_error*angle_likelihood
def plot_pr(self, i0, rg, qmax=5., dmax=200., ax=None):
""" calculate p(r) function
use the given i0 and rg value to fill in the low q part of the gap in data
truncate the high q end at qmax
"""
if ax==None:
ax = plt.gca()
ax.set_xscale('linear')
ax.set_yscale('linear')
if self.qgrid[-1]<qmax: qmax=self.qgrid[-1]
tqgrid = np.arange(0,qmax,qmax/len(self.qgrid))
tint = np.interp(tqgrid,self.qgrid,self.data)
tint[tqgrid*rg<1.] = i0*np.exp(-(tqgrid[tqgrid*rg<1.]*rg)**2/3.)
#tint -= tint[-10:].sum()/10
# Hanning window for reducing fringes in p(r)
tw = np.hanning(2*len(tqgrid)+1)[len(tqgrid):-1]
tint *= tw
trgrid = np.arange(0,dmax,1.)
kern = np.asmatrix([[rj**2*np.sinc(qi*rj/np.pi) for rj in trgrid] for qi in tqgrid])
tt = np.asmatrix(tint*tqgrid**2).T
tpr = np.reshape(np.array((kern.T*tt).T),len(trgrid))
tpr /= tpr.sum()
#plt.plot(tqgrid,tint,"g-")
#tpr = np.fft.rfft(tint)
#tx = range(len(tpr))
ax.plot(trgrid,tpr,"g-")
ax.set_xlabel("$r (\AA)$", fontsize='x-large')
ax.set_ylabel("$P(r)$", fontsize='x-large')
def predict(self, image):
"""
Predict the face
"""
#image as row
imageAsRow = np.asarray(image.reshape(image.shape[0]*image.shape[1],1),
np.float64);
#project inthe subspace
p = self.pca.apply_to_feature_vector(RealFeatures(imageAsRow).get_feature_vector(0));
#min value to find the face
minDist =1e100;
#class
minClass = -1;
#search which face is the best match
for sampleIdx in range(len(self._projections)):
test = RealFeatures(np.asmatrix(p,np.float64).T)
projection = RealFeatures(np.asmatrix(self._projections[sampleIdx],
np.float64).T)
dist = EuclideanDistance( test, projection).distance(0,0)
if(dist < minDist ):
minDist = dist;
minClass = self._labels[sampleIdx];
return minClass
def mk_stochastic(T):
"""
% MK_STOCHASTIC Ensure the argument is a stochastic matrix, i.e., the sum over the last dimension is 1.
% [T,Z] = mk_stochastic(T)
%
% If T is a vector, it will sum to 1.
% If T is a matrix, each row will sum to 1.
% If T is a 3D array, then sum_k T(i,j,k) = 1 for all i,j.
% Set zeros to 1 before dividing
% This is valid since S(j) = 0 iff T(i,j) = 0 for all j
"""
T = np.asfarray(T)
if T.ndim == 1 or (T.ndim == 2 and (T.shape[0] == 1 or T.shape[1] == 1)): # isvector
T, Z = normalise(T)
elif T.ndim == 2: # matrix
T = np.asmatrix(T)
Z = np.sum(T, 1)
S = Z + (Z == 0)
norm = np.tile(S, (1, T.shape[1]))
T = np.divide(T, norm)
else: # multi-dimensional array
ns = T.shape
T = np.asmatrix(np.reshape(T, (np.prod(ns[0:-1]), ns[-1])))
Z = np.sum(T, 1)
S = Z + (Z == 0)
norm = np.tile(S, (1, ns[-1]))
T = np.divide(T, norm)
T = np.reshape(np.asarray(T), ns)
return T, Z
def dynamical_matrix(struc,protopairs,fconstants,k):
"""Calculate the dynamical matrix for a given k point.
:struc: Crystal
:protopairs: [(Site,Site)], (probably NN pairs)
:fconstants: list of 4 floats, for each xx,xy,yx,yy forces
:k: 2x1 matrix, k-point of interest
:returns: 2x2 matrix
"""
D=np.zeros((2*len(struc._basis),2*len(struc._basis)),dtype=complex)
sg=struc.factor_group()
dynbasisentries=dynamical_basis_entries(protopairs,sg,struc,fconstants)
for stack,pair in dynbasisentries:
#This is the 2x2 sum of the tensor basis with the force constants
L=flatten_tensor_stack(stack)
#This is the exponential part
rn,tb0,tb1=dynamical_exp_inputs(pair[0],pair[1],struc._lattice)
expstuff=dynamical_exp_elem(k,rn,tb0,tb1)
sumvalue=L*expstuff
D_entry=dynamical_pair_location(pair[0],pair[1],struc)
D[D_entry]+=sumvalue
D=np.asmatrix(D)
assert is_hermitian(D)
return np.asmatrix(D)
def main():
fnm = 'prob3.data'
data = md.read_data(fnm)
D1 = data[0:8,].T
D2 = data[8:,].T
u1 = np.matrix((np.mean(D1[0,:]), np.mean(D1[1,:]))).T
u2 = np.matrix((np.mean(D2[0,:]), np.mean(D2[1,:]))).T
sigma1 = np.asmatrix(np.cov(D1, bias=1))
sigma2 = np.asmatrix(np.cov(D1, bias=1))
g1 = discrim_func(u1, sigma1)
g2 = discrim_func(u2, sigma2)
steps = 100
x = np.linspace(-2,2,steps)
y = np.linspace(-6,6,steps)
X,Y = np.meshgrid(x,y)
z = [g1(X[r,c], Y[r,c]) - g2(X[r,c], Y[r,c])
for r in range(0,steps) for c in range(0,steps)]
Z = np.array(z)
px = X.ravel()
py = Y.ravel()
pz = Z.ravel()
gridsize = 50
plot = plt.subplot(111)
plt.hexbin(px,py,C=pz, gridsize=gridsize, cmap=cm.jet, bins=None)
cb = plt.colorbar()
cb.set_label('g1 minus g2')
return plot
def active(self, X):
pre_h = np.zeros((1, self.h_size), dtype=theano.config.floatX)
[R, Z, GH, H] = self.cell.active(X, pre_h)
self.activation = np.asmatrix(H)
self.R = np.asmatrix(R)
self.Z = np.asmatrix(Z)
self.GH = np.asmatrix(GH)
def train_map(self):
if len(self.dataset) == 0:
return
X = self.dataset.inputs
Y = self.dataset.targets
# choose random center vectors from training set
rnd_idx = np.random.permutation(X.shape[0])[:self.numCenters]
self.centers = [X[i,:] for i in rnd_idx]
# calculate activations of RBFs
G = np.asmatrix(self._designMatrix(X))
Y = np.asmatrix(Y)
M = self.numCenters
# create (reset) prior over weights w
m0 = np.matrix(np.zeros((M, 1), float))
S0 = np.matrix(self.alpha*np.eye(M))
# calculate posterior (p. 153, eqns. 3.50, 3.51)
self.SN = S0.I + self.beta*G.T*G
self.mN = np.linalg.inv(self.SN) * (S0.I*m0 + self.beta*G.T*Y)
self.W = np.asarray(self.mN)
def similarity(self):
matrixvectout = numpy.asmatrix(self.vectout)
# print("matrixvectout shape is ", matrixvectout.shape)
matrixqvectsout = numpy.asmatrix(self.qvectsout.toarray())
# print("matrix qvectsout shape is ", matrixqvectsout.shape)
out = self.bm_vectobj.get_feature_names()
self.similaritymatrix = numpy.asarray(matrixvectout*matrixqvectsout.T)
def similarity(self):
matrixvectout = numpy.asmatrix(self.vectout)
print("matrixvectout shape is ", matrixvectout.shape)
matrixqvectsout = numpy.asmatrix(self.qvectsout.toarray())
print("matrix qvectsout shape is ", matrixqvectsout.shape)
self.similaritymatrix = numpy.asarray(matrixvectout*matrixqvectsout.T)
print(self.similaritymatrix.shape)
def test_sum_squares(self):
X = Variable(5, 4)
P = np.asmatrix(np.random.randn(3, 5))
Q = np.asmatrix(np.random.randn(4, 7))
M = np.asmatrix(np.random.randn(3, 7))
y = P*X*Q + M
self.assertFalse(y.is_constant())
self.assertTrue(y.is_affine())
self.assertTrue(y.is_quadratic())
self.assertTrue(y.is_dcp())
s = sum_squares(y)
self.assertFalse(s.is_constant())
self.assertFalse(s.is_affine())
self.assertTrue(s.is_quadratic())
self.assertTrue(s.is_dcp())
# Frobenius norm squared is indeed quadratic
# but can't show quadraticity using recursive rules
t = norm(y, 'fro')**2
self.assertFalse(t.is_constant())
self.assertFalse(t.is_affine())
self.assertFalse(t.is_quadratic())
self.assertTrue(t.is_dcp())
def generate_dataset():
global avg_trans_lis, type2_patient_lis, data_set, patient_ge_ag_lis, trans_dic, patient_smok_rec
for it in avg_trans_lis:
item_lis = it[1:6]
# get the gender and age
for a_it in patient_ge_ag_lis:
if it[0] == a_it[0]:
# gender and age
item_lis.append(a_it[1])
item_lis.append(a_it[2])
# get the number of visiting doctors
num_vis = len(trans_dic[it[0]])
item_lis.append(num_vis)
# get the smoking status record
item_lis.append(patient_smok_rec[it[0]])
# get the class tag
for ite in type2_patient_lis:
if it[0] == ite[0]:
item_lis.append(int(ite[1]))
# only store the patient has smoking record
# if int(patient_smok_rec[it[0]])>0:
# print ".......................00000000000000000000000000000"
data_set.append(item_lis)
# transform the dataset to change the distance from euclidean distance
# to mahalanobis distance
# get the covariance matrix
cov_matri = np.cov((np.asmatrix(data_set)[:, [0, 1, 2, 3, 4, 5, 6, 7, 8]]).transpose())
temp_data_set = (np.dot(np.asmatrix(data_set)[:, [0, 1, 2, 3, 4, 5, 6, 7, 8]], cov_matri)).tolist()
for it in range(0, len(data_set)):
item_lis = temp_data_set[it][0:9]
item_lis.append(data_set[it][9])
data_set[it] = item_lis
def __init__(self, submod, V, eps_p_f, ti=None, tally=True, verbose=0):
self.f_eval = submod.f_eval
self.f = submod.f
pm.StepMethod.__init__(self, [self.f, self.f_eval], tally=tally)
self.children_no_data = copy.copy(self.children)
if isinstance(eps_p_f, pm.Variable):
self.children_no_data.discard(eps_p_f)
self.eps_p_f = eps_p_f
else:
for epf in eps_p_f:
self.children_no_data.discard(epf)
self.eps_p_f = pm.Lambda("eps_p_f", lambda e=eps_p_f: np.hstack(e), trace=False)
self.V = pm.Lambda("%s_vect" % V.__name__, lambda V=V: V * np.ones(len(submod.f_eval)))
self.C_eval = submod.C_eval
self.M_eval = submod.M_eval
self.S_eval = submod.S_eval
M_eval_shape = pm.utils.value(self.M_eval).shape
C_eval_shape = pm.utils.value(self.C_eval).shape
self.ti = ti or np.arange(M_eval_shape[0])
# Work arrays
self.scratch1 = np.asmatrix(np.empty(C_eval_shape, order="F"))
self.scratch2 = np.asmatrix(np.empty(C_eval_shape, order="F"))
self.scratch3 = np.empty(M_eval_shape)
# Initialize hidden attributes
self.accepted = 0.0
self.rejected = 0.0
self._state = ["rejected", "accepted", "proposal_distribution"]
self._tuning_info = []
self.proposal_distribution = None
def GDA_N_D(X, M, cov1, cov2, cov3, classes,priors):
dclass1 = []
dclass2 = []
dclass3 = []
cov1 = np.asmatrix(cov1, dtype='float')
cov2 = np.asmatrix(cov2, dtype='float')
cov3 = np.asmatrix(cov3, dtype='float')
X = np.asmatrix(X[:, 0:4], dtype='float')
M = np.asmatrix(M, dtype='float')
for i in range(0, len(X)):
x = (X[i] - M[0])
y = (X[i] - M[1])
z = (X[i] - M[2])
dclass1.append(-mth.log(np.linalg.det(cov1)) - 0.5 * (
np.dot(np.dot(x, np.linalg.inv(cov1)), x.transpose())) + mth.log(priors[0]))
dclass2.append(-mth.log(np.linalg.det(cov2)) - 0.5 * (
np.dot(np.dot(y, np.linalg.inv(cov2)), y.transpose())) + mth.log(priors[1]))
dclass3.append(-mth.log(np.linalg.det(cov3)) - 0.5 * (
np.dot(np.dot(z, np.linalg.inv(cov3)), z.transpose())) + mth.log(priors[2]))
predict_class = []
for i, j, k in zip(dclass1, dclass2, dclass3):
if i > j and i > k:
predict_class.append(classes[0])
elif j > i and j > k:
predict_class.append(classes[1])
else:
predict_class.append(classes[2])
return predict_class
def k_means(data, k, init_center=None, max_iter=10, dist=lambda x, y: np.dot((x - y), (x - y).T), tau=1e-6):
old_center = None
if init_center is None:
center = random.sample([np.asmatrix(d) for d in data], k)
else:
center = [np.asmatrix(c) for c in init_center]
i = 0
label = [
np.argmax([dist(c, x) for c in center]) for x in data
]
while i < max_iter and \
(old_center is None or not all(np.allclose(o, c, tau) for o, c in zip(old_center, center))):
old_center = center
# find the mean of the cluster.
center = [
np.average([c[0] for c in cluster], axis=0)
for label, cluster in itertools.groupby(sorted(zip(data, label),
key=lambda d: d[1]),
key=lambda d: d[1])
]
# in case that length of center does not equal to k.
for i in range(k - len(center)):
center.append(max((min(dist(c, x) for c in center), x) for x in data)[1])
# label the data.
label = [
np.argmin([dist(c, x) for c in center]) for x in data
]
# increment iteration.
i += 1
return center, label
def find_fiedler(L, x, normalized, tol):
q = 2 if method == 'pcg' else min(4, L.shape[0] - 1)
X = asmatrix(normal(size=(q, L.shape[0]))).T
sigma, X = _tracemin_fiedler(L, X, normalized, tol, method)
return sigma[0], X[:, 0]
def Datahandler():
global start_time, PI, pub, a, b, c, n, w1, w2, w3, mode, Veh_init_X, Veh_init_Y, X_offset, Y_offset, phase, STATES, start_state, Des_X, Des_Y, R_star, V_veh, Range, pub_vt #,pub_Range#,vt
WP = Trajectories()
WP.Obj = [Trajectory()] * 1
time_now = rospy.get_time()
t = time_now - start_time
Xv_init = start_state.x
Yv_init = start_state.y
#Veh_pos = np.asmatrix(np.zeros((3,1)))
#Veh_pos[0] = STATES.x
#Veh_pos[1] = STATES.y
#Veh_pos[2] = STATES.z
xx = STATES.x
yy = STATES.y
zz = STATES.z
Veh_V = np.asmatrix(np.zeros((3, 1)))
Veh_V[0] = STATES.u
Veh_V[1] = STATES.v
Veh_V[2] = STATES.w
V_v = np.linalg.norm(Veh_V)
#print V_v
if t < 0.1: # This time should be multiples of 0.05 and cannot be less than 0.05, otherwise this node will shut down.
RANGE = R_star # Formula for Initial Range has to be defined here.
else:
RANGE = Range.data
#print RANGE
if mode == 0:
#=================#
# Trajectory #
#=================#
traj = Trajectory()
traj.name = "WP"
# Position
traj.x = Veh_init_X
traj.y = Veh_init_Y
traj.z = n
traj.psi = 0
#-3.14/2
# Velocity
traj.xdot = 0
traj.ydot = 0
traj.zdot = 0
traj.psidot = 0
# Acceleration
traj.xddot = 0
traj.yddot = 0
traj.zddot = 0
traj.psiddot = 0
vt = V_veh
else:
#Correction_X = (Xv_init-Des_X)
#Correction_Y = (Yv_init-Des_Y)
if RANGE < 0.008 * R_star:
LOS = R_star
else:
LOS = RANGE
#print LOS
vt = (V_veh *
R_star) / LOS # CHECK IF (V_v) is Working or (V_veh) would work
#if vt > 1.5*V_veh:
# Tar_vel = 0
#else:
# Tar_vel = vt
#print vt
vt = np.convolve(vt, 0.5)
w = vt / a
#=================#
# Trajectory #
#=================#
traj = Trajectory()
traj.name = "TS"
# Position
traj.x = a * cos(phase + w * t) #Correction_X+
traj.y = b * sin(phase + w * t) #Correction_Y+
traj.z = n + c * sin(w * t)
traj.psi = 0
# Velocity
traj.xdot = -a * w * sin(w * t)
traj.ydot = b * w * cos(w * t)
traj.zdot = c * w * cos(w * t)
traj.psidot = 0
# Acceleration
traj.xddot = -a * w * w * cos(w * t)
traj.yddot = -b * w * w * sin(w * t)
traj.zddot = -c * w * w * sin(w * t)
traj.psiddot = 0
#print yy
#Rxy = sqrt((traj.x-xx)*(traj.x-xx)+(traj.y-yy)*(traj.y-yy))
#==================#
# Publish #
#==================#
WP.Obj = [traj]
pub.publish(WP)
pub_vt.publish(vt)
#for all the directories #for all the files in a directory #wordLengthMatrix.py #put matrix in a list for the author #for each author's list of matrices #compute centroid #put each centroid in a list of centroids #for each book #calculate distance between the book and each of the centroids import numpy as np import analysis_functions as af A = np.array([[1, 2], [3, 4]]) B = np.array([[0, 1], [3, 5]]) C = np.array([[1, 3], [6, 10]]) print(af.distance(np.asmatrix(A), np.asmatrix(C))) #print(af.centroid([np.asmatrix(A),np.asmatrix(B),np.asmatrix(C)]))
# In[66]: # Generate equispaced floats in the interval [0, 2*pi] x_train = np.linspace(0, 2*np.pi, N) # Generate noise mean = 0 std = 0.05 # Generate some numbers from the sine function y = np.sin(x_train) # Add noise y += np.random.normal(mean, std, N) #defining it as a matrix y_train = np.asmatrix(y.reshape(N,1)) # # adding the bias and higher order terms to x # In[72]: x = x_train.reshape((N,1)) for i in range(0,poly_order-1): x = np.append(x,(x_train.reshape((N,1)))**(i+2),axis = 1) x = np.asmatrix(x) print(x.shape) # print(x)
def objective(x):
return (np.square(((np.linalg.lstsq(T, self.fkine(x))[0]) -
np.asmatrix(np.eye(4, 4))) * omega)).sum()
def vec_linspace(a, b, num=10):
return np.asmatrix([
np.linspace(a[0, 0], b[0, 0], num=num),
np.linspace(a[0, 1], b[0, 1], num=num),
np.linspace(a[0, 2], b[0, 2], num=num)
])
SHOULDER_LINK = 'shoulder_Link' UPPER_ARM_LINK = 'upperArm_Link' FOREARM_LINK = 'foreArm_Link' WRIST1_LINK = 'wrist1_Link' WRIST2_LINK = 'wrist2_Link' WRIST3_LINK = 'wrist3_Link' # Set end effector constants INITIAL_JOINTS = [0, 0, 0, 0, 0, 0] # Set the number of goal points. 1 by default for a single end effector tip. NUM_EE_POINTS = 1 EE_POINTS = np.array([[0, 0, 0]]) # Specify a goal state in cartesian coordinates. EE_POS_TGT = np.asmatrix([.30, -0.30, .80]) """UR 10 Examples: EE_POS_TGT = np.asmatrix([.29, .52, .62]) # Target where all joints are 0. EE_POS_TGT = np.asmatrix([.65, .80, .30]) # Target in positive octant near ground. EE_POS_TGT = np.asmatrix([.70, .70, .50]) # Target in positive octant used for debugging convergence. The Gazebo sim converges to the above point with non-action costs: (-589.75, -594.71, -599.54, -601.54, -602.75, -603.28, -604.28, -604.79, -605.55, -606.29) Distance from Goal: (0.014, 0.005, -0.017) """ # Set to identity unless you want the goal to have a certain orientation. EE_ROT_TGT = np.asmatrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) # Only edit these when editing the robot joints and links. # The lengths of these arrays define numerous parameters in GPS. JOINT_ORDER = [
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
x_train = np.linspace(-1, 1, 10)
y_train = np.asmatrix([0, 0, 0, 0, 1, 1, 1, 1, 1, 1]).T
x_train = np.asmatrix(x_train).T
n_dim = x_train.shape[1]
lr = tf.constant(0.01, dtype=tf.float32)
num_epochs = 3000
x = tf.placeholder(tf.float32, [x_train.shape[0], n_dim])
y = tf.placeholder(tf.float32, [x_train.shape[0], 1])
w = tf.Variable(np.ones([n_dim, 1]), dtype=tf.float32)
b = tf.Variable(0, dtype=tf.float32)
init = tf.initialize_all_variables()
yhat = (1. / (1 + tf.exp(tf.matmul(x, w) + b)))
loss = tf.reduce_mean(tf.square(yhat - y))
train_op = tf.train.GradientDescentOptimizer(lr).minimize(loss)
sess = tf.Session()
sess.run(init)
loss_history = []
for epoch in range(num_epochs):
sess.run(train_op, feed_dict={x: x_train, y: y_train})
loss_history.append(sess.run(loss, feed_dict={x: x_train, y: y_train}))
def getHomography(histogram, capturePoints, canonicalPoints):
NH = 0
orderIdx = np.argsort(histogram)
bestMarker = orderIdx[len(orderIdx)-1]
secondBestMarker = orderIdx[len(orderIdx)-2]
H1 = None
H2 = None
bestRatio = None
mat_canonical_points1 = None
mat_capture_points1 = None
mat_canonical_points2 = None
mat_capture_points2 = None
#Get RANSCAR homography for the best marker
if histogram[bestMarker] >= 4:
H1 = cv.CreateMat(3, 3, cv.CV_32FC1)
mat_canonical_points1 = cv.CreateMat(len(canonicalPoints[bestMarker]), 3, cv.CV_32FC1)
mat_capture_points1 = cv.CreateMat(len(canonicalPoints[bestMarker]), 3, cv.CV_32FC1)
for i in range(0,len(canonicalPoints[bestMarker])):
mat_canonical_points1[i,0] = canonicalPoints[bestMarker][i][0]
mat_canonical_points1[i,1] = canonicalPoints[bestMarker][i][1]
mat_canonical_points1[i,2] = 1
mat_capture_points1[i,0] = capturePoints[bestMarker][i][0]
mat_capture_points1[i,1] = capturePoints[bestMarker][i][1]
mat_capture_points1[i,2] = 1
cv.FindHomography(mat_canonical_points1, mat_capture_points1, H1, cv.CV_RANSAC, 10)
NH+=1
#Get RANSCAR homography for the second best marker
if histogram[secondBestMarker] >= 4:
H2 = cv.CreateMat(3, 3, cv.CV_32FC1)
mat_canonical_points2 = cv.CreateMat(len(canonicalPoints[secondBestMarker]), 3, cv.CV_32FC1)
mat_capture_points2 = cv.CreateMat(len(canonicalPoints[secondBestMarker]), 3, cv.CV_32FC1)
for i in range(0,len(canonicalPoints[secondBestMarker])):
mat_canonical_points2[i,0] = canonicalPoints[secondBestMarker][i][0]
mat_canonical_points2[i,1] = canonicalPoints[secondBestMarker][i][1]
mat_canonical_points2[i,2] = 1
mat_capture_points2[i,0] = capturePoints[secondBestMarker][i][0]
mat_capture_points2[i,1] = capturePoints[secondBestMarker][i][1]
mat_capture_points2[i,2] = 1
cv.FindHomography(mat_canonical_points2, mat_capture_points2, H2, cv.CV_RANSAC, 10)
NH+=1
THRESHOLD = 10
bestH = None
bestImage = None
if(H1!=None):
##Calculare outliner and inliners for H1
i1 = 0.
o1 = 0.
H1np = np.asarray(H1)
for i in range(0,len(canonicalPoints[bestMarker])):
tempPoint = np.dot(H1np,np.asmatrix(mat_canonical_points1[i]).T)
dist = euclidDist([tempPoint[0]/tempPoint[2],tempPoint[1]/tempPoint[2]], capturePoints[bestMarker][i])
if dist < THRESHOLD:
i1+=1.
else:
o1+=1.
if(H2!=None):
##Calculte outliners and inliners for H2
i2 = 0.
o2 = 0.
H2np = np.asarray(H2)
for i in range(0,len(canonicalPoints[secondBestMarker])):
tempPoint = np.dot(H2np,np.asmatrix(mat_canonical_points2[i]).T)
dist = euclidDist([tempPoint[0]/tempPoint[2],tempPoint[1]/tempPoint[2]], capturePoints[secondBestMarker][i])
if dist < THRESHOLD:
i2+=1.
else:
o2+=1.
#print "I/0: "+str(i1)+", "+str(o1)+", "+str(i2)+", "+str(o2)
#Compare ratios of inliers and outliers
if(i1/(i1+o1) < i2/(i2+o2)):
bestH = H2
bestImage = secondBestMarker
bestRatio = i1/(i1+o1)
else:
bestH = H1
bestImage = bestMarker
bestRatio = i2/(i2+o2)
if H1 !=None and H2 == None:
bestH = H1
bestImage = bestMarker
bestRatio = i1/(i1+o1)
return bestH, bestImage, NH, bestRatio
def _tracemin_fiedler(L, X, normalized, tol, method):
"""Compute the Fiedler vector of L using the TraceMIN-Fiedler algorithm.
"""
n = X.shape[0]
if normalized:
# Form the normalized Laplacian matrix and determine the eigenvector of
# its nullspace.
e = sqrt(L.diagonal())
D = spdiags(1. / e, [0], n, n, format='csr')
L = D * L * D
e *= 1. / norm(e, 2)
if not normalized:
def project(X):
"""Make X orthogonal to the nullspace of L.
"""
X = asarray(X)
for j in range(X.shape[1]):
X[:, j] -= X[:, j].sum() / n
else:
def project(X):
"""Make X orthogonal to the nullspace of L.
"""
X = asarray(X)
for j in range(X.shape[1]):
X[:, j] -= dot(X[:, j], e) * e
if method is None:
method = 'pcg'
if method == 'pcg':
# See comments below for the semantics of P and D.
def P(x):
x -= asarray(x * X * X.T)[0, :]
if not normalized:
x -= x.sum() / n
else:
x = daxpy(e, x, a=-ddot(x, e))
return x
solver = _PCGSolver(lambda x: P(L * P(x)), lambda x: D * x)
elif method == 'chol' or method == 'lu':
# Convert A to CSC to suppress SparseEfficiencyWarning.
A = csc_matrix(L, dtype=float, copy=True)
# Force A to be nonsingular. Since A is the Laplacian matrix of a
# connected graph, its rank deficiency is one, and thus one diagonal
# element needs to modified. Changing to infinity forces a zero in the
# corresponding element in the solution.
i = (A.indptr[1:] - A.indptr[:-1]).argmax()
A[i, i] = float('inf')
solver = (_CholeskySolver if method == 'chol' else _LUSolver)(A)
else:
raise nx.NetworkXError('unknown linear system solver.')
# Initialize.
Lnorm = abs(L).sum(axis=1).flatten().max()
project(X)
W = asmatrix(ndarray(X.shape, order='F'))
while True:
# Orthonormalize X.
X = qr(X)[0]
# Compute interation matrix H.
W[:, :] = L * X
H = X.T * W
sigma, Y = eigh(H, overwrite_a=True)
# Compute the Ritz vectors.
X *= Y
# Test for convergence exploiting the fact that L * X == W * Y.
res = dasum(W * asmatrix(Y)[:, 0] - sigma[0] * X[:, 0]) / Lnorm
if res < tol:
break
# Depending on the linear solver to be used, two mathematically
# equivalent formulations are used.
if method == 'pcg':
# Compute X = X - (P * L * P) \ (P * L * X) where
# P = I - [e X] * [e X]' is a projection onto the orthogonal
# complement of [e X].
W *= Y # L * X == W * Y
W -= (W.T * X * X.T).T
project(W)
# Compute the diagonal of P * L * P as a Jacobi preconditioner.
D = L.diagonal().astype(float)
D += 2. * (asarray(X) * asarray(W)).sum(axis=1)
D += (asarray(X) * asarray(X * (W.T * X))).sum(axis=1)
D[D < tol * Lnorm] = 1.
D = 1. / D
# Since TraceMIN is globally convergent, the relative residual can
# be loose.
X -= solver.solve(W, 0.1)
else:
# Compute X = L \ X / (X' * (L \ X)). L \ X can have an arbitrary
# projection on the nullspace of L, which will be eliminated.
W[:, :] = solver.solve(X)
project(W)
X = (inv(W.T * X) * W.T).T # Preserves Fortran storage order.
return sigma, asarray(X)
def test_boolean_indexing(self):
A = np.arange(6)
A.shape = (3, 2)
x = asmatrix(A)
assert_array_equal(x[:, np.array([True, False])], x[:, 0])
assert_array_equal(x[np.array([True, False, False]),:], x[0,:])
def main(env_name, seed=1, run_name=None):
# Read hyperparameters
try:
globals().update(config_env[env_name])
except KeyError as e:
print()
print('\033[93m No hyperparameters defined for \"' + env_name + '\". Using default one.\033[0m')
print()
pass
# Init environment
env = gym.make(env_name)
if filter_env:
env = make_filtered_env(env)
# Init seeds
seed = int(seed)
np.random.seed(seed)
tf.set_random_seed(seed)
env.seed(seed)
config_tf = tf.ConfigProto()
config_tf.gpu_options.allow_growth=True
session = tf.Session(config=config_tf)
# Init placeholders
obs_size = env.observation_space.shape[0]
act_size = env.action_space.shape[0]
obs = tf.placeholder(dtype=precision, shape=[None, obs_size], name='obs')
# Build pi
act_bound = np.asscalar(env.action_space.high[0])
assert act_bound == -np.asscalar(env.action_space.low[0])
mean = MLP([obs], pi_sizes+[act_size], pi_activations+[None], 'pi_mean')
with tf.variable_scope('pi_std'): std = tf.Variable(std_noise * tf.ones([1, act_size], dtype=precision), dtype=precision)
pi = MVNPolicy(session, obs, mean.output[0], std, act_bound=act_bound)
# Build V
v = MLP([obs], v_sizes+[1], v_activations+[None], 'v')
# V optimization
target_v = tf.placeholder(dtype=precision, shape=[None, 1], name='target_v')
loss_v = tf.losses.mean_squared_error(v.output[0], target_v)
optimize_v = tf.train.AdamOptimizer(lrate_v).minimize(loss_v)
# pi optimization
advantage = tf.placeholder(dtype=precision, shape=[None, 1], name='advantage')
td_reg = tf.placeholder(dtype=precision, shape=[None, 1], name='td_reg')
old_log_probs = tf.placeholder(dtype=precision, shape=[None, 1], name='old_log_probs')
prob_ratio = tf.exp(pi.log_prob - old_log_probs)
clip_pr = tf.clip_by_value(prob_ratio, 1.-e_clip, 1.+e_clip)
alpha = tf.placeholder(dtype=precision, name='alpha') # TD-regularization coefficient
loss_pi = -tf.reduce_mean(tf.minimum(tf.multiply(prob_ratio, advantage), tf.multiply(clip_pr, advantage))) + tf.reduce_mean(tf.maximum(tf.multiply(prob_ratio, alpha*td_reg), tf.multiply(clip_pr, alpha*td_reg)))
optimize_pi = tf.train.AdamOptimizer(lrate_pi).minimize(loss_pi)
# Init variables
session.run(tf.global_variables_initializer())
mean.reset(session, 0.)
v.reset(session, 0.)
alpha_value = 0.1
alpha_decay = 0.99999
logger = LoggerData('ppo_tdreg_' + str(alpha_value) + '_' + str(alpha_decay), env_name, run_name)
print()
print(' V LOSS PI LOSS ENTROPY RETURN MSTDE')
for itr in range(maxiter):
paths = collect_samples(env, policy=pi.draw_action, min_trans=min_trans_per_iter)
nb_trans = len(paths["rwd"])
# Update V
for epoch in range(epochs_v):
v_values = session.run(v.output[0], {obs: paths["obs"]})
a_values = gae(paths, v_values, gamma, lambda_trace) # compute the advantage
target_values = v_values + a_values # generalized Bellman operator
if epoch == 0:
v_loss_before = session.run(loss_v, {obs: paths["obs"], target_v: target_values})
for batch_idx in minibatch_idx_list(batch_size, nb_trans):
session.run(optimize_v, {obs: paths["obs"][batch_idx], target_v: target_values[batch_idx]})
v_loss_after = session.run(loss_v, {obs: paths["obs"], target_v: target_values})
# Estimate advantages and TD error
v_values = session.run(v.output[0], {obs: paths["obs"]})
a_values = gae(paths, v_values, gamma, lambda_trace)
td_values = gae(paths, v_values, gamma, 0)
mstde = np.mean(td_values**2)
a_values = (a_values - np.mean(a_values)) / np.std(a_values)
td_values = (td_values - np.mean(td_values)) / np.std(td_values)
reg_values = td_values**2
reg_values = (reg_values - np.mean(reg_values)) / np.std(reg_values)
# Udpate pi
old_lp = pi.get_log_prob(paths["obs"], paths["act"])
pi_loss_before = session.run(loss_pi, {obs: paths["obs"], pi.act: paths["act"], old_log_probs: old_lp, advantage: a_values, alpha: alpha_value, td_reg: reg_values})
for epoch in range(epochs_pi):
for batch_idx in minibatch_idx_list(batch_size, nb_trans):
dct_pi = {obs: paths["obs"][batch_idx],
pi.act: paths["act"][batch_idx],
old_log_probs: old_lp[batch_idx],
advantage: a_values[batch_idx],
td_reg: reg_values[batch_idx],
alpha: alpha_value}
session.run(optimize_pi, dct_pi)
pi_loss_after = session.run(loss_pi, {obs: paths["obs"], pi.act: paths["act"], old_log_probs: old_lp, advantage: a_values, alpha: alpha_value, td_reg: reg_values})
alpha_value *= alpha_decay
# Evaluate pi
# avg_rwd = evaluate_policy(env, policy=pi.draw_action_det, min_paths=paths_eval)
avg_rwd = np.sum(paths["rwd"]) / paths["nb_paths"]
entr = pi.estimate_entropy(paths["obs"])
print('%d | %e -> %e %e -> %e %e %e %e ' % (itr, v_loss_before, v_loss_after, pi_loss_before, pi_loss_after, entr, avg_rwd, mstde), flush=True)
with open(logger.fullname, 'ab') as f:
np.savetxt(f, np.asmatrix([v_loss_before, v_loss_after, pi_loss_before, pi_loss_after, entr, avg_rwd, mstde])) # save data
def test_scalar_indexing(self):
x = asmatrix(np.zeros((3, 2), float))
assert_equal(x[0, 0], x[0][0])
def test_list_indexing(self):
A = np.arange(6)
A.shape = (3, 2)
x = asmatrix(A)
assert_array_equal(x[:, [1, 0]], x[:, ::-1])
assert_array_equal(x[[2, 1, 0],:], x[::-1,:])
def test_asmatrix(self):
A = np.arange(100).reshape(10, 10)
mA = asmatrix(A)
A[0, 0] = -10
assert_(A[0, 0] == mA[0, 0])
def test_row_column_indexing(self):
x = asmatrix(np.eye(2))
assert_array_equal(x[0,:], [[1, 0]])
assert_array_equal(x[1,:], [[0, 1]])
assert_array_equal(x[:, 0], [[1], [0]])
assert_array_equal(x[:, 1], [[0], [1]])
def to_dense(self):
t = self.contract_tags(...)
t.fuse([('k', list(map(self.site_ind_id.format, self.sites)))],
inplace=True)
return np.asmatrix(t.data.reshape(-1, 1))
def test_basic(self):
x = asmatrix(np.zeros((3, 2), float))
y = np.zeros((3, 1), float)
y[:, 0] = [0.8, 0.2, 0.3]
x[:, 1] = y > 0.5
assert_equal(x, [[0, 1], [0, 0], [0, 0]])
def main():
lqr.init()
clock = pygame.time.Clock()
pos = np.asmatrix([0., 1., 0.]).T
vel = np.asmatrix([3., 0., 3.]).T
visualizer = vis.Visualizer()
fps = 60
dt = 1.0 / fps
t = 0.0
i = 0
maxon_motor = motor.Motor(
resistance=1.03,
torque_constant=0.0335,
speed_constant=0.0335,
rotor_inertia=135*1e-3*(1e-2**2))
gearbox = motor.Gearbox(gear_ratio=20.0 / 60.0, gear_inertia=0)
gear_motor = motor.GearMotor(maxon_motor, gearbox)
our_robot = robot.Robot(
robot_mass=6.5,
robot_radius=0.085,
gear_motor=gear_motor,
robot_inertia=6.5*0.085*0.085*0.5,
wheel_radius=0.029,
wheel_inertia=2.4e-5,
wheel_angles = np.deg2rad([45, 135, -135, -45]))
# wheel_angles=np.deg2rad([60, 129, -129, -60]))
controller = Controller(dt, our_robot)
while not visualizer.close:
visualizer.update_events()
v = 3
rx = np.asmatrix([np.sin(v * t), np.cos(v * t / 3), v * np.sin(t)]).T
rv = v * np.asmatrix([np.cos(v * t), -np.sin(v * t / 3) / 3, np.cos(t)]).T
ra = v ** 2 * np.asmatrix([-np.sin(v * t), -np.cos(v * t / 3) / 9, -np.sin(t) / v]).T
vel_b = np.linalg.inv(rotation_matrix(pos[2,0])) * vel
rv_b = np.linalg.inv(rotation_matrix(pos[2,0])) * rv
rx_b = np.linalg.inv(rotation_matrix(pos[2,0])) * rx
pos_b = np.linalg.inv(rotation_matrix(pos[2,0])) * pos
# u = controller.feedforward_control(pos, vel, rx, rv, ra)
state_vector = np.vstack((rx_b-pos_b,rv_b-vel_b))
u = lqr.controlLQR(state_vector) # +=
u = u[2:,0]
# u = controller.control(pos, vel, rx, rv, ra)
vdot_b = our_robot.forward_dynamics_body(vel_b, u)
vdot = our_robot.forward_dynamics_world(pos, vel, u)
# print(u - our_robot.inverse_dynamics_body(vel_b, vdot_b))
robot.sysID(u[0,0], u[1,0], u[2,0], u[3,0], vel_b[0,0], vel_b[1,0], vel_b[2,0], vdot_b[0,0], vdot_b[1,0], vdot_b[2,0])
visualizer.draw(pos, rx)
pos += dt * vel + 0.5 * vdot * dt ** 2
vel += dt * vdot
# robot_data_line = [vdot_b[0,0], vdot_b[1,0], vdot_b[2,0], vel_b[0,0], vel_b[1,0], vel_b[2,0], u[0,0], u[1,0], u[2,0], u[3,0]]
# robot_data.append(robot_data_line)
clock.tick(60)
t += dt
i += 1
if t > 20:
print("t = 20")
t = 0.0
i = 0
pos = np.asmatrix([0, 1, 0.]).T
vel = np.asmatrix([3, 0, 3.]).T
controller.reset()
robot.main()
def to_dense(self):
t = self.TN.contract_tags(...)
t.fuse([('k', list(map(self.lower_ind_id.format, self.TN.sites))),
('b', list(map(self.upper_ind_id.format, self.TN.sites)))],
inplace=True)
return np.asmatrix(t.data)
def test_PCA():
'''(10 points) PCA'''
#-------------------------------
# an example matrix
#X = np.random.random((100,10)) # generate an N = 100, D = 10 random data matrix
X = np.mat([[0., 2.],
[2., 0.],
[1., 1.]])
# call the function
Xp, P = PCA(X)
assert type(P) == np.matrixlib.defmatrix.matrix
assert type(Xp) == np.matrixlib.defmatrix.matrix
assert Xp.shape ==(3,1)
assert P.shape ==(2,1)
P_true = np.mat([[ .707],
[-.707]])
Xp_true = np.mat([[-1.414],
[ 1.414],
[ 0 ]])
# test the result
assert np.allclose(P,P_true, atol=1e-2) or np.allclose(P,-P_true, atol=1e-2)
assert np.allclose(Xp, Xp_true, atol=1e-2) or np.allclose(Xp, -Xp_true, atol=1e-2)
#-------------------------------
# an example matrix
X = np.mat([[0., 2., 2.],
[2., 0., 0]])
# call the function
Xp, P = PCA(X)
assert Xp.shape ==(2,1)
assert P.shape ==(3,1)
# test the result
P_true = np.mat([[ .577],
[-.577],
[-.577]])
Xp_true = np.mat([[-1.73205081],
[ 1.73205081]])
assert np.allclose(P,P_true, atol=1e-2) or np.allclose(P,-P_true, atol=1e-2)
assert np.allclose(Xp,Xp_true, atol=1e-2) or np.allclose(Xp,-Xp_true, atol=1e-2)
#-------------------------------
# an example matrix
#X = np.random.random((100,10)) # generate an N = 100, D = 10 random data matrix
X = np.mat([[2., 2.],
[0., 0]])
# call the function
Xp, P = PCA(X,2)
assert Xp.shape ==(2,2)
assert P.shape ==(2,2)
P_true = np.mat([[.707, -.707],
[.707, .707]])
Xp_true = np.mat([[ 1.414, 0],
[-1.414, 0]])
assert np.allclose(P,P_true, atol=1e-2) or np.allclose(P,-P_true, atol=1e-2)
assert np.allclose(Xp,Xp_true, atol=1e-2) or np.allclose(Xp,-Xp_true, atol=1e-2)
#-------------------------------
# test on random matrix
for _ in range(20):
n = np.random.randint(3,40)
p = np.random.randint(3,40)
k = np.random.randint(p-1)+1
X = np.random.random((n,p))
X = np.asmatrix(X)
# call the function
Xp, P = PCA(X,k)
# test the result
assert Xp.shape == (n,k)
assert P.shape == (p,k)
def to_numpy_matrix(G,
nodelist=None,
dtype=None,
order=None,
multigraph_weight=sum,
weight='weight'):
"""Return the graph adjacency matrix as a NumPy matrix.
Parameters
----------
G : graph
The NetworkX graph used to construct the NumPy matrix.
nodelist : list, optional
The rows and columns are ordered according to the nodes in `nodelist`.
If `nodelist` is None, then the ordering is produced by G.nodes().
dtype : NumPy data type, optional
A valid single NumPy data type used to initialize the array.
This must be a simple type such as int or numpy.float64 and
not a compound data type (see to_numpy_recarray)
If None, then the NumPy default is used.
order : {'C', 'F'}, optional
Whether to store multidimensional data in C- or Fortran-contiguous
(row- or column-wise) order in memory. If None, then the NumPy default
is used.
multigraph_weight : {sum, min, max}, optional
An operator that determines how weights in multigraphs are handled.
The default is to sum the weights of the multiple edges.
weight : string or None optional (default='weight')
The edge attribute that holds the numerical value used for
the edge weight. If None then all edge weights are 1.
Returns
-------
M : NumPy matrix
Graph adjacency matrix.
See Also
--------
to_numpy_recarray, from_numpy_matrix
Notes
-----
The matrix entries are assigned with weight edge attribute. When
an edge does not have the weight attribute, the value of the entry is 1.
For multiple edges, the values of the entries are the sums of the edge
attributes for each edge.
When `nodelist` does not contain every node in `G`, the matrix is built
from the subgraph of `G` that is induced by the nodes in `nodelist`.
Examples
--------
>>> G = nx.MultiDiGraph()
>>> G.add_edge(0,1,weight=2)
>>> G.add_edge(1,0)
>>> G.add_edge(2,2,weight=3)
>>> G.add_edge(2,2)
>>> nx.to_numpy_matrix(G, nodelist=[0,1,2])
matrix([[ 0., 2., 0.],
[ 1., 0., 0.],
[ 0., 0., 4.]])
"""
try:
import numpy as np
except ImportError:
raise ImportError(\
"to_numpy_matrix() requires numpy: http://scipy.org/ ")
if nodelist is None:
nodelist = G.nodes()
nodeset = set(nodelist)
if len(nodelist) != len(nodeset):
msg = "Ambiguous ordering: `nodelist` contained duplicates."
raise nx.NetworkXError(msg)
nlen = len(nodelist)
undirected = not G.is_directed()
index = dict(zip(nodelist, range(nlen)))
if G.is_multigraph():
# Handle MultiGraphs and MultiDiGraphs
# array of nan' to start with, any leftover nans will be converted to 0
# nans are used so we can use sum, min, max for multigraphs
M = np.zeros((nlen, nlen), dtype=dtype, order=order) + np.nan
# use numpy nan-aware operations
operator = {sum: np.nansum, min: np.nanmin, max: np.nanmax}
try:
op = operator[multigraph_weight]
except:
raise ValueError('multigraph_weight must be sum, min, or max')
for u, v, attrs in G.edges_iter(data=True):
if (u in nodeset) and (v in nodeset):
i, j = index[u], index[v]
e_weight = attrs.get(weight, 1)
M[i, j] = op([e_weight, M[i, j]])
if undirected:
M[j, i] = M[i, j]
# convert any nans to zeros
M = np.asmatrix(np.nan_to_num(M))
else:
# Graph or DiGraph, this is much faster than above
M = np.zeros((nlen, nlen), dtype=dtype, order=order)
for u, nbrdict in G.adjacency_iter():
for v, d in nbrdict.items():
try:
M[index[u], index[v]] = d.get(weight, 1)
except KeyError:
pass
M = np.asmatrix(M)
return M
def __init__(self, W1, W2, b1, b2):
self.W1 = np.asmatrix(W1)
self.W2 = np.asmatrix(W2)
self.b1 = b1
self.b2 = b2
"/home/emily2h/Summer/cg-abstracts/data_encompassing/ar/ar_{}{}1".
format(flag2, flag), "rb") as f:
label1 = pickle.load(f)
with open(
"/home/emily2h/Summer/cg-abstracts/data_encompassing/ar/ar_{}{}2".
format(flag2, flag), "rb") as f:
label2 = pickle.load(f)
with open(
"/home/emily2h/Summer/cg-abstracts/data_encompassing/ar/ar_{}{}3".
format(flag2, flag), "rb") as f:
label3 = pickle.load(f)
with open(
"/home/emily2h/Summer/cg-abstracts/data_encompassing/ar/ar_{}{}4".
format(flag2, flag), "rb") as f:
label4 = pickle.load(f)
print(label0.shape, label1.shape, label2.shape, label3.shape, label4.shape)
mat = np.asmatrix([label0, label1, label2, label3, label4]).transpose()
print(mat)
matfunc = np.vectorize(func)
mat = matfunc(mat)
print(mat.shape)
print(type(mat))
print(mat)
pickling_on = open(
"data_encompassing/label_mat_{}/label_mat_{}{}.pickle".format(
flag, flag2, flag), "wb")
pickle.dump(mat, pickling_on)
def goal(t):
return np.asmatrix([0., 300.]).T
def Cart2Pixel(Q=None,
A=None,
B=None,
dynamic_size=False,
mutual_info=False,
only_model=False,
params=None):
# TODO controls on input
if A is not None:
A = A - 1
if (B != None):
B = B - 1
# to dataframe
feat_cols = ["col-" + str(i + 1) for i in range(Q["data"].shape[1])]
df = pd.DataFrame(Q["data"], columns=feat_cols)
if Q["method"] == 'pca':
pca = PCA(n_components=2)
Y = pca.fit_transform(df)
elif Q["method"] == 'tSNE':
tsne = TSNE(n_components=2, method="exact")
Y = tsne.fit_transform(df)
elif Q["method"] == 'kpca':
kpca = KernelPCA(n_components=2, kernel='linear')
Y = kpca.fit_transform(df)
x = Y[:, 0]
y = Y[:, 1]
n, n_sample = Q["data"].shape
plt.scatter(x, y)
bbox = minimum_bounding_rectangle(Y)
plt.fill(bbox[:, 0], bbox[:, 1], alpha=0.2)
# rotation
grad = (bbox[1, 1] - bbox[0, 1]) / (bbox[1, 0] - bbox[0, 0])
theta = np.arctan(grad)
R = np.asmatrix([[np.cos(theta), np.sin(theta)],
[-np.sin(theta), np.cos(theta)]])
bboxMatrix = np.matrix(bbox)
zrect = (R.dot(bboxMatrix.transpose())).transpose()
# zrect=R.dot(bboxMatrix)
plt.fill(zrect[:, 0], zrect[:, 1], alpha=0.2)
coord = np.array([x, y])
rotatedData = np.array(R.dot(coord)) # Z
# rotatedData = np.delete(rotatedData, [59], 1)
# rotatedData=np.delete(rotatedData, [175],1)
# rotatedData=np.delete(rotatedData, [184],1)
# Q["data"] = np.delete(Q["data"], [59], axis=0)
# Q["data"] = np.delete(Q["data"], [175], axis=0)
# Q["data"] = np.delete(Q["data"], [184], axis=0)
# n = n - 1
plt.scatter(rotatedData[0, :], rotatedData[1:])
plt.axis('square')
plt.show(block=False)
# find duplicate
for i in range(len(rotatedData[0, :])):
for j in range(i + 1, len(rotatedData[0])):
if rotatedData[0, i] == rotatedData[0, j] and rotatedData[
1, i] == rotatedData[1, j]:
print("duplicate:" + str(i) + " " + str(j))
# nearest point
min_dist = np.inf
min_p1 = 0
min_p2 = 0
for p1 in range(n):
for p2 in range(p1 + 1, n):
d = (rotatedData[0, p1] - rotatedData[0, p2])**2 + (
rotatedData[1, p1] - rotatedData[1, p2])**2
if min_dist > d > 0 and p1 != p2:
min_p1 = p1
min_p2 = p2
min_dist = d
# plt.scatter([rotatedData[0, min_p1], rotatedData[0, min_p2]], [rotatedData[1, min_p1], rotatedData[1, min_p2]])
# plt.show(block=False)
# euclidean distance
dmin = np.linalg.norm(rotatedData[:, min_p1] - rotatedData[:, min_p2])
rec_x_axis = abs(zrect[0, 0] - zrect[1, 0])
rec_y_axis = abs(zrect[1, 1] - zrect[2, 1])
if only_model:
count_model_col(rotatedData, Q, 5, 50, params)
if dynamic_size:
precision_old = math.sqrt(2)
A = math.ceil(rec_x_axis * precision_old / dmin)
B = math.ceil(rec_y_axis * precision_old / dmin)
print("Dynamic [A:" + str(A) + " ; B:" + str(B) + "]")
if A > Q["max_A_size"] or B > Q["max_B_size"]:
# precision = precision_old * Q["max_px_size"] / max([A, B])
precision = precision_old * (Q["max_A_size"] /
A) * (Q["max_B_size"] / B)
A = math.ceil(rec_x_axis * precision / dmin)
B = math.ceil(rec_y_axis * precision / dmin)
# cartesian coordinates to pixels
tot = []
xp = np.round(1 + (A * (rotatedData[0, :] - min(rotatedData[0, :])) /
(max(rotatedData[0, :]) - min(rotatedData[0, :]))))
yp = np.round(1 + (-B) * (rotatedData[1, :] - max(rotatedData[1, :])) /
(max(rotatedData[1, :]) - min(rotatedData[1, :])))
# Modified Feature Position | custom cut
cut = params["cut"]
if cut is not None:
xp[59] = cut
zp = np.array([xp, yp])
A = max(xp)
B = max(yp)
# find duplicates
print("Collisioni: " + str(find_duplicate(zp)))
# Training set
images = []
toDelete = 0
name = "_" + str(int(A)) + 'x' + str(int(B))
if params["No_0_MI"]:
name = name + "_No_0_MI"
if mutual_info:
Q["data"], zp, toDelete = dataset_with_best_duplicates(
Q["data"], Q["y"], zp)
name = name + "_MI"
else:
name = name + "_Mean"
if cut is not None:
name = name + "_Cut" + str(cut)
# save model to file
image_model = {
"xp": zp[0].tolist(),
"yp": zp[1].tolist(),
"A": A,
"B": B,
"custom_cut": cut,
"toDelete": toDelete
}
j = json.dumps(image_model)
f = open(params["dir"] + "model" + name + ".json", "w")
f.write(j)
f.close()
if only_model:
a = ConvPixel(Q["data"][:, 0], zp[0], zp[1], A, B)
plt.imshow(a, cmap="gray")
plt.show()
else: # custom_cut=range(0, cut),
a = ConvPixel(Q["data"][:, i], zp[0], zp[1], A, B, index=i)
plt.imshow(a, cmap="gray")
plt.show()
if cut is not None:
images = [
ConvPixel(Q["data"][:, i],
zp[0],
zp[1],
A,
B,
custom_cut=cut - 1,
index=i) for i in range(0, n_sample)
]
else:
# a=np.where(Q["y"]==0)
# attacks=Q["data"][:,a]
for i in range(0, 3):
images = [
ConvPixel(Q["data"][:, i], zp[0], zp[1], A, B, index=i)
for i in range(0, n_sample)
]
filename = params["dir"] + "train" + name + ".pickle"
f_myfile = open(filename, 'wb')
pickle.dump(images, f_myfile)
f_myfile.close()
return images, image_model, toDelete
A_d, B_d, Q_d, R_d = c2d(A_c, B_c, dt, Q_noise, R_noise)
K = clqr(A_c, B_c, Q_controller, R_controller)
Kff = feedforwards(A_d, B_d, Q_ff)
L = place(A_d.T, C.T, [0.05, 0.12]).T
gains = StateSpaceGains(name, dt, A_d, B_d, C, None, Q_d, R_noise, K, Kff,
L)
gains.A_c = A_c
gains.B_c = B_c
gains.Q_c = Q_noise
return gains
u_max = np.asmatrix([12.]).T
x0 = np.asmatrix([0., 0.]).T
gains = make_gains()
plant = StateSpacePlant(gains, x0)
controller = StateSpaceController(gains, -u_max, u_max)
observer = StateSpaceObserver(gains, x0)
def goal(t):
return np.asmatrix([0., 300.]).T
if __name__ == '__main__':
if len(sys.argv) == 3:
def removeInterference(self,
interf=2,
hei_interf=None,
nhei_interf=None,
offhei_interf=None):
jspectra = self.dataOut.data_spc
jcspectra = self.dataOut.data_cspc
jnoise = self.dataOut.getNoise()
num_incoh = self.dataOut.nIncohInt
num_channel = jspectra.shape[0]
num_prof = jspectra.shape[1]
num_hei = jspectra.shape[2]
# hei_interf
if hei_interf is None:
count_hei = int(num_hei / 2)
hei_interf = numpy.asmatrix(list(
range(count_hei))) + num_hei - count_hei
hei_interf = numpy.asarray(hei_interf)[0]
# nhei_interf
if (nhei_interf == None):
nhei_interf = 5
if (nhei_interf < 1):
nhei_interf = 1
if (nhei_interf > count_hei):
nhei_interf = count_hei
if (offhei_interf == None):
offhei_interf = 0
ind_hei = list(range(num_hei))
# mask_prof = numpy.asarray(range(num_prof - 2)) + 1
# mask_prof[range(num_prof/2 - 1,len(mask_prof))] += 1
mask_prof = numpy.asarray(list(range(num_prof)))
num_mask_prof = mask_prof.size
comp_mask_prof = [0, num_prof / 2]
# noise_exist: Determina si la variable jnoise ha sido definida y contiene la informacion del ruido de cada canal
if (jnoise.size < num_channel or numpy.isnan(jnoise).any()):
jnoise = numpy.nan
noise_exist = jnoise[0] < numpy.Inf
# Subrutina de Remocion de la Interferencia
for ich in range(num_channel):
# Se ordena los espectros segun su potencia (menor a mayor)
power = jspectra[ich, mask_prof, :]
power = power[:, hei_interf]
power = power.sum(axis=0)
psort = power.ravel().argsort()
# Se estima la interferencia promedio en los Espectros de Potencia empleando
junkspc_interf = jspectra[ich, :, hei_interf[psort[list(
range(offhei_interf, nhei_interf + offhei_interf))]]]
if noise_exist:
# tmp_noise = jnoise[ich] / num_prof
tmp_noise = jnoise[ich]
junkspc_interf = junkspc_interf - tmp_noise
#junkspc_interf[:,comp_mask_prof] = 0
jspc_interf = junkspc_interf.sum(axis=0) / nhei_interf
jspc_interf = jspc_interf.transpose()
# Calculando el espectro de interferencia promedio
noiseid = numpy.where(
jspc_interf <= tmp_noise / numpy.sqrt(num_incoh))
noiseid = noiseid[0]
cnoiseid = noiseid.size
interfid = numpy.where(
jspc_interf > tmp_noise / numpy.sqrt(num_incoh))
interfid = interfid[0]
cinterfid = interfid.size
if (cnoiseid > 0):
jspc_interf[noiseid] = 0
# Expandiendo los perfiles a limpiar
if (cinterfid > 0):
new_interfid = (numpy.r_[interfid - 1, interfid, interfid + 1]
+ num_prof) % num_prof
new_interfid = numpy.asarray(new_interfid)
new_interfid = {x for x in new_interfid}
new_interfid = numpy.array(list(new_interfid))
new_cinterfid = new_interfid.size
else:
new_cinterfid = 0
for ip in range(new_cinterfid):
ind = junkspc_interf[:, new_interfid[ip]].ravel().argsort()
jspc_interf[new_interfid[ip]] = junkspc_interf[
ind[nhei_interf // 2], new_interfid[ip]]
jspectra[ich, :, ind_hei] = jspectra[
ich, :, ind_hei] - jspc_interf # Corregir indices
# Removiendo la interferencia del punto de mayor interferencia
ListAux = jspc_interf[mask_prof].tolist()
maxid = ListAux.index(max(ListAux))
if cinterfid > 0:
for ip in range(cinterfid * (interf == 2) - 1):
ind = (jspectra[ich, interfid[ip], :] < tmp_noise *
(1 + 1 / numpy.sqrt(num_incoh))).nonzero()
cind = len(ind)
if (cind > 0):
jspectra[ich, interfid[ip], ind] = tmp_noise * \
(1 + (numpy.random.uniform(cind) - 0.5) /
numpy.sqrt(num_incoh))
ind = numpy.array([-2, -1, 1, 2])
xx = numpy.zeros([4, 4])
for id1 in range(4):
xx[:, id1] = ind[id1]**numpy.asarray(list(range(4)))
xx_inv = numpy.linalg.inv(xx)
xx = xx_inv[:, 0]
ind = (ind + maxid + num_mask_prof) % num_mask_prof
yy = jspectra[ich, mask_prof[ind], :]
jspectra[ich,
mask_prof[maxid], :] = numpy.dot(yy.transpose(), xx)
indAux = (jspectra[ich, :, :] < tmp_noise *
(1 - 1 / numpy.sqrt(num_incoh))).nonzero()
jspectra[ich, indAux[0], indAux[1]] = tmp_noise * \
(1 - 1 / numpy.sqrt(num_incoh))
# Remocion de Interferencia en el Cross Spectra
if jcspectra is None:
return jspectra, jcspectra
num_pairs = int(jcspectra.size / (num_prof * num_hei))
jcspectra = jcspectra.reshape(num_pairs, num_prof, num_hei)
for ip in range(num_pairs):
#-------------------------------------------
cspower = numpy.abs(jcspectra[ip, mask_prof, :])
cspower = cspower[:, hei_interf]
cspower = cspower.sum(axis=0)
cspsort = cspower.ravel().argsort()
junkcspc_interf = jcspectra[ip, :, hei_interf[cspsort[list(
range(offhei_interf, nhei_interf + offhei_interf))]]]
junkcspc_interf = junkcspc_interf.transpose()
jcspc_interf = junkcspc_interf.sum(axis=1) / nhei_interf
ind = numpy.abs(jcspc_interf[mask_prof]).ravel().argsort()
median_real = int(
numpy.median(
numpy.real(junkcspc_interf[
mask_prof[ind[list(range(3 * num_prof // 4))]], :])))
median_imag = int(
numpy.median(
numpy.imag(junkcspc_interf[
mask_prof[ind[list(range(3 * num_prof // 4))]], :])))
comp_mask_prof = [int(e) for e in comp_mask_prof]
junkcspc_interf[comp_mask_prof, :] = numpy.complex(
median_real, median_imag)
for iprof in range(num_prof):
ind = numpy.abs(junkcspc_interf[iprof, :]).ravel().argsort()
jcspc_interf[iprof] = junkcspc_interf[iprof,
ind[nhei_interf // 2]]
# Removiendo la Interferencia
jcspectra[ip, :,
ind_hei] = jcspectra[ip, :, ind_hei] - jcspc_interf
ListAux = numpy.abs(jcspc_interf[mask_prof]).tolist()
maxid = ListAux.index(max(ListAux))
ind = numpy.array([-2, -1, 1, 2])
xx = numpy.zeros([4, 4])
for id1 in range(4):
xx[:, id1] = ind[id1]**numpy.asarray(list(range(4)))
xx_inv = numpy.linalg.inv(xx)
xx = xx_inv[:, 0]
ind = (ind + maxid + num_mask_prof) % num_mask_prof
yy = jcspectra[ip, mask_prof[ind], :]
jcspectra[ip, mask_prof[maxid], :] = numpy.dot(yy.transpose(), xx)
# Guardar Resultados
self.dataOut.data_spc = jspectra
self.dataOut.data_cspc = jcspectra
return 1
if __name__ == "__main__":
if len(sys.argv) !=2:
print >> sys.stderr, "Usage: linreg <datafile>"
exit(-1)
sc = SparkContext(appName="LinearRegression")
# Input yx file has y_i as the first element of each line
# and the remaining elements constitute x_i
yxinputFile = sc.textFile(sys.argv[1])
yxlines = yxinputFile.map(lambda line: line.split(','))
print yxlines
#We need to calculate A. First Calculate (X * (X_Transpose)) and add them using reduceBYKey function
A = np.asmatrix(yxlines.map(lambda line: ("KeyA",keyA(line))).reduceByKey(lambda x1,x2: np.add(x1,x2)).map(lambda l: l[1]).collect()[0])
print A
#We need to calculate B. First Calculate (X * Y) and add them using reduceBYKey function
B = np.asmatrix(yxlines.map(lambda line: ("KeyB",keyB(line))).reduceByKey(lambda x1,x2: np.add(x1,x2)).map(lambda l: l[1]).collect()[0])
print B
yxfirstline = yxlines.first()
#print yxfirstline[0]," ",yxfirstline[1]
yxlength = len(yxfirstline)
print "yxlength: ", yxlength
# dummy floating point array for beta to illustrate desired output format
beta = np.zeros(yxlength, dtype=float)
def make_gains():
# x = | Angle |
# | Angular velocity |
# u = voltage
# y = encoder
name = 'gains'
# Parameters
moment_inertia = 0.226796 * (1 * .0256)**2.0 / 2.0 + 0.226796 * (
0.5 * 0.0256)**2.0
gear_ratio = 1.0 / 4.0
efficiency = .91
# motor characteristics
free_speed = 18700. / 60.0 * 6.28
free_current = .67
stall_torque = .71
stall_current = 134.
resistance = 12. / stall_current
torque_constant = stall_torque / stall_current
velocity_constant = (12. - free_current * resistance) / free_speed
num_motors = 2.0
sensor_ratio = 1.0
# back emf torque
emf = -(torque_constant * velocity_constant) / (
resistance * gear_ratio**2. / num_motors)
# motor torque
mtq = efficiency * torque_constant / (gear_ratio * resistance / num_motors)
# rotational acceleration
t2a = 1. / moment_inertia
A_c = np.asmatrix([[0., 1.], [0., t2a * emf]])
B_c = np.asmatrix([[0.], [t2a * mtq]])
C = np.asmatrix([[sensor_ratio, 0.]])
# Controller weighting
Q_controller = np.asmatrix([[0., 0.], [0., 5e-3]])
R_controller = np.asmatrix([[1.]])
# Noise
Q_noise = np.asmatrix([[1e-2, 0.], [0., 1e3]])
R_noise = np.asmatrix([[0.1]])
Q_ff = np.asmatrix([[0., 0.], [0., 1.]])
A_d, B_d, Q_d, R_d = c2d(A_c, B_c, dt, Q_noise, R_noise)
K = clqr(A_c, B_c, Q_controller, R_controller)
Kff = feedforwards(A_d, B_d, Q_ff)
L = place(A_d.T, C.T, [0.05, 0.12]).T
gains = StateSpaceGains(name, dt, A_d, B_d, C, None, Q_d, R_noise, K, Kff,
L)
gains.A_c = A_c
gains.B_c = B_c
gains.Q_c = Q_noise
return gains
