Merge pull request #12 from foulwall/perceptron

data importer

common/fetch_data.py

@@ -3,16 +3,16 @@
 import json
 def get_binary_features(request):
     try:
-        class_a_point_set_raw = json.loads(request.POST['mouse_left_click_point_set'])
-        class_b_point_set_raw = json.loads(request.POST['mouse_right_click_point_set'])
+        point_set_raw = json.loads(request.POST['point_set'])
     except:
         raise ValueError("cannot read click pts")
     class_a_point_set = []
     class_b_point_set = []
-    for point in class_a_point_set_raw:
-        class_a_point_set.append([point['x'], point['y']])
-    for point in class_b_point_set_raw:
-        class_b_point_set.append([point['x'], point['y']])
+    for point in point_set_raw:
+        if point['label'] == 1:
+            class_a_point_set.append([point['x'], point['y']])
+        else:
+            class_b_point_set.append([point['x'], point['y']])
     class_a = np.transpose(np.array(class_a_point_set, dtype=float))
     class_b = np.transpose(np.array(class_b_point_set, dtype=float))
 

demo/classification_binary.py

@@ -52,7 +52,10 @@ def entrance(request):
                            'panel_name': 'arguments',
                            'panel_label': 'Arguments',
                            'panel_property': arguments
-                       }]}
+                       },
+                       {
+                           'panel_name': 'toy_data',
+                           'panel_label': 'Toy Data'}]}
     return render_to_response("classification/binary.html",
                               properties,
                               context_instance = RequestContext(request))
@@ -69,8 +72,9 @@ def classify(request):
         return HttpResponse(json.dumps({"status": e.message}))
 
     try:
+        domain = json.loads(request.POST['axis_domain'])
         C = float(request.POST["C"])
-        x, y, z = classify_svm(sg.LibSVM, features, labels, kernel, C=C)
+        x, y, z = classify_svm(sg.LibSVM, features, labels, kernel, domain, C=C)
     except Exception as e:
         import traceback
         return HttpResponse(json.dumps({"status": repr(traceback.format_exc())}))
@@ -79,13 +83,13 @@ def classify(request):
                                      'domain': [np.min(z), np.max(z)],
                                      'z': z.tolist() }))
 
-def classify_svm(classifier, features, labels, kernel, C=1):
+def classify_svm(classifier, features, labels, kernel, domain, C=1):
     svm = classifier(C, kernel, labels)
     svm.train(features)
 
     size = 100
-    x1 = np.linspace(0, 1, size)
-    y1 = np.linspace(0, 1, size)
+    x1 = np.linspace(domain['horizontal'][0], domain['horizontal'][1], size)
+    y1 = np.linspace(domain['vertical'][0], domain['vertical'][1], size)
     x, y = np.meshgrid(x1, y1)
 
     test = sg.RealFeatures(np.array((np.ravel(x), np.ravel(y))))

demo/classification_perceptron.py

@@ -41,7 +41,10 @@ def entrance(request):
                            'panel_name': 'arguments',
                            'panel_label': 'Arguments',
                            'panel_property': arguments
-                       }]}
+                       },
+                       {
+                           'panel_name': 'toy_data',
+                           'panel_label': 'Toy Data'}]}
     return render_to_response("classification/binary.html",
                               properties,
                               context_instance = RequestContext(request))

demo/clustering.py

@@ -28,6 +28,7 @@ def entrance(request):
         }]
     properties = { 'title': 'Clustering',
                    'template': {'type': 'coordinate-2dims',
+                                'feature': 'binary',
                                 'coordinate_range': {'horizontal': [0, 1],
                                                      'vertical': [0, 0.8]},
                                 'coordinate_system': {'horizontal_axis': {'position': 'bottom',
@@ -42,7 +43,10 @@ def entrance(request):
                            'panel_name': 'arguments',
                            'panel_label': 'Arguments',
                            'panel_property': arguments
-                       }]}
+                       },
+                       {
+                           'panel_name': 'toy_data',
+                           'panel_label': 'toy data'}]}
     return render_to_response("clustering/index.html", properties, context_instance=RequestContext(request))
 
 def cluster(request):
@@ -52,40 +56,37 @@ def cluster(request):
         centers = kmeans.get_cluster_centers()
         radi = kmeans.get_radiuses()
         result = {'circle': []}
-        for i in xrange(arguments[3]): # arguments[3] is k
+        for i in xrange(arguments[2]): # arguments[3] is k
             result['circle'].append({'x': centers[0,i],
                                      'y': centers[1,i],
                                      'r': radi[i]})
         return HttpResponse(json.dumps(result))
     except:
+        import traceback
+        print traceback.format_exc()
         return HttpResponseNotFound()
 
 def _read_data(request):
     k = int(request.POST['number_of_clusters'])
     if k > 500:
         raise TypeError
-    positive = json.loads(request.POST['mouse_left_click_point_set'])
-    negative = json.loads(request.POST['mouse_right_click_point_set'])
+    point_set = json.loads(request.POST['point_set'])
     distance_name = request.POST['distance']
-        
-    if len(positive) == 0 and len(negative) == 0:
+
+    if len(point_set) == 0:
         raise TypeError
-    return (positive, negative, distance_name, k)
+    return (point_set, distance_name, k)
 
-def _train_clustering(positive, negative, distance_name, k):
-    labels = np.array([1]*len(positive) + [-1]*len(negative), dtype=np.float64)
-    num_pos = len(positive)
-    num_neg = len(negative)
-    features = np.zeros((2, num_pos+num_neg))
-
-    for i in xrange(num_pos):
-        features[0, i] = positive[i]['x']
-        features[1, i] = positive[i]['y']
-
-    for i in xrange(num_neg):
-        features[0, i+num_pos] = negative[i]['x']
-        features[1, i+num_pos] = negative[i]['y']
-
+def _train_clustering(point_set, distance_name, k):
+    labels = np.array([0]*len(point_set))
+    features = np.zeros((2, len(point_set)))
+
+    print labels
+    for i in xrange(len(point_set)):
+        features[0, i] = point_set[i]['x']
+        features[1, i] = point_set[i]['y']
+        labels[i] = point_set[i]['label']
+
     lab = sg.BinaryLabels(labels)
     train = sg.RealFeatures(features)
 
@@ -96,7 +97,7 @@ def _train_clustering(positive, negative, distance_name, k):
     elif distance_name == "JensenMetric":
         distance = sg.JensenMetric(train, train)
     else:
-       raise TypeError
+        raise TypeError
 
     kmeans = sg.KMeans(k, distance)
     kmeans.train()

demo/gp.py

@@ -27,14 +27,21 @@ def entrance(request):
             'argument_label': 'Kernel Width',
             'argument_name': 'sigma',
             'argument_default': '2.0'},
+        {
+            'argument_type': 'decimal',
+            'argument_label': 'Noise Level',
+            'argument_name': 'noise_level',
+            'argument_default': '0.1'},
         {
             'argument_type': 'button-group',
-            'argument_items': [{'button_name': 'TrainGP'},
-                               {'button_name': 'Clear'}]
+            'argument_items': [{'button_name': 'TrainGP',
+                                'button_type': 'json_up_down_load'},
+                               {'button_name': 'clear'}]
         }
     ]
     properties = { 'title': 'Gaussian Process Regression Demo',
                    'template': {'type': 'coordinate-2dims',
+                                'mouse_click_enabled': 'left',
                                 'coordinate_system': {'horizontal_axis': {'range': [-5, 5]},
                                                       'vertical_axis': {'range': [-5, 5]}}},
                    'panels': [
@@ -44,7 +51,7 @@ def entrance(request):
                            'panel_property': arguments
                        },
                        {
-                           'panel_name': 'toy_data_generator',
+                           'panel_name': 'toy_data',
                            'panel_label': 'Toy Data'
                        }]}
     return render_to_response("gp/index.html", properties, context_instance = RequestContext(request))
@@ -62,11 +69,12 @@ def train(request):
 def _read_toy_data(request):
     y_set = []
     x_set = []
-    toy_data = json.loads(request.POST['mouse_left_click_point_set'])
+    toy_data = json.loads(request.POST['point_set'])
     for pt in toy_data:
         y_set.append(float(pt["y"]))
         x_set.append(float(pt["x"]))
     noise_level = float(request.POST['noise_level'])
+    domain = json.loads(request.POST['axis_domain'])
 
     labels = np.array(y_set, dtype = np.float64)
     num = len(x_set)
@@ -78,9 +86,9 @@ def _read_toy_data(request):
     feat_train = sg.RealFeatures(examples)
     labels = sg.RegressionLabels(labels)
     kernel = get_kernel(request, feat_train)
-    return (feat_train, labels, noise_level, kernel)
+    return (feat_train, labels, noise_level, kernel, domain)
 
-def _process(feat_train, labels, noise_level, kernel):
+def _process(feat_train, labels, noise_level, kernel, domain):
     n_dimensions = 1
 
     likelihood = sg.GaussianLikelihood()
@@ -95,7 +103,9 @@ def _process(feat_train, labels, noise_level, kernel):
     inf = sg.ExactInferenceMethod(SECF, feat_train, zmean, labels, likelihood)
 
     # location of unispaced predictions
-    x_test = np.array([np.linspace(-5, 5, feat_train.get_num_vectors())])
+    x_test = np.array([np.linspace(domain['horizontal'][0],
+                                   domain['horizontal'][1],
+                                   feat_train.get_num_vectors())])
     feat_test = sg.RealFeatures(x_test)
 
     gp = sg.GaussianProcessRegression(inf)

demo/kernel_matrix.py

@@ -4,7 +4,7 @@
 
 import modshogun as sg
 import numpy as np
-import scipy as sp
+import scipy as spxx
 import json
 
 def entrance(request):
@@ -34,21 +34,18 @@ def entrance(request):
                    'template': {'type': 'coordinate-2dims',
                                 'mouse_click_enabled': 'left',
                                 'heatmap': { 'contour': True },
-                                'coordinate_system': {'horizontal_axis': {'range':[-5.0, 5.0],
-                                                                          'position': 'bottom'},
-                                                      'vertical_axis': {'range':[-4.0, 4.0],
-                                                                        'position': 'left'}}},
+                                'coordinate_system': {'horizontal_axis': {'range':[-5.0, 5.0]},
+                                                      'vertical_axis': {'range':[-4.0, 4.0]}}},
                    'panels': [
                         {
                             'panel_name': 'arguments',
                             'panel_label': 'Arguments',
                             'panel_property': arguments
                         },
                         {
-                            'panel_name': 'toy_data_generator',
+                            'panel_name': 'toy_data',
                             'panel_label': 'Toy Data'
-                        },
-                        ]
+                        }]}
     return render_to_response("kernel_matrix/index.html",
                               properties,
                               context_instance = RequestContext(request))
@@ -59,8 +56,6 @@ def generate(request):
         arguments = _read_toy_data(request)
         result = _process(*arguments)
     except:
-        import traceback
-        print traceback.format_exc()
         raise Http404
 
     return HttpResponse(json.dumps({'status': 'ok',
@@ -70,7 +65,7 @@ def generate(request):
 def _read_toy_data(request):
     y_set = []
     x_set = []
-    data = json.loads(request.POST['mouse_left_click_point_set'])
+    data = json.loads(request.POST['point_set'])
     for pt in data:
         y_set.append(float(pt["y"]))
         x_set.append(float(pt["x"]))
@@ -90,7 +85,7 @@ def _process(x1_set, x2_set, kernel_width, kernel_name, degree):
     feat_train = sg.RealFeatures(examples)
 
     # construct covariance function
-    if kernel_name == "LinearKernel":
+    if kernelname == "LinearKernel":
         kernel = sg.LinearKernel(feat_train, feat_train)
     elif kernel_name == "PolynomialKernel":
         kernel = sg.PolyKernel(feat_train, feat_train, degree, True)

demo/svr.py

@@ -58,26 +58,31 @@ def entrance(request):
                            'panel_name': 'arguments',
                            'panel_label': 'Arguments',
                            'panel_property': arguments
+                       },
+                       {
+                           'panel_name': 'toy_data',
+                           'panel_label': 'toy data',
                        }]}
     return render_to_response("svr/index.html", properties, context_instance=RequestContext(request))
 
 def point(request):
     try:
         arguments=_read_data(request)
         svm=_train_svr(*arguments)
-        x=np.linspace(0, 1, 100)
+        domain = json.loads(request.POST['axis_domain'])
+        x=np.linspace(domain['horizontal'][0], domain['horizontal'][1], 100)
         y=np.array(svm.apply(sg.RealFeatures(np.array([x]))).get_labels(), dtype=np.float64)
         line_dot = []
         for i in xrange(len(x)):
-            line_dot.append({'x_value' : x[i], 'y_value' : y[i]})
+            line_dot.append({'x' : x[i], 'y' : y[i]})
         return HttpResponse(json.dumps(line_dot))
     except:
         raise Http404
 
 def _read_data(request):
     labels = []
     features = []
-    data = json.loads(request.POST['mouse_left_click_point_set'])
+    data = json.loads(request.POST['point_set'])
     cost = float(request.POST['C'])
     tubeeps = float(request.POST['tube'])
     kernel_name = request.POST['kernel']
@@ -92,7 +97,7 @@ def _read_data(request):
 
     for i in xrange(num):
         examples[0,i] = features[i]
-        
+
     lab = sg.RegressionLabels(labels)
     train = sg.RealFeatures(examples)
     kernel = get_kernel(request, train)

shogun_demo/settings.py

@@ -157,3 +157,7 @@
         },
     }
 }
+
+TEMPLATE_CONTEXT_PROCESSORS = (
+    'toy_data.importer.files',
+)

shogun_demo/urls.py

@@ -25,10 +25,11 @@
     url(r'^gp/entrance', 'demo.gp.entrance'),
     url(r'^gp/create_toy_data', 'demo.gp.create_toy_data'),
     url(r'^gp/load_toy_data', 'demo.gp.load_toy_data'),
-    url(r'^gp/train', 'demo.gp.train'),
+    url(r'^gp/TrainGP', 'demo.gp.train'),
     url(r'^kernel_matrix/entrance', 'demo.kernel_matrix.entrance'),
     url(r'^kernel_matrix/generate', 'demo.kernel_matrix.generate'),
     url(r'^toy_data/generator/generate', 'toy_data.generator.generate'),
+    url(r'^toy_data/importer/dump', 'toy_data.importer.dump'),
 
     # url(r'^shogun_demo/', include('shogun_demo.foo.urls')),