Skip to content

Latest commit

 

History

History
95 lines (85 loc) · 7.79 KB

README.md

File metadata and controls

95 lines (85 loc) · 7.79 KB
Raw
  • Author : Shogun.
  • Description : Shogun demos, done in django.

Running Demos Locally

  • To server the static files (required to run the demos) in the development server
    • In /settings.py change PRODUCTION = True to PRODUCTION = False
  • Start the Django development server using python manage.py runserver
  • On doing python manage.py runserver you should see the <addr>:<port> its running at. (Typically http://127.0.0.1:8000/)
  • Third Party distributions for Django

Explanation of directory content

  • /demos : Handles the requests, present the demos
  • /toy_data : Handles the requests, and generate/import toy data.
  • /static : css, js used by demo
  • /template : All templates for each different page.
  • /shogun_demo:
    • settings.py : Configuration.
    • urls.py : Urls and method in demos.

Currently available demos

  • http://<addr>:<port>/regression/svr/ : A demo for support vector regression
  • http://<addr>:<port>/regression/regression/ : A demo for ridge regression
  • http://<addr>:<port>/regression/gp/ : A demo for gaussian process regression
  • http://<addr>:<port>/classifier/binary/ : A demo for binary classification
  • http://<addr>:<port>/classifier/perceptron/ : A demo for binary perceptron
  • http://<addr>:<port>/classifier/multiclass/ : A demo for multiclass classification
  • http://<addr>:<port>/classifier/gp/ : A demo for gaussian process classification
  • http://<addr>:<port>/misc/kernel_matrix/ : A demo for kernel matrix visualization
  • http://<addr>:<port>/application/ocr/ : A demo for recognizing hand-written digits.
  • http://<addr>:<port>/application/language_detect/ : A demo for language detection
  • http://<addr>:<port>/clustering/kmeans/ : A demo for clustering using kmeans

Docs

An Example contains a front-end script(javascript) and a backend controller(python).

  • front-end

    • Entrance Generator Entrance generator is a python method used to generate the entrance page of the demo. All the demo's entrance page will be in same layout(a main title, a canvas section and a panel section). The Entrance Generator takes an HttpRequest Object as its first parameter, which is typically named request. The method returns an rendered template HttpResponse. A python dict is needed to define the property of the entrance page.
      • Property Dict
        • 'title': define title of the entrance page,
        • 'template': a python dict to specify the property of the canvas
          • 'type': specify the type of the canvas
            • option 'coordinate-2dims': use the canvas as a coordinate system of 2 dimensions
            • option 'drawing': use the canvas as a mouse drag drawing area
          • 'mouse_click_enabled': specify if mouse click input is enabled. only used with type 'coordinate-2dims'
            • option 'none' [default]: disable the mouse
            • option 'left': only allow left mouse click for 1 feature input
            • option 'both': allow left and right mouse click, left for feature 1 and right for feature 2.
          • 'heatmap': specify if heatmap data is allowed to draw on the page
            • 'contour'
              • option False [default]: do not display contour
              • option true: display contour(using conrec.js)
          • 'coordinate_system': a dict specifys the property of the coordinate system
            • 'horizontal_axis': a dict specifys the property of the horizontal axis
            • 'vertical_axis': a dict specifys the property of the vertical axis
              • 'range': an 2-item list specifys the range of the axis, eg. [-5.0, 5.0]
          • 'description': A brief introduction to the demo, like how it works and its capabilities. Wll be displayed beneath the title.
        • 'panels': an list of dicts, each item is a configuration of a single panel in panel section item dict info:
          • 'panel_name': the html id of the panel
            , in other word, you can access the panel by document.getElementById() in javascript.
            • if 'panel_name' is 'arguments', the generator will generate a form with the argument type information set in panel_property
            • if 'panel_name' is 'toy_data', the generator will make a toy data generator/importer panel in the panel section.
          • 'panel_label' [default same as 'panel_name']: the title of the panel.
          • 'panel_property': use along with 'panel_name' equals 'argument', which provide the argument information of the particular argument panel.
            • Arguments List, an list of dicts, each item of the list represents a profile of input zone for a single argument. item dict info:
              • 'argument_type': set as one of ['integer', decimal', 'select'],
                • 'integer': make the text input zone only accepts integer.
                • 'decimal': make the text input zone only accepts decimal number.
                • 'select': make the zone as a drop-down menu. in this case, an string list of 'argument_items' must be set to specify the items in the menu.
                • 'button-group': create a button group. in this case, a dict list of 'argument_items' must be set to specify each button information in the group.
              • 'argument_label': the label(or name) of the input.
              • 'argument_name': the html id of the input
              • 'argument_explain': pop-up explanation of the argument. html tags allowed.
              • 'argument_default': use with argument_type equals 'integer' or 'decimal', specify the default value of the input zone.
              • 'argument_items': use with argument_type equals 'select' or 'button-group', specify the items under the drop-down menu or button group.
                • when use with 'argument_type' == 'select', a list of the drop-down menu items' name need to be provided.
                • when use with 'argument_type' == 'button-group', a list of button's information dicts need to be provided. button info:
                  • 'button_name': the html id of , in other word, you can access the button by document.getElementId() in javascript.
                  • 'button_label': the caption shown on the button.
                  • 'button_type': if 'button_type' == 'json_up_down_load', a json interactive javascript will be generate. The function upload all the parameter specified in the argument list, and send a ajax request. The target URL is the correspond 'button_name', which means if a button named 'generate', and it's a 'json_up_down_load' button, when hit the button, it'll send 'generate/' a ajax request. When the browser received the data sent back from server, a custom function named 'button_name' will be called to do further work, such as draw the data on the canvas section.
    • frontend script Detailed javascript is needed to specify the way data input and output, and it can be done by modifying the {% block javascript %} block in the template file. Meanwhile, when there's a button group defined in the panel section, you can add the mousedown event to the button by creating functions named <button_name>_action.

  • python backend A python backend is needed to specify the algorithm. The backend method is better in the same file with the entrance generator. Just like the entrance generator, the backend is a method which needs a HttpRequest object as input argument and provide with a HttpResponse object. The HttpRequest object contains the input data of the algorithm, and we can access a single parameter with request.POST[<argument_name>]. When the calculation is down, it'd be better to dump it in a json file and send.