class PCR:
def __init__(self, X, Y):
self.X = X
self.Y = Y
# 对X进行SVD分解，返回分解后的矩阵，可以使用compare，和cum来确定独立分组数目
def confirmPCs(self):
self.pca = PCA(self.X)
compare, cum = self.pca.SVDdecompose()
return compare, cum
# PCs为独立分组数
def fit(self, PCs):
T, P = self.pca.PCAdecompose(PCs)
self.P = P
self.T = T
self.mlr = MLR(T, self.Y, False)
self.mlr.fit()
self.A = self.mlr.getCoef()
def predict(self, Xnew):
T = np.dot(Xnew, self.P)
ans = self.mlr.predict(T)
return ans
def fTest(self, arfa):
return self.mlr.Ftest(arfa)
def getLayerDimensionality(layer,index,inputDict):
if layer.name.startswith(inputDict['ValidDimLayers']): # Must be either a single string or tuple of strings
pcaObj = PCA(matrix=layer.get_weights()[0])
message = "Layer {}: Dimensionality: {:4.2f}".format(index,pcaObj.dimensionality())
else:
message = "Layer {}: Dimensonality is N/A".format(index)
return message
def runPCA(data, elems=None, components=None, threshold=None):
t_data = theano.shared(np.asarray(data, dtype=theano.config.floatX),
name='data',
borrow=True)
if components is not None and threshold is not None:
print('You Can' ' Run PCA Using Threshold And Components')
exit(-1)
t_components = None
t_threshold = None
if components is not None:
t_components = theano.shared(value=components,
name='components',
borrow=True)
elif threshold is not None:
t_threshold = theano.shared(value=threshold,
name='components',
borrow=True)
idx = T.lvector('idx')
m_data = T.matrix('data')
pca = PCA(data=m_data, components=t_components, threshold=t_threshold)
theanoPCA = theano.function(inputs=[idx],
outputs=pca.process(),
givens={m_data: t_data[idx]})
if elems is None:
elems = np.arange(len(data), dtype='int64')
return theanoPCA(elems)
def test_pca(filename):
# データセットの読み込み
X = []
for l in open(filename).readlines():
data = l.split(' ')
rec = [float(d) for d in data]
X.append(rec)
X = np.array(X)
# 主成分分析
# （Trueを指定すると、分散で割ってnormalizeする）
pca = PCA(X, False)
print pca.eigenvalues / np.sum(pca.eigenvalues)
# 寄与率を表示
accm = []
total = 0.0
for v in pca.eigenvalues:
total += v
accm.append(total)
accm /= total
plt.plot(accm, 'b-');
plt.show()
# 主成分空間への写像の表示
X_pca = pca.project(dim=2)
plt.plot(X_pca, 'b.')
plt.show()
def main(args):
# Read data file into numpy matrices
with gzip.open(args.mnist_train_data, 'rb') as in_gzip:
magic, num, rows, columns = struct.unpack('>IIII', in_gzip.read(16))
all_data = [np.array(struct.unpack('>{}B'.format(rows * columns),
in_gzip.read(rows * columns)))
for _ in range(60000)]
# Read labels file into labels
with gzip.open(args.mnist_train_labels, 'rb') as in_gzip:
magic, num = struct.unpack('>II', in_gzip.read(8))
all_labels = struct.unpack('>60000B', in_gzip.read(60000))
pca = PCA(5)
pca.fit(all_data)
components = pca.return_components()
components = np.reshape(components, (5, 28, 28))
one = PCA(5)
one.fit()
one_comp = pca.return_components()
f, axarr = plt.subplots(1, 5, figsize=(18, 4), sharey=True)
for i in range(5):
axarr[i].imshow(components[i])
axarr[i].set_aspect('equal')
axarr[i].set_title('Component {}'.format(i + 1))
plt.tight_layout()
name = 'Hrach'
plt.savefig('comps-{}.png'.format(name), dpi=320)
def test_pca(filename):
# データセットの読み込み
X = []
for l in open(filename).readlines():
data = l.split(' ')
rec = [float(d) for d in data]
X.append(rec)
X = np.array(X)
# 主成分分析
# （Trueを指定すると、分散で割ってnormalizeする）
pca = PCA(X, False)
print pca.eigenvalues / np.sum(pca.eigenvalues)
# 寄与率を表示
accm = []
total = 0.0
for v in pca.eigenvalues:
total += v
accm.append(total)
accm /= total
plt.plot(accm, 'b-')
plt.show()
# 主成分空間への写像の表示
X_pca = pca.project(dim=2)
plt.plot(X_pca, 'b.')
plt.show()
class PCR:
def __init__(self, X, Y):
self.X = X
self.Y = Y
def confirmPCs(self):
self.pca = PCA(self.X)
compare = self.pca.SVDdecompose()
return compare
def fit(self, PCs):
T, P = self.pca.PCAdecompose(PCs)
print('T=', T)
self.P = P
oneCol = np.ones(T.shape[0])
T = np.c_[oneCol, T]
self.mlr = MLR(T, self.Y)
self.mlr.fit()
self.A = self.mlr.getCoef()
def predict(self, Xnew):
T = np.dot(Xnew, self.P)
oneCol = np.ones(T.shape[0])
T = np.c_[oneCol, T]
ans = self.mlr.predict(T)
return ans
def fTest(self, arfa):
return self.mlr.Ftest(arfa)
def test_pca():
data_ingestor = DataIngestor()
X, y, _, _ = data_ingestor.load_mnist()
X = X.T
pca = PCA()
dimensionality = [1, 10, 100, 500, 784]
element = [1, 2, 3, 4]
fig, axes = plt.subplots(len(dimensionality), 1, sharey=True)
plt.gray()
for i, big_ax in enumerate(axes, start=0):
big_ax.set_title('PCs = ' + str(dimensionality[i]))
big_ax.tick_params(labelcolor=(1.,1.,1., 0.0), top='off', bottom='off', left='off', right='off')
big_ax._frameon = False
_, X_tilde = pca.compute_pca(X, dimensionality[i])
for j in range(len(element)):
ax = fig.add_subplot(len(dimensionality), len(element), i*len(element) + j + 1)
ax.imshow(X_tilde.T[element[j]].reshape([28,28]))
plt.axis('off')
plt.show()
eigvals, _ = pca.compute_pca(X)
reconstruction_error = [np.sum(eigvals[i:]) for i in range(len(eigvals))]
plt.plot(range(len(reconstruction_error)), reconstruction_error)
plt.axhline(0, color='black')
plt.title('Average Construction Error')
plt.show()
def compress_images(DATA, k):
pca = PCA(DATA, k)
reconst = pca.perform_PCA()
reconst = rescale_images(reconst)
save_images(reconst)
def train_PCA_train():
"""
Test that PCA has a working train abstract method
"""
some = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
m = PCA(some)
assert m.train()
def run_pca():
data = Data(FILENAME)
d = 2
pca = PCA()
pca.train(data.x1.T, d)
plt.plot(pca.pc[0], pca.pc[1], 'ro')
plt.savefig("pca")
plt.clf()
def fit(self, X, y):
self.pca = PCA(n_components=self.pca_components).fit(X)
pca_projected = self.pca.project(X)
self.lda = LDA(n_components=self.n_components).fit(pca_projected, y)
self.subspace = np.dot(self.pca.pro_subspace, self.lda.pro_subspace)
return self
def test_PCA_init():
"""
Given a pandas dataframe, test the creation of a PCA class.
"""
some = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
m = PCA(some)
data_2 = m.getData()
assert some.equals(data_2)
def reduceLayerDimensionality(layer,index,inputDict):
if layer.name.startswith(inputDict['ValidDimLayers']): # Must be either a single string or tuple of strings
weights = layer.get_weights()
pcaObj = PCA(matrix=weights[0])
weights[0] = pcaObj.filterMatrix(n=pcaObj.computeTargetPCs(targetRatio=inputDict['targetRatio']))
layer.set_weights(weights)
message = "Layer {}: Reduced layer dimensionality".format(index)
else:
message = "Layer {}: Dimensionality unchanged".format(index)
return(message)
def model(self, k):
pca = PCA(self.X)
U, S, V, compare = pca.SVDdecompose() # 不可去，会用到计算得到的结果
# 得到得分矩阵和载荷矩阵
T, P = pca.PCAdecompose(k)
#print("得分矩阵T: ", T)
#print("载荷矩阵P: ", P)
mlr = MLR(T, self.Y)
mlr.modelling()
self.A = np.dot(P, mlr.A)
def test_PCA_convert():
"""
Test that PCA has a working test abstract method
"""
some = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
m = PCA(some)
m.train(2)
results = m.convert(some)
assert results.shape[0] == 4
assert results.shape[1] == 2
def __init__(self, index_test):
data_test_ke = data_test[int(index_test)]
pca = PCA(data_train)
orang, pose = pca.calc_pca(data_test_ke)
Input_LDA = {}
Input_LDA['bobot'] = pca.bobot_train
Input_LDA['proyeksi'] = pca.matrix_proyeksi
Input_LDA['jumlah_kelas'] = ORL_face.data.shape[
0] # jumlah semua kelas(40) bukan pose
Input_LDA['jumlah_pose'] = len(
ORL_face.list_data_train) # jumlah semua pose train
Input_LDA['data_train'] = data_train
self.input_LDA = Input_LDA
jumlah_kelas = self.input_LDA['jumlah_kelas']
jumlah_pose_train = self.input_LDA['jumlah_pose']
jumlah_data = jumlah_kelas * jumlah_pose_train
self.proyeksi_pca_baru = self.get_proyeksi_pca_baru(
self.input_LDA['proyeksi'], jumlah_data, jumlah_kelas)
self.input_LDA = self.get_input_LDA(self.input_LDA['data_train'],
self.proyeksi_pca_baru)
self.rata_per_kelas = self.get_rata_tiap_kelas(self.input_LDA,
jumlah_kelas,
jumlah_pose_train)
self.rata_total_kelas = self.get_rata_total_kelas(self.input_LDA)
self.Sb = self.get_between_class_scatter(self.rata_per_kelas,
self.rata_total_kelas,
jumlah_kelas)
self.Sw = self.get_within_class_scatter(self.input_LDA,
self.rata_per_kelas,
jumlah_data, jumlah_kelas,
jumlah_pose_train)
self.eigen_value, self.eigen_vector = self.get_eigen(self.Sb, self.Sw)
self.descending_eigen_vector = self.descending(self.eigen_value,
self.eigen_vector)
self.wFid = np.transpose(
self.descending_eigen_vector[:, 0:jumlah_kelas - 1])
self.proyeksi = self.get_proyeksi(self.wFid, self.proyeksi_pca_baru)
self.bobot_train = self.get_bobot(data_train, self.proyeksi)
print("\nLDA", "==" * 30)
print("proyeksi lama", self.proyeksi_pca_baru.shape)
print("input LDA", self.input_LDA.shape)
print("rata per kelas", self.rata_per_kelas.shape)
print("rata semua kelas", self.rata_total_kelas.shape)
print("Sb", self.Sb.shape)
print("Sw", self.Sw.shape)
print("eva", self.eigen_value.shape)
print("eve", self.eigen_vector.shape,
self.descending_eigen_vector.shape)
print("wFid", self.wFid.shape)
print("proyeksi", self.proyeksi.shape)
print("bobot", self.bobot_train.shape)
def main():
dim = 2
num_class = 3
dataset_dir = '../input/wine.csv'
train_x, train_y, raw_data = data_loader(dataset_dir)
pca = PCA(first_k=dim, use_threshold=False, threshold=0.5)
proj = pca.fit(train_x)
kmeans = KMeans(K=num_class)
center, predict_y = kmeans.fit(proj)
result = evaluate(proj, train_y, predict_y, k=num_class)
visualization(center, proj, predict_y, dim)
save_to_csv(raw_data, predict_y)
print(result)
def pca_data(train_x, test_x, fold):
pca = PCA()
train_x, test_x = pca.process(train_x, test_x)
#with open('train_pca_'+str(fold)+'.pkl', 'wb') as f1:
#pickle.dump(train_x, f1)
#with open('test_pca_'+str(fold)+'.pkl', 'wb') as f2:
#pickle.dump(test_x, f2)
#with open('train_pca_'+str(fold)+'.pkl', 'rb') as f1:
#train_x = pickle.load(f1)
#with open('test_pca_'+str(fold)+'.pkl', 'rb') as f2:
#test_x = pickle.load(f2)
train_x = train_x.astype(np.float, copy=True)
test_x = test_x.astype(np.float, copy=True)
return train_x, test_x
def computePCs(self):
# 确定主成分
Percentage = 0.95
pca = PCA(self.X)
U, S, V, compare = pca.SVDdecompose()
self.kcount = compare.__len__() # 记录主成分最大数
comSum = 0
cSum = sum(compare)
for i in compare:
comSum += i
if comSum / cSum >= Percentage:
PCs = int(np.where(compare == i)[0][-1]) + 1
#print("主成分数k: ", PCs)
self.k = PCs # 记录符合条件的最佳主成分数
break
def buildPCA(self, marks):
TableMarks, mean_shape = pa.GPA(marks)
self.mean_shape = mean_shape
marks = np.asarray(TableMarks)
accuracy = 0.98
PCAmodel = PCA(marks, accuracy)
return PCAmodel
def test_PCA_dtype():
"""
Test that the initialization of a PCA class throws a type error for
things that are not pandas dataframes
"""
some = "A wrong data type of type string"
with pytest.raises(TypeError):
PCA(some)
def test_pca(self):
pic_num = END_INDEX - START_INDEX
images = loadFace()
for i in range(len(images)):
images[i] = images[i][:, :]
pca = PCA(images[START_INDEX:END_INDEX])
pca_ims = pca.ret()
for i in range(START_INDEX, END_INDEX):
before_pca = Image.fromarray(images[i])
after_pca = Image.fromarray(pca_ims[i - START_INDEX])
fig = plt.figure('pca')
ax = fig.add_subplot(pic_num, 2, i * 2 + 1 - START_INDEX * 2)
ax.imshow(before_pca, cmap='gray', vmin=0, vmax=255)
ax = fig.add_subplot(pic_num, 2, i * 2 + 2 - START_INDEX * 2)
ax.imshow(after_pca, cmap='gray', vmin=0, vmax=255)
plt.show()
class TestStandardize(object): def setup(self): intDATA = np.arange(10).reshape(5,2) self.intPCA = PCA(intDATA, 1) def testArrayEqual(self): testResult = np.array([[-.5,.5],[-.5,.5],[-.5,.5],[-.5,.5],[-.5,.5]]) np.testing.assert_array_equal(self.intPCA.standardize(), testResult)
def makeColourProfile(self):
"""Make a colour profile based on ksig information"""
working_data = np_array(self.kmerSigs, copy=True)
Center(working_data,verbose=0)
p = PCA(working_data)
components = p.pc()
# now make the colour profile based on PC1
self.kmerVals = np_array([float(i) for i in components[:,0]])
# normalise to fit between 0 and 1
self.kmerVals -= np_min(self.kmerVals)
self.kmerVals /= np_max(self.kmerVals)
if(False):
plt.figure(1)
plt.subplot(111)
plt.plot(components[:,0], components[:,1], 'r.')
plt.show()
def test_pca2(self):
pic_num = END_INDEX - START_INDEX
images = loadFace()
print(images)
m, n = images[0].shape
images_in = images.copy()
#针对不同图片的降维，这会使图片趋同
pca = PCA(np.array([[image.reshape(-1) for image in images_in]]))
pca_ims = pca.ret()
for i in range(START_INDEX, END_INDEX):
before_pca = Image.fromarray(images[i])
after_pca = Image.fromarray(pca_ims[0][i].reshape(m, n))
fig = plt.figure('pca')
ax = fig.add_subplot(pic_num, 2, i * 2 + 1 - START_INDEX * 2)
ax.imshow(before_pca, cmap='gray', vmin=0, vmax=255)
ax = fig.add_subplot(pic_num, 2, i * 2 + 2 - START_INDEX * 2)
ax.imshow(after_pca, cmap='gray', vmin=0, vmax=255)
plt.show()
def test():
a = array([[5, 9, 7], [3, 7, 4], [2, 3, 9]])
pca = PCA(a, 2)
print "mean: %s" % pca.mean
print "covar: %s" % pca.covar
print "eval: %s" % pca.eval
print "evec: %s" % pca.evec
print "esort: %s" % pca.esort
print "pc: %s" % pca.pc
print "pca: %s" % pca.pca
def isCorrect(self, attemptFile, correctFile, transMatrixFile,
standDevFile):
errors = self.getErrors(correctFile, attemptFile)
# transform back into array of joint angles
invTransMatrix = 1 / PCA().readMatrix(transMatrixFile).transpose()
jointErrors = np.dot(invTransMatrix, np.array(errors))
# read in standard deviation file to get joint angle error bounds
sdVector = PCA().readVector(standDevFile)
# find and report joint angle errors above the "acceptable" threshhold
numBadJoints = 0
for i in range(jointErrors.shape[0]):
if jointErrors[i] > sdVector[i] * 5:
print(
indexJoints.get(i) + ": " +
str(jointErrors[i] * 180 / np.pi))
numBadJoints += 1
if numBadJoints == 0: print("true")
def main(args):
# Read data file into numpy matrices
with gzip.open(args.mnist_train_data, 'rb') as in_gzip:
magic, num, rows, columns = struct.unpack('>IIII', in_gzip.read(16))
all_data = np.array([
np.array(
struct.unpack('>{}B'.format(rows * columns),
in_gzip.read(rows * columns)))
for _ in range(16000)
])
with gzip.open(args.mnist_train_labels, 'rb') as in_gzip:
magic, num = struct.unpack('>II', in_gzip.read(8))
all_labels = struct.unpack('>16000B', in_gzip.read(16000))
zeros = all_data[np.array(all_labels) < 0.5]
#plt.imshow(all_data[0].reshape(28,28))
#plt.show()
pca = PCA(5)
pca.fit(all_data)
print(pca.return_components().shape)
components = pca.return_components().reshape(5, 28, 28)
f, axarr = plt.subplots(1, 5, figsize=(18, 4), sharey=True)
for i in range(5):
axarr[i].imshow(components[i])
print(i, components[i].shape)
axarr[i].set_aspect('equal')
axarr[i].set_title('Component {}'.format(i + 1))
plt.tight_layout()
name = 'TODO' # TODO: Remplace name with your name
plt.savefig('comps-{}.png'.format(name), dpi=320)
def get_data(pca_ON=False, print_shapes=False):
data = pd.read_csv('mnist_train.csv').as_matrix()
Xtrain = data[:-10000, 1:]
Ytrain = data[:-10000, 0]
Xtest = data[-10000:, 1:]
Ytest = data[-10000:, 0]
dataset = {}
if pca_ON:
pca = PCA(n_components=30)
pca.fit(Xtrain)
if print_shapes:
print('\nEigenvectors size:', pca.evecs.shape)
Xtrain = pca.transform(Xtrain)
Xtest = pca.transform(Xtest)
if print_shapes:
print('\nXtrain: {}, Ytrain: {}'.format(Xtrain.shape, Ytrain.shape))
print('Xtest: {}, Ytest: {}'.format(Xtest.shape, Ytest.shape))
dataset['train'] = (Xtrain, Ytrain)
dataset['test'] = (Xtest, Ytest)
return dataset
def main(args):
# Read data file into numpy matrices
with gzip.open(args.mnist_train_data, 'rb') as in_gzip:
magic, num, rows, columns = struct.unpack('>IIII', in_gzip.read(16))
all_data = np.array([np.array(struct.unpack('>{}B'.format(rows * columns),
in_gzip.read(rows * columns)))
for _ in range(16000)])
with gzip.open(args.mnist_train_labels, 'rb') as in_gzip:
magic, num = struct.unpack('>II', in_gzip.read(8))
all_labels = struct.unpack('>16000B', in_gzip.read(16000))
each_label = np.empty(10, dtype = object)
for i in range(10):
each_label[i] = all_data[np.array(all_labels) == i]
pca = PCA(15)
pca.fit(all_data)
all_data_transform = pca.transform(all_data)
kmeans_labels = KMeans(n_clusters=10, random_state=0).fit_predict(all_data_transform)
each_cluster = np.empty(10, dtype = object)
for i in range(10):
each_cluster[i] = all_data_transform[:,:2][np.array(kmeans_labels) == i]
f, axarr = plt.subplots(2, 10, figsize=(18, 4), sharey=True)
for i in range(10):
a = pca.transform(each_label[i])
axarr[0][i].scatter(a.T[0], a.T[1], s = 1)
for i in range(10):
axarr[1][i].scatter(each_cluster[i].T[0], each_cluster[i].T[1], s = 1)
#plt.show()
coincidence_matrix = np.zeros((10,10)).astype(int)
for i in range(16000):
coincidence_matrix[all_labels[i], kmeans_labels[i]]+=1
print(coincidence_matrix)
plt.savefig("labels_vs_kmeans_clusters.jpg")
def get_descriptors(img, imageName, database):
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
img = clahe.apply(img)
img = image_enhance.image_enhance(img)
img = np.array(img, dtype=np.uint8)
# Threshold
ret, img = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)
# Normalize to 0 and 1 range
img[img == 255] = 1
# Thinning
skeleton = skeletonize(img)
skeleton = np.array(skeleton, dtype=np.uint8)
skeleton = removedot(skeleton)
# Creating Block Size of 144 x 96 total of 8 blocks for an image and then generating descriptors and keypoints
# Storing these 4 descriptors and 8 keypoints of one image in a Mainlist and key(image name) is associated to represent this
# list in a dictionary. So we store all these lists of individual in dictionary and pickling dictionary
# Creating List Format ( [[keypoints][descriptors]]): List initialization
DescriptorList = list()
for i in range(0, 400, 200):
for j in range(0, 274, 137):
blockImg = img[i:i + 200, j:j + 137]
# Harris corners
harris_corners = cv2.cornerHarris(blockImg, 3, 3, 0.04)
harris_normalized = cv2.normalize(harris_corners, 0, 255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32FC1)
threshold_harris = 125;
# Extract keypoints
keypoints = []
for x in range(0, harris_normalized.shape[0]):
for y in range(0, harris_normalized.shape[1]):
if harris_normalized[x][y] > threshold_harris:
keypoints.append(cv2.KeyPoint(y, x, 1))
# Define descriptor
orb = cv2.ORB_create()
# Compute descriptors
_, des = orb.compute(blockImg, keypoints)
# pca = PCA(2) # project from 32 to 2 dimensions
# projected = pca.fit_transform(des)
# print(des.shape)
# print(projected.shape)
Reduced_des = PCA(des)
print(type(Reduced_des))
print(Reduced_des.shape)
DescriptorList.append(Reduced_des)
database.update({imageName: DescriptorList})
def testPCAanalytic(self):
'''
Test to ensure that I understand how PCA works and how it is implemented
in numpy.
'''
pca = PCA()
mux, sigmax = 30, 1
muy, sigmay = 20, 0.5
xprime = (sigmax * np.random.normal(loc=0,size=10000)) #mux
yprime = (sigmay * np.random.normal(loc=0,size=10000)) # muy
for i in range(10):
theta = np.random.random()*2.0*np.pi
print 'theta', theta
# mux, sigmax = 30, 1
# muy, sigmay = 20, 0.5
# theta = -1.0*np.pi/3.0
#
# xprime = (sigmax * np.random.normal(loc=0,size=10000)) #mux
# yprime = (sigmay * np.random.normal(loc=0,size=10000)) # muy
x = np.cos(theta)*xprime - np.sin(theta)*yprime
y = np.sin(theta)*xprime + np.cos(theta)*yprime
# analytic_PCs = np.array([[np.cos(theta) - np.sin(theta),
# np.sin(theta) + np.cos(theta)],
# [np.sin(theta) + np.cos(theta),
# np.sin(theta) - np.cos(theta)]])
analytic_PCs = np.array([[-np.cos(theta),
-np.sin(theta)],
[np.sin(theta) ,
-np.cos(theta)]])
#
x += mux
y += muy
#
#
pca.config_space = np.array([x,y]).swapaxes(0,1)
# cov = np.cov(pca.config_space.T)
# eigh = np.linalg.eigh(cov)
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
#
ax.scatter(pca.config_space[:,0],pca.config_space[:,1],c=xprime, alpha = 0.2, marker = 'o')
#
pca.runPCA()
print 'analytic\n',analytic_PCs
print 'calc\n', pca.PCs, '\n', np.dot(pca.PCs[0][:],pca.PCs[1][:])
# print 'pca.config_mu', pca.config_mu
# print 'pca.config_sigma', pca.config_sigma
# print 'pca.PCs', pca.PCs
# print 'pca.PCs[1]', pca.PCs[1]
# print 'pca.PCs[0]', pca.PCs[0]
# print 'cov', pca.cov
# print 'variance', pca.variance
# print 'std', pca.std
#
#
ax.scatter(pca.Y[:,0], pca.Y[:,1], alpha = 0.2, c=xprime, marker = 'o')
#
plt.plot([pca.config_mu[0], pca.config_mu[0] + (pca.PCs[0][0])*5.0*pca.std[0]]
,[pca.config_mu[1], pca.config_mu[1] + (pca.PCs[0][1])*5.0*pca.std[0]],
c = 'red')
plt.plot([pca.config_mu[0], pca.config_mu[0] + (pca.PCs[1][0])*5.0*pca.std[1]]
,[pca.config_mu[1], pca.config_mu[1] + (pca.PCs[1][1])*5.0*pca.std[1]],
c = 'blue')
ax.grid(True)
# plt.show()
for l in range(2):
for j in range(2):
self.assertAlmostEqual(np.abs(pca.PCs[l][j]),
np.abs(analytic_PCs[l][j]),
delta=0.051,
msg = 'l: %d j: %d pca: %1.3f analytic: %1.3f'
%(l,j,pca.PCs[l][j], analytic_PCs[l][j]) )
#!/usr/bin/env python
'''
Created on Aug 31, 2012
@author: masumadmin
'''
from PCA import PCA
from Utility import read_data
if __name__ == '__main__':
pca= PCA(3)
pca.train(read_data('data/iris_sans_class.arff'))
print "ev1: ",pca.eigenvalues[0]
print "ev2: ",pca.eigenvalues[1]
print "ev3: ",pca.eigenvalues[2]
print pca.principal_components
print pca.reduce([0.36158967923198376, -0.08226888783524387, 0.8565721047950943, 0.35884392603772075])
print pca.expand([1.0, -7.091680853665849e-10, -1.7341683644644945e-13])
print "OK"
