In the previous post, I made an introduction and a POC to interact with ONNX models and Go.

I have decoded the information to reconstruct a graph. Now I propose to expand the principle and to create a proper execution backend based on Gorgonia. This post is a bit more technical than the previous one because all the concepts needed to work should be present in the last article.

Decoding the tensor

In machine learning, the fundamental element of a computation graph is a Tensor. In ONNX this element is described in the structure TensorProto. A tensor:

This year has started with a lot of deep thoughts about the software 2.0. My conclusion (which is slightly different from Andrej Karpathy’s consideration) is that a software 2.0 is a combination of a Neural network model and its associated weights. This is a concept; now the question is: how to materialize the idea? What artifact represents a software 2.0.

I emitted several ideas and tried one of them: to serialize the mathematical model and the weights. The main drawback of this idea is that it is not easy to write down and to parse any mathematical equation. The best way to express a model is, as of today, via its computation graph (this is what most ML frameworks are doing).

During the past weeks, I’ve had the opportunity to play a bit with Wasm and Go.

All those experiments led me to a write a proof of concepts that can illustrate everything I have said recently about:

• Thinking the deep-learning stack like an Ops (see my post about NNRE/NNDK).
• Capturing the real value of the training process (the knowledge) into a sequence of bits (the lightning talk I gave about it at the dotAI should be online soon).

Greetings professor Falken… Shall we play a game?

For a demo, I have developed a simple LSTM that can play the tic-tac-toe game. I am a fan of this example for AI-related kinds of stuff, it is indeed a “Madeleine” for me.

Disclaimer This is a technical article about a work in progress. The primary goal is to document what I did and to clarify my ideas. A more general and complete article about software 2.0 is in development and should be published on my company’s blog later.

This post describes the concept of software 2.0. It evaluates an instance of the Unicode equation parser (as described in my earlier post on equation parsing) to give a strict separation of the software 1.0 and the software 2.0.

In a previous article, I described an implementation of an RNN from scratch in go. The target is to use the RNN as a processing unit. The ultimate goal is to create a portable tool cross platform and able to grab and process data where they are. I have many applications in mind such as finding the root-cause of an incident or managing the capacity of an infrastructure.

Note I stick to the Go language for many reasons: Some of them a personnal and not opposable (I simply like it). But another reason is that, in a distant future, this tool could act as a node of a processing network that would communicate via a tuple space (see my previous posts about Linda: Linda, 31yo with 5 starving philosophers, To Go and touch Linda’s Lisp and Linda’s eval/C: a tuplespace oddity.