index.xml

<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>GopherData on GopherData</title>
    <link>http://gopherdata.io/</link>
    <description>Recent content in GopherData on GopherData</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <copyright>&amp;copy; 2017 GopherData</copyright>
    <lastBuildDate>Wed, 20 Apr 2016 00:00:00 +0000</lastBuildDate>
    <atom:link href="/" rel="self" type="application/rss+xml" />
    
    <item>
      <title>GopherData Conference</title>
      <link>http://gopherdata.io/talk/gopherdata/</link>
      <pubDate>Wed, 01 Jan 2042 00:00:00 +0000</pubDate>
      
      <guid>http://gopherdata.io/talk/gopherdata/</guid>
      <description>&lt;p&gt;More details, actual dates (hopefully sooner than 2042), and details coming soon!&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>More Go-based Workflow Tools in Bioinformatics</title>
      <link>http://gopherdata.io/post/more_go_based_workflow_tools_in_bioinformatics/</link>
      <pubDate>Thu, 02 Nov 2017 23:10:02 +0100</pubDate>
      
      <guid>http://gopherdata.io/post/more_go_based_workflow_tools_in_bioinformatics/</guid>
      <description>

&lt;p&gt;It is an exciting time for Go as a data science language and for the
&lt;a href=&#34;http://gopherdata.io/&#34; target=&#34;_blank&#34;&gt;#gopherdata&lt;/a&gt; movement. The
&lt;a href=&#34;https://github.com/gopherdata/resources/blob/master/tooling/README.md&#34; target=&#34;_blank&#34;&gt;ecosystem of tools&lt;/a&gt;
is constantly improving, with both general purpose tools (e.g., for data frames and
statistical analyses) and more specialized ones (e.g., for neural networks and
graph-based algorithms) popping up every day.&lt;/p&gt;

&lt;p&gt;Recent weeks have been particularly exciting for those involved in the
bioinformatics field. In addition to generic libraries for bioinformatics such
as &lt;a href=&#34;https://github.com/biogo/biogo&#34; target=&#34;_blank&#34;&gt;bíogo&lt;/a&gt;, which was recently reviewed in quite some detail in a two blog posts
(&lt;a href=&#34;https://medium.com/@boti_ka/a-gentle-introduction-to-b%C3%ADogo-part-i-65dbd40e31d4&#34; target=&#34;_blank&#34;&gt;part I&lt;/a&gt;
and &lt;a href=&#34;https://medium.com/@boti_ka/a-gentle-introduction-to-bíogo-part-ii-1f0df1cf72f0&#34; target=&#34;_blank&#34;&gt;part II&lt;/a&gt;),
the ecosystem of scientific workflow tools focusing on or being used in
bioinformatics is also growing: Last week, another Go-based workflow
orchestration tool, &lt;a href=&#34;https://github.com/grailbio/reflow&#34; target=&#34;_blank&#34;&gt;Reflow&lt;/a&gt;, was released
as open source, by life science startup &lt;a href=&#34;https://grail.com/&#34; target=&#34;_blank&#34;&gt;Grail Inc&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Reflow brings a number of interesting features to the
table including: (i)&amp;nbsp;comprehensive and very easy-to-use Amazon Web
Services (AWS) integration, (ii)&amp;nbsp;memoization features based on S3
storage, and (iii)&amp;nbsp;ability to run the same, docker-based workflow on your
local computer or on AWS.&lt;/p&gt;

&lt;p&gt;Because we are users of and contributors to two other existing Go-based
workflow projects (&lt;a href=&#34;http://pachyderm.io/&#34; target=&#34;_blank&#34;&gt;Pachyderm&lt;/a&gt; and
&lt;a href=&#34;http://scipipe.org/&#34; target=&#34;_blank&#34;&gt;SciPipe&lt;/a&gt;), we thought that a brief comparison of the
different approaches would be useful. In particular, we hope that this summary
helps highlight differences between the tools, guide users to appropriate
workflow and orchestration tools, and/or provide a jumping-off-point for
contributions and experimentation&lt;/p&gt;

&lt;h2 id=&#34;workflow-tools-in-bio-and-cheminformatics&#34;&gt;Workflow Tools in Bio- and Cheminformatics&lt;/h2&gt;

&lt;p&gt;Before we continue, lets step back and add a few words about what workflow
tools are and why they are relevant in Bioinformatics (or Science in general),
for anyone new to the term.&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://en.wikipedia.org/wiki/Scientific_workflow_system&#34; target=&#34;_blank&#34;&gt;Scientific workflow tools&lt;/a&gt; are tools or
systems designed to help coordinate computations when the number of computation
steps is very large and/or the steps have complex dependencies between their
input and output data. This is common in many scientific fields, but it is
common in bioinformatics in particular, because of the vast plethora of tools
built to analyze the extremely heterogeneous data types describing biological
organisms, from molecules to cells to organs to full body physiology.&lt;/p&gt;

&lt;p&gt;Common tasks in bioinformatics necessitating the use of workflow tools include
(DNA) sequence alignment, (gene) variant calling, RNA quantification, and more.
In the related field of cheminformatics, workflow tools are often used to build
predictive models relating the chemical structure of drug compounds to some
measurable property of the compound, in what is commonly called Quantitative
Structure Activity Relationship (QSAR). Examples of such properties are the
level of binding to protein targets in the body, or various chemical properties
such as solubility, that might affect its potential for update in the body.&lt;/p&gt;

&lt;h2 id=&#34;the-go-bioinformatics-workflow-tooling-ecosystem&#34;&gt;The Go bioinformatics workflow tooling ecosystem&lt;/h2&gt;

&lt;p&gt;&lt;img src=&#34;http://gopherdata.io/img/wftools/gopher_thinking_workflows.png&#34; alt=&#34;Gopher thinking about workflows, surrounded by workflow tool logos&#34; /&gt;&lt;/p&gt;

&lt;p&gt;The main Go-based workflow tools that have targeted bioinformatics workflows
(or have been used to implement bioinformatics workflows) are:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href=&#34;http://pachyderm.io/&#34; target=&#34;_blank&#34;&gt;Pachyderm&lt;/a&gt;&lt;/strong&gt; - This platform allows users to build
scalable, containerized data pipelines using any language or framework, while
also getting the right data to the right code as both data and code change over
time. Individual pipeline stages are defined by docker images and can be
individually parallelized across large data sets (by leveraging
&lt;a href=&#34;https://kubernetes.io/&#34; target=&#34;_blank&#34;&gt;Kubernetes&lt;/a&gt; under the hood).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href=&#34;http://scipipe.org/&#34; target=&#34;_blank&#34;&gt;SciPipe&lt;/a&gt;&lt;/strong&gt; - This tool is much smaller than something
like Pachyderm and is focused on highly dynamic workflow constructs in
which on-line scheduling is key. SciPipe also focuses, thus far, on workflows
that run on HPC clusters and local computers.  Although, it can be integrated
in a more comprehensive framework, such as Pachyderm or Reflow.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href=&#34;https://github.com/MG-RAST/AWE&#34; target=&#34;_blank&#34;&gt;AWE&lt;/a&gt;&lt;/strong&gt; - The AWE framework is a
comprehensive bioinformatics system targeting the cloud. It reportedly
comes with multi-cloud support and, as it seems, HPC support, and AWE allows
users to leverage the &lt;a href=&#34;http://www.commonwl.org/&#34; target=&#34;_blank&#34;&gt;Common Workflow Language (CWL)&lt;/a&gt;. As
with Reflow, we don’t have hands-on experience with AWE, so our comments
are limited to what we’ve read in the documentation and examples.&lt;/p&gt;

&lt;h2 id=&#34;comparing-reflow-and-pachyderm&#34;&gt;Comparing Reflow and Pachyderm&lt;/h2&gt;

&lt;p&gt;Reflow and Pachyderm seems to be closest at first glance. Both frameworks
utilize containers as the main unit of data processing. However, there are some
differences in both workflow orchestration and data storage/management that we
will stress below.&lt;/p&gt;

&lt;h3 id=&#34;orchestration&#34;&gt;Orchestration&lt;/h3&gt;

&lt;p&gt;While Reflow implements custom “runners” for each target environment (AWS and
your local machine currently), Pachyderm leverages Kubernetes under-the-hood
for container orchestration. This use of Kubernetes allows Pachyderm to
be maximally vendor-agnostic, as Kubernetes is widely deployed in all the
major clouds and on-premise. Reflow authors are reportedly planning to
support other cloud providers, like GCP, in the near future though, but
this effort seems to require writing custom runner code per target
environment/cloud.&lt;/p&gt;

&lt;p&gt;The use of Kubernetes also allows Pachyderm to automatically bring certain
orchestration functionality into a context that has otherwise
propelled Kubernetes to become industry leader in orchestration. More
specifically, Pachyderm pipelines are automatically “self-healing” in that they are
rescheduled and restarted when cluster nodes or jobs fail, and Pachyderm is
able to optimally schedule work across high-value nodes (e.g., high-CPU or GPU
nodes) using methods such as auto-scaling. Reflow appears to use it’s own
logic to match workloads with available instance types.&lt;/p&gt;

&lt;p&gt;Finally, Pachyderm and Reflow have differences in the way workflows are
actually defined. Pachyderm leverages the established JSON/YAML format that is
common in the Kubernetes community, and Reflow implements what seems to be its
own readable, Go-inspired domain specific language (DSL).&lt;/p&gt;

&lt;h3 id=&#34;data-storage-management&#34;&gt;Data Storage/Management&lt;/h3&gt;

&lt;p&gt;For the data that is to be processed in workflow stages, Reflow provides an
interesting memoization mechanism based on S3, with automatic re-runs triggered
by updates to data. Similarly, Pachyderm provides a familiar, git-inspired
versioned data store, where new versions of data in the versioned data store
are also used to automatically trigger relevant parts of the workflow.
Pachyderm’s data store can be backed by any of the popular vendor-specific
object stores (GCS in GCP, S3 in AWS, or Blob Storage in Azure) or any other
object store with an S3-compatible API (e.g., an open source option like
Minio).&lt;/p&gt;

&lt;p&gt;In terms of metadata associated with jobs, versions of data, etc., Reflow
appears to use a Reflow-specific cache based on S3 and DynamoDB. In
contrast, Pachyderm utilizes etcd, a distributed key-value store, for metadata.&lt;/p&gt;

&lt;p&gt;Lastly with regard to data sharding and parallelization, Pachyderm seems to go
further than Reflow. While Reflow does parallelize tools running on separate
data sets, Pachyderm also provides automatic parallelization of tools accessing
“datums” that may correspond to the same data set or even the same
file. Pachyderm automatically distributes the processing of these datums to
containers running in parallel (pods in Kubernetes) and gathers all of the
results back into a single logical collection of data. Pachyderm thus provides
what other frameworks like Hadoop and Spark are promising, but without the need
to replace legacy code and tools with code written in the MapReduce-style or
explicitly implement parallelism and data sharding in code.&lt;/p&gt;

&lt;p&gt;With these notes in mind, we think Reflow and Pachyderm are addressing slightly
different user needs. While Reflow seems to be an excellent choice for a quick
setup on AWS or a local docker-based server, we think Pachyderm will generally
provide more vendor agnosticity, better parallelization, and valuable
optimizations and updates that come out of the growing
Kubernetes community. Finally, we think that Pachyderm provides a stronger
foundation for rigorous and manageable data science with its unified data
versioning system, which can help data scientists and engineers better
understand data, collaborate, perform tests, share workflows, and so on.&lt;/p&gt;

&lt;h2 id=&#34;how-does-scipipe-compare&#34;&gt;How does SciPipe compare?&lt;/h2&gt;

&lt;p&gt;SciPipe is, in this context, more of an apples-to-oranges comparison to
Pachyderm, Reflow or AWE. While Reflow and Pachyderm provides an integrated
tool encapsulation solution based on containers, SciPipe (in its current
form) is primarily focused on managing command-line driven workflows on local
computers or HPC clusters with a shared file system, where containers might not
be an option. However, there are also other relevant differences related to
complexity of the tools, workflow implementation, and deployment/integration:&lt;/p&gt;

&lt;h3 id=&#34;complexity&#34;&gt;Complexity&lt;/h3&gt;

&lt;p&gt;SciPipe is a much smaller tool in many ways. For example, a very simple
count of LOC for the different frameworks shows that SciPipe is implemented with
more than an order of magnitude less lines of code than the other tools:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;$ cd $GOPATH/src/github.com/grailbio/reflow
$ find | grep &amp;quot;\.go&amp;quot; | grep -vP “(vendor|examples|_test)” | xargs cat | grep -vP &amp;quot;^\/\/&amp;quot; | sed &#39;/^\s*$/d&#39; | wc -l
26371
&lt;/code&gt;&lt;/pre&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;$ cd $GOPATH/src/github.com/pachyderm/pachyderm/src
$ find | grep &amp;quot;\.go&amp;quot; | grep -vP “(vendor|examples|_test)” | xargs cat | grep -vP &amp;quot;^\/\/&amp;quot; | sed &#39;/^\s*$/d&#39; | wc -l
25778
&lt;/code&gt;&lt;/pre&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;$ cd $GOPATH/src/github.com/MG-RAST/AWE
$ find | grep &amp;quot;\.go&amp;quot; | grep -vP &amp;quot;(vendor|examples|_test)&amp;quot; | xargs cat | grep -vP &amp;quot;^\/\/&amp;quot; | sed &#39;/^\s*$/d&#39; | wc -l
24485
&lt;/code&gt;&lt;/pre&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;$ cd $GOPATH/src/github.com/scipipe/scipipe
$ find | grep &amp;quot;\.go&amp;quot; | grep -vP “(vendor|examples|_test)” | xargs cat | grep -vP &amp;quot;^\/\/&amp;quot; | sed &#39;/^\s*$/d&#39; | wc -l
1699
&lt;/code&gt;&lt;/pre&gt;

&lt;h3 id=&#34;workflow-implementation&#34;&gt;Workflow Implementation&lt;/h3&gt;

&lt;p&gt;Further, SciPipe was designed to primarily support highly dynamic workflow
constructs, where dynamic/on-line scheduling is needed. These workflows include
scenarios in which you are continuously chunking up and computing a dataset of
unknown size or parametrizing parts of the workflow with parameter values
extracted in an earlier part of the workflow. An example of the former would
be lazily processing data extracted from a database without saving the
temporary output to disk. An example of the latter would be doing a parameter
optimization to select, e.g., good gamma and cost values for libSVM before
actually training the model with the obtained parameters.&lt;/p&gt;

&lt;p&gt;Also, where Pachyderm and Reflow provide manifest formats or DSLs for writing
workflows, SciPipe lets you write workflows directly in Go. SciPipe is
thus consumed as a programming-library rather than a framework.
This feature might scare off some users intimidated by Go’s relative
verboseness compared to specialized DSLs, but it also allows users to leverage
extremely powerful existing tooling and editor support for Go.&lt;/p&gt;

&lt;h3 id=&#34;deployment-integration&#34;&gt;Deployment/Integration&lt;/h3&gt;

&lt;p&gt;What is perhaps most interesting in the context of this comparison is the fact
that SciPipe workflows can be compiled to small static binaries. This
compilation makes it very easy to package up smaller SciPipe workflows in
individual containers and integrate them into tools like Pachyderm or Reflow or
other services. We thus imagine that SciPipe could be a complement to Pachyderm
or Reflow when highly dynamic workflow constructs are needed, which
may be a challenge to implement in the manifests and DSLs of Pachyderm or
Reflow.&lt;/p&gt;

&lt;h2 id=&#34;reflow-and-awe&#34;&gt;Reflow and AWE?&lt;/h2&gt;

&lt;p&gt;We know the least about AWE at this point, so we don’t want to venture too far
into a detailed comparison with Reflow (which is also new to us). However,
based on our reading of online materials, we can note that they seem to share
the focus on bioinformatics and cloud support. AWE additionally supports Common
Workflow Language and HPC clusters. We expect there to be some differences in
terms of storage, because AWE ships with its own storage solution and isn’t
based on a cloud offering like S3. Past that, we will leave it to the authors
of AWE and Reflow or the community to provide more comprehensive comparisons.&lt;/p&gt;

&lt;h2 id=&#34;in-summary&#34;&gt;In Summary&lt;/h2&gt;

&lt;p&gt;In summary, we think that it is extremely exciting and reassuring to see
continued innovation in the Go Data Science ecosystem, and we are excited to
see more and more data gophers and projects join the community.  We also hope
this little overview will help users navigate the growing ecosystem of workflow
tools by highlighting some of their inherent differences.&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;&lt;a href=&#34;https://twitter.com/smllmp&#34; target=&#34;_blank&#34;&gt;Samuel Lampa&lt;/a&gt;, PhD Student at &lt;a href=&#34;http://pharmb.io&#34; target=&#34;_blank&#34;&gt;Uppsala University&lt;/a&gt;&lt;br&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://www.linkedin.com/in/jon-ander-novella/&#34; target=&#34;_blank&#34;&gt;Jon Ander Novella&lt;/a&gt;, Research Assistant at &lt;a href=&#34;http://pharmb.io&#34; target=&#34;_blank&#34;&gt;Uppsala University&lt;/a&gt;&lt;br&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://twitter.com/dwhitena&#34; target=&#34;_blank&#34;&gt;Daniel Whitenack&lt;/a&gt;, Data Scientist and Lead Developer Advocate at &lt;a href=&#34;http://pachyderm.io&#34; target=&#34;_blank&#34;&gt;Pachyderm Inc.&lt;/a&gt;&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Building an ML-Powered Game AI using TensorFlow in Go</title>
      <link>http://gopherdata.io/post/build_ml_powered_game_ai_tensorflow/</link>
      <pubDate>Thu, 10 Aug 2017 08:43:45 +1000</pubDate>
      
      <guid>http://gopherdata.io/post/build_ml_powered_game_ai_tensorflow/</guid>
      <description>

&lt;p&gt;&lt;em&gt;Based on a lightning talk given at GopherCon 2017 &amp;ldquo;Building an ML-Powered Game AI using TensorFlow in Go&amp;rdquo; &lt;a href=&#34;https://www.youtube.com/watch?v=oiorteQg9n0&#34; target=&#34;_blank&#34;&gt;Video&lt;/a&gt; / &lt;a href=&#34;https://github.com/gophercon/2017-talks/tree/master/lightningtalks/PeteGarcin-BuildingMLPoweredGameAIwithTensorFlow&#34; target=&#34;_blank&#34;&gt;Slides&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;(Author: Pete Garcin, Developer Advocate @ &lt;a href=&#34;https://activestate.com&#34; target=&#34;_blank&#34;&gt;ActiveState&lt;/a&gt;, @rawktron on &lt;a href=&#34;https://twitter.com/rawktron&#34; target=&#34;_blank&#34;&gt;Twitter&lt;/a&gt; and @peteg on Gophers Slack)&lt;/p&gt;

&lt;p&gt;For GopherCon, we wanted to demonstrate some of the capabilities of the emerging machine learning and data science ecosystem in Go. Originally built as a demo for PyCon, I had put together a simple arcade space shooter game that features enemies powered by machine learning. It was a fun way to get folks engaged at conferences and to learn about the growing library of tools that are available. It also gave me an opportunity to build something non-trivial using machine learning techniques, and my background in games made this kind of interactive demo a good fit.&lt;/p&gt;

&lt;p&gt;NeuroBlast is a vertically scrolling space shooter where you control a ship that tries to defeat increasing waves of enemies. Normally, these enemies fly in predefined formations, with predefined firing patterns, and come in waves. The big difference in NeuroBlast is that the enemies use machine learning to determine what their firing pattern should be.&lt;/p&gt;

&lt;h2 id=&#34;under-the-hood-tensorflow&#34;&gt;Under the Hood: TensorFlow&lt;/h2&gt;

&lt;p&gt;Go is one of the languages that has a TensorFlow client available, and so it was a great opportunity to port the original Python game to Go and demonstrate that it’s also possible to deploy trained models in Go applications.&lt;/p&gt;

&lt;p&gt;It is worth noting that the Go TensorFlow client currently does not support training models, and so we relied on a model that was previously trained using the Python version of the game and then exported using the &lt;code&gt;SavedModelBuilder&lt;/code&gt; functionality in order to load it in Go. This will export a TensorFlow graph as a protocol buffer and allow it to be loaded in Go using the &lt;code&gt;LoadSavedModel&lt;/code&gt; function.&lt;/p&gt;

&lt;p&gt;For the game portion, I used a library called &lt;a href=&#34;https://github.com/faiface/pixel&#34; target=&#34;_blank&#34;&gt;Pixel&lt;/a&gt; which is still early in development but has a really active community, and offered excellent stability and performance. I was pretty performance conscious when building and porting the game, so there are certain limitations such as non-pixel-perfect collisions, in order to ensure that the game could run acceptably under all conditions.&lt;/p&gt;

&lt;h3 id=&#34;training-the-neural-net&#34;&gt;Training the Neural Net&lt;/h3&gt;

&lt;p&gt;Our Neural Net is ultimately a very simple one &amp;ndash; four inputs and a single output neuron. It will use supervised learning to do binary classification on a simple problem: was each shot a hit or a miss? It utilizes the delta between player and enemy position, and player and enemy velocity as the inputs. The single output neuron will fire if its activation value is &amp;gt;= 0.5 and will not fire if it is &amp;lt; 0.5.&lt;/p&gt;

&lt;p&gt;When building the network, I initially had only a single hidden layer with 4 nodes but found that after training it, it was somewhat erratic. It seemed like it was very sensitive to the training data and would not ‘settle’ on a particular strategy in any consistent way. I experimented with a few different configurations, and ultimately settled on the one we used for the demo. It’s quite likely not the optimal setup, and may have more layers than is necessary. What appealed to me though was that even with a very small amount of training data, and regardless of how you trained it, it would consistently settle into a similar behaviour pattern which made it great for a floor demo where anyone could play or train the game.&lt;/p&gt;

&lt;p&gt;&lt;img src=&#34;http://gopherdata.io/img/gameai/NNViz.png&#34; alt=&#34;Neural Network Visualization&#34; title=&#34;Neural Net Visualization&#34; /&gt;
&lt;em&gt;The inputs are the four nodes at the top, with the output node (primed to fire here) at the bottom. Thicker lines represent higher weights. Activation values appear in the node centers.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The visualization was cobbled together by myself to run using the Pixel immediate mode drawing functions. Inspired by &lt;a href=&#34;https://medium.com/deep-learning-101/how-to-generate-a-video-of-a-neural-network-learning-in-python-62f5c520e85c&#34; target=&#34;_blank&#34;&gt;this blog post&lt;/a&gt;, the visualization here shows connections between nodes as either red or green lines. Green lines indicate positive weights that will bias the network towards “shooting”, and red values inhibit shooting. Thicker lines indicate higher weight values and thus “stronger” connections.&lt;/p&gt;

&lt;p&gt;After training, the network consistently seems to converge on the following strategy:&lt;/p&gt;

&lt;p&gt;If the player is within a reasonable cone of forward “vision” then fire indiscriminately.
If the player is not within that reasonable forward cone, then do not fire at all.&lt;/p&gt;

&lt;p&gt;At first, it was very interesting to me that the network did not settle on the more obvious “just fire constantly” strategy, but given that it does receive training data that indicates that “misses” are undesirable, it makes sense that it would avoid firing shots with a low probability of hitting.&lt;/p&gt;

&lt;p&gt;&lt;img src=&#34;http://gopherdata.io/img/gameai/GopherPos.png&#34; alt=&#34;Positive Network Output&#34; title=&#34;Positive Network Output&#34; /&gt;
&lt;em&gt;In this image, notice that because I’m in a forward cone, most of the enemies are firing at my indiscriminately.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;img src=&#34;http://gopherdata.io/img/gameai/GopherNeg.png&#34; alt=&#34;Negative Network Output&#34; title=&#34;Negative Network Output&#34; /&gt;
&lt;em&gt;In this image, you’ll notice none of the enemies are firing because I am clearly outside their range of possible success. However, if you look at the activation values, you’ll see that the enemy who has just come onto the screen is about to blast me because his output is 0.83. Yikes!&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;In the training mode, the enemies fire randomly, and then each shot taken by the enemy is recorded as a hit or a miss along with its initial relative position/velocity values.&lt;/p&gt;

&lt;p&gt;It’s worth noting that in early iterations of the game, I was passing in raw pixel values for positions and velocities. This meant that there was a really wide variation between the values in the input and I found that the network would just not really converge to a consistent behaviour. So, I normalized the input data to be roughly between 0.0-1.0 and found that it basically instantly converged to a usable behaviour. So, lesson for you kids: normalize your input data!&lt;/p&gt;

&lt;p&gt;It&amp;rsquo;s also important that you make all your input values framerate independent since the model is being trained in Python, any discrepancies between either the co-ordinate space or velocity values when running in Go will result in getting incorrect results back from the network.&lt;/p&gt;

&lt;p&gt;Once the network is trained, when you play the game, every instance of an enemy spaceship uses its own instance of the neural network to make decisions about when it should fire.&lt;/p&gt;

&lt;h3 id=&#34;using-the-model-in-go&#34;&gt;Using the model in Go&lt;/h3&gt;

&lt;p&gt;As mentioned above, we exported our model from Python using the SavedModelBuilder and then need to load this in Go. The &lt;code&gt;SavedModelBuilder&lt;/code&gt; will export the model into a folder, and you only need to specify that folder when loading in Go, along with the tag for your model. There are two available tags - TRAIN and SERVING. In our case, I used TRAIN but for deployment, it is suggested that you use the SERVING tag.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-Go&#34;&gt;    // bundle contains Session + Graph
    bundle, err := tf.LoadSavedModel(&amp;quot;exported_brain&amp;quot;, []string{&amp;quot;train&amp;quot;}, nil)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;This code will load your saved model and return a struct that contains pointers to the TensorFlow graph, and a new TensorFlow session that you can use for evaluation. However, at this stage many are left wondering - so, now what?&lt;/p&gt;

&lt;p&gt;This is where current limitations in the Go binding and documentation show themselves. The key next step is to access the nodes in the TensorFlow graph for the input and output nodes. Right now, the only way to do this is to print the graph node names from Python when you are exporting. You do have the option of labelling nodes as you output them, but don&amp;rsquo;t have the ability to access those nodes by their labels from Go.&lt;/p&gt;

&lt;p&gt;In this case, once we have the names of the nodes, we need to access them in Go via the &lt;code&gt;Operation&lt;/code&gt; method on the TensorFlow graph. Remember that because TensorFlow is storing our network as a series of computation operations, that&amp;rsquo;s why it is called &lt;code&gt;Operation&lt;/code&gt;.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-Go&#34;&gt;    inputop := bundle.Graph.Operation(&amp;quot;dense_1_input&amp;quot;)
    outputop := bundle.Graph.Operation(&amp;quot;dense_5/Sigmoid&amp;quot;)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;So now, we have both a Session with our Graph, and we have also found our input and output Operations, so now we&amp;rsquo;re ready to send data to the graph and use it to evaluate that data. In our case, since we&amp;rsquo;ve trained the graph using the relative position and velocity in the game, each frame, for each enemy we will take their relative position and velocity to the player and feed it into the network to get a decision back on whether or not we should fire at the player.&lt;/p&gt;

&lt;p&gt;Our first step in having our enemies &amp;ldquo;think&amp;rdquo; is to build a new &amp;lsquo;Tensor&amp;rsquo; (which is like a vector) to feed into the network:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-Go&#34;&gt;    var column *tf.Tensor
    column, err = tf.NewTensor([1][4]float32{{dx, dy, du, dv}})
    results, err := bundle.Session.Run(map[tf.Output]*tf.Tensor{inputop.Output(0): column}, []tf.Output{outputop.Output(0)}, nil)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;What you see above is that we&amp;rsquo;re building a tensor from the relative position (dx, dy) and the relative velocity (du, dv) and then running our TensorFlow session, specifying which nodes are the input and output nodes. The session will then return the results in the form of an array. In our case, since we only have one output node, the array only has one entry.&lt;/p&gt;

&lt;p&gt;Our enemies have almost made a decision - all we need to do is read the output value from their neuron. If value at the output node is greater than or equal to 0.5 we use that threshold to determine that we should fire at the player:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-Go&#34;&gt;    for _, result := range results {
        if result.Value().([][]float32)[0][0] &amp;gt;= 0.5 &amp;amp;&amp;amp; enemy.canfire {
           // FIRE!!
        }
    }
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;And that&amp;rsquo;s it! This is literally the only logic governing the attack behaviour of the enemies, and despite its simplicity, this network generates a compelling and interesting set of enemy behaviour. By applying this repeatedly to all enemies, we&amp;rsquo;ve been able to create an enemy AI for our game.&lt;/p&gt;

&lt;p&gt;There are obviously lots of easy and obvious ways to improve this, and to make it more sophisticated - but as a demonstration of utilizing a model loaded at runtime in Go and &amp;lsquo;deployed&amp;rsquo; into our game - it demonstrates the ease and power of these techniques and how accessible the tools are making them.&lt;/p&gt;

&lt;h2 id=&#34;next-steps&#34;&gt;Next Steps&lt;/h2&gt;

&lt;p&gt;The Machine Learning and Data Science ecosystem in Go is growing, and there are lots of exciting opportunties to contribute to a wide variety of projects - including TensorFlow.&lt;/p&gt;

&lt;p&gt;In the near future, I plan to push this to GitHub as I had a number of requests at both GopherCon and PyCon to do so and would love to see others learn from this project as well as help to develop and expand its capabilities.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Update 08/29/17 - Full Source Code is now live on &lt;a href=&#34;https://github.com/ActiveState/neuroblast&#34; target=&#34;_blank&#34;&gt;GitHub&lt;/a&gt;!&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;If you want to ask questions about this project, feel free to hit me up on Twitter &lt;a href=&#34;https://twitter.com/rawktron&#34; target=&#34;_blank&#34;&gt;@rawktron&lt;/a&gt;.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Building a distributed Trump finder</title>
      <link>http://gopherdata.io/post/distributed_trump_finder/</link>
      <pubDate>Wed, 26 Apr 2017 12:00:00 +0000</pubDate>
      
      <guid>http://gopherdata.io/post/distributed_trump_finder/</guid>
      <description>&lt;p&gt;(Author: Daniel Whitenack, @dwhitena on &lt;a href=&#34;https://twitter.com/dwhitena&#34; target=&#34;_blank&#34;&gt;Twitter&lt;/a&gt; and Gophers Slack)&lt;/p&gt;

&lt;p&gt;If you haven&amp;rsquo;t heard, there is a new kid on the machine learning block named &lt;a href=&#34;https://machinebox.io/&#34; target=&#34;_blank&#34;&gt;Machine Box&lt;/a&gt;.  It&amp;rsquo;s pretty cool, and you should check it out.  Machine Box provides pre-built Docker images that enable easy, production ready, and reproducible machine learning operations.  For example, you can get a &amp;ldquo;facebox&amp;rdquo; Docker image from Machine Box for facial recognition. When you run &amp;ldquo;facebox,&amp;rdquo; you get a full JSON API that lets you to easily &amp;ldquo;teach&amp;rdquo; facebox certain people&amp;rsquo;s faces, identify those faces in images, and persist the &amp;ldquo;state&amp;rdquo; of trained facial recognition models.&lt;/p&gt;

&lt;p&gt;Experimenting with &amp;ldquo;facebox&amp;rdquo; got me thinking about how it could be integrated into some of my workflows.  In particular, I wanted to see how Machine Box images could be utilized as part of distributed data processing pipeline built with &lt;a href=&#34;http://pachyderm.io/&#34; target=&#34;_blank&#34;&gt;Pachyderm&lt;/a&gt;.  Pachyderm builds, runs, and manages pipelines, such as machine learning workflows, based on Docker images.  Thus, an integration of Machine Box images seems to be only natural.&lt;/p&gt;

&lt;p&gt;And that&amp;rsquo;s how the first (to my knowledge) distributed, Docker-ized, &amp;ldquo;Trump-finding&amp;rdquo; data pipeline came to be. In the sections below we will walk through the creation of a facial recognition pipeline that is able to find and tag the location of Donald Trump&amp;rsquo;s face in images.  Actually, this pipeline could be used to identify any faces, and we will illustrate this flexibility by updating the pipeline to learn a second face, Hillary Clinton.&lt;/p&gt;

&lt;p&gt;The below sections assume that you have a Pachyderm cluster running, that &lt;code&gt;pachctl&lt;/code&gt;(the Pachyderm CLI tool) is connected to that cluster, and that you have signed up for a Machine Box key (which you can do for free).  All the code and more detailed instructions can be found &lt;a href=&#34;https://github.com/dwhitena/pach-machine-box&#34; target=&#34;_blank&#34;&gt;here&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Create the pipeline inputs&lt;/strong&gt;:&lt;/p&gt;

&lt;p&gt;To train our facial recognition model, identify faces in images, and tag those faces with certain labels, we need to create three &amp;ldquo;data repositories&amp;rdquo; that will be the inputs to our Pachyderm pipeline:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;code&gt;training&lt;/code&gt; - which includes images of faces that we use to &amp;ldquo;teach&amp;rdquo; facebox&lt;/li&gt;
&lt;li&gt;&lt;code&gt;unidentified&lt;/code&gt; - which includes images with faces we want to detect and identify&lt;/li&gt;
&lt;li&gt;&lt;code&gt;labels&lt;/code&gt; - which includes label images that we will overlay on the unidentified images to indicate identified faces&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;This can be done with &lt;code&gt;pachctl&lt;/code&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-sh&#34;&gt;➔ pachctl create-repo training
➔ pachctl create-repo unidentified
➔ pachctl create-repo labels
➔ pachctl list-repo
NAME                CREATED             SIZE                
labels              3 seconds ago       0 B                 
unidentified        11 seconds ago      0 B                 
training            17 seconds ago      0 B
➔ cd data/train/faces1/
➔ ls
trump1.jpg  trump2.jpg  trump3.jpg  trump4.jpg  trump5.jpg
➔ pachctl put-file training master -c -r -f .
➔ pachctl list-repo
NAME                CREATED             SIZE                
training            5 minutes ago       486.2 KiB           
labels              5 minutes ago       0 B                 
unidentified        5 minutes ago       0 B                 
➔ pachctl list-file training master
NAME                TYPE                SIZE                
trump1.jpg          file                78.98 KiB           
trump2.jpg          file                334.5 KiB           
trump3.jpg          file                11.63 KiB           
trump4.jpg          file                27.45 KiB           
trump5.jpg          file                33.6 KiB
➔ cd ../../labels/
➔ ls
clinton.jpg  trump.jpg
➔ pachctl put-file labels master -c -r -f .
➔ cd ../unidentified/
➔ ls
image1.jpg  image2.jpg
➔ pachctl put-file unidentified master -c -r -f .
➔ pachctl list-repo
NAME                CREATED             SIZE                
unidentified        7 minutes ago       540.4 KiB           
labels              7 minutes ago       15.44 KiB           
training            7 minutes ago       486.2 KiB
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;strong&gt;Train, or &amp;ldquo;teach,&amp;rdquo; facebox&lt;/strong&gt;:&lt;/p&gt;

&lt;p&gt;Next, we create a Pachyderm pipeline stage that will take the &lt;code&gt;training&lt;/code&gt; data as input, provide those training images to facebox, and output the &amp;ldquo;state&amp;rdquo; of a trained model.  This is done by providing Pachyderm with a pipeline spec, &lt;a href=&#34;https://github.com/dwhitena/pach-machine-box/blob/master/pipelines/train.json&#34; target=&#34;_blank&#34;&gt;train.json&lt;/a&gt;.  This pipeline spec specifies the Docker image to use for data processing, the commands to execute in that Docker container, and what data is input to the pipeline.&lt;/p&gt;

&lt;p&gt;In our particular case, &lt;code&gt;train.json&lt;/code&gt; specifies that we should use an image based on the facebox image from Machine Box and execute a number of cURL commands to post the training data to facebox.  Once those training images are provided to and processed by facebox, we specify another cURL command to export the state of the facebox model (for use later in our pipeline).&lt;/p&gt;

&lt;p&gt;We are using a little bash magic here to perform these operations.  However, it is very possible that, in the future, Machine Box will provide a more standardized command line implementation for these sorts of use cases.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-sh&#34;&gt;create-MB-pipeline.sh  identify.json  tag.json  train.json
➔ ./create-MB-pipeline.sh train.json
➔ pachctl list-pipeline
NAME                INPUT               OUTPUT              STATE               
model               training            model/master        running    
➔ pachctl list-job
ID                                   OUTPUT COMMIT STARTED       DURATION RESTART PROGRESS STATE            
3425a7a0-543e-4e2a-a244-a3982c527248 model/-       9 seconds ago -        1       0 / 1    running
➔ pachctl list-job
ID                                   OUTPUT COMMIT                          STARTED       DURATION  RESTART PROGRESS STATE            
3425a7a0-543e-4e2a-a244-a3982c527248 model/1b9c158e33394056a18041a4a86cb54a 5 minutes ago 5 minutes 1       1 / 1    success
➔ pachctl list-repo
NAME                CREATED             SIZE                
model               5 minutes ago       4.118 KiB           
unidentified        18 minutes ago      540.4 KiB           
labels              18 minutes ago      15.44 KiB           
training            19 minutes ago      486.2 KiB           
➔ pachctl list-file model master
NAME                TYPE                SIZE                
state.facebox       file                4.118 KiB
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;As you can see the output of this pipeline is a &lt;code&gt;.facebox&lt;/code&gt; file that contained the trained state of our facebox model.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Use the trained facebox to identify faces&lt;/strong&gt;:&lt;/p&gt;

&lt;p&gt;We then launch another Pachyderm pipeline, based on an &lt;a href=&#34;https://github.com/dwhitena/pach-machine-box/blob/master/pipelines/identify.json&#34; target=&#34;_blank&#34;&gt;identify.json&lt;/a&gt; pipeline specification, to identify faces within the &lt;code&gt;unidentified&lt;/code&gt; images.  This pipeline will take the persisted state of our model in &lt;code&gt;model&lt;/code&gt; along with the &lt;code&gt;unidentified&lt;/code&gt; images as input.  It will also execute cURL commands to interact with facebox, and it will output indications of identified faces to JSON files, one per &lt;code&gt;unidentified&lt;/code&gt; image.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-sh&#34;&gt;➔ ./create-MB-pipeline.sh identify.json
➔ pachctl list-job
ID                                   OUTPUT COMMIT                          STARTED       DURATION  RESTART PROGRESS STATE            
281d4393-05c8-44bf-b5de-231cea0fc022 identify/-                             6 seconds ago -         0       0 / 2    running
3425a7a0-543e-4e2a-a244-a3982c527248 model/1b9c158e33394056a18041a4a86cb54a 8 minutes ago 5 minutes 1       1 / 1    success
➔ pachctl list-job
ID                                   OUTPUT COMMIT                             STARTED            DURATION   RESTART PROGRESS STATE            
281d4393-05c8-44bf-b5de-231cea0fc022 identify/287fc78a4cdf42d89142d46fb5f689d9 About a minute ago 53 seconds 0       2 / 2    success
3425a7a0-543e-4e2a-a244-a3982c527248 model/1b9c158e33394056a18041a4a86cb54a    9 minutes ago      5 minutes  1       1 / 1    success
➔ pachctl list-repo
NAME                CREATED              SIZE                
identify            About a minute ago   1.932 KiB           
model               10 minutes ago       4.118 KiB           
unidentified        23 minutes ago       540.4 KiB           
labels              23 minutes ago       15.44 KiB           
training            24 minutes ago       486.2 KiB           
➔ pachctl list-file identify master
NAME                TYPE                SIZE                
image1.json         file                1.593 KiB           
image2.json         file                347 B
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;If we look at the JSON output for, e.g., &lt;code&gt;image1.jpg&lt;/code&gt;, we can see that there is a portion of the file that clearly identifies Donald Trump in the image along with the location and size of his face in the image:&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;{
	&amp;quot;success&amp;quot;: true,
	&amp;quot;facesCount&amp;quot;: 13,
	&amp;quot;faces&amp;quot;: [
		...
		...
		{
			&amp;quot;rect&amp;quot;: {
				&amp;quot;top&amp;quot;: 175,
				&amp;quot;left&amp;quot;: 975,
				&amp;quot;width&amp;quot;: 108,
				&amp;quot;height&amp;quot;: 108
			},
			&amp;quot;id&amp;quot;: &amp;quot;58ff31510f7707a01fb3e2f4d39f26dc&amp;quot;,
			&amp;quot;name&amp;quot;: &amp;quot;trump&amp;quot;,
			&amp;quot;matched&amp;quot;: true
		},
		...
		...
	]
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;strong&gt;Tagging identified faces in the images&lt;/strong&gt;:&lt;/p&gt;

&lt;p&gt;We are most of the way there! We have identified Trump in the &lt;code&gt;unidentified&lt;/code&gt; images, but the JSON output isn&amp;rsquo;t the most visually appealling.  As such, let&amp;rsquo;s overlay a label on the images at the location of Trump&amp;rsquo;s face.&lt;/p&gt;

&lt;p&gt;To do this, we can use a &lt;a href=&#34;https://github.com/dwhitena/pach-machine-box/blob/master/tagimage/main.go&#34; target=&#34;_blank&#34;&gt;simple Go program&lt;/a&gt; to draw the label image on the &lt;code&gt;unidentified&lt;/code&gt; image at the appropriate location.  This part of the pipeline is specified by a &lt;a href=&#34;https://github.com/dwhitena/pach-machine-box/blob/master/pipelines/tag.json&#34; target=&#34;_blank&#34;&gt;tag.json&lt;/a&gt; pipeline specification, and can be created as follows:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-sh&#34;&gt;➔ pachctl create-pipeline -f tag.json
➔ pachctl list-job
ID                                   OUTPUT COMMIT                             STARTED        DURATION   RESTART PROGRESS STATE            
cd284a28-6c97-4236-9f6d-717346c60f24 tag/-                                     2 seconds ago  -          0       0 / 2    running
281d4393-05c8-44bf-b5de-231cea0fc022 identify/287fc78a4cdf42d89142d46fb5f689d9 5 minutes ago  53 seconds 0       2 / 2    success
3425a7a0-543e-4e2a-a244-a3982c527248 model/1b9c158e33394056a18041a4a86cb54a    13 minutes ago 5 minutes  1       1 / 1    success
➔ pachctl list-job
ID                                   OUTPUT COMMIT                             STARTED        DURATION   RESTART PROGRESS STATE            
cd284a28-6c97-4236-9f6d-717346c60f24 tag/ae747e8032704b6cae6ae7bba064c3c3      25 seconds ago 11 seconds 0       2 / 2    success
281d4393-05c8-44bf-b5de-231cea0fc022 identify/287fc78a4cdf42d89142d46fb5f689d9 5 minutes ago  53 seconds 0       2 / 2    success
3425a7a0-543e-4e2a-a244-a3982c527248 model/1b9c158e33394056a18041a4a86cb54a    14 minutes ago 5 minutes  1       1 / 1    success
➔ pachctl list-repo
NAME                CREATED             SIZE                
tag                 30 seconds ago      591.3 KiB           
identify            5 minutes ago       1.932 KiB           
model               14 minutes ago      4.118 KiB           
unidentified        27 minutes ago      540.4 KiB           
labels              27 minutes ago      15.44 KiB           
training            27 minutes ago      486.2 KiB           
➔ pachctl list-file tag master
NAME                TYPE                SIZE                
tagged_image1.jpg   file                557 KiB             
tagged_image2.jpg   file                34.35 KiB           
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;As you can see, we now have two &amp;ldquo;tagged&amp;rdquo; versions of the images in the output &lt;code&gt;tag&lt;/code&gt; data repository.  If we get these images, we can see that&amp;hellip; Boom! Our Trump finder works:&lt;/p&gt;

&lt;p&gt;&lt;img src=&#34;https://raw.githubusercontent.com/dwhitena/pach-machine-box/master/tagged_images1.jpg&#34; alt=&#34;alt text&#34; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Teaching a new face, updating the output&lt;/strong&gt;:&lt;/p&gt;

&lt;p&gt;Our pipeline isn&amp;rsquo;t restricted to Trump or any one face.  Actually, we can teach facebox another face by updating our &lt;code&gt;training&lt;/code&gt;.  Moreover, because Pachyderm versions your data and knows what data is new, it can automatically update all our results once facebox learns the new face:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-sh&#34;&gt;➔ cd ../data/train/faces2/
➔ ls
clinton1.jpg  clinton2.jpg  clinton3.jpg  clinton4.jpg
➔ pachctl put-file training master -c -r -f .
➔ pachctl list-job
ID                                   OUTPUT COMMIT                             STARTED        DURATION   RESTART PROGRESS STATE            
56e24ac0-0430-4fa4-aa8b-08de5c1884db model/-                                   4 seconds ago  -          0       0 / 1    running
cd284a28-6c97-4236-9f6d-717346c60f24 tag/ae747e8032704b6cae6ae7bba064c3c3      6 minutes ago  11 seconds 0       2 / 2    success
281d4393-05c8-44bf-b5de-231cea0fc022 identify/287fc78a4cdf42d89142d46fb5f689d9 11 minutes ago 53 seconds 0       2 / 2    success
3425a7a0-543e-4e2a-a244-a3982c527248 model/1b9c158e33394056a18041a4a86cb54a    20 minutes ago 5 minutes  1       1 / 1    success
➔ pachctl list-job
ID                                   OUTPUT COMMIT                             STARTED            DURATION   RESTART PROGRESS STATE            
6aa6c995-58ce-445d-999a-eb0e0690b041 tag/7cbd2584d4f0472abbca0d9e015b9829      5 seconds ago      1 seconds  0       2 / 2    success
8a7961b7-1085-404a-b0ee-66034fae7212 identify/1bc94ec558e44e0cb45ed5ab7d9f9674 59 seconds ago     54 seconds 0       2 / 2    success
56e24ac0-0430-4fa4-aa8b-08de5c1884db model/002f16b63a4345a4bc6bdf5510c9faac    About a minute ago 19 seconds 0       1 / 1    success
cd284a28-6c97-4236-9f6d-717346c60f24 tag/ae747e8032704b6cae6ae7bba064c3c3      8 minutes ago      11 seconds 0       2 / 2    success
281d4393-05c8-44bf-b5de-231cea0fc022 identify/287fc78a4cdf42d89142d46fb5f689d9 13 minutes ago     53 seconds 0       2 / 2    success
3425a7a0-543e-4e2a-a244-a3982c527248 model/1b9c158e33394056a18041a4a86cb54a    21 minutes ago     5 minutes  1       1 / 1    success
➔ pachctl list-file tag master
NAME                TYPE                SIZE                
tagged_image1.jpg   file                557 KiB             
tagged_image2.jpg   file                36.03 KiB
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Now if we look at our images, we find that everything has been updated without any annoying manual work on our hands:&lt;/p&gt;

&lt;p&gt;&lt;img src=&#34;https://raw.githubusercontent.com/dwhitena/pach-machine-box/master/tagged_images2.jpg&#34; alt=&#34;alt text&#34; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Conclusion/Resources&lt;/strong&gt;:&lt;/p&gt;

&lt;p&gt;As you can see, Machine Box and Pachyderm make it really quick and easy to deploy a distributed, machine learning data pipeline.  Be sure to:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Visit &lt;a href=&#34;https://github.com/dwhitena/pach-machine-box&#34; target=&#34;_blank&#34;&gt;this repo&lt;/a&gt; to get the code and pipeline specs, so you can create your own Trump finder!&lt;/li&gt;
&lt;li&gt;Join the &lt;a href=&#34;http://slack.pachyderm.io/&#34; target=&#34;_blank&#34;&gt;Pachyderm Slack team&lt;/a&gt; to get help implementing your ML pipelines, and participate in the discussion in the #data-science channel on Gophers Slack.&lt;/li&gt;
&lt;li&gt;Follow &lt;a href=&#34;https://twitter.com/pachydermIO&#34; target=&#34;_blank&#34;&gt;Pachyderm on Twitter&lt;/a&gt;,&lt;/li&gt;
&lt;li&gt;Sign up for a free &lt;a href=&#34;https://machinebox.io/&#34; target=&#34;_blank&#34;&gt;Machine Box&lt;/a&gt; API key, and&lt;/li&gt;
&lt;li&gt;Follow &lt;a href=&#34;https://twitter.com/machineboxio&#34; target=&#34;_blank&#34;&gt;Machine Box on Twitter&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>Deep Learning from Scratch in Go - Part 1: Equations Are Graphs</title>
      <link>http://gopherdata.io/post/deeplearning_in_go_part_1/</link>
      <pubDate>Wed, 19 Apr 2017 08:43:45 +1000</pubDate>
      
      <guid>http://gopherdata.io/post/deeplearning_in_go_part_1/</guid>
      <description>

&lt;p&gt;(Author: Chewxy, @chewxy on &lt;a href=&#34;https://twitter.com/chewxy&#34; target=&#34;_blank&#34;&gt;Twitter&lt;/a&gt; and Gophers Slack)&lt;/p&gt;

&lt;p&gt;Welcome to the first part of many about writing deep learning algorithms in Go. The goal of this series is to go from having no knowledge at all to implementing some of the latest developments in this area.&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://en.wikipedia.org/wiki/Deep_learning&#34; target=&#34;_blank&#34;&gt;Deep learning&lt;/a&gt; is not new. In fact the idea of deep learning was spawned in the early 1980s. What&amp;rsquo;s changed since then is our computers - they have gotten much much more powerful.  In this blog post we&amp;rsquo;ll start with something familiar, and edge towards building a conceptual model of deep learning. We won&amp;rsquo;t define deep learning for the first few posts, so don&amp;rsquo;t worry so much about the term.&lt;/p&gt;

&lt;p&gt;There are a few terms of clarification to be made before we begin proper. In this series, the word &amp;ldquo;graph&amp;rdquo; refers to the concept of graph as used in &lt;a href=&#34;https://en.wikipedia.org/wiki/Graph_(discrete_mathematics)&#34; target=&#34;_blank&#34;&gt;graph theory&lt;/a&gt;. For the other kind of &amp;ldquo;graph&amp;rdquo; which is usually used for data visualization, I&amp;rsquo;ll use the term &amp;ldquo;chart&amp;rdquo;.&lt;/p&gt;

&lt;h2 id=&#34;computation&#34;&gt;Computation&lt;/h2&gt;

&lt;p&gt;I&amp;rsquo;m going to start by making a claim: all programs can be represented as graphs. This claim is not new, of course. Nor is it bold or revolutionary. It&amp;rsquo;s the fundamental theory that computer scientists have been working on ever since the birth of the field of computation. But you may have missed it. If you have missed it, the logic goes as such:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;All modern computer programs run on what essentially is a &lt;a href=&#34;https://en.wikipedia.org/wiki/Turing_machine&#34; target=&#34;_blank&#34;&gt;Turing Machine&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;All Turing machines are equivalent to untyped lambda calculus (this is commonly known as the &lt;a href=&#34;https://en.wikipedia.org/wiki/Church_Turing_thesis&#34; target=&#34;_blank&#34;&gt;Church-Turing thesis&lt;/a&gt;)&lt;/li&gt;
&lt;li&gt;Lambda calculus can be represented as graphs.&lt;/li&gt;
&lt;li&gt;Therefore all programs can be represented as graphs.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;To make this idea more concrete, let&amp;rsquo;s look at a simple program:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;func main() {
	fmt.Printf(&amp;quot;%v&amp;quot;, 1+1)	
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;This generates an &lt;a href=&#34;https://en.wikipedia.org/wiki/Abstract_syntax_tree&#34; target=&#34;_blank&#34;&gt;abstract syntax tree&lt;/a&gt; like so (the AST was generated with a library built on top of &lt;a href=&#34;https://github.com/yuroyoro/goast-viewer&#34; target=&#34;_blank&#34;&gt;goast-viewer&lt;/a&gt;):&lt;/p&gt;

&lt;div style=&#34;margin-left:auto; margin-right:auto;&#34;&gt;
&lt;svg style=&#34;width:100%; height:auto;&#34;
 viewBox=&#34;0.00 0.00 1167.98 548.00&#34; xmlns=&#34;http://www.w3.org/2000/svg&#34; xmlns:xlink=&#34;http://www.w3.org/1999/xlink&#34;&gt;
&lt;g id=&#34;graph0&#34; class=&#34;graph&#34; transform=&#34;scale(1 1) rotate(0) translate(4 544)&#34;&gt;
&lt;title&gt;%3&lt;/title&gt;
&lt;polygon fill=&#34;white&#34; stroke=&#34;none&#34; points=&#34;-4,4 -4,-544 1163.98,-544 1163.98,4 -4,4&#34;/&gt;
&lt;!-- mainFn --&gt;
&lt;g id=&#34;node1&#34; class=&#34;node&#34;&gt;&lt;title&gt;mainFn&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;445.942&#34; cy=&#34;-522&#34; rx=&#34;52.7911&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;445.942&#34; y=&#34;-518.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;func main()&lt;/text&gt;
&lt;/g&gt;
&lt;!-- mainBody --&gt;
&lt;g id=&#34;node2&#34; class=&#34;node&#34;&gt;&lt;title&gt;mainBody&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;445.942&#34; cy=&#34;-450&#34; rx=&#34;61.1893&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;445.942&#34; y=&#34;-446.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.BlocStmt&lt;/text&gt;
&lt;/g&gt;
&lt;!-- mainFn&amp;#45;&amp;gt;mainBody --&gt;
&lt;g id=&#34;edge1&#34; class=&#34;edge&#34;&gt;&lt;title&gt;mainFn&amp;#45;&amp;gt;mainBody&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M445.942,-503.697C445.942,-495.983 445.942,-486.712 445.942,-478.112&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;449.442,-478.104 445.942,-468.104 442.442,-478.104 449.442,-478.104&#34;/&gt;
&lt;/g&gt;
&lt;!-- bodyList --&gt;
&lt;g id=&#34;node3&#34; class=&#34;node&#34;&gt;&lt;title&gt;bodyList&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;445.942&#34; cy=&#34;-378&#34; rx=&#34;46.2923&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;445.942&#34; y=&#34;-374.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;[]ast.Stmt&lt;/text&gt;
&lt;/g&gt;
&lt;!-- mainBody&amp;#45;&amp;gt;bodyList --&gt;
&lt;g id=&#34;edge2&#34; class=&#34;edge&#34;&gt;&lt;title&gt;mainBody&amp;#45;&amp;gt;bodyList&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M445.942,-431.697C445.942,-423.983 445.942,-414.712 445.942,-406.112&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;449.442,-406.104 445.942,-396.104 442.442,-406.104 449.442,-406.104&#34;/&gt;
&lt;/g&gt;
&lt;!-- list0 --&gt;
&lt;g id=&#34;node4&#34; class=&#34;node&#34;&gt;&lt;title&gt;list0&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;445.942&#34; cy=&#34;-306&#34; rx=&#34;61.99&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;445.942&#34; y=&#34;-302.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.ExprStmt&lt;/text&gt;
&lt;/g&gt;
&lt;!-- bodyList&amp;#45;&amp;gt;list0 --&gt;
&lt;g id=&#34;edge3&#34; class=&#34;edge&#34;&gt;&lt;title&gt;bodyList&amp;#45;&amp;gt;list0&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M445.942,-359.697C445.942,-351.983 445.942,-342.712 445.942,-334.112&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;449.442,-334.104 445.942,-324.104 442.442,-334.104 449.442,-334.104&#34;/&gt;
&lt;/g&gt;
&lt;!-- call --&gt;
&lt;g id=&#34;node5&#34; class=&#34;node&#34;&gt;&lt;title&gt;call&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;445.942&#34; cy=&#34;-234&#34; rx=&#34;59.2899&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;445.942&#34; y=&#34;-230.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.CallExpr&lt;/text&gt;
&lt;/g&gt;
&lt;!-- list0&amp;#45;&amp;gt;call --&gt;
&lt;g id=&#34;edge4&#34; class=&#34;edge&#34;&gt;&lt;title&gt;list0&amp;#45;&amp;gt;call&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M445.942,-287.697C445.942,-279.983 445.942,-270.712 445.942,-262.112&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;449.442,-262.104 445.942,-252.104 442.442,-262.104 449.442,-262.104&#34;/&gt;
&lt;/g&gt;
&lt;!-- fn --&gt;
&lt;g id=&#34;node6&#34; class=&#34;node&#34;&gt;&lt;title&gt;fn&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;303.942&#34; cy=&#34;-162&#34; rx=&#34;73.387&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;303.942&#34; y=&#34;-158.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.SelectorExpr&lt;/text&gt;
&lt;/g&gt;
&lt;!-- call&amp;#45;&amp;gt;fn --&gt;
&lt;g id=&#34;edge5&#34; class=&#34;edge&#34;&gt;&lt;title&gt;call&amp;#45;&amp;gt;fn&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M416.174,-218.326C395.302,-208.037 367.156,-194.162 344.272,-182.881&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;345.662,-179.664 335.145,-178.382 342.567,-185.943 345.662,-179.664&#34;/&gt;
&lt;/g&gt;
&lt;!-- args --&gt;
&lt;g id=&#34;node9&#34; class=&#34;node&#34;&gt;&lt;title&gt;args&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;587.942&#34; cy=&#34;-162&#34; rx=&#34;46.2923&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;587.942&#34; y=&#34;-158.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;[]ast.Expr&lt;/text&gt;
&lt;/g&gt;
&lt;!-- call&amp;#45;&amp;gt;args --&gt;
&lt;g id=&#34;edge8&#34; class=&#34;edge&#34;&gt;&lt;title&gt;call&amp;#45;&amp;gt;args&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M475.71,-218.326C497.582,-207.544 527.443,-192.823 550.866,-181.277&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;552.721,-184.265 560.142,-176.704 549.625,-177.986 552.721,-184.265&#34;/&gt;
&lt;/g&gt;
&lt;!-- fnPkg --&gt;
&lt;g id=&#34;node7&#34; class=&#34;node&#34;&gt;&lt;title&gt;fnPkg&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;92.9418&#34; cy=&#34;-90&#34; rx=&#34;92.8835&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;92.9418&#34; y=&#34;-86.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.Ident (Name: fmt)&lt;/text&gt;
&lt;/g&gt;
&lt;!-- fn&amp;#45;&amp;gt;fnPkg --&gt;
&lt;g id=&#34;edge6&#34; class=&#34;edge&#34;&gt;&lt;title&gt;fn&amp;#45;&amp;gt;fnPkg&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M262.255,-147.17C229.431,-136.281 183.405,-121.012 147.625,-109.141&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;148.418,-105.717 137.825,-105.89 146.214,-112.361 148.418,-105.717&#34;/&gt;
&lt;/g&gt;
&lt;!-- fnFn --&gt;
&lt;g id=&#34;node8&#34; class=&#34;node&#34;&gt;&lt;title&gt;fnFn&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;303.942&#34; cy=&#34;-90&#34; rx=&#34;100.182&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;303.942&#34; y=&#34;-86.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.Ident (Name: Printf)&lt;/text&gt;
&lt;/g&gt;
&lt;!-- fn&amp;#45;&amp;gt;fnFn --&gt;
&lt;g id=&#34;edge7&#34; class=&#34;edge&#34;&gt;&lt;title&gt;fn&amp;#45;&amp;gt;fnFn&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M303.942,-143.697C303.942,-135.983 303.942,-126.712 303.942,-118.112&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;307.442,-118.104 303.942,-108.104 300.442,-118.104 307.442,-118.104&#34;/&gt;
&lt;/g&gt;
&lt;!-- args0 --&gt;
&lt;g id=&#34;node10&#34; class=&#34;node&#34;&gt;&lt;title&gt;args0&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;587.942&#34; cy=&#34;-90&#34; rx=&#34;165.971&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;587.942&#34; y=&#34;-86.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.BasicLit (Kind: STRING) (Value: %v)&lt;/text&gt;
&lt;/g&gt;
&lt;!-- args&amp;#45;&amp;gt;args0 --&gt;
&lt;g id=&#34;edge9&#34; class=&#34;edge&#34;&gt;&lt;title&gt;args&amp;#45;&amp;gt;args0&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M587.942,-143.697C587.942,-135.983 587.942,-126.712 587.942,-118.112&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;591.442,-118.104 587.942,-108.104 584.442,-118.104 591.442,-118.104&#34;/&gt;
&lt;/g&gt;
&lt;!-- args1 --&gt;
&lt;g id=&#34;node11&#34; class=&#34;node&#34;&gt;&lt;title&gt;args1&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;868.942&#34; cy=&#34;-90&#34; rx=&#34;97.4827&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;868.942&#34; y=&#34;-86.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.BinaryExpr (Op: +)&lt;/text&gt;
&lt;/g&gt;
&lt;!-- args&amp;#45;&amp;gt;args1 --&gt;
&lt;g id=&#34;edge10&#34; class=&#34;edge&#34;&gt;&lt;title&gt;args&amp;#45;&amp;gt;args1&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M625.839,-151.559C671.25,-140.247 748.104,-121.102 803.251,-107.364&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;804.426,-110.679 813.284,-104.865 802.734,-103.886 804.426,-110.679&#34;/&gt;
&lt;/g&gt;
&lt;!-- lhs --&gt;
&lt;g id=&#34;node12&#34; class=&#34;node&#34;&gt;&lt;title&gt;lhs&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;718.942&#34; cy=&#34;-18&#34; rx=&#34;141.075&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;718.942&#34; y=&#34;-14.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.BasicLit (Kind: INT) (Value: 1)&lt;/text&gt;
&lt;/g&gt;
&lt;!-- args1&amp;#45;&amp;gt;lhs --&gt;
&lt;g id=&#34;edge11&#34; class=&#34;edge&#34;&gt;&lt;title&gt;args1&amp;#45;&amp;gt;lhs&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M834.904,-73.1159C813.785,-63.26 786.413,-50.4867 763.567,-39.825&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;764.951,-36.6089 754.409,-35.5516 761.991,-42.9522 764.951,-36.6089&#34;/&gt;
&lt;/g&gt;
&lt;!-- rhs --&gt;
&lt;g id=&#34;node13&#34; class=&#34;node&#34;&gt;&lt;title&gt;rhs&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;1018.94&#34; cy=&#34;-18&#34; rx=&#34;141.075&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;1018.94&#34; y=&#34;-14.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.BasicLit (Kind: INT) (Value: 1)&lt;/text&gt;
&lt;/g&gt;
&lt;!-- args1&amp;#45;&amp;gt;rhs --&gt;
&lt;g id=&#34;edge12&#34; class=&#34;edge&#34;&gt;&lt;title&gt;args1&amp;#45;&amp;gt;rhs&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M902.979,-73.1159C924.099,-63.26 951.47,-50.4867 974.317,-39.825&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;975.892,-42.9522 983.474,-35.5516 972.932,-36.6089 975.892,-42.9522&#34;/&gt;
&lt;/g&gt;
&lt;/g&gt;
&lt;/svg&gt;
&lt;/div&gt;

&lt;p&gt;By this, we can also say that any equation that can be represented as a computer program, and a computer program can be represented as a graph. In particular, let&amp;rsquo;s zoom in &lt;code&gt;1+1&lt;/code&gt; part:&lt;/p&gt;

&lt;p&gt;This corresponds to this part of the cleaned up graph (with unnecessary nodes removed):&lt;/p&gt;

&lt;div style=&#34;margin-left:auto; margin-right:auto;&#34;&gt;
&lt;svg style=&#34;width:100%; height:auto;&#34;
 viewBox=&#34;0.00 0.00 590.07 116.00&#34; xmlns=&#34;http://www.w3.org/2000/svg&#34; xmlns:xlink=&#34;http://www.w3.org/1999/xlink&#34;&gt;
&lt;g id=&#34;graph0&#34; class=&#34;graph&#34; transform=&#34;scale(1 1) rotate(0) translate(4 112)&#34;&gt;
&lt;title&gt;%3&lt;/title&gt;
&lt;polygon fill=&#34;white&#34; stroke=&#34;none&#34; points=&#34;-4,4 -4,-112 586.075,-112 586.075,4 -4,4&#34;/&gt;
&lt;!-- args1 --&gt;
&lt;g id=&#34;node1&#34; class=&#34;node&#34;&gt;&lt;title&gt;args1&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;291.037&#34; cy=&#34;-90&#34; rx=&#34;97.4827&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;291.037&#34; y=&#34;-86.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.BinaryExpr (Op: +)&lt;/text&gt;
&lt;/g&gt;
&lt;!-- lhs --&gt;
&lt;g id=&#34;node2&#34; class=&#34;node&#34;&gt;&lt;title&gt;lhs&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;141.037&#34; cy=&#34;-18&#34; rx=&#34;141.075&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;141.037&#34; y=&#34;-14.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.BasicLit (Kind: INT) (Value: 1)&lt;/text&gt;
&lt;/g&gt;
&lt;!-- args1&amp;#45;&amp;gt;lhs --&gt;
&lt;g id=&#34;edge1&#34; class=&#34;edge&#34;&gt;&lt;title&gt;args1&amp;#45;&amp;gt;lhs&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M257,-73.1159C235.88,-63.26 208.509,-50.4867 185.663,-39.825&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;187.047,-36.6089 176.505,-35.5516 184.087,-42.9522 187.047,-36.6089&#34;/&gt;
&lt;/g&gt;
&lt;!-- rhs --&gt;
&lt;g id=&#34;node3&#34; class=&#34;node&#34;&gt;&lt;title&gt;rhs&lt;/title&gt;
&lt;ellipse fill=&#34;none&#34; stroke=&#34;black&#34; cx=&#34;441.037&#34; cy=&#34;-18&#34; rx=&#34;141.075&#34; ry=&#34;18&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;441.037&#34; y=&#34;-14.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;*ast.BasicLit (Kind: INT) (Value: 1)&lt;/text&gt;
&lt;/g&gt;
&lt;!-- args1&amp;#45;&amp;gt;rhs --&gt;
&lt;g id=&#34;edge2&#34; class=&#34;edge&#34;&gt;&lt;title&gt;args1&amp;#45;&amp;gt;rhs&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M325.075,-73.1159C346.195,-63.26 373.566,-50.4867 396.412,-39.825&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;397.988,-42.9522 405.57,-35.5516 395.028,-36.6089 397.988,-42.9522&#34;/&gt;
&lt;/g&gt;
&lt;/g&gt;
&lt;/svg&gt;

&lt;/div&gt;

&lt;p&gt;The graph is traversed in a depth-first manner, starting from the top. The values of the program flow from bottom to top. When the program runs, it starts right at the top. The node will not be resolved until the dependent nodes have been evaluated. The arrows point to what each node depends on. So for example, the value of the &lt;code&gt;*ast.BinaryExpr&lt;/code&gt; node is dependent on the values of &lt;code&gt;*ast.BasicLit (Kind: INT)&lt;/code&gt;. Since we know both values are &lt;code&gt;1&lt;/code&gt;, and we know what &lt;code&gt;+&lt;/code&gt; does, we know that the value at the node &lt;code&gt;*ast.BinaryExpr&lt;/code&gt; is &lt;code&gt;2&lt;/code&gt;.&lt;/p&gt;

&lt;h2 id=&#34;equations-as-graphs&#34;&gt;Equations As Graphs&lt;/h2&gt;

&lt;p&gt;Now why did we spend all that time show 1+1 in graph form? Well, it&amp;rsquo;s because deep learning is really in its core, just a bunch of mathematical equations. Wait, don&amp;rsquo;t go yet! It&amp;rsquo;s not that scary. I am personally of the opinion that one can&amp;rsquo;t really do deep learning (or any machine learning, really) without understanding the mathematics behind it. And in my experience there hasn&amp;rsquo;t been a better way to learn it than visually, if only to internalize the concepts.&lt;/p&gt;

&lt;p&gt;Most deep learning libraries like &lt;a href=&#34;https://tensorflow.org&#34; target=&#34;_blank&#34;&gt;Tensorflow&lt;/a&gt;, &lt;a href=&#34;https://deeplearning.org/theano&#34; target=&#34;_blank&#34;&gt;Theano&lt;/a&gt;, or even my own for Go - &lt;a href=&#34;https://github.com/chewxy/gorgonia&#34; target=&#34;_blank&#34;&gt;Gorgonia&lt;/a&gt;, rely on this core concept that equations are representable by graphs. More importantly, these libraries expose the equation graphs as objects that can be manipulated by the programmer.&lt;/p&gt;

&lt;p&gt;So instead of the program above, we&amp;rsquo;d create something like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;func main() {
	// Create a graph.
	g := G.NewGraph()                         
	
	// Create a node called &amp;quot;x&amp;quot; with the value 1.
	x := G.NodeFromAny(g, 1, G.WithName(&amp;quot;x&amp;quot;)) 
	
	// Create a node called &amp;quot;y&amp;quot; with the value 1.
	y := G.NodeFromAny(g, 1, G.WithName(&amp;quot;y&amp;quot;)) 
	
	// z := x + y
	z := G.Must(G.Add(x, y))                  

	// Create a VM to execute the graph.
	vm := G.NewTapeMachine(g) 

	// Run the VM. Errors are not checked.
	vm.RunAll()               

	// Print the value of z.
	fmt.Printf(&amp;quot;%v&amp;quot;, z.Value()) 
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The equation graph looks like this:&lt;/p&gt;

&lt;div style=&#34;margin-left:auto; margin-right:auto;&#34;&gt;
&lt;svg style=&#34;width:100%; height:auto;&#34;
 viewBox=&#34;0.00 0.00 715.00 360.00&#34; xmlns=&#34;http://www.w3.org/2000/svg&#34; xmlns:xlink=&#34;http://www.w3.org/1999/xlink&#34;&gt;
&lt;g id=&#34;graph0&#34; class=&#34;graph&#34; transform=&#34;scale(1 1) rotate(0) translate(4 356)&#34;&gt;
&lt;title&gt;fullGraph&lt;/title&gt;
&lt;polygon fill=&#34;white&#34; stroke=&#34;none&#34; points=&#34;-4,4 -4,-356 1109.3,-356 1109.3,4 -4,4&#34;/&gt;
&lt;g id=&#34;clust1&#34; class=&#34;cluster&#34;&gt;&lt;title&gt;cluster_expressionGraph&lt;/title&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;black&#34; points=&#34;8,-192 8,-344 574,-344 574,-192 8,-192&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;291&#34; y=&#34;-328.8&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt;expressionGraph&lt;/text&gt;
&lt;/g&gt;
&lt;!-- Node_0xc420146300 --&gt;
&lt;g id=&#34;node1&#34; class=&#34;node&#34;&gt;&lt;title&gt;Node_0xc420146300&lt;/title&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#ff0000&#34; points=&#34;206,-287.5 206,-308.5 254,-308.5 254,-287.5 206,-287.5&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;225.5&#34; y=&#34;-294.3&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;2&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#ff0000&#34; points=&#34;254,-287.5 254,-308.5 558,-308.5 558,-287.5 254,-287.5&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;257&#34; y=&#34;-294.3&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;+ false(%a8d96c31, %82d6f1c8) :: int&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#ff0000&#34; points=&#34;206,-266.5 206,-287.5 254,-287.5 254,-266.5 206,-266.5&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;221.5&#34; y=&#34;-273.3&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;Op&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#ff0000&#34; points=&#34;254,-266.5 254,-287.5 558,-287.5 558,-266.5 254,-266.5&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;323&#34; y=&#34;-273.3&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;+ false :: a → a → a&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#ff0000&#34; points=&#34;206,-245.5 206,-266.5 558,-266.5 558,-245.5 206,-245.5&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;373.5&#34; y=&#34;-252.3&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;()&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#ff0000&#34; points=&#34;206,-224.5 206,-245.5 558,-245.5 558,-224.5 206,-224.5&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;373.5&#34; y=&#34;-231.3&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;&amp;#45;1&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#ff0000&#34; points=&#34;206,-203.5 206,-224.5 254,-224.5 254,-203.5 206,-203.5&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;209&#34; y=&#34;-210.3&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;Value&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#ff0000&#34; points=&#34;254,-203.5 254,-224.5 558,-224.5 558,-203.5 254,-203.5&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;377&#34; y=&#34;-210.3&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;2 :: int&lt;/text&gt;
&lt;/g&gt;
&lt;!-- Node_0xc420146000 --&gt;
&lt;g id=&#34;node2&#34; class=&#34;node&#34;&gt;&lt;title&gt;Node_0xc420146000&lt;/title&gt;
&lt;polygon fill=&#34;lightyellow&#34; stroke=&#34;none&#34; points=&#34;217.5,-4 217.5,-88 338.5,-88 338.5,-4 217.5,-4&#34;/&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;218,-67 218,-88 266,-88 266,-67 218,-67&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;237.5&#34; y=&#34;-73.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;0&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;266,-67 266,-88 339,-88 339,-67 266,-67&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;269&#34; y=&#34;-73.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;x :: int&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;218,-46 218,-67 339,-67 339,-46 218,-46&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;270&#34; y=&#34;-52.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;()&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;218,-25 218,-46 339,-46 339,-25 218,-25&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;270&#34; y=&#34;-31.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;&amp;#45;1&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;218,-4 218,-25 266,-25 266,-4 218,-4&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;221&#34; y=&#34;-10.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;Value&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;266,-4 266,-25 339,-25 339,-4 266,-4&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;273.5&#34; y=&#34;-10.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;1 :: int&lt;/text&gt;
&lt;/g&gt;
&lt;!-- Node_0xc420146300&amp;#45;&amp;gt;Node_0xc420146000 --&gt;
&lt;g id=&#34;edge1&#34; class=&#34;edge&#34;&gt;&lt;title&gt;Node_0xc420146300⚓️s&amp;#45;&amp;gt;Node_0xc420146000⚓️n&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M382,-202.5C382,-137.689 288.68,-155.213 278.837,-99.0855&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;282.315,-98.6762 278,-89 275.339,-99.2553 282.315,-98.6762&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;385.75&#34; y=&#34;-191.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt; 0 &lt;/text&gt;
&lt;/g&gt;
&lt;!-- Node_0xc420146240 --&gt;
&lt;g id=&#34;node3&#34; class=&#34;node&#34;&gt;&lt;title&gt;Node_0xc420146240&lt;/title&gt;
&lt;polygon fill=&#34;lightyellow&#34; stroke=&#34;none&#34; points=&#34;426.5,-4 426.5,-88 547.5,-88 547.5,-4 426.5,-4&#34;/&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;427,-67 427,-88 475,-88 475,-67 427,-67&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;446.5&#34; y=&#34;-73.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;1&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;475,-67 475,-88 548,-88 548,-67 475,-67&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;478&#34; y=&#34;-73.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;y :: int&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;427,-46 427,-67 548,-67 548,-46 427,-46&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;479&#34; y=&#34;-52.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;()&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;427,-25 427,-46 548,-46 548,-25 427,-25&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;479&#34; y=&#34;-31.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;&amp;#45;1&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;427,-4 427,-25 475,-25 475,-4 427,-4&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;430&#34; y=&#34;-10.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;Value&lt;/text&gt;
&lt;polygon fill=&#34;none&#34; stroke=&#34;#00ff00&#34; points=&#34;475,-4 475,-25 548,-25 548,-4 475,-4&#34;/&gt;
&lt;text text-anchor=&#34;start&#34; x=&#34;482.5&#34; y=&#34;-10.8&#34; font-family=&#34;monospace&#34; font-size=&#34;14.00&#34;&gt;1 :: int&lt;/text&gt;
&lt;/g&gt;
&lt;!-- Node_0xc420146300&amp;#45;&amp;gt;Node_0xc420146240 --&gt;
&lt;g id=&#34;edge2&#34; class=&#34;edge&#34;&gt;&lt;title&gt;Node_0xc420146300⚓️s&amp;#45;&amp;gt;Node_0xc420146240⚓️n&lt;/title&gt;
&lt;path fill=&#34;none&#34; stroke=&#34;black&#34; d=&#34;M382,-202.5C382,-137.404 476.218,-155.453 486.155,-99.1258&#34;/&gt;
&lt;polygon fill=&#34;black&#34; stroke=&#34;black&#34; points=&#34;489.656,-99.2565 487,-89 482.68,-98.6742 489.656,-99.2565&#34;/&gt;
&lt;text text-anchor=&#34;middle&#34; x=&#34;374.5&#34; y=&#34;-191.3&#34; font-family=&#34;Times,serif&#34; font-size=&#34;14.00&#34;&gt; 1 &lt;/text&gt;
&lt;/g&gt;
&lt;!-- outsideRoot --&gt;
&lt;!-- insideInputs --&gt;
&lt;!-- outsideRoot&amp;#45;&amp;gt;insideInputs --&gt;
&lt;!-- outsideExprG --&gt;
&lt;!-- outsideRoot&amp;#45;&amp;gt;outsideExprG --&gt;
&lt;!-- insideExprG --&gt;
&lt;!-- insideInputs&amp;#45;&amp;gt;insideExprG --&gt;
&lt;!-- outsideExprG&amp;#45;&amp;gt;insideExprG --&gt;
&lt;/g&gt;
&lt;/svg&gt;


&lt;/div&gt;

&lt;h2 id=&#34;why-graph-objects&#34;&gt;Why Graph Objects?&lt;/h2&gt;

&lt;p&gt;So far you might be thinking - if all computer programs are graphs, and all mathematical equations are graphs, we could just program the mathematical equations in, right? Why write the above example with object graphs when a simple &lt;code&gt;fmt.Printf(&amp;quot;%v&amp;quot;, 1+1)&lt;/code&gt; would do? Afterall, the graphs are mostly the same. Having a graph object at this point seem like a silly amount of overhead.&lt;/p&gt;

&lt;p&gt;You would be right. For simple equations, having a programmer manipulatable graph object is really overkill (unless you live in Java land, where it&amp;rsquo;s classes all the way down).&lt;/p&gt;

&lt;p&gt;I would however, posit at least three advantages of having a graph object. All of these have got to do with reducing human errors.&lt;/p&gt;

&lt;h3 id=&#34;numerical-stability&#34;&gt;Numerical Stability&lt;/h3&gt;

&lt;p&gt;Consider the equation $y = log(1 + x)$. This equation is not &lt;a href=&#34;https://en.wikipedia.org/wiki/Numerical_stability&#34; target=&#34;_blank&#34;&gt;numerically stable&lt;/a&gt; - for very small values of &lt;code&gt;x&lt;/code&gt;, the answer will most likely be wrong. This is because of the way &lt;code&gt;float64&lt;/code&gt; is designed - a &lt;code&gt;float64&lt;/code&gt; does not have enough bits to be able to tell apart &lt;code&gt;1&lt;/code&gt; and &lt;code&gt;1 + 10e-16&lt;/code&gt;. In fact, the correct way to do $ y = log(1 + x)$ is to use the built in library function &lt;code&gt;math.Log1p&lt;/code&gt;. It can be shown in this simple program:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;func main() {
	fmt.Printf(&amp;quot;%v\n&amp;quot;, math.Log(1.0+10e-16))
	fmt.Printf(&amp;quot;%v\n&amp;quot;, math.Log1p(10e-16))
}

1.110223024625156e-15 // wrong
9.999999999999995e-16 // correct
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Now, of course the programmer may be well aware of this issue and opt to use &lt;code&gt;math.Log1p&lt;/code&gt; when implementing neural network algorithms, but I&amp;rsquo;m sure you&amp;rsquo;d agree that having a library that automatically converts &lt;code&gt;log(1+x)&lt;/code&gt; to use &lt;code&gt;math.Log1p(x)&lt;/code&gt; be rather awesome? It reduces the element of human error.&lt;/p&gt;

&lt;h3 id=&#34;machine-learning-specific-optimizations&#34;&gt;Machine-Learning Specific Optimizations&lt;/h3&gt;

&lt;p&gt;Consider a variant of the first program in this post:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;func a() int {
	return 1 + 1
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;This is the same program compiled down to assembly:&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;&amp;quot;&amp;quot;.a t=1 size=10 args=0x8 locals=0x0
	(main.go:5)	TEXT	&amp;quot;&amp;quot;.a(SB), $0-8
	(main.go:5)	FUNCDATA	$0, gclocals·2a5305abe05176240e61b8620e19a815(SB)
	(main.go:5)	FUNCDATA	$1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
	(main.go:6)	MOVQ	$2, &amp;quot;&amp;quot;.~r0+8(FP)
	(main.go:6)	RET
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;In particular, pay attention to the second last line: &lt;code&gt;MOVQ $2, &amp;quot;&amp;quot;.~r0+8(FP)&lt;/code&gt;. The function has been optimized in such a way that &lt;code&gt;2&lt;/code&gt; is returned. No addition operation will be performed at run time. This is because the compiler knows, &lt;em&gt;at compile time&lt;/em&gt;, that 1 + 1 = 2. By replacing the expression with a constant, the compiler is saving on computation cycles at run time. If you&amp;rsquo;re interested in building compilers, this is known as &lt;a href=&#34;https://en.wikipedia.org/wiki/Constant_folding&#34; target=&#34;_blank&#34;&gt;constant folding&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;So, we&amp;rsquo;ve established that compilers are smart enough to do optimizations. But the Go compiler (and in fact most non-machine-learning specific compilers) isn&amp;rsquo;t smart enough to handle values that are used for machine learning. For machine learning, we frequently use array-based values, like a slice of &lt;code&gt;float64&lt;/code&gt;s, or a matrix of &lt;code&gt;float32&lt;/code&gt;s.&lt;/p&gt;

&lt;p&gt;Imagine if you will, if you&amp;rsquo;re not doing &lt;code&gt;1 + 1&lt;/code&gt;. Instead you&amp;rsquo;re doing &lt;code&gt;[]int{1, 1, 1} + []int{1,1,1}&lt;/code&gt;. The compiler wouldn&amp;rsquo;t be able to optimize this and just replace it with &lt;code&gt;[]int{2, 2, 2}&lt;/code&gt;. But building a graph object that can be optimized allows users to do just that. Gorgonia currently doesn&amp;rsquo;t do constant folding yet (earlier versions had constant folding but it is quite difficult to get right), but it comes with other forms of graph optimizations like &lt;a href=&#34;https://en.wikipedia.org/wiki/Common_subexpression_elimination&#34; target=&#34;_blank&#34;&gt;common expression elimination&lt;/a&gt;, some amount of variable elimination and some minimal form of tree shaking. Other more mature libraries like TensorFlow or Theano comes with very many optimization algorithms for their graphs.&lt;/p&gt;

&lt;p&gt;Again, one could argue that this could be done by hand, and coding it into the program would be more than doable. But is this really where you&amp;rsquo;d rather spend your time and effort? Or would you rather be creating the coolest new deep learning stuff?&lt;/p&gt;

&lt;h3 id=&#34;backpropagation&#34;&gt;Backpropagation&lt;/h3&gt;

&lt;p&gt;Lastly, and most importantly, the graph object is most important in the implementation of backpropagation. In the following posts, I will talk about backpropagation and how it relates to computing partial derivatives. It&amp;rsquo;s there we shall see the true power of having graph objects that are manipulatable by the programmer.&lt;/p&gt;

&lt;p&gt;In a far future post, I shall also touch on the capacity to generate better code, using the graph object.&lt;/p&gt;

&lt;h2 id=&#34;why-go&#34;&gt;Why Go?&lt;/h2&gt;

&lt;p&gt;If you&amp;rsquo;re working on a truly homoiconic language such as lisp or Julia, you probably wouldn&amp;rsquo;t need a graph object. If you could have access to the program&amp;rsquo;s internal data structures and they&amp;rsquo;re modifiable on the fly at run time, you would be able to augment plenty of the operations on the fly (yes, you can do the same for Go, but why would you?). This would make backpropagation algorithms a lot simpler to perform at runtime. Unfortunately this isn&amp;rsquo;t the case. Which is why we&amp;rsquo;d have to build up extra data structures for deep learning.&lt;/p&gt;

&lt;p&gt;Do note that this isn&amp;rsquo;t a knock on Go or Python or Lua. All of these languages have their strengths and weaknesses. But why do deep learning related work in Go when there are more mature libraries in Python or Lua? Well, one of the major reasons I developed Gorgonia was the ability to deploy everything neatly into one single binary. Doing that with Python or Lua would take an immense amount of effort. By contrast, deploying Go programs are a breeze.&lt;/p&gt;

&lt;p&gt;I believe that Go for data science is an amazing idea. It is typesafe (enough for me), and it&amp;rsquo;s compiled down to binary. Go allows for better mechanical sympathy, which I believe is key to having faster and better AI out there. Afterall, we are ALL bound by our hardware. I just wish there were better higher level data structures for me to express my ideas. There weren&amp;rsquo;t, so I built them. And I hope you use them.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Welcome to GopherData</title>
      <link>http://gopherdata.io/post/introduction_to_gopherdata/</link>
      <pubDate>Sat, 11 Mar 2017 12:00:00 +0000</pubDate>
      
      <guid>http://gopherdata.io/post/introduction_to_gopherdata/</guid>
      <description>&lt;p&gt;(Author: Daniel Whitenack, @dwhitena on &lt;a href=&#34;https://twitter.com/dwhitena&#34; target=&#34;_blank&#34;&gt;Twitter&lt;/a&gt; and Gophers Slack)&lt;/p&gt;

&lt;p&gt;Welcome to GopherData!  This site/organization intends to be a place for all Gophers (i.e., go programmers) doing data analysis, science, numerical computing, or anything else data/math related.  It&amp;rsquo;s also a place where non-Gophers can learn about doing these things in Go. The site to will serve as a hub of info about related events and an eventual GopherData conference.&lt;/p&gt;

&lt;p&gt;If you have ideas about how this site/organization can function best or any related feeback please reach out the @dwhitena on Twitter or Gophers Slack.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Key Activities&lt;/strong&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Blog posts&lt;/li&gt;
&lt;li&gt;Curated resources&lt;/li&gt;
&lt;li&gt;Discussion outlets&lt;/li&gt;
&lt;li&gt;Online and in-person events&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Topics of interest&lt;/strong&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Data Science&lt;/li&gt;
&lt;li&gt;Data Engineering&lt;/li&gt;
&lt;li&gt;Scientific Computing&lt;/li&gt;
&lt;li&gt;Numerical Computing&lt;/li&gt;
&lt;li&gt;Machine Learning&lt;/li&gt;
&lt;li&gt;Artificial Intelligence&lt;/li&gt;
&lt;li&gt;Data Visualization&lt;/li&gt;
&lt;li&gt;Data Cleaning/Munging&lt;/li&gt;
&lt;li&gt;Databases&lt;/li&gt;
&lt;li&gt;Distributed Computing&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Get Involved&lt;/strong&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;We are going to start publishing blog posts from our community.  If you have an idea for a blog post, please sign up &lt;a href=&#34;https://docs.google.com/spreadsheets/d/19YnjEGnsmgOnXRqecbIObvYe2-ZHxaItWCjnvadIzVc/edit?usp=sharing&#34; target=&#34;_blank&#34;&gt;here&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;If you are interested in helping sponsor or organize a GopherData conference, please contact @dwhitena on Twitter or Gophers Slack.&lt;/li&gt;
&lt;li&gt;If you know of good related resources (packages, events, etc.), please PR github.com/gopherdata/www or contact @dwhitena on Twitter or Gophers Slack.&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>Deep Learning</title>
      <link>http://gopherdata.io/project/deep-learning/</link>
      <pubDate>Wed, 27 Apr 2016 00:00:00 +0000</pubDate>
      
      <guid>http://gopherdata.io/project/deep-learning/</guid>
      <description>&lt;p&gt;Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis posuere tellus ac convallis placerat. Proin tincidunt magna sed ex sollicitudin condimentum. Sed ac faucibus dolor, scelerisque sollicitudin nisi. Cras purus urna, suscipit quis sapien eu, pulvinar tempor diam. Quisque risus orci, mollis id ante sit amet, gravida egestas nisl. Sed ac tempus magna. Proin in dui enim. Donec condimentum, sem id dapibus fringilla, tellus enim condimentum arcu, nec volutpat est felis vel metus. Vestibulum sit amet erat at nulla eleifend gravida.&lt;/p&gt;

&lt;p&gt;Nullam vel molestie justo. Curabitur vitae efficitur leo. In hac habitasse platea dictumst. Sed pulvinar mauris dui, eget varius purus congue ac. Nulla euismod, lorem vel elementum dapibus, nunc justo porta mi, sed tempus est est vel tellus. Nam et enim eleifend, laoreet sem sit amet, elementum sem. Morbi ut leo congue, maximus velit ut, finibus arcu. In et libero cursus, rutrum risus non, molestie leo. Nullam congue quam et volutpat malesuada. Sed risus tortor, pulvinar et dictum nec, sodales non mi. Phasellus lacinia commodo laoreet. Nam mollis, erat in feugiat consectetur, purus eros egestas tellus, in auctor urna odio at nibh. Mauris imperdiet nisi ac magna convallis, at rhoncus ligula cursus.&lt;/p&gt;

&lt;p&gt;Cras aliquam rhoncus ipsum, in hendrerit nunc mattis vitae. Duis vitae efficitur metus, ac tempus leo. Cras nec fringilla lacus. Quisque sit amet risus at ipsum pharetra commodo. Sed aliquam mauris at consequat eleifend. Praesent porta, augue sed viverra bibendum, neque ante euismod ante, in vehicula justo lorem ac eros. Suspendisse augue libero, venenatis eget tincidunt ut, malesuada at lorem. Donec vitae bibendum arcu. Aenean maximus nulla non pretium iaculis. Quisque imperdiet, nulla in pulvinar aliquet, velit quam ultrices quam, sit amet fringilla leo sem vel nunc. Mauris in lacinia lacus.&lt;/p&gt;

&lt;p&gt;Suspendisse a tincidunt lacus. Curabitur at urna sagittis, dictum ante sit amet, euismod magna. Sed rutrum massa id tortor commodo, vitae elementum turpis tempus. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean purus turpis, venenatis a ullamcorper nec, tincidunt et massa. Integer posuere quam rutrum arcu vehicula imperdiet. Mauris ullamcorper quam vitae purus congue, quis euismod magna eleifend. Vestibulum semper vel augue eget tincidunt. Fusce eget justo sodales, dapibus odio eu, ultrices lorem. Duis condimentum lorem id eros commodo, in facilisis mauris scelerisque. Morbi sed auctor leo. Nullam volutpat a lacus quis pharetra. Nulla congue rutrum magna a ornare.&lt;/p&gt;

&lt;p&gt;Aliquam in turpis accumsan, malesuada nibh ut, hendrerit justo. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Quisque sed erat nec justo posuere suscipit. Donec ut efficitur arcu, in malesuada neque. Nunc dignissim nisl massa, id vulputate nunc pretium nec. Quisque eget urna in risus suscipit ultricies. Pellentesque odio odio, tincidunt in eleifend sed, posuere a diam. Nam gravida nisl convallis semper elementum. Morbi vitae felis faucibus, vulputate orci placerat, aliquet nisi. Aliquam erat volutpat. Maecenas sagittis pulvinar purus, sed porta quam laoreet at.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>External Project</title>
      <link>http://gopherdata.io/project/example-external-project/</link>
      <pubDate>Wed, 27 Apr 2016 00:00:00 +0000</pubDate>
      
      <guid>http://gopherdata.io/project/example-external-project/</guid>
      <description></description>
    </item>
    
    <item>
      <title>A Person Re-Identification System For Mobile Devices</title>
      <link>http://gopherdata.io/publication/person-re-identification/</link>
      <pubDate>Tue, 01 Sep 2015 00:00:00 +0000</pubDate>
      
      <guid>http://gopherdata.io/publication/person-re-identification/</guid>
      <description>&lt;p&gt;More detail can easily be written here using &lt;em&gt;Markdown&lt;/em&gt; and $\rm \LaTeX$ math code.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Mobile visual clothing search</title>
      <link>http://gopherdata.io/publication/clothing-search/</link>
      <pubDate>Mon, 01 Jul 2013 00:00:00 +0000</pubDate>
      
      <guid>http://gopherdata.io/publication/clothing-search/</guid>
      <description>&lt;p&gt;More detail can easily be written here using &lt;em&gt;Markdown&lt;/em&gt; and $\rm \LaTeX$ math code.&lt;/p&gt;
</description>
    </item>
    
  </channel>
</rss>