The idea that you had to instrumentally combine perceptual and symbolic reasoning has been around since at least the 1970s and has been implemented variously (see, for example: Hermina J.M. Tabachneck-Schijf, Anthony M. Leonardo, Herbert A. Simon (1997) CaMeRa: A Computational Model of Multiple Representations). What those models didn't do is learn, but just pouring learning into that sort of model and hoping it will magically become a GAI seems like an implementation idea without a theory.
Anybody familiar with the space have pointers to good introductory material on this field? Or terms to search on to get at current work - differentiable logic?
The recent survey on Neurosymbolic Programming is a great introduction to the field: https://twitter.com/swarat/status/1474105098401943555 (pardon the Twitter link). I don't think the full version is publicly available, but I suspect you might be able to get access to it if you DM someone involved.
Other than that, here are some names of people working in this field that you might be able to find representative work from:
- Mayur Naik, UPenn (whose group I think were behind Scallop?)
- Swarat Chaudhuri (and maybe also Isil Dillig), UT Austin
- Luc de Raedt, KU Leuven (whose earlier work on Statistical Relational AI is very similar to the Scallop style of neurosymbolic work - I think there's a good textbook available on this)
- Guy van den Broeck, UCLA
- Armando Solar-Lezama, MIT
If you're more interested in the logic side of things then maybe some of MIRI's (https://intelligence.org/) older work may be of interest.
There's also a lot of people who are interested in neuro-symbolic stuff in the wider sense. You can find out more here: http://www.neurosymbolic.org/index.html. If you sign up for the mailing list, there are monthly (or bi-monthly? I can't remember) talks that are open to the public. You can even find recordings of past talks on Armando Solar-Lezama's youtube channel.
At a glance, this looks like a new syntax in the Prolog family (with some other special stuff). Erlang, which kept Prolog syntax but lost its semantics, has a similar new syntax in Elixir.
> Scallop is a full-fledged logic programming language based on Datalog [...] a logic rule-based query language for relational databases. [...] Scallop is a scalable Datalog solver equipped with support for discrete, probabilistic, and differentiable modes of reasoning
What's the applicability? What are some concrete examples of problems that you would solve with it? Why is a better fit than using you preferred language with your own code?
Their NeurIps paper is all about scalable training/inference in ML systems that combine deep learning for perception and symbolic logic for e.g. visual question answering
The underlying big idea, as quoted from the medium article:
They posit that humans are born with a pre-programmed rough understanding of the world, in some ways analogous to the game engines used to build interactive immersive video games. This “game engine in the head” provides the ability to simulate the world and our interactions with it, and serves as the target of perception and the world model that guides our planning.
Crucially, this game engine learns from data, starting in infancy, to be able to model the actual situations — the endless range of “games” — we find ourselves in. It is approximate yet gets more and more efficient — to the point that very quickly, humans make instant mental approximations that are good enough to thrive in the world. And, the researchers think, it’s possible to replicate this type of system in a machine by embedding ideas and tools from game engine design inside frameworks for neurosymbolic AI and probabilistic modeling and inference known as probabilistic programs.
it looks really good, the sort of trully new generation of programming languages we need, bringing new constructs and solutions for the new world challenges and solutions as the previous abstractions are already falling short.
I wish it would be clear on which platforms does it run, because for its description I can only read about python's integration, which is great, but not sure whether I could run a "client" on javascript devices or C embedded and communicate to a Scallop backend that speaks python.
that's true although that's not a target platform for which it compiles to. Later today I've seen the runtime appears to be written in rust, so it might be possible to port it to many architectures althought at the moment it looks to be a desktop only runtime/embedded library.
I have been a few months into PyNeuraLogic because of its focus on Relational Deep Learning (in particular Lifted Relational Neural Networks). I would say the main selling point is extending GNNs (Graph Neural Networks)
From what I can see on the Scallop website, the focus is on vision and NLP.
So both are similar approaches combining deep learning with symbolic reasoning (and both are based in Datalog) but the problems they are tackling are quite different. Also, both approaches have made it to top conferences like NeurIPS and ICLR, so I guess this field is gaining momentum.
Just based on the docs, on the lowest level they both create a mapping from input features to relations. Then NeuraLogic has an example for implementing GCN like message passing with a simple relational rule:
```
node2(X) <= W node1(Y), edge(X, Y)
```
Do you know, is it possible to implement something on Scallop as well, or are the differences much larger?
The GCN implementation is based on the concept of templating (or lifting) which is not exploited in Scallop. In fact, this is the key idea of Neuralogic for joining deep learning and relational-logic representations.
It only just dropped, so no one has used it in anger yet. I've written a couple of small things in it today though.
It just seems like such a lovely little language, but prologs are. It is pretty damn great to be able to attach probabilities to things and prolog away.
