{"id":150,"date":"2018-02-02T18:10:53","date_gmt":"2018-02-02T18:10:53","guid":{"rendered":"http:\/\/phylanx.stellar-group.org\/?p=150"},"modified":"2018-02-02T18:10:53","modified_gmt":"2018-02-02T18:10:53","slug":"introduction-to-phylanx-coding","status":"publish","type":"post","link":"https:\/\/phylanx.stellar-group.org\/index.php\/2018\/02\/02\/introduction-to-phylanx-coding\/","title":{"rendered":"Introduction to Phylanx Coding"},"content":{"rendered":"

In this post I\u2019ll go through the simple implementation of <\/span>LRA<\/span><\/a> (Logistic Regression Algorithm) to outline the Phylanx architecture and also demonstrate how one might go about writing their own programs in Phylanx. The complete version of the code discussed in this post can be found in the project\u2019s GitHub <\/span>repository<\/span><\/a> under examples\/algorithms directory and the corresponding dataset can be found <\/span>here<\/span><\/a>.<\/span><\/p>\n

Phylanx Architecture<\/span><\/h2>\n

The core of Phylanx has been implemented in <\/span>HPX<\/span><\/a> (a C++ Standard Library for Concurrency and Parallelism), and has three components (figure 1):<\/span><\/p>\n

    \n
  1. PhySL<\/span><\/i>– a minimal language developed for testing purposes (the syntax is subject to change).<\/span><\/li>\n
  2. Phylanx AST- constructed by the Phylanx (PhySL) parser and will be used for analyses and optimizations.<\/span><\/li>\n
  3. Execution Tree- compiled from the AST and will run asynchronously for maximum performance.<\/span><\/li>\n<\/ol>\n
    \"\"

    Figure 1. Phylanx Components<\/p><\/div>\n

     <\/p>\n

    We recognize the fact that Phylanx will mostly be used by domain experts working on massive datasets. Therefore, to lift the burden of learning a new language, we also provide a Python interface (frontend) to Phylanx. The Python frontend enables programmers to write their code once, in a familiar language, and run it on any platform (whether a PC or large cluster) without changing the source code. At the moment this feature is available through the use of \u00a0<\/span>Python decorators<\/span><\/a>. Any valid Python code with Phylanx constructs can be wrapped into a function which in turn is decorated with <\/span>*@phyfun*<\/span> function (the name is subject to change). @phyfun will automatically generate the equivalent PhySL string, and subsequently compile, and evaluate it.<\/span><\/p>\n

    LRA Example<\/h2>\n

    In this example we will demonstrate how to write an LRA with the Python frontend. We will use a breast cancer diagnostic dataset as an input to our algorithm. This dataset contains 569 rows (1 for each patient) with 30 columns containing the features and one last row with the diagnosis.<\/span><\/p>\n

    As mentioned above, any code snippet to be translated into PhySL must first be wrapped in a function. Here, we call the function\u00a0lra<\/em> and decorate it with @phyfun.<\/span><\/p>\n

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    <\/div><\/td>
    import<\/span> phylanx
    \nfrom<\/span> phylanx.util<\/span> import<\/span> *
    \n
    \n@<\/span>phyfun
    \ndef<\/span> lra(<\/span>file_name,<\/span>
    \n        xlo1,<\/span> xhi1,<\/span> ylo1,<\/span> yhi1,<\/span>
    \n        xlo2,<\/span> xhi2,<\/span> ylo2,<\/span> yhi2,<\/span>
    \n        alpha,<\/span> iterations,<\/span> enable_output)<\/span>:
    \n
    \n    # <code to be transformed into PhySL><\/span>
    \n
    \n    return<\/span> weights<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n

    Now we can write our program as the body of the\u00a0lra<\/em> function and Phylanx will automatically translate the code into PhySL.<\/span><\/p>\n

    As the first step we need to read data which is stored in CSV format. Phylanx provides a primitive (function) read_csv_file<\/em> to read this type of file. We read the file and store the feature values in matrix\u00a0x<\/em> and diagnoses in vector y<\/em>:<\/span><\/p>\n

    1
    2
    3
    <\/div><\/td>
    data =<\/span> file_read_csv(<\/span>file_name)<\/span>
    \nx =<\/span> data[<\/span>xlo1:xhi1,<\/span>ylo1:yhi1]<\/span>
    \ny =<\/span> data[<\/span>xlo2:xhi2,<\/span>ylo2:yhi2]<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n

    Next we\u2019ll initialize the prediction, gradient and error vectors to zero using the constant<\/em>\u00a0function:<\/span><\/p>\n

    1
    2
    3
    <\/div><\/td>
    pred =<\/span> constant(<\/span>0.0<\/span>,<\/span> shape(<\/span>x,<\/span> 0<\/span>)<\/span>)<\/span> \/\/ prediction
    \nerror =<\/span> constant(<\/span>0.0<\/span>,<\/span> shape(<\/span>x,<\/span> 0<\/span>)<\/span>)<\/span>
    \ngradient =<\/span> constant(<\/span>0.0<\/span>,<\/span> shape(<\/span>x,<\/span> 1<\/span>)<\/span>)<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n

    We also store the transpose of the\u00a0x<\/em> as we\u2019ll use it many times later within the while loop:<\/span><\/p>\n

    1
    <\/div><\/td>
    transx =<\/span> transpose(<\/span>x)<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n

    Once everything is initialized and loaded, we can start the iterations to find the (optimal) weight function. Within the loop, we calculate the prediction (using Phylanx functions exp<\/em> and dot<\/em>), error, gradient (using dot<\/em>) and weight. One should note that division, summation, negation are all also Phylanx primitives.<\/span><\/p>\n

    1
    2
    3
    4
    5
    6
    <\/div><\/td>
    while<\/span> step <<\/span> iterations:
    \n    pred =<\/span> 1.0<\/span> \/ (<\/span>1.0<\/span> + exp(<\/span>-dot(<\/span>x,<\/span> weights)<\/span>)<\/span>)<\/span>
    \n    error =<\/span> pred - y
    \n    gradient =<\/span> dot(<\/span>transx,<\/span> error)<\/span>
    \n    weights =<\/span> weights - (<\/span>alpha * gradient)<\/span>
    \n    step +=<\/span> 1<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n

    Now, when the lra<\/em>\u00a0function is called, Phylanx will automatically generate the PhySL and evaluate it. We can print the result using phy_print<\/em> function.<\/span><\/p>\n

    1
    2
    <\/div><\/td>
    res =<\/span> lra(<\/span>"breast_cancer.csv"<\/span>,<\/span> 0<\/span>,<\/span>569<\/span>,<\/span>0<\/span>,<\/span>30<\/span>,<\/span> 0<\/span>,<\/span>569<\/span>,<\/span>30<\/span>,<\/span>31<\/span>,<\/span> 1e-5<\/span>,<\/span>750<\/span>,<\/span>0<\/span>)<\/span>
    \nphy_print(<\/span>res)<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n

    We have also done some preliminary performance analysis of our toolchain.\u00a0 We found that the performance achieved by Phylanx is comparable to that of <\/span>numpy<\/span><\/a>:<\/span><\/p>\n

    \"\"<\/p>\n

    We are confident that as we continue to expand and improve Phylanx we will be able to pare down our execution time and improve upon the scalability we currently observe.<\/p>\n","protected":false},"excerpt":{"rendered":"

    In this post I\u2019ll go through the simple implementation of LRA (Logistic Regression Algorithm) to outline the Phylanx architecture and also demonstrate how one might go about writing their own programs in Phylanx. The complete version of the code discussed in this post can be found in the project\u2019s GitHub\u2026 Continue reading<\/a><\/p>\n","protected":false},"author":7,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[4],"tags":[20,21,18,17,5,19,13],"_links":{"self":[{"href":"https:\/\/phylanx.stellar-group.org\/index.php\/wp-json\/wp\/v2\/posts\/150"}],"collection":[{"href":"https:\/\/phylanx.stellar-group.org\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/phylanx.stellar-group.org\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/phylanx.stellar-group.org\/index.php\/wp-json\/wp\/v2\/users\/7"}],"replies":[{"embeddable":true,"href":"https:\/\/phylanx.stellar-group.org\/index.php\/wp-json\/wp\/v2\/comments?post=150"}],"version-history":[{"count":53,"href":"https:\/\/phylanx.stellar-group.org\/index.php\/wp-json\/wp\/v2\/posts\/150\/revisions"}],"predecessor-version":[{"id":204,"href":"https:\/\/phylanx.stellar-group.org\/index.php\/wp-json\/wp\/v2\/posts\/150\/revisions\/204"}],"wp:attachment":[{"href":"https:\/\/phylanx.stellar-group.org\/index.php\/wp-json\/wp\/v2\/media?parent=150"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/phylanx.stellar-group.org\/index.php\/wp-json\/wp\/v2\/categories?post=150"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/phylanx.stellar-group.org\/index.php\/wp-json\/wp\/v2\/tags?post=150"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}