def em_pca(data_matrix, n_pcs, tolerance=.000001):
[n_vars, n_obs] = data_matrix.shape
# Start with an initial guess for the loadings matrix (or eigenvectors)
loadings = matrix(rand_array(n_vars, n_pcs))
prev_err = float("inf")
while(True):
# E-STEP - compute new scores based on current loadings
# a.k.a. compute projected data based on current eigenvectors
proj_data = inv(loadings.transpose() * loadings) * loadings.transpose() * data_matrix
# M-STEP - compute new loadings based on current scores
# a.k..a. compute best eigenvectors based on current projected data
loadings = data_matrix * proj_data.transpose() * inv(proj_data * proj_data.transpose())
# Compute the squared error
error = square(data_matrix - loadings * proj_data).sum()
# If the error is no longer decreasing, then we have converged
error_ratio = error / prev_err
print(error_ratio)
if (error_ratio > (1 - tolerance)):
break
prev_err = error
# Now that the EM algorithm has converged, the loadings span the correct lower-
# dimensional space, and the data is projected into it. We now use the regular
# PCA on this lower-dimensional matrix to finish it off and decorrelate the
# dimensions
proj_matrix = inv(loadings.transpose() * loadings) * loadings.transpose()
proj_data = proj_matrix * data_matrix
new_cov = cov(proj_data)
orth_cov, rmat = qr(new_cov)
del(rmat)
orth_cov = matrix(orth_cov)
"""
new_pcs, new_projected_data = pca(proj_data, n_pcs)
print proj_matrix.shape
print new_pcs.shape
print new_projected_data.shape
final_pcs = (new_pcs * proj_matrix).transpose()
new_data = final_pcs.transpose() * data_matrix
"""
import pdb; pdb.set_trace()
return final_pcs , new_projected_data
def em_pca(data_matrix, n_pcs, tolerance=.000001):
[n_vars, n_obs] = data_matrix.shape
# Start with an initial guess for the loadings matrix (or eigenvectors)
loadings = matrix(rand_array(n_vars, n_pcs))
prev_err = float("inf")
while (True):
# E-STEP - compute new scores based on current loadings
# a.k.a. compute projected data based on current eigenvectors
proj_data = inv(loadings.transpose() *
loadings) * loadings.transpose() * data_matrix
# M-STEP - compute new loadings based on current scores
# a.k..a. compute best eigenvectors based on current projected data
loadings = data_matrix * proj_data.transpose() * inv(
proj_data * proj_data.transpose())
# Compute the squared error
error = square(data_matrix - loadings * proj_data).sum()
# If the error is no longer decreasing, then we have converged
error_ratio = error / prev_err
print(error_ratio)
if (error_ratio > (1 - tolerance)):
break
prev_err = error
# Now that the EM algorithm has converged, the loadings span the correct lower-
# dimensional space, and the data is projected into it. We now use the regular
# PCA on this lower-dimensional matrix to finish it off and decorrelate the
# dimensions
proj_matrix = inv(loadings.transpose() * loadings) * loadings.transpose()
proj_data = proj_matrix * data_matrix
new_cov = cov(proj_data)
orth_cov, rmat = qr(new_cov)
del (rmat)
orth_cov = matrix(orth_cov)
"""
new_pcs, new_projected_data = pca(proj_data, n_pcs)
print proj_matrix.shape
print new_pcs.shape
print new_projected_data.shape
final_pcs = (new_pcs * proj_matrix).transpose()
new_data = final_pcs.transpose() * data_matrix
"""
import pdb
pdb.set_trace()
return final_pcs, new_projected_data
import datetime
import os
from weakref import ref
from numpy import array_split, short, fromstring
from numpy.random import rand as rand_array
import anfft
import RPi.GPIO as GPIO
pins = [0, 1, 4, 7, 8, 9, 10, 11, 14, 15, 17, 18, 21, 22, 23, 24, 25]
# Warm up ANFFT, allowing it to determine which FFT algorithm will work fastest on this machine.
anfft.fft(rand_array(1024), measure=True)
class SpectrumAnalyzer(object):
def __init__(self, messageQueue, config):
self.messageQueue = messageQueue
self._dataSinceLastSpectrum = []
self.loadSettings(config)
self.lights = LightController(self, config)
def loadSettings(self, gcp):
# The number of spectrum analyzer bands (also light output channels) to use.
self.frequencyBands = int(gcp.get('main', 'frequencyBands', 16))
