sja

As requested: answer to puzzle 4 (I think):

14.2981, 101.2189

Start from top-left, move the number of spaces given by the number of your current square:

down right left down right right up down down right down

It's a maze; worked backwards from the numbers that have commas and points next to them.

Number: 19; Title: Thailand https://photos.google.com/share/AF1QipMNGiEkdfeZKK5uus5iOmt-...

14.2981, 101.2189 Start from top: down right left down right right up down down right down It's a maze; worked backwards from the numbers that have commas and points next to them. Number: 19; Title: Thailand https://drive.google.com/drive/folders/0B2BGioksxQiRc2hpTDJ1...

14.2981, 101.2189

Start from top-left, move the number of spaces given by the number of your current square:

down right left down right right up down down right down

It's a maze; worked backwards from the numbers that have commas and points next to them.

Number: 19; Title: Thailand https://photos.google.com/share/AF1QipMNGiEkdfeZKK5uus5iOmt-...

A ha! Very cool- apologies for not seeing how it worked at first; I assumed you used the server to control/collect data manually, and then loaded the model onto the device. Thanks for the demo!

I might be missing it, but I don't see instructions for installing TensorFlow/Keras on the Raspberry Pi in the Donkey repo or in this blog post (needed to actually run the trained model, it looks like). For TensorFlow, there are pre-built binaries and instructions to build from source here:

https://github.com/samjabrahams/tensorflow-on-raspberry-pi

Note: I am the owner of this repo

In the contrib folder in the TensorFlow project, you'll find the makefile subdirectory:

https://github.com/tensorflow/tensorflow/tree/master/tensorf...

The readme has a general overview of how you'll approach using it. Note that you'll want to optimize for inference (remove unnecessary operations from the graph) [0] and freeze your graph (convert Variables into constant tensors) [1] to drop in your own model for the pretrained Inception model that's used as an example.

[0]: https://github.com/tensorflow/tensorflow/blob/master/tensorf...

[1]: https://github.com/tensorflow/tensorflow/blob/master/tensorf...

"Automatically" isn't the best word, as TensorFlow won't make use of multiple GPUs unless you explicitly tell it to (at this time). That said, there are a number of benefits to using TensorFlow (including the ability to use multiple GPUs, if not automatically :) )

- Several common gradient optimization algorithms (Momentum, AdaGrad, AdaDelta, Adam, etc) are implemented already, which makes it a bit faster to get your training logic in place

- Going along with the above, there is more in the TensorFlow API focused specifically on training models, as opposed to being purely a math engine. Some might consider the extra funtionality "bloat", but I think it serves a good purpose

- The afforementioned multi-GPU functionality is nice, once you get used to it. It's good for either training multiple versions of a model in parallel or doing data parallel updates of parameters

- There are tools for compiling your trained models as static C++ binaries on mobile devices

- The TensorFlow ecosystem is quite nice: TensorBoard for visualizing training, the topology of your model, and various statistics (most recently visualizing projections of embeddings). TensorFlow Serving for deploying trained models. TF Slim for a more Keras-like layer by layer approach to model building. Several pre-trained models to jump start your own work.

- No compile times. There is a "no optimizations" option in Theano to remove the compilation, but many people's experience with Theano is having to wait to iterate on their code.

- I think the community is pretty swell too :) The Google team does a good job of responding to and working with folks who open issues or PRs

Generally, I'd say TensorFlow is really good when you want to minimize the amount of time between researching, training, and deploying your model.

Edit: line formatting

I imagine that they did this in order to be able to use more of (or all of) the TensorFlow functionality available in the Python API without having to rewrite a huge amount of code in R.

There are Operations in TensorFlow that don't invoke the C++ layer directly. Instead, they are composed of other Operations in Python, meaning that binding directly to the C++ layer would require finding and rewriting that code.

It still gets sent down to the C++ layer at the end of it, though the stack traces might end up looking pretty ridiculous.

Good list! I think it's important to note that this article is (intentionally) focused on modern CNN architectures, and not "deep learning" in general.

I'd also add in the following "technique" articles: Geoff Hinton et al.'s dropout paper[0] and Loffe and Szegedy's Batch Normalization paper[1]. I don't think there's been enough time for the dust to settle, but I'm excited about the possibilities Stochastic Depth[2] could offer, too.

[0]: http://arxiv.org/abs/1207.0580 [1]: http://arxiv.org/abs/1502.03167 [2]: http://arxiv.org/abs/1603.09382

This is true, though there is a workaround by using cdn.saw fit.com domain. I use the trick to display SVG figures in these white paper notes[1], and I found out about it in this issue thread[2]

Example:

<img src="http://cdn.rawgit.com/<username>/<path>/<to>/<image.svg>">

[1]: https://github.com/samjabrahams/tensorflow-white-paper-notes... [2]: https://github.com/isaacs/github/issues/316#issuecomment-113...

One of the authors here- let me know if you have any questions about the book (or TensorFlow in general)!

Implementing a new operation in TensorFlow does require a fair amount of overhead, and you'll need to know CUDA if you want to create something that works on (NVIDIA) GPUs.

The "Creating an Op" how-to[1] goes over the basic steps necessary to implement an operation, but there are a couple of things missing. Notably, proper documentation for the various functions and classes used when writing operations, as well as information on writing (and registering) a Python wrapper for additional functionality.

All this said, if you want to commit your work to the GitHub master, the Google team working on the repository does an excellent job of walking contributors through the steps necessary to get their work over the hump.

[1]: https://www.tensorflow.org/versions/master/how_tos/adding_an...

Just a quick technicality note: they would have it on their books as both an asset and a liability. The cash they received would be the asset, and the money owed back as a liability.

Have to keep "assets = liabilities + equity" balanced!

I'm a little hesitant to learn how to 'understand large programs', or how to structure them for that matter, from a repository that has 100 code files in the root directory.

I'm not sure what I'm looking at?