Update Citation and Bump Version (#207)

* Update Citation and Bump Version

* Improve README

* Add RNNPool Camera Ready

README.md

@@ -18,6 +18,7 @@ Algorithms that shine in this setting in terms of both model size and compute, n
  - **Shallow RNN**: A meta-architecture for training RNNs that can be applied to streaming data.
  - **FastRNN & FastGRNN - FastCells**: **F**ast, **A**ccurate, **S**table and **T**iny (**G**ated) RNN cells.
  - **DROCC**: **D**eep **R**obust **O**ne-**C**lass **C**lassfiication for training robust anomaly detectors.
+ - **RNNPool**: An efficient non-linear pooling operator for RAM constrained inference.
 
 These algorithms can train models for classical supervised learning problems
 with memory requirements that are orders of magnitude lower than other modern
@@ -37,9 +38,10 @@ Applications demonstrating usecases of these algorithms:
    and `examples/tf` contains sample training routines for these algorithms.
  - The `pytorch` directory contains the `edgeml_pytorch` package which specifies these architectures in PyTorch,
    and `examples/pytorch` contains sample training routines for these algorithms.
- - The `cpp` directory has training and inference code for Bonsai and ProtoNN algorithms in C++.
+ - The `cpp` directory has training and inference code for `Bonsai` and `ProtoNN` algorithms in C++.
  - The `applications` directory has code/demonstrations of applications of the EdgeML algorithms. 
  - The `tools/SeeDot` directory has the quantization tool to generate fixed-point inference code.  
+ - The `c_reference` directory contains the inference code (floating-point or quantized) for various algorithms in C.
 
 Please see install/run instructions in the README pages within these directories.
 
@@ -55,7 +57,8 @@ the PLDI '19 publication on [SeeDot compiler](/docs/publications/SeeDot.pdf),
 the UIST '19 publication on [Gesturepod](/docs/publications/GesturePod-UIST19.pdf), 
 the BuildSys '19 publication on [MSC-RNN](/docs/publications/MSCRNN.pdf),
 the NeurIPS '19 publication on [Shallow RNNs](/docs/publications/Sha-RNN.pdf),
-and the ICML '20 publication on [DROCC](/docs/publications/drocc.pdf).
+the ICML '20 publication on [DROCC](/docs/publications/drocc.pdf),
+and the NeurIPS '20 publication on [RNNPool](/docs/publications/RNNPool.pdf).
 
 
 Also checkout the [ELL](https://github.com/Microsoft/ELL) project which can
@@ -69,6 +72,7 @@ Code for algorithms, applications and tools contributed by:
   - [Sachin Goyal](https://saching007.github.io/)
   - [Chirag Gupta](https://aigen.github.io/)
   - [Moksh Jain](https://github.com/MJ10)
+  - [Shikhar Jaiswal](https://shikharj.github.io/)
   - [Ashish Kumar](https://ashishkumar1993.github.io/)
   - [Aditya Kusupati](https://adityakusupati.github.io/)
   - [Chris Lovett](https://github.com/lovettchris)
@@ -83,13 +87,14 @@ Please [email us](mailto:edgeml@microsoft.com) your comments, criticism, and que
 If you use software from this library in your work, please use the BibTex entry below for citation.
 
 ```
-@software{edgeml03,
+@misc{edgeml04,
    author = {{Dennis, Don Kurian and Gaurkar, Yash and Gopinath, Sridhar and Goyal, Sachin 
-              and Gupta, Chirag and Jain, Moksh and Kumar, Ashish and Kusupati, Aditya and 
-              Lovett, Chris and Patil, Shishir G and Saha, Oindrila and Simhadri, Harsha Vardhan}},
+              and Gupta, Chirag and Jain, Moksh and Jaiswal, Shikhar and Kumar, Ashish and
+              Kusupati, Aditya and  Lovett, Chris and Patil, Shishir G and Saha, Oindrila and
+              Simhadri, Harsha Vardhan}},
    title = {{EdgeML: Machine Learning for resource-constrained edge devices}},
    url = {https://github.com/Microsoft/EdgeML},
-   version = {0.3},
+   version = {0.4},
 }
 ```
 

pytorch/README.md

@@ -22,16 +22,21 @@ for these algorithms are in `edgeml_pytorch.trainer`.
     training routine for FastRNN and FastGRNN is decoupled from the custom cells to enable plug and
     play behaviour of the custom RNN cells in other architectures (NMT, Encoder-Decoder etc.).
     Additionally, numerically equivalent CUDA-based implementations `FastRNNCUDACell` and 
-    `FastGRNNCUDACell` are provided for faster training. `edgeml_pytorch.graph.rnn`.
+    `FastGRNNCUDACell` are provided for faster training. 
     `edgeml_pytorch.graph.rnn.Fast(G)RNN(CUDA)` provides unrolled RNNs equivalent to `nn.LSTM` and `nn.GRU`.
     `edgeml_pytorch.trainer.fastmodel` presents a sample multi-layer RNN + multi-class classifier model.
 4. [S-RNN](https://github.com/microsoft/EdgeML/blob/master/docs/publications/SRNN.pdf): `edgeml_pytorch.graph.rnn.SRNN2` implements a 
-    2 layer SRNN network which can be instantied with a choice of RNN cell. The training
+    2 layer SRNN network which can be instantiated with a choice of RNN cell. The training
     routine for SRNN is in `edgeml_pytorch.trainer.srnnTrainer`.
 5. [DROCC & DROCC-LF](https://github.com/microsoft/EdgeML/blob/master/docs/publications/drocc.pdf): `edgeml_pytorch.trainer.drocc_trainer` implements 
     a DROCC meta-trainer for training any given model architecture
-    for one-class classification on the supplied dataset. `edgeml_pytorch.trainer.drocclf_trainer` implements the DROCC-LF varaint
+    for one-class classification on the supplied dataset. `edgeml_pytorch.trainer.drocclf_trainer` implements the DROCC-LF variant
     for training models for one-class classification with limited negatives.
+6. [RNNPool](https://github.com/microsoft/EdgeML/blob/master/docs/publications/RNNPool.pdf): `edgeml_pytorch.graph.RNNPool` implements
+   the RNNPool pooling layer which can be instantiated with the dimensions of the input patch
+   and the hidden states. Currently only the inference code is implemented, as training routines
+   are written individually for specific use cases. Please checkout the [RNNPool examples](https://github.com/microsoft/EdgeML/tree/master/examples/pytorch/vision) for reference implementations
+   of the trainer modules.
 
 Usage directions and examples notebooks for this package are provided [here](https://github.com/microsoft/EdgeML/blobl/master/examples/pytorch).