Merge pull request #3027 from tonmoy-saikia/refactor_cgauss

Separate out compact computation of gaussian into a subclass

src/interfaces/modular/Kernel.i

@@ -59,6 +59,7 @@ PROTOCOLS_CUSTOMKERNEL(CustomKernel, float32_t, "f\0", NPY_FLOAT32)
 %rename(DistanceKernel) CDistanceKernel;
 %rename(FixedDegreeStringKernel) CFixedDegreeStringKernel;
 %rename(GaussianKernel) CGaussianKernel;
+%rename(GaussianCompactKernel) CGaussianCompactKernel;
 %rename(DirectorKernel) CDirectorKernel;
 %rename(WaveletKernel) CWaveletKernel;
 %rename(GaussianShiftKernel) CGaussianShiftKernel;

src/shogun/kernel/GaussianCompactKernel.cpp

@@ -0,0 +1,38 @@
+#include <shogun/kernel/GaussianCompactKernel.h>
+
+using namespace shogun;
+
+CGaussianCompactKernel::CGaussianCompactKernel() : CGaussianKernel()
+{
+}
+
+CGaussianCompactKernel::CGaussianCompactKernel(int32_t size, float64_t width)
+                                              : CGaussianKernel(size, width)
+{
+}
+
+CGaussianCompactKernel::CGaussianCompactKernel(CDotFeatures* l, CDotFeatures* r,
+                                              float64_t width, int32_t size)
+                                              : CGaussianKernel(l, r,
+                                                                width, size)
+{
+}
+
+CGaussianCompactKernel::~CGaussianCompactKernel()
+{
+}
+
+float64_t CGaussianCompactKernel::compute(int32_t idx_a, int32_t idx_b)
+{
+    int32_t len_features, power;
+    len_features=((CDotFeatures*) lhs)->get_dim_feature_space();
+    power=(len_features%2==0) ? (len_features+1):len_features;
+
+    float64_t result=distance(idx_a,idx_b);
+    float64_t result_multiplier=1-(CMath::sqrt(result))/3;
+
+    if(result_multiplier<=0)
+        return 0;
+
+    return CMath::pow(result_multiplier, power)*CMath::exp(-result);
+}

src/shogun/kernel/GaussianCompactKernel.h

@@ -0,0 +1,79 @@
+#ifndef _GAUSSIANCOMPACTKERNEL_H___
+#define _GAUSSIANCOMPACTKERNEL_H___
+
+#include <shogun/kernel/GaussianKernel.h>
+
+namespace shogun
+{
+class CDotFeatures;
+/** @brief The compact version as given in Bart Hamers' thesis
+ * <i>Kernel Models for Large Scale Applications</i>
+ * (Eq. 4.10) is computed as
+ *
+ * \f[
+ * k({\bf x},{\bf x'})= max(0, (1-\frac{||{\bf x}-{\bf x'}||}{3\tau})^v)) *
+ * exp(-\frac{||{\bf x}-{\bf x'}||^2}{\tau})
+ * \f]
+ *
+ * where \f$\tau\f$ is the kernel width.
+ *
+ */
+
+class CGaussianCompactKernel: public CGaussianKernel
+{
+    public:
+        /** default constructor */
+        CGaussianCompactKernel();
+
+        /** constructor
+         *
+         * @param size cache size
+         * @param width width
+         */
+        CGaussianCompactKernel(int32_t size, float64_t width);
+
+        /** constructor
+         *
+         * @param l features of left-hand side
+         * @param r features of right-hand side
+         * @param width width
+         * @param size cache size
+         */
+        CGaussianCompactKernel(CDotFeatures* l, CDotFeatures* r,
+                               float64_t width, int32_t size=10);
+
+        /* destructor */
+        virtual ~CGaussianCompactKernel();
+
+        /** return what type of kernel we are
+         *
+         * @return kernel type GAUSSIAN
+         */
+        virtual EKernelType get_kernel_type()
+        {
+            return K_GAUSSIANCOMPACT;
+        }
+
+        /** return the kernel's name
+         *
+         * @return name GaussianCompactKernel
+         */
+        virtual const char* get_name() const
+        {
+            return "GaussianCompactKernel";
+        }
+
+    protected:
+        /** compute kernel function for features a and b
+         * idx_{a,b} denote the index of the feature vectors
+         * in the corresponding feature object
+         *
+         * @param idx_a index a
+         * @param idx_b index b
+         * @return computed kernel function at indices a,b
+         */
+        virtual float64_t compute(int32_t idx_a, int32_t idx_b);
+
+};
+}
+#endif /* _GAUSSIANCOMPACTKERNEL_H__ */

src/shogun/kernel/GaussianKernel.cpp

@@ -117,25 +117,8 @@ bool CGaussianKernel::init(CFeatures* l, CFeatures* r)
 
 float64_t CGaussianKernel::compute(int32_t idx_a, int32_t idx_b)
 {
-	if (!m_compact)
-	{
-		float64_t result=distance(idx_a,idx_b);
-		return CMath::exp(-result);
-	}
-
-	int32_t len_features, power;
-	len_features=((CDotFeatures*) lhs)->get_dim_feature_space();
-	power=(len_features%2==0) ? (len_features+1):len_features;
-
-	float64_t result=distance(idx_a,idx_b);
-	float64_t result_multiplier=1-(sqrt(result))/3;
-
-	if (result_multiplier<=0)
-		result_multiplier=0;
-	else
-		result_multiplier=pow(result_multiplier, power);
-
-	return result_multiplier*exp(-result);
+    float64_t result=distance(idx_a,idx_b);
+    return CMath::exp(-result);
 }
 
 void CGaussianKernel::load_serializable_post() throw (ShogunException)
@@ -185,11 +168,9 @@ SGMatrix<float64_t> CGaussianKernel::get_parameter_gradient(
 void CGaussianKernel::init()
 {
 	set_width(1.0);
-	set_compact_enabled(false);
 	sq_lhs=NULL;
 	sq_rhs=NULL;
 	SG_ADD(&m_log_width, "log_width", "Kernel width in log domain", MS_AVAILABLE, GRADIENT_AVAILABLE);
-	SG_ADD(&m_compact, "compact", "Compact enabled option", MS_AVAILABLE);
 }
 
 float64_t CGaussianKernel::distance(int32_t idx_a, int32_t idx_b)

src/shogun/kernel/GaussianKernel.h

@@ -35,15 +35,6 @@ namespace shogun
  *
  * where \f$\tau\f$ is the kernel width.
  *
- * The compact version as given in Bart Hamers' thesis <i>Kernel Models for
- * Large Scale Applications</i> (Eq. 4.10) is computed as
- *
- * \f[
- * k({\bf x},{\bf x'})= max(0, (1-\frac{||{\bf x}-{\bf x'}||}{3\tau})^v)) *
- * exp(-\frac{||{\bf x}-{\bf x'}||^2}{\tau})
- * \f]
- *
- * where \f$\tau\f$ is the kernel width.
  */
 class CGaussianKernel: public CDotKernel
 {
@@ -114,18 +105,6 @@ class CGaussianKernel: public CDotKernel
 		 */
 		virtual float64_t get_width() const;
 
-		/** set the compact option
-		 *
-		 * @param compact value of the compact option
-		 */
-		inline void set_compact_enabled(bool compact) {	m_compact=compact; }
-
-		/** return value of the compact option
-		 *
-		 * @return whether the compact option is enabled
-		 */
-		inline bool get_compact_enabled() { return m_compact; }
-
 		/** return derivative with respect to specified parameter
 		 *
 		 * @param param the parameter
@@ -194,8 +173,6 @@ class CGaussianKernel: public CDotKernel
 		float64_t* sq_lhs;
 		/** squared right-hand side */
 		float64_t* sq_rhs;
-		/** whether compact output enabled */
-		bool m_compact;
 };
 }
 #endif /* _GAUSSIANKERNEL_H__ */

src/shogun/kernel/Kernel.cpp

@@ -720,6 +720,7 @@ void CKernel::list_kernel()
 		ENUM_CASE(K_GAUSSIAN)
 		ENUM_CASE(K_GAUSSIANSHIFT)
 		ENUM_CASE(K_GAUSSIANMATCH)
+		ENUM_CASE(K_GAUSSIANCOMPACT)
 		ENUM_CASE(K_HISTOGRAM)
 		ENUM_CASE(K_SALZBERG)
 		ENUM_CASE(K_LOCALITYIMPROVED)

src/shogun/kernel/Kernel.h

@@ -62,6 +62,7 @@ enum EKernelType
 	K_GAUSSIAN = 30,
 	K_GAUSSIANSHIFT = 32,
 	K_GAUSSIANMATCH = 33,
+	K_GAUSSIANCOMPACT = 34,
 	K_HISTOGRAM = 40,
 	K_SALZBERG = 41,
 	K_LOCALITYIMPROVED = 50,