Introduced two shifts to customize LLE algorithm processing

shogun-toolbox · Oct 4, 2011 · a0cc551 · a0cc551
1 parent 5fab1f0
commit a0cc551
Show file tree

Hide file tree

Showing 2 changed files with 68 additions and 7 deletions.
diff --git a/src/shogun/preprocessor/LocallyLinearEmbedding.cpp b/src/shogun/preprocessor/LocallyLinearEmbedding.cpp
@@ -55,6 +55,8 @@ struct LINRECONSTRUCTION_THREAD_PARAM
 	float64_t* id_vector;
 	/// weight matrix
 	float64_t* W_matrix;
+	/// reconstruction regularization shift
+	float64_t m_reconstruction_shift;
 };
 
 struct NEIGHBORHOOD_THREAD_PARAM
@@ -100,13 +102,19 @@ CLocallyLinearEmbedding::CLocallyLinearEmbedding() :
 		CDimensionReductionPreprocessor<float64_t>()
 {
 	m_k = 3;
+	m_nullspace_shift = -1e-9;
+	m_reconstruction_shift = 1e-3;
 
 	init();
 }
 
 void CLocallyLinearEmbedding::init()
 {
 	m_parameters->add(&m_k, "k", "number of neighbors");
+	m_parameters->add(&m_nullspace_shift, "nullspace_shift",
+	                  "nullspace finding regularization shift");
+	m_parameters->add(&m_reconstruction_shift, "reconstruction_shift", 
+	                  "shift used to regularize reconstruction step");
 }
 
 
@@ -125,6 +133,26 @@ int32_t CLocallyLinearEmbedding::get_k() const
 	return m_k;
 }
 
+void CLocallyLinearEmbedding::set_nullspace_shift(float64_t nullspace_shift)
+{
+	m_nullspace_shift = nullspace_shift;
+}
+
+float64_t CLocallyLinearEmbedding::get_nullspace_shift() const
+{
+	return m_nullspace_shift;
+}
+
+void CLocallyLinearEmbedding::set_reconstruction_shift(float64_t reconstruction_shift)
+{
+	m_reconstruction_shift = reconstruction_shift;
+}
+
+float64_t CLocallyLinearEmbedding::get_reconstruction_shift() const
+{
+	return m_reconstruction_shift;
+}
+
 const char* CLocallyLinearEmbedding::get_name() const
 {
 	return "LocallyLinearEmbedding";
@@ -246,6 +274,7 @@ SGMatrix<float64_t> CLocallyLinearEmbedding::construct_weight_matrix(CSimpleFeat
 		parameters[t].covariance_matrix = covariance_matrix+(m_k*m_k)*t;
 		parameters[t].id_vector = id_vector+m_k*t;
 		parameters[t].W_matrix = W_matrix;
+		parameters[t].m_reconstruction_shift = m_reconstruction_shift;
 		pthread_create(&threads[t], &attr, run_linearreconstruction_thread, (void*)&parameters[t]);
 	}
 	for (t=0; t<num_threads; t++)
@@ -267,6 +296,7 @@ SGMatrix<float64_t> CLocallyLinearEmbedding::construct_weight_matrix(CSimpleFeat
 	single_thread_param.covariance_matrix = covariance_matrix;
 	single_thread_param.id_vector = id_vector;
 	single_thread_param.W_matrix = W_matrix;
+	single_thread_param.m_reconstruction_shift = m_reconstruction_shift;
 	run_linearreconstruction_thread((void*)single_thread_param);
 #endif
 
@@ -366,7 +396,7 @@ SGMatrix<float64_t> CLocallyLinearEmbedding::find_null_space(SGMatrix<float64_t>
 		// using ARPACK (faster)
 		eigenvalues_vector = SG_MALLOC(float64_t, dimension+1);
 		#ifdef HAVE_ARPACK
-		arpack_xsxupd<float64_t>(matrix.matrix,NULL,N,dimension+1,"LA",3,true,0.0,0.0,
+		arpack_xsxupd<float64_t>(matrix.matrix,NULL,N,dimension+1,"LA",3,true,m_nullspace_shift,0.0,
 		                         eigenvalues_vector,matrix.matrix,eigenproblem_status);
 		#endif
 	}
@@ -425,6 +455,7 @@ void* CLocallyLinearEmbedding::run_linearreconstruction_thread(void* p)
 	float64_t* covariance_matrix = parameters->covariance_matrix;
 	float64_t* id_vector = parameters->id_vector;
 	float64_t* W_matrix = parameters->W_matrix;
+	float64_t m_reconstruction_shift = parameters->m_reconstruction_shift;
 
 	int32_t i,j,k;
 	float64_t norming,trace;
@@ -464,7 +495,7 @@ void* CLocallyLinearEmbedding::run_linearreconstruction_thread(void* p)
 				trace += covariance_matrix[j*m_k+j];
 
 			for (j=0; j<m_k; j++)
-				covariance_matrix[j*m_k+j] += 1e-3*trace;
+				covariance_matrix[j*m_k+j] += m_reconstruction_shift*trace;
 		}
 
 		// solve system of linear equations: covariance_matrix * X = 1

diff --git a/src/shogun/preprocessor/LocallyLinearEmbedding.h b/src/shogun/preprocessor/LocallyLinearEmbedding.h
@@ -41,9 +41,9 @@ class CDistance;
  *
  * Due to computation speed, ARPACK is being used with small 
  * regularization of weight matrix and Cholesky factorization is used
- * internally for Lanzcos iterations. If the results aren't reasonable
- * LUP factorization could be used with posdef parameter set to 
- * false using set_posdef.
+ * internally for Lanzcos iterations (in case of only LAPACK is available)
+ * and SUPERLU library for fast solving sparse equations stated by ARPACK 
+ * is being used if available.
  *
  */
 class CLocallyLinearEmbedding: public CDimensionReductionPreprocessor<float64_t>
@@ -81,16 +81,37 @@ class CLocallyLinearEmbedding: public CDimensionReductionPreprocessor<float64_t>
 	void set_k(int32_t k);
 
 	/** getter for k parameter
-	 * @return k value
+	 * @return m_k value
 	 */
 	int32_t get_k() const;
 
+	/** setter for reconstruction shift parameter
+	 * @param reconstruction_shift reconstruction shift value
+	 */
+	void set_reconstruction_shift(float64_t reconstruction_shift);
+
+	/** getter for reconstruction shift parameter
+	 * @return m_reconstruction_shift value
+	 */
+	float64_t get_reconstruction_shift() const;
+
+	/** setter for nullspace shift parameter
+	 * @param reconstruction_shift reconstruction shift value
+	 */
+	void set_nullspace_shift(float64_t nullspace_shift);
+
+	/** getter for nullspace shift parameter
+	 * @return m_nullspace_shift value
+	 */
+	float64_t get_nullspace_shift() const;
+
 	/** get name */
 	virtual const char* get_name() const;
 
 	/** get type */
 	virtual EPreprocessorType get_type() const;
 
+	/// HELPERS
 protected:
 
 	/** default init */
@@ -118,17 +139,26 @@ class CLocallyLinearEmbedding: public CDimensionReductionPreprocessor<float64_t>
 	 */
 	SGMatrix<int32_t> get_neighborhood_matrix(SGMatrix<float64_t> distance_matrix);
 
+	/// FIELDS
 protected:
 
 	/** number of neighbors */
 	int32_t m_k;
 
+	/** regularization shift of reconstruction step */
+	float64_t m_reconstruction_shift;
+
+	/** regularization shift of nullspace finding step */
+	float64_t m_nullspace_shift;
+
+	/// CONSTANTS
 public:
 
-	/** adaptive k choice 
+	/** adaptive k choice flag
 	 * NOT IMPLEMENTED */
 	static const int32_t ADAPTIVE_K = -1;
 
+	/// THREADS
 protected:
 
 	/** runs neighborhood determination thread