.. Singa documentation master file, created by
   sphinx-quickstart on Sat Jul  9 20:36:57 2016.
   You can adapt this file completely to your liking, but it should at least
   contain the root `toctree` directive.

Welcome to Apache Singa
=======================

Recent News
===========

* The **third release** is now available, 20 April, 2016. `Download SINGA v0.3.0 <downloads.html>`_

* The **second release** is now available, 14 Jan, 2016. `Download SINGA v0.2.0 <downloads.html>`_.

* SINGA will be presented at `Strata+Hadoop <http://strataconf.com/big-data-conference-sg-2015/public/schedule/detail/45123>`_ on 2 Dec, 2015

* SINGA was presented at `ACM Multimedia <http://www.acmmm.org/2015/at-a-glance/>`_ Best Paper session and Open Source Software Competition session, 26-30 Oct, 2015 (`Slides <http://www.comp.nus.edu.sg/~dbsystem/singa//assets/file/mm2015.ppt>`_)

* The **first release** is now available, 8 Oct, 2015. `Download SINGA v0.1.0 <downloads.html>`_.

* SINGA was presented at `workshop on deep learning <http://www.comp.nus.edu.sg/~dbsystem/singa/workshop>`_  held on 16 Sep, 2015

* SINGA was presented at `BOSS <http://boss.dima.tu-berlin.de/>`_ of `VLDB 2015 <http://www.vldb.org/2015/>`_ at Hawaii, 4 Sep, 2015. (slides: `overview <http://www.comp.nus.edu.sg/~dbsystem/singa/assets/file/singa-vldb-boss.pptx>`_, `basic <http://www.comp.nus.edu.sg/~dbsystem/singa/assets/file/basic-user-guide.pptx>`_, `advanced <http://www.comp.nus.edu.sg/~dbsystem/singa/assets/file/advanced-user-guide.pptx>`_)

* SINGA was presented at `ADSC/I2R Deep Learning Workshop <http://adsc.illinois.edu/contact-us>`_, 25 Aug, 2015.

* A tutorial on SINGA was given at VLDB summer school at Tsinghua University,  25-31 July, 2015.

* A half day tutorial on SINGA was given at I2R, 29 June, 2015.

* SINGA was presented at `DanaC <http://danac.org/>`_ of `SIGMOD 2015 <http://www.sigmod2015.org/index.shtml>`_ at Melbourne, 31 May - 4 June, 2015.

* SINGA has been accepted by `Apache Incubator <http://incubator.apache.org/>`_, 17 March, 2015.

Getting Started
===============
* The `Introduction <docs/overview.html>`_ page gives an overview of SINGA.

* The `Installation <docs/installation.html>`_ guide describes details on downloading and installing SINGA.

* Please follow the `Quick Start <docs/quick-start.html>`_ guide to run simple applications on SINGA.

Documentation
=============

* Documentations are listed `here <docs.html>`_.

* Code API can be found `here <api/index.html>`_.

* Research publication list is available `here <http://www.comp.nus.edu.sg/~dbsystem/singa/research/publication/>`_.

How to contribute
=================

* Please subscribe to our development mailing list dev-subscribe@singa.incubator.apache.org.

* If you find any issues using SINGA, please report it to the `Issue Tracker <https://issues.apache.org/jira/browse/singa>`_.

* You can also contact with `SINGA committers <community.html>`_ directly.

More details on contributing to SINGA is described `here <develop/how-contribute.html>`_ .

Citing SINGA
============

Please cite the following two papers if you use SINGA in your research:

* B. C. Ooi, K.-L. Tan, S. Wang, W. Wang, Q. Cai, G. Chen, J. Gao, Z. Luo, A. K. H. Tung, Y. Wang, Z. Xie, M. Zhang, and K. Zheng. `SINGA: A distributed deep learning platform <http://www.comp.nus.edu.sg/~ooibc/singaopen-mm15.pdf>`_. ACM Multimedia (Open Source Software Competition) 2015 (`BibTex <http://www.comp.nus.edu.sg/~dbsystem/singa//assets/file/bib-oss.txt>`_).

* W. Wang, G. Chen, T. T. A. Dinh, B. C. Ooi, K.-L.Tan, J. Gao, and S. Wang. `SINGA: putting deep learning in the hands of multimedia users <http://www.comp.nus.edu.sg/~ooibc/singa-mm15.pdf>`_. ACM Multimedia 2015 (`BibTex <http://www.comp.nus.edu.sg/~dbsystem/singa//assets/file/bib-singa.txt>`_, `Slides <files/mm2015.ppt>`_).

.. toctree::
   :hidden:

   downloads
   docs/index

.. toctree::
   :hidden:
   :maxdepth: 2
   :caption: Development

   develop/schedule
   develop/how-contribute
   develop/contribute-code
   develop/contribute-docs

.. toctree::
   :hidden:
   :maxdepth: 2
   :caption: Community

   community/source-repository
   community/mail-lists
   community/issue-tracking
   community/team-list



License
=======
SINGA is released under `Apache License Version 2.0 <http://www.apache.org/licenses/LICENSE-2.0>`_.

Disclaimers
===========

Apache SINGA is an effort undergoing incubation at The Apache Software Foundation (ASF), sponsored by the Apache Incubator. Incubation is required of all newly accepted projects until a further review indicates that the infrastructure, communications, and decision making process have stabilized in a manner consistent with other successful ASF projects. While incubation status is not necessarily a reflection of the completeness or stability of the code, it does indicate that the project has yet to be fully endorsed by the ASF.
