def procrustes2d(origin):
f = np.copy(origin)
numberOfShapes = np.shape(f)[0]
diff = np.inf
timesToConverge = 0
while(timesToConverge < 2):
print(timesToConverge)
if(timesToConverge == 0):
pivotIndex = np.random.randint(0, numberOfShapes)
for i in range(0, numberOfShapes):
if(i == pivotIndex):
continue
mtx1, mtx2, disparity = procrustes(f[pivotIndex], f[i])
f[pivotIndex] = mtx1
f[i] = mtx2
else:
for i in range(0, numberOfShapes):
mtx1, mtx2, disparity = procrustes(newMean[0], f[i])
f[i] = mtx2
newMean = np.sum(f, axis = 0, keepdims=True)/numberOfShapes
diff = np.sqrt(np.sum(np.square(f-newMean)))
print(diff)
timesToConverge += 1
print(diff)
return f, newMean
def test_procrustes2(self):
# procrustes disparity should not depend on order of matrices
m1, m3, disp13 = procrustes(self.data1, self.data3)
m3_2, m1_2, disp31 = procrustes(self.data3, self.data1)
assert_almost_equal(disp13, disp31)
# try with 3d, 8 pts per
rand1 = np.array([[2.61955202, 0.30522265, 0.55515826],
[0.41124708, -0.03966978, -0.31854548],
[0.91910318, 1.39451809, -0.15295084],
[2.00452023, 0.50150048, 0.29485268],
[0.09453595, 0.67528885, 0.03283872],
[0.07015232, 2.18892599, -1.67266852],
[0.65029688, 1.60551637, 0.80013549],
[-0.6607528, 0.53644208, 0.17033891]])
rand3 = np.array([[0.0809969, 0.09731461, -0.173442],
[-1.84888465, -0.92589646, -1.29335743],
[0.67031855, -1.35957463, 0.41938621],
[0.73967209, -0.20230757, 0.52418027],
[0.17752796, 0.09065607, 0.29827466],
[0.47999368, -0.88455717, -0.57547934],
[-0.11486344, -0.12608506, -0.3395779],
[-0.86106154, -0.28687488, 0.9644429]])
res1, res3, disp13 = procrustes(rand1, rand3)
res3_2, res1_2, disp31 = procrustes(rand3, rand1)
assert_almost_equal(disp13, disp31)
def test_eigsh(self):
np.random.seed(123)
X = np.vstack([
np.repeat([[0.2, 0.2, 0.2]], 50, axis=0),
np.repeat([[0.5, 0.5, 0.5]], 50, axis=0),
])
P = X @ X.T
A = np.random.binomial(1, P).astype(np.float)
A = symmetrize(A, method="triu")
n_components = 3
# Full SVD
U_full, D_full, V_full = select_svd(A,
n_components=n_components,
algorithm="full")
X_full = U_full @ np.diag(np.sqrt(D_full))
_, _, norm_full = procrustes(X, X_full)
# eigsh SVD
U_square, D_square, V_square = select_svd(A,
n_components=n_components,
algorithm="eigsh",
n_iter=10)
X_square = U_square @ np.diag(np.sqrt(D_square))
_, _, norm_square = procrustes(X, X_square)
rtol = 1e-4
atol = 1e-4
np.testing.assert_allclose(norm_full, norm_square, rtol, atol)
def test_outputs():
np.random.seed(123)
X = np.vstack([
np.repeat([[0.2, 0.2, 0.2]], 50, axis=0),
np.repeat([[0.5, 0.5, 0.5]], 50, axis=0),
])
P = X @ X.T
A = np.random.binomial(1, P).astype(np.float)
n_components = 3
U_full, D_full, V_full = selectSVD(A,
n_components=n_components,
algorithm="full")
X_full = U_full @ np.diag(np.sqrt(D_full))
_, _, norm_full = procrustes(X, X_full)
U_trunc, D_trunc, V_trunc = selectSVD(A,
n_components=n_components,
algorithm="truncated")
X_trunc = U_trunc @ np.diag(np.sqrt(D_trunc))
_, _, norm_trunc = procrustes(X, X_trunc)
U_rand, D_rand, V_rand = selectSVD(A,
n_components=n_components,
algorithm="randomized",
n_iter=10)
X_rand = U_rand @ np.diag(np.sqrt(D_rand))
_, _, norm_rand = procrustes(X, X_rand)
rtol = 1e-4
atol = 1e-4
assert_allclose(norm_full, norm_trunc, rtol, atol)
assert_allclose(norm_full, norm_rand, rtol, atol)
def test_procrustes2(self):
# procrustes disparity should not depend on order of matrices
m1, m3, disp13 = procrustes(self.data1, self.data3)
m3_2, m1_2, disp31 = procrustes(self.data3, self.data1)
assert_almost_equal(disp13, disp31)
# try with 3d, 8 pts per
rand1 = np.array([[2.61955202, 0.30522265, 0.55515826],
[0.41124708, -0.03966978, -0.31854548],
[0.91910318, 1.39451809, -0.15295084],
[2.00452023, 0.50150048, 0.29485268],
[0.09453595, 0.67528885, 0.03283872],
[0.07015232, 2.18892599, -1.67266852],
[0.65029688, 1.60551637, 0.80013549],
[-0.6607528, 0.53644208, 0.17033891]])
rand3 = np.array([[0.0809969, 0.09731461, -0.173442],
[-1.84888465, -0.92589646, -1.29335743],
[0.67031855, -1.35957463, 0.41938621],
[0.73967209, -0.20230757, 0.52418027],
[0.17752796, 0.09065607, 0.29827466],
[0.47999368, -0.88455717, -0.57547934],
[-0.11486344, -0.12608506, -0.3395779],
[-0.86106154, -0.28687488, 0.9644429]])
res1, res3, disp13 = procrustes(rand1, rand3)
res3_2, res1_2, disp31 = procrustes(rand3, rand1)
assert_almost_equal(disp13, disp31)
def align(self, standardfigure=None):
'''Uses Procrustes transformation to align to standard figure
If you have nans in your data, then it will try to use subset of keypoints that are not nans.
Args:
standardfigure: dataframe in Pose2D format to act as standard. default, standardfig.csv
Returns:
df: Pose2D dataframe with aligned coordinates.
'''
aligned_df = self._obj.copy()
if standardfigure is None:
standardfigure = pd.read_csv(os.path.join(get_resource_path(),
'standardfig.csv'),
index_col=['frame'])
xy_standard = _grab_coordinates(standardfigure)
for rowix, row in self._obj.iterrows():
# check if nans exist
coords = _grab_coordinates(row.to_frame().T)
coordbool = np.any(~np.isnan(coords), axis=1)
if np.any(~coordbool):
mtx1, mtx2, _ = procrustes(xy_standard[coordbool],
coords[coordbool])
coords[coordbool] = mtx2
aligned_df.loc[rowix, [
col for col in self._obj.columns
if 'x_' in col or 'y_' in col
]] = coords.flatten()
else:
mtx1, mtx2, _ = procrustes(xy_standard, coords)
aligned_df.loc[rowix, [
col for col in self._obj.columns
if 'x_' in col or 'y_' in col
]] = mtx2.flatten()
return aligned_df
def protest(a, b, n=999):
"""a: pd.DataFrame of Ordination coordinates for dataset a
b: pd.DataFrame of Ordination coordinates for dataset b
n: Integer, number of randomizations
- - - - - - - - - - - - - - - - - - - -
returns:
disparity, pval"""
mtx1, mtx2, disparity = procrustes(a, b)
#Randomization test time
rows, cols = a.shape
#disparities will be the list containing M^2 values for each test
disparities = []
for x in range(n):
#start by randomly sampling 100% of the ordination coordinates
a_rand = a.sample(frac=1, axis=0).reset_index(drop=True)
b_rand = b.sample(frac=1, axis=0).reset_index(drop=True)
#run the procrustes on the two randomly sampled coordinates
mtx1_rand, mtx2_rand, disparity_rand = procrustes(a_rand, b_rand)
#add the result to disparities
disparities.append(disparity_rand)
#set pval = proportion of randomized samples where the random disparity is smaller than
#our observed disparity
pval = (sum([disparity > d for d in disparities]) + 1) / (n + 1)
return disparity, pval, disparities
def compareBeforeAndAfterDataReduction(self, current_row):
## get current settings
current_u_level = self.threshold_setting_summary['u'].iloc[current_row]
current_l_level = self.threshold_setting_summary['l'].iloc[current_row]
current_t_level = self.threshold_setting_summary['t'].iloc[current_row]
## iteration
iteratesThroughGroupSet_return_dict = self.iteratesThroughGroupSet(current_u_level = current_u_level, current_l_level = current_l_level, current_t_level = current_t_level)
info_rich_at_current_threshold_level = iteratesThroughGroupSet_return_dict['info_rich_at_current_threshold_level']
merged_data = iteratesThroughGroupSet_return_dict['merged_data']
## when there are information-rich feature(s)
if len(info_rich_at_current_threshold_level) > 0:
# subset data
non_info = [value for value in merged_data.columns.values if value not in info_rich_at_current_threshold_level]
current_non_info = merged_data[non_info]
self.current_non_info = current_non_info # pass x on to self.x for unittest; use x in computation; TODO: update unittest code
current_info_rich = merged_data[info_rich_at_current_threshold_level]
self.current_info_rich = current_info_rich # pass x on to self.x for unittest; use x in computation; TODO: update unittest code
# project samples onto PCA space
current_data_info_projection = Projection(merged_dataframe = merged_data, normalize = self.normalize).projection_df
current_non_info_projection = Projection(merged_dataframe = current_non_info, normalize = self.normalize).projection_df
current_info_rich_projection = Projection(merged_dataframe = current_info_rich, normalize = self.normalize).projection_df
# procrustes test
if current_info_rich_projection.shape[1] > 1:
if current_info_rich_projection.shape[1] > 2:
d = 3
else:
d = 2
data_projection = numpy.array(current_data_info_projection.iloc[:, 0:d])
non_info_projection = numpy.array(current_non_info_projection.iloc[:, 0:d])
info_projection = numpy.array(current_info_rich_projection.iloc[:, 0:d])
current_non_info_projection_disparity = procrustes(data_projection, non_info_projection)[2]
current_info_projection_disparity = procrustes(data_projection, info_projection)[2]
else:
current_non_info_projection_disparity = numpy.nan
current_info_projection_disparity = numpy.nan
## when there is no information-rich feature
else:
current_non_info_projection_disparity = 0
current_info_projection_disparity = numpy.nan
# ['current_u_level', 'current_l_level', 'current_t_level', 'num_info_rich', 'current_info_projection_disparity', 'current_non_info_projection_disparity']
compareBeforeAndAfterDataReduction_return_list = [current_u_level, current_l_level, current_t_level, info_rich_at_current_threshold_level, current_info_projection_disparity, current_non_info_projection_disparity]
return(compareBeforeAndAfterDataReduction_return_list)
def test_summarize_pcoas(self):
"""summarize_pcoas works
"""
master_pcoa = [['1', '2', '3'], \
array([[-1.0, 0.0, 1.0], [2.0, 4.0, -4.0]]), \
array([.76, .24])]
jn1 = [['1', '2', '3'], \
array([[1.2, 0.1, -1.2],[-2.5, -4.0, 4.5]]), \
array([0.80, .20])]
jn2 = [['1', '2', '3'], \
array([[-1.4, 0.05, 1.3],[2.6, 4.1, -4.7]]), \
array([0.76, .24])]
jn3 = [['1', '2', '3'], \
array([[-1.5, 0.05, 1.6],[2.4, 4.0, -4.8]]), \
array([0.84, .16])]
jn4 = [['1', '2', '3'], \
array([[-1.5, 0.05, 1.6],[2.4, 4.0, -4.8]]), \
array([0.84, .16])]
support_pcoas = [jn1, jn2, jn3, jn4]
#test with the ideal_fourths option
matrix_average, matrix_low, matrix_high, eigval_average, m_names = \
summarize_pcoas(master_pcoa, support_pcoas, 'ideal_fourths',
apply_procrustes=False)
self.assertEqual(m_names, ['1', '2', '3'])
assert_almost_equal(matrix_average[(0, 0)], -1.4)
assert_almost_equal(matrix_average[(0, 1)], 0.0125)
assert_almost_equal(matrix_low[(0, 0)], -1.5)
assert_almost_equal(matrix_high[(0, 0)], -1.28333333)
assert_almost_equal(matrix_low[(0, 1)], -0.0375)
assert_almost_equal(matrix_high[(0, 1)], 0.05)
assert_almost_equal(eigval_average[0], 0.81)
assert_almost_equal(eigval_average[1], 0.19)
#test with the IQR option
matrix_average, matrix_low, matrix_high, eigval_average, m_names = \
summarize_pcoas(master_pcoa, support_pcoas, method='IQR',
apply_procrustes=False)
assert_almost_equal(matrix_low[(0, 0)], -1.5)
assert_almost_equal(matrix_high[(0, 0)], -1.3)
#test with procrustes option followed by sdev
m, m1, msq = procrustes(master_pcoa[1], jn1[1])
m, m2, msq = procrustes(master_pcoa[1], jn2[1])
m, m3, msq = procrustes(master_pcoa[1], jn3[1])
m, m4, msq = procrustes(master_pcoa[1], jn4[1])
matrix_average, matrix_low, matrix_high, eigval_average, m_names = \
summarize_pcoas(master_pcoa, support_pcoas, method='sdev',
apply_procrustes=True)
x = array([m1[0, 0], m2[0, 0], m3[0, 0], m4[0, 0]])
self.assertEqual(x.mean(), matrix_average[0, 0])
self.assertEqual(-x.std(ddof=1) / 2, matrix_low[0, 0])
self.assertEqual(x.std(ddof=1) / 2, matrix_high[0, 0])
def task_2_3():
knn1 = KNeighborsClassifier()
knn1.fit(XTrain, XTrainL)
knn1Predictions = knn1.predict(XTest)
PrintAccuracy(XTestL, knn1Predictions)
train2 = procrustes(XTrain[0], XTrain)
test2 = procrustes(XTrain[0], XTest)
knn2 = KNeighborsClassifier()
knn2.fit(train2, XTrainL)
knn2Predictions = knn2.predict(test2)
PrintAccuracy(XTestL, knn2Predictions)
def normLmarks(lmarks):
norm_list = []
idx = -1
max_openness = 0.2
mouthParams = np.zeros((1, 100))
mouthParams[:, 1] = -0.06
tmp = deepcopy(MSK)
tmp[:, 48 * 2:] += np.dot(mouthParams, SK)[0, :, 48 * 2:]
open_mouth_params = np.reshape(np.dot(S, tmp[0, :] - MSK[0, :]), (1, 100))
if len(lmarks.shape) == 2:
lmarks = lmarks.reshape(1, 68, 2)
for i in range(lmarks.shape[0]):
mtx1, mtx2, disparity = procrustes(ms_img, lmarks[i, :, :])
mtx1 = np.reshape(mtx1, [1, 136])
mtx2 = np.reshape(mtx2, [1, 136])
norm_list.append(mtx2[0, :])
pred_seq = []
init_params = np.reshape(np.dot(S, norm_list[idx] - mtx1[0, :]), (1, 100))
for i in range(lmarks.shape[0]):
params = np.reshape(np.dot(S, norm_list[i] - mtx1[0, :]), (1, 100)) \
- init_params - open_mouth_params
predicted = np.dot(params, SK)[0, :, :] + MSK
pred_seq.append(predicted[0, :])
return np.array(pred_seq), np.array(norm_list), 1
def errorCalculation(robots,logFile):
"""
Error calculation of modelling, computes different errors and writes to file
Input arguments:
robots = instance of the robots
logFile = where to save the output
"""
#TODO: use nrmse next time or fnorm
for robot in robots:
rmse = np.sqrt(np.square(robot.mappingGroundTruth - robot.expectedMeasurement).mean())
logFile.writeError(robot.ID,rmse,robot.currentTime, 'RMSE', endTime=True)
# nrmse = 100 * rmse/(np.max(robot.mappingGroundTruth)-np.min(robot.mappingGroundTruth))
# logFile.writeError(robot.ID,nrmse,robot.currentTime, 'NRMSE', endTime=True)
# rmse = np.sqrt(np.sum(np.square(robot.mappingGroundTruth - robot.expectedMeasurement)))
# fnorm = rmse/(np.sqrt(np.sum(np.square(robot.mappingGroundTruth))))
# logFile.writeError(robot.ID,fnorm,robot.currentTime, 'FNORM', endTime=True)
similarity = ssim(robot.mappingGroundTruth,robot.expectedMeasurement, gaussian_weights=False)
logFile.writeError(robot.ID,similarity,robot.currentTime, 'SSIM', endTime=True)
_, _, procru = procrustes(robot.mappingGroundTruth,robot.expectedMeasurement)
logFile.writeError(robot.ID,procru,robot.currentTime, 'Dissim')
def fit(self, corpus):
self.vocab = corpus.vocab
self.inv_vocab = {val: key for key, val in self.vocab.items()}
self.embeddings = [static_w2v(M, self.rank) for M in corpus.SPPMI]
for t in range(1, corpus.times):
self.embeddings[t - 1], self.embeddings[t], disp = procrustes(
self.embeddings[t - 1], self.embeddings[t])
def _calculate_error(
self, data, data_prev=None, weights=None, subsample_genes=None
):
"""Calculates difference before and after diffusion
Parameters
----------
data : array-like
current data matrix
data_prev : array-like, optional (default: None)
previous data matrix. If None, `data` is simply prepared for
comparison and no error is returned
weights : list-like, optional (default: None)
weightings for dimensions of data. If None, dimensions are equally
weighted
subsample_genes : like-like, optional (default: None)
genes to select in subsampling. If None, no subsampling is
performed
Returns
-------
error : float
Procrustes disparity value
data_curr : array-like
transformed data to use for the next comparison
"""
if subsample_genes is not None:
data = data[:, subsample_genes]
if weights is None:
weights = np.ones(data.shape[1]) / data.shape[1]
if data_prev is not None:
_, _, error = spatial.procrustes(data_prev, data)
else:
error = None
return error, data
def get_circle_positions(topic_similarity_matrix):
#Get new circle position regarding to proposed topic similarity matrix
new_circle_positions = dict()
for lambda_ in range(0, 101):
lambda_ = lambda_ / 100
matrix_cosine_distance = 1 - topic_similarity_matrix[lambda_]
np.fill_diagonal(matrix_cosine_distance, 0)
new_circle_positions[lambda_] = _pcoa(matrix_cosine_distance,
n_components=2).tolist()
#Apply procrusteres
lambdas = list(new_circle_positions.keys())
standardized_matrix = dict()
disparity_values = dict()
original_a = new_circle_positions[0.0]
for i in range(len(lambdas) - 1):
#print(lambdas[i], lambdas[i+1])
original_b = new_circle_positions[lambdas[i + 1]]
mtx1, mtx2, disparity = procrustes(original_a, original_b)
disparity_values[lambdas[i]] = disparity
standardized_matrix[lambdas[i]] = mtx1.tolist()
original_a = mtx2
standardized_matrix[lambdas[len(lambdas) - 1]] = mtx2.tolist()
disparity_values[lambdas[len(lambdas) - 1]] = disparity
new_circle_positions = standardized_matrix
new_circle_positions = json.dumps(new_circle_positions)
return new_circle_positions
def procrustes_analysis(data):
for d in data:
mtx1, mtx2, disparity = procrustes(data[0], d)
# disparity is the sum of the square errors
# mtx2 is the optimal matrix transformation
disp_vals.append(disparity.round(3))
pd_maps.append(mtx2)
def GPA(specTooth, disp):
#specTooth is a matrix containing the shapes of the 14 teeth in a specific position, 40x2x1x14 matrix
#keeping the third dimension, more practical to handle
#choose initial reference shape randomly
initShapePos = random.randint(0, 13)
#initialize point matrices
ComparedShape = specTooth[:, :, initShapePos]
sumShape = np.zeros((40, 2), dtype=np.double)
normalizedShapes = np.zeros((40, 2, 14), dtype=np.double)
#initialize variables for checking the disparity reduction
prev_meanDisp = 0
dispReduct = 1
cyc = 1
#cycles through until the difference beetween the mean disparity of the cicle i and the mean disparity of the cycle i-1
#gets smaller than the selected treshold
thresh = 1e-06
while abs(dispReduct) > thresh:
sumShape = np.zeros((40, 2), dtype=np.double)
sumDisp = 0
for inst in range(13):
[stdMat1, orientation,
disparity] = spsptl.procrustes(ComparedShape, specTooth[:, :,
inst])
#normalizedShapes[:,:,inst] = stdMat1
sumShape = sumShape + orientation
sumDisp = sumDisp + disparity
if disp:
plt.axis([-0.3, 0.3, -0.3, 0.3])
plt.plot(orientation[:, 0], orientation[:, 1], 'ro', hold=True)
plt.pause(0.05)
plt.show()
meanShape = sumShape / 14
meanDisp = sumDisp / 14
dispReduct = meanDisp - prev_meanDisp
print 'disparity reduction, cycle ', cyc, ': ', dispReduct
print 'mean disparity, cycle ', cyc, ': ', meanDisp
if disp:
plt.plot(stdMat1[:, 0], stdMat1[:, 1], 'bo', hold=True)
plt.plot(meanShape[:, 0], meanShape[:, 1], 'yo', hold=True)
plt.pause(0.05)
plt.show()
plt.figure()
plt.axis([-0.3, 0.3, -0.3, 0.3])
ComparedShape = meanShape
prev_meanDisp = meanDisp
cyc += 1
return [meanShape, meanDisp]
def procrustes_word2vec(self, row):
try:
if row['id'] % 10000 == 0:
elapsed = time.time() - start_time
print("Processed {:10.0f} questions in {:10.0f} s ".format(
row['id'], elapsed))
except KeyError:
if row['test_id'] % 10000 == 0:
elapsed = time.time() - start_time
print("Processed {:10.0f} questions in {:10.0f} s ".format(
row['test_id'], elapsed))
stops = set(stopwords.words("english"))
q1 = self.getWordVecs(row['question1'])
q2 = self.getWordVecs(row['question2'])
q1 = list(set(word for word in q1 if word not in stops))
q2 = list(set(word for word in q2 if word not in stops))
trim_length = min(4, min(len(q1), len(q2)))
q1 = q1[:trim_length]
q2 = q2[:trim_length]
if len(q1) == 0 or len(q2) == 0 or len(q1) == 1 or len(q2) == 1:
return 0
q1_vecs = tuple(self.wordvecs[word].reshape((1, 300)) for word in q1)
q2_vecs = tuple(self.wordvecs[word].reshape((1, 300)) for word in q2)
q1_vecs = np.concatenate(q1_vecs, axis=0)
q2_vecs = np.concatenate(q2_vecs, axis=0)
score = procrustes(q1_vecs, q2_vecs)[2]
return score
def summarize_pcoas(master_pcoa, support_pcoas, method='IQR', apply_procrustes=True):
"""returns the average PCoA vector values for the support pcoas
Also returns the ranges as calculated with the specified method.
The choices are:
IQR: the Interquartile Range
ideal fourths: Ideal fourths method as implemented in scipy
"""
if apply_procrustes:
# perform procrustes before averaging
support_pcoas = [list(sp) for sp in support_pcoas]
master_pcoa = list(master_pcoa)
for i, pcoa in enumerate(support_pcoas):
master_std, pcoa_std, m_squared = procrustes(master_pcoa[1],pcoa[1])
support_pcoas[i][1] = pcoa_std
master_pcoa[1] = master_std
m_matrix = master_pcoa[1]
m_eigvals = master_pcoa[2]
m_names = master_pcoa[0]
jn_flipped_matrices = []
all_eigvals = []
for rep in support_pcoas:
matrix = rep[1]
eigvals = rep[2]
all_eigvals.append(eigvals)
jn_flipped_matrices.append(_flip_vectors(matrix, m_matrix))
matrix_average, matrix_low, matrix_high = _compute_jn_pcoa_avg_ranges(\
jn_flipped_matrices, method)
#compute average eigvals
all_eigvals_stack = vstack(all_eigvals)
eigval_sum = numpy_sum(all_eigvals_stack, axis=0)
eigval_average = eigval_sum / float(len(all_eigvals))
return matrix_average, matrix_low, matrix_high, eigval_average, m_names
def get_circle_positions_from_old_matrix(old_circle_positions,
topic_similarity_matrix):
data_keys = list(old_circle_positions.keys())
#get new positions from new matrix
new_circle_positions = dict()
for lambda_ in range(0, 101):
lambda_ = lambda_ / 100
matrix_cosine_distance = 1 - topic_similarity_matrix[lambda_]
np.fill_diagonal(matrix_cosine_distance, 0)
new_circle_positions[str(lambda_)] = _pcoa(matrix_cosine_distance,
n_components=2).tolist()
#Apply procrusteres. Compare old positions with new positions
standardized_matrix = dict()
disparity_values = dict()
for i in range(len(data_keys)):
current_omega = data_keys[i]
original_a = np.array(old_circle_positions[current_omega])
original_b = np.array(new_circle_positions[current_omega])
mtx1, mtx2, disparity = procrustes(original_a, original_b)
disparity_values[current_omega] = disparity
standardized_matrix[current_omega] = mtx2.tolist()
new_circle_positions = standardized_matrix
new_circle_positions = json.dumps(new_circle_positions)
return new_circle_positions
def procrustes_plot(a, b, a_name, b_name):
"""a: ordination coordinates for dataset a
b: ordination coordinates for dataset b
a_name: name for dataset a
b_name: name for dataset b
- - - - - - - - - - - - - - - - - - - -
returns:
ax: axes of plot
disp: disparity score of procrustes
"""
# do procrustes
mtx1, mtx2, disparity = procrustes(a, b)
# Make our plotting df
proplot = pd.concat([pd.DataFrame(mtx1), pd.DataFrame(mtx2)])
proplot.columns = ["PCo1", "PCo2", "PCo3"]
proplot["Dataset"] = [a_name] * a.shape[0] + [b_name] * b.shape[0]
# plot
ax = sns.scatterplot(x="PCo1",
y="PCo2",
style="Dataset",
hue="Dataset",
data=proplot,
markers=["v", "o"],
s=150)
# Add lines
for i in range(len(mtx1)):
plt.plot([mtx1[i, 0], mtx2[i, 0]], [mtx1[i, 1], mtx2[i, 1]],
c="black",
linewidth=0.75)
return ax, disparity
def Proc_PDB(inputPtr, comparePtr):
xyzIn = Read_PDB(inputPtr)
xyzComp = Read_PDB(comparePtr)
standXYZComp, newXYZ, dis = procrustes(xyzComp, xyzIn)
print(xyzIn)
print(xyzComp)
print(newXYZ)
return standXYZComp, newXYZ
def inter_procrustes(matrix_array):
# input: matrix_array, n_subj x n_units x n_examples
n_nets = np.shape(matrix_array)[0]
D = np.zeros((n_nets, n_nets))
for i in range(n_nets):
for j in np.arange(0, i):
_, _, D[i, j] = procrustes(matrix_array[i], matrix_array[j])
return D
def test_procrustes(self):
# tests procrustes' ability to match two matrices.
#
# the second matrix is a rotated, shifted, scaled, and mirrored version
# of the first, in two dimensions only
#
# can shift, mirror, and scale an 'L'?
a, b, disparity = procrustes(self.data1, self.data2)
assert_allclose(b, a)
assert_almost_equal(disparity, 0.)
# if first mtx is standardized, leaves first mtx unchanged?
m4, m5, disp45 = procrustes(self.data4, self.data5)
assert_equal(m4, self.data4)
# at worst, data3 is an 'L' with one point off by .5
m1, m3, disp13 = procrustes(self.data1, self.data3)
def test_procrustes(self):
# tests procrustes' ability to match two matrices.
#
# the second matrix is a rotated, shifted, scaled, and mirrored version
# of the first, in two dimensions only
#
# can shift, mirror, and scale an 'L'?
a, b, disparity = procrustes(self.data1, self.data2)
assert_allclose(b, a)
assert_almost_equal(disparity, 0.)
# if first mtx is standardized, leaves first mtx unchanged?
m4, m5, disp45 = procrustes(self.data4, self.data5)
assert_equal(m4, self.data4)
# at worst, data3 is an 'L' with one point off by .5
m1, m3, disp13 = procrustes(self.data1, self.data3)
def rescaledProcrustes(self, mtx1, mtx2):
#Move all data to origin
newMtx1, newMtx2, disparity1 = procrustes(mtx1, mtx2)
#Rescale by multiplying the normals
newMtx1 *= np.linalg.norm(mtx1)
newMtx2 *= np.linalg.norm(mtx2)
return newMtx1, newMtx2
def procrustes_analysis(
reference: OrdinationResults,
other: OrdinationResults,
dimensions: int = 5,
permutations: int = 999
) -> (OrdinationResults, OrdinationResults, pd.DataFrame):
if reference.samples.shape != other.samples.shape:
raise ValueError('The matrices cannot be fitted unless they have the '
'same dimensions')
if reference.samples.shape[1] < dimensions:
raise ValueError('Cannot fit fewer dimensions than available')
# fail if there are any elements in the symmetric difference
diff = reference.samples.index.symmetric_difference(other.samples.index)
if not diff.empty:
raise ValueError('The ordinations represent two different sets of '
'samples')
# make the matrices be comparable
other.samples = other.samples.reindex(index=reference.samples.index)
mtx1, mtx2, m2 = procrustes(reference.samples.values[:, :dimensions],
other.samples.values[:, :dimensions])
axes = reference.samples.columns[:dimensions]
samples1 = pd.DataFrame(data=mtx1,
index=reference.samples.index.copy(),
columns=axes.copy())
samples2 = pd.DataFrame(data=mtx2,
index=reference.samples.index.copy(),
columns=axes.copy())
info = _procrustes_monte_carlo(reference.samples.values[:, :dimensions],
other.samples.values[:, :dimensions], m2,
permutations)
out1 = OrdinationResults(short_method_name=reference.short_method_name,
long_method_name=reference.long_method_name,
eigvals=reference.eigvals[:dimensions].copy(),
samples=samples1,
features=reference.features,
biplot_scores=reference.biplot_scores,
sample_constraints=reference.sample_constraints,
proportion_explained=reference.
proportion_explained[:dimensions].copy())
out2 = OrdinationResults(
short_method_name=other.short_method_name,
long_method_name=other.long_method_name,
eigvals=other.eigvals[:dimensions].copy(),
samples=samples2,
features=other.features,
biplot_scores=other.biplot_scores,
sample_constraints=other.sample_constraints,
proportion_explained=other.proportion_explained[:dimensions].copy())
return out1, out2, info
def proc(to_fit):
# Reshape to_fit
to_fit = to_fit.reshape(self.template_dims)
# Call procrustes
_, pr_fit, _ = procrustes(self.average_shape, to_fit)
# Returned flattened version
return pr_fit.flatten()
def procrustes_analysis(landmarks):
mean = np.mean(landmarks, 0)
landmarks_std = np.empty_like(landmarks)
for i, landmark in enumerate(landmarks):
mean_std, landmark_std, disp = procrustes(mean, landmark)
landmarks_std[i] = landmark_std
return landmarks_std
def extract_procrustes( ref_coord, result_MDS, ismean = True):
if ismean:
disp_layer, score_procrustes, tform_procrustes = algos.procrustes( ref_coord, result_MDS[:,:3] )
return disp_layer, tform_procrustes
else:
DISPLAY, TFORM = list(),list()
for i in range(len(result_MDS)):
disp_layer, score_procrustes, tform_procrustes = algos.procrustes( ref_coord, result_MDS[i][:,:3] )
_, m2, disp_layer = procrustes(ref_coord, result_MDS[i][:,:3])
DISPLAY.append(100*(1 - disp_layer)), TFORM.append(tform_procrustes)
return DISPLAY, TFORM
def _calculate_error(data, data_prev=None, weights=None, subsample_genes=None):
if subsample_genes is not None:
data = data[:, subsample_genes]
if weights is None:
weights = np.ones(data.shape[1]) / data.shape[1]
if data_prev is not None:
_, _, error = spatial.procrustes(data_prev, data)
else:
error = 99999
return error, data
def generalized_procrustes_analysis(G_cen):
# Initialize data arrays based on input training set
G_cen_aligned = np.zeros(np.shape(G_cen))
shapes = np.zeros((np.shape(G_cen)[0], int(np.shape(G_cen)[1] / 3), 3))
shapes_aligned = np.zeros((np.shape(G_cen)[0], int(np.shape(G_cen)[1] / 3), 3))
# Convert training set for procrustest analysis
for i in range(0, np.shape(G_cen)[0]):
shapes[i, :, :] = np.reshape(G_cen[i, :], (-1, 3))
# initialize Procrustest distance
current_distance = 0
# Initialize a mean shape (first element), with zero mean and Frobenius norm
mean_shape = shapes[0, :, :]
mean_shape -= np.mean(mean_shape, 0)
norm1 = np.linalg.norm(mean_shape)
mean_shape /= norm1
num_shapes = len(shapes)
while True:
shapes_aligned[0, :, :] = mean_shape
for sh in range(1, num_shapes):
shapes_aligned[0, :, :], shapes_aligned[sh, :, :], _ = procrustes(mean_shape, shapes[sh, :, :])
new_mean = np.mean(shapes_aligned, axis=0)
new_distance = procrustes_distance(new_mean, mean_shape)
if new_distance == current_distance:
break
_, new_mean, _ = procrustes(mean_shape, new_mean)
mean_shape = new_mean
current_distance = new_distance
for i in range(0, np.shape(G_cen)[0]):
G_cen_aligned[i, :] = shapes_aligned[i, :, :].flatten()
return shapes_aligned, G_cen_aligned
def procrustes_analysis(reference: OrdinationResults, other: OrdinationResults,
dimensions: int=5) -> (OrdinationResults,
OrdinationResults):
if reference.samples.shape != other.samples.shape:
raise ValueError('The matrices cannot be fitted unless they have the '
'same dimensions')
if reference.samples.shape[1] < dimensions:
raise ValueError('Cannot fit fewer dimensions than available')
# fail if there are any elements in the symmetric difference
if not (reference.samples.index ^ other.samples.index).empty:
raise ValueError('The ordinations represent two different sets of '
'samples')
# make the matrices be comparable
other.samples = other.samples.reindex(index=reference.samples.index)
mtx1, mtx2, _ = procrustes(reference.samples.values[:, :dimensions],
other.samples.values[:, :dimensions])
axes = reference.samples.columns[:dimensions]
samples1 = pd.DataFrame(data=mtx1,
index=reference.samples.index.copy(),
columns=axes.copy())
samples2 = pd.DataFrame(data=mtx2,
index=reference.samples.index.copy(),
columns=axes.copy())
out1 = OrdinationResults(
short_method_name=reference.short_method_name,
long_method_name=reference.long_method_name,
eigvals=reference.eigvals[:dimensions].copy(),
samples=samples1,
features=reference.features,
biplot_scores=reference.biplot_scores,
sample_constraints=reference.sample_constraints,
proportion_explained=reference.proportion_explained[:dimensions]
.copy())
out2 = OrdinationResults(
short_method_name=other.short_method_name,
long_method_name=other.long_method_name,
eigvals=other.eigvals[:dimensions].copy(),
samples=samples2,
features=other.features,
biplot_scores=other.biplot_scores,
sample_constraints=other.sample_constraints,
proportion_explained=other.proportion_explained[:dimensions]
.copy())
return out1, out2
