Added current version of the EDRT tutorial

shogun-toolbox · Jan 26, 2012 · 2f45918 · 2f45918
1 parent a40d724
commit 2f45918
Show file tree

Hide file tree

Showing 14 changed files with 370 additions and 0 deletions.
diff --git a/applications/edrt/tutorial.pdf b/applications/edrt/tutorial.pdf
diff --git a/applications/edrt/tutorial_examples/data.py b/applications/edrt/tutorial_examples/data.py
@@ -0,0 +1,9 @@
+import numpy
+
+def swissroll(N=1000):
+	tt = numpy.array((5*numpy.pi/4)*(1+2*numpy.random.rand(N)))
+	height = numpy.array((numpy.random.rand(N)-0.5))
+	noise = 0.0
+	X = numpy.array([(tt+noise*numpy.random.randn(N))*numpy.cos(tt), 10*height, (tt+noise*numpy.random.randn(N))*numpy.sin(tt)])
+	return X
+
diff --git a/applications/edrt/tutorial_examples/dm.py b/applications/edrt/tutorial_examples/dm.py
@@ -0,0 +1,31 @@
+import modshogun as sg
+import data
+import numpy as np
+
+# load data
+feature_matrix = data.swissroll()
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Diffusion Maps converter instance
+converter = sg.DiffusionMaps()
+
+# set target dimensionality
+converter.set_target_dim(2)
+# set number of time-steps
+converter.set_t(2)
+
+# create Gaussian kernel instance
+kernel = sg.GaussianKernel(100,10.0)
+# enable converter instance to use created kernel instance
+converter.set_kernel(kernel)
+
+# compute embedding with Diffusion Maps method
+embedding = converter.embed(features)
+
+# compute linear kernel matrix
+kernel_matrix = np.dot(feature_matrix.T,feature_matrix)
+# create Custom Kernel instance
+custom_kernel = sg.CustomKernel(kernel_matrix)
+# construct embedding based on created kernel
+kernel_embedding = converter.embed_kernel(custom_kernel)
diff --git a/applications/edrt/tutorial_examples/hlle.py b/applications/edrt/tutorial_examples/hlle.py
@@ -0,0 +1,22 @@
+import modshogun as sg
+import data
+
+# load data
+feature_matrix = data.swissroll()
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Hessian Locally Linear Embedding converter instance
+converter = sg.HessianLocallyLinearEmbedding()
+
+# set target dimensionality
+converter.set_target_dim(2)
+# set number of neighbors 
+converter.set_k(10)
+# set number of threads
+converter.parallel.set_num_threads(2)
+# set nullspace shift (optional)
+converter.set_nullspace_shift(-1e-6)
+
+# compute embedding with Hessian Locally Linear Embedding method
+embedding = converter.embed(features)
diff --git a/applications/edrt/tutorial_examples/isomap.py b/applications/edrt/tutorial_examples/isomap.py
@@ -0,0 +1,40 @@
+import modshogun as sg
+import data
+import numpy as np
+
+# load data
+feature_matrix = data.swissroll()
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Isomap converter instance
+converter = sg.Isomap()
+
+# set target dimensionality
+converter.set_target_dim(2)
+
+# compute embedding with Isomap method
+embedding = converter.embed(features)
+
+# enable landmark approximation
+converter.set_landmark(True)
+# set number of landmarks
+converter.set_landmark_number(100)
+# set number of threads
+converter.parallel.set_num_threads(2)
+# compute approximate embedding
+approx_embedding = converter.embed(features)
+# disable landmark approximation
+converter.set_landmark(False)
+
+# compute cosine distance matrix 'manually'
+N = features.get_num_vectors()
+distance_matrix = np.zeros((N,N))
+for i in range(N):
+	for j in range(N):
+		distance_matrix[i,j] = \
+		  np.cos(np.linalg.norm(feature_matrix[:,i]-feature_matrix[:,j],2))
+# create custom distance instance
+distance = sg.CustomDistance(distance_matrix)
+# construct embedding based on created distance
+converter.embed_distance(distance)
diff --git a/applications/edrt/tutorial_examples/klle.py b/applications/edrt/tutorial_examples/klle.py
@@ -0,0 +1,35 @@
+import modshogun as sg
+import data
+import numpy as np
+
+# load data
+feature_matrix = data.swissroll()
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Kernel Locally Linear Embedding converter instance
+converter = sg.KernelLocallyLinearEmbedding()
+
+# set target dimensionality
+converter.set_target_dim(2)
+# set number of neighbors 
+converter.set_k(10)
+# set number of threads
+converter.parallel.set_num_threads(2)
+# set nullspace shift (optional)
+converter.set_nullspace_shift(-1e-6)
+
+# create Gaussian kernel instance
+kernel = sg.GaussianKernel(100,10.0)
+# enable converter instance to use created kernel instance
+converter.set_kernel(kernel)
+
+# compute embedding with Kernel Locally Linear Embedding method
+embedding = converter.embed(features)
+
+# compute linear kernel matrix
+kernel_matrix = np.dot(feature_matrix.T,feature_matrix)
+# create Custom Kernel instance
+custom_kernel = sg.CustomKernel(kernel_matrix)
+# construct embedding based on created kernel
+kernel_embedding = converter.embed_kernel(custom_kernel)
diff --git a/applications/edrt/tutorial_examples/kltsa.py b/applications/edrt/tutorial_examples/kltsa.py
@@ -0,0 +1,36 @@
+import modshogun as sg
+import data
+import numpy as np
+
+# load data
+feature_matrix = data.swissroll()
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Kernel Local Tangent Space Alignment converter instance
+converter = sg.KernelLocalTangentSpaceAlignment()
+
+# set target dimensionality
+converter.set_target_dim(2)
+# set number of neighbors 
+converter.set_k(10)
+# set number of threads
+converter.parallel.set_num_threads(2)
+# set nullspace shift (optional)
+converter.set_nullspace_shift(-1e-6)
+
+# create Sigmoid kernel instance
+kernel = sg.SigmoidKernel(100,10.0,1.0)
+# enable converter instance to use created kernel instance
+converter.set_kernel(kernel)
+
+# compute embedding with Kernel Local Tangent Space Alignment method
+embedding = converter.embed(features)
+
+# compute linear kernel matrix
+kernel_matrix = np.dot(feature_matrix.T,feature_matrix)
+# create Custom Kernel instance
+custom_kernel = sg.CustomKernel(kernel_matrix)
+# construct embedding based on created kernel
+kernel_embedding = converter.embed_kernel(custom_kernel)
+
diff --git a/applications/edrt/tutorial_examples/la.py b/applications/edrt/tutorial_examples/la.py
@@ -0,0 +1,33 @@
+import modshogun as sg
+import data
+import numpy as np
+
+# load data
+feature_matrix = data.swissroll()
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Laplacian Eigenmaps converter instance
+converter = sg.LaplacianEigenmaps()
+
+# set target dimensionality
+converter.set_target_dim(2)
+# set number of neighbors
+converter.set_k(20)
+# set tau multiplier 
+converter.set_tau(1.0)
+
+# compute embedding with Laplacian Eigenmaps method
+embedding = converter.embed(features)
+
+# compute cosine distance matrix 'manually'
+N = features.get_num_vectors()
+distance_matrix = np.zeros((N,N))
+for i in range(N):
+	for j in range(N):
+		distance_matrix[i,j] = \
+		  np.linalg.norm(feature_matrix[:,i]-feature_matrix[:,j],2)
+# create custom distance instance
+distance = sg.CustomDistance(distance_matrix)
+# construct embedding based on created distance
+converter.embed_distance(distance)
diff --git a/applications/edrt/tutorial_examples/lle.py b/applications/edrt/tutorial_examples/lle.py
@@ -0,0 +1,38 @@
+import modshogun as sg
+import data
+
+# load data
+feature_matrix = data.swissroll() 
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Locally Linear Embedding converter instance
+converter = sg.LocallyLinearEmbedding()
+
+# set target dimensionality
+converter.set_target_dim(2)
+# set number of neighbors 
+converter.set_k(10)
+# set number of threads
+converter.parallel.set_num_threads(2)
+# set reconstruction shift (optional)
+converter.set_reconstruction_shift(1e-3)
+# set nullspace shift (optional)
+converter.set_nullspace_shift(-1e-6)
+# check whether arpack is used
+if converter.get_use_arpack():
+	print 'ARPACK is used'
+else:
+	print 'LAPACK is used'
+
+# compute embedding with Locally Linear Embedding method
+embedding_first = converter.embed(features)
+
+# enable auto k search in range of (10,100)
+# based on reconstruction error
+converter.set_k(50)
+converter.set_max_k(100)
+converter.set_auto_k(True)
+
+# compute embedding with Locally Linear Embedding method
+embedding_second = converter.embed(features)
diff --git a/applications/edrt/tutorial_examples/lltsa.py b/applications/edrt/tutorial_examples/lltsa.py
@@ -0,0 +1,22 @@
+import modshogun as sg
+import dataloader as loader
+
+# load data
+feature_matrix = loader.load('mnist.mat')
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Linear Local Tangent Space Alignment converter instance
+converter = sg.LinearLocalTangentSpaceAlignment()
+
+# set target dimensionality
+converter.set_target_dim(2)
+# set number of neighbors 
+converter.set_k(10)
+# set number of threads
+converter.parallel.set_num_threads(2)
+# set nullspace shift (optional)
+converter.set_nullspace_shift(-1e-6)
+
+# compute embedding with Linear Local Tangent Space Alignment method
+embedding = converter.embed(features)
diff --git a/applications/edrt/tutorial_examples/lpp.py b/applications/edrt/tutorial_examples/lpp.py
@@ -0,0 +1,20 @@
+import modshogun as sg
+import data
+
+# load data
+feature_matrix = data.swissroll()
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Locality Preserving Projections converter instance
+converter = sg.LocalityPreservingProjections()
+
+# set target dimensionality
+converter.set_target_dim(2)
+# set number of neighbors 
+converter.set_k(10)
+# set number of threads
+converter.parallel.set_num_threads(2)
+
+# compute embedding with Locality Preserving Projections method
+embedding = converter.embed(features)
diff --git a/applications/edrt/tutorial_examples/ltsa.py b/applications/edrt/tutorial_examples/ltsa.py
@@ -0,0 +1,22 @@
+import modshogun as sg
+import data
+
+# load data
+feature_matrix = data.swissroll()
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Local Tangent Space Alignment converter instance
+converter = sg.LocalTangentSpaceAlignment()
+
+# set target dimensionality
+converter.set_target_dim(2)
+# set number of neighbors 
+converter.set_k(10)
+# set number of threads
+converter.parallel.set_num_threads(2)
+# set nullspace shift (optional)
+converter.set_nullspace_shift(-1e-6)
+
+# compute embedding with Local Tangent Space Alignment method
+embedding = converter.embed(features)
diff --git a/applications/edrt/tutorial_examples/mds.py b/applications/edrt/tutorial_examples/mds.py
@@ -0,0 +1,40 @@
+import modshogun as sg
+import data
+import numpy as np
+
+# load data
+feature_matrix = data.swissroll()
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Multidimensional Scaling converter instance
+converter = sg.MultidimensionalScaling()
+
+# set target dimensionality
+converter.set_target_dim(2)
+
+# compute embedding with Multidimensional Scaling method
+embedding = converter.embed(features)
+
+# enable landmark approximation
+converter.set_landmark(True)
+# set number of landmarks
+converter.set_landmark_number(100)
+# set number of threads
+converter.parallel.set_num_threads(2)
+# compute approximate embedding
+approx_embedding = converter.embed(features)
+# disable landmark approximation
+converter.set_landmark(False)
+
+# compute cosine distance matrix 'manually'
+N = features.get_num_vectors()
+distance_matrix = np.zeros((N,N))
+for i in range(N):
+	for j in range(N):
+		distance_matrix[i,j] = \
+		  np.cos(np.linalg.norm(feature_matrix[:,i]-feature_matrix[:,j],2))
+# create custom distance instance
+distance = sg.CustomDistance(distance_matrix)
+# construct embedding based on created distance
+converter.embed_distance(distance)
diff --git a/applications/edrt/tutorial_examples/npe.py b/applications/edrt/tutorial_examples/npe.py
@@ -0,0 +1,22 @@
+import modshogun as sg
+import data
+
+# load data
+feature_matrix = data.swissroll()
+# create features instance
+features = sg.RealFeatures(feature_matrix)
+
+# create Neighborhood Preserving Embedding converter instance
+converter = sg.NeighborhoodPreservingEmbedding()
+
+# set target dimensionality
+converter.set_target_dim(2)
+# set number of neighbors 
+converter.set_k(10)
+# set number of threads
+converter.parallel.set_num_threads(2)
+# set nullspace shift (optional)
+converter.set_nullspace_shift(-1e-6)
+
+# compute embedding with Neighborhood Preserving Projections method
+embedding = converter.embed(features)