Seeing it in DataLogic Studio
DataLogic Studio is a visual editor and debugger for JSONLogic, built on datalogic-rs, the engine the platform runs your adapter on. The Studio runs the arena’s language: it draws your adapter as a flow diagram, runs it against an observation, and steps through the evaluation one node at a time.
Every example in this chapter has an Open in DataLogic Studio link. The link carries the expression and the data, so it opens that example evaluated, with no account and nothing to save. A link you make works the same way: it carries your adapter, and anyone you send it to can read it.
The Studio still differs from the referee in a few narrow places, and the table below lists them.
Opening your own adapter
- Open the Studio.
- Tick Templating, above the diagram.
- Paste one adapter into Logic: the value of one input’s
adapterkey, without the rest of the manifest. - Paste an observation into Data.
- Share copies a link to what is on the screen.
For observations to paste, What your model sees has a small
one, and tinybrains adapt writes every reference observation beside the tensors it produced, as
case-N/observation.json (how).
What you are looking at
- Logic, Data, Result. Result holds the Studio’s output. For an adapter, that is the tensor
call at the top with its arguments evaluated:
{"scatter": [[[12, 30], [13, 30], [43, 66]], [64, 96], "i8"]}says that the node’sscatterwill receive those three points, that shape, and that dtype. - The diagram. The Studio draws each operator as a node, with its inputs flowing in. Flow draws the data left to right; Hierarchy draws the JSON’s nesting.
- The debugger. The step controls walk the evaluation one node at a time, and the current node
shows the value it produced. Stepping is the quickest way to watch a
mapbody receive each element in turn, or areduceaccumulator grow.
Where the Studio and the arena differ
| In the Studio | In the arena | |
|---|---|---|
The core operators: var, val, map, filter, reduce, if, arithmetic, comparisons, merge and the rest | Evaluated | Evaluated the same way, by the same engine |
{"==": [0, null]} | true | true. The arena is datalogic too, so JavaScript’s coercion rules apply on both sides |
| An object with more than one key | With Templating on, an object literal | An output template, as in the Studio, and the same in tinybrains |
| A single-key object whose key is not an operator | With Templating on, an object literal | Data, as in the Studio. tinybrains warns about it, which is how you catch a misspelt operator |
A $-escaped key, {"$shape": [6, 7]} | Data with the $ kept, {"$shape": [6, 7]}: the Studio sets no escape | The data {"shape": [6, 7]}, on the node and in tinybrains |
| The tensor operators | Shown with their arguments evaluated | The node builds the tensors and checks shapes and dtypes against your declaration |
| The operation count | Not shown | Counted, and capped at 1,000,000 per adapter |
| Shapes, dtypes, saturation, a scatter point off the board | Not modelled | Enforced |
| The Studio’s version | Whatever that site last deployed | The version the node links, recorded on your version as orion_version |
Remember the objects rows: an object is data in all three places, so an expression that returns
{"mine": …, "theirs": …} gives a tidy result in the Studio, and a node refuses it because it is
not a tensor. Return an array.
A trap the Studio reproduces
{"var": "3"} on a [row, col, owner] triple is null, and null compares equal to 0. This
filter keeps every hill, yours and your opponents’, and neither the Studio nor the arena reports
a problem:
{"filter": [{"var": "hills"}, {"==": [{"var": "3"}, 0]}]}
Open in DataLogic Studio — against an illustrative observation: three ants, a foe, a food, both hills, three cells of water
This is the most expensive mistake an adapter can make, and the Studio shows it the way the arena
runs it. To avoid it, compare with ===, read a field that resolves, or give var a fallback:
{"var": ["3", -1]}.
When the Studio is enough, and when it is not
The Studio shows you whether your JSON half picks out the right things: the right lists, fields, coordinates and shape. A scope mistake, a filter on the wrong field, or a shape assembled in the wrong order shows up in the Result pane.
The Studio cannot tell you whether your adapter builds the tensor your graph was trained on, fits
the budget, or produces a tensor the graph accepts.
tinybrains adapt writes out the tensors and
what each one charged, and tinybrains check
measures what admission measures.