freenode/#lisp - IRC Chatlog
Search
13:55:26
z147
so I suppose I'll have to do a machine learning vs rules only comparison due to trends in the market at the moment
13:56:04
MichaelRaskin
The problem with machine learning is that it is optimised for comparisons that are easy to do with the available data
13:57:58
White_Flame
machine learning is a statistics reinforcer. that's like the opposite of what you want to handle edge cases
14:01:40
z147
just as MichaelRaskin pointed out, one example would be someone touting their "efficient" triage system trained on past patient data
14:04:03
_death
the field you're talking about has a long history, at least going to the 1960s.. you seem to simultaneously have strong opinions while asking for basic information
14:04:15
MichaelRaskin
I think there was a case where they «reliably distinguished» two diagnoses which are basically two schools of naming the same thing.
14:07:17
White_Flame
we looked for good, semi-modern resources some years back, and found practically nothing
14:07:42
White_Flame
we basically built our system from first principles, desiring GOFAI as a programming environment
14:10:03
MichaelRaskin
I think A.Colyer has relatively recently wrote a review about a system that learns a neural net, then uses the neural net to learn a rule system (which can then be reviewed by a domain expert).
14:11:03
White_Flame
the great thing about proper rule programming is that it completely decouples you from managing a program counter at all. The system simply notices state and reacts to it
14:11:38
White_Flame
regardless of how the state got there, and without having to ensure you have calls & hooks enabled in all the right places
14:12:27
_death
z147: there are many books about the history of expert systems.. one famous system was DENDRAL, writtein in Lisp during the 1960s.. in the late 1980s Bayesian networks caused a revolution in the field, and they are still going strong.. there is research on interpretable machine learning, not just for medicine but for other fields where it is critical to understand why a diagnosis or prognosis was made
14:17:12
dmiles
yeah the GOFAI being the helper system to write prograsms somehow slipped everyones mind
14:17:51
White_Flame
yep, as encapsulated in the term "expert system _shell_" that is no longer used
14:18:05
dmiles
worse now is we have an inferior version of the field that emerged (the automated programing field) in that people have accepts that things like Agda/Idris is the "newest greatest thing"
14:18:50
z147
White_Flame, so far not much has come up in a quick search for me as far as domain and CL, so i suppose i will review the current practices outside CL and go from there
14:19:37
z147
interestingly, there are some publications coming up due to COVID where they are pushing for rules-based triage
14:20:27
MichaelRaskin
Expert systems need experts to maintain, and the experts can migrate to another software base if needed. Current machine learning is about making sure your data center is the only environment where the learning procedure can be deployed with reasonable efficiency (and that humans are fungible)
14:21:42
White_Flame
yeah, regarding CL, when we were looking at stuff a decade back or so, most of it was Java. Even charles forgy was moving everything to java
14:22:02
MichaelRaskin
Re: triage — well, decisions that are life-or-death even when made perfectly are politically easier to push towards being explainable to humans
14:23:57
z147
although I presume there is an ongoing migration to the cloud as subscription gathering and customer lock-in
14:24:06
_death
continuing on the path of Bayesian networks, recent research by Pearl and his students led to results about what he calls "causality diagrams".. not too long ago he published a book placing this research in a historical context, called "The Book of Why"..
14:24:42
White_Flame
z147: but really, what are you looking for? to build up tech from scratch or to use something existing?
14:25:36
z147
White_Flame, my interest sparked about 5 years back when I started observing a movement for check-lists in the medical profession
14:28:14
dmiles
I remember the GOFAI sort of happened to overcome a broken version of AI that proceeded it
14:31:13
_death
"GOFAI" is kind of misnamed.. approaches like "neural networks" (at the time it was quite offensive to call them that, so they had a name like "neuron-like elements") rose at the same time as the rule-based heuristic approaches, in the 1950s..
14:31:47
White_Flame
yeah, "symbolic AI" is more correct, though "SAI" hasn't caught on as an acronym
14:32:49
_death
today's "deep learning" stuff is basically a rehash of Selfridge's Pandemonium architecture (1959)
14:33:41
dmiles
yeah i sorta actualyl think the history went as follows: Perceptrons/Baysian -> SAI/GOFAI -> BaysianRehashed
14:34:28
dmiles
yeah i sorta actualyl think the history went as follows: Perceptrons/Connectionism -> SAI/GOFAI -> Connectionism done much better as Baysian
14:36:48
dmiles
At some point arround the Genetic Algos of the late 1970s it was seen that we needed better Symbolic systems for the GAs to author
14:38:27
_death
z147: here's one use of BNs in a critical field today https://ercim-news.ercim.eu/en107/special/bonaparte-bayesian-networks-to-give-victims-back-their-names
14:40:21
_death
there's a good Lisp book called "Building Problem Solvers" that deals with backward/forward chaining, truth-maintenance systems, etc.
14:41:33
White_Flame
the tech is there, but the actual use and programming design of how to architect the rules is what's sorely lacking
14:42:29
White_Flame
but then again, nobody's doing actual rule-based programming, except for maybe SOAR, which is tightly bound in a very particular agent-based model
14:44:47
dmiles
EventCalc is where you actually declare the order in which proddedures will happen such as memory intializatio
14:45:03
z147
I've found a medical field article that mentions Rule-Based Reasoning but I have to follow up with what they actually mean with that in their implementation https://www.ncbi.nlm.nih.gov/pubmed/29673601
14:50:20
White_Flame
yeah, looks like they dropped the all-caps, probably a while ago https://soar.eecs.umich.edu/
14:54:18
White_Flame
z147: in any case, I need to be afk. If you're serious about building something and want to use CL stuff, PM me
14:54:51
White_Flame
but certainly see wha'ts out there, and there might already be a system directly applicable
15:04:07
MichaelRaskin
And if you want to do anything with rule-based system, do something with many of the existing prolog-like libraries (or with actual Prolog, or with Datalog, …)
15:06:52
MichaelRaskin
You don't need anything fancy, just do something to get a feeling, I think a few Lisp books include Prolog-in-100-lines or something like that
15:28:23
jcowan
I was going to say that Prolog is by no means dead. I've found the folks on ##prolog to be quite welcoming.
17:44:28
ecraven
regarding SLIME in Emacs, there used to be default keybindings, but somehow I lost them.. were they removed, or do I just have to explicitly enable them somehow?
17:44:55
ecraven
things like `slime-inspect-presentation-at-point' (which now seems to be completely unbound)
18:21:50
tcr
ecraven: Many things have moved into contribs, but that happened like over 10 years ago
18:24:23
tcr
ecraven, you probably want to add (setq slime-contribs '(slime-fancy slime-presentations)) into your .emacs
18:25:20
tcr
`M-x find-library slime` and then `M-x rgrep slime-inspect-presentation` revealed that ;)
18:26:37
ecraven
hm.. `lisp-show-variable-documentation' is bound to C-c C-v, not `slime-presentation-map' :-/
19:01:34
random-nick
I want to make a binding to a C library, should I manually transcribe the API to CFFI definition forms or should I use something which does it automatically?
19:33:57
jackdaniel
beats me, trying it or looking at the source is the best way to see how it works
20:00:17
random-nick
I might be missing something, but it seems the groveller doesn't have anything for creating function bindings
20:37:51
phoe
you can later distribute the binding specs to everyone along with your library; no need for them to have clang
20:54:09
void_pointer
The one downside is that you have to run it for each processor architecture and sometimes OS you want to target (because the width of an int can change radically between architectures and even OSes on the same architecture)
20:58:09
aeth
cl-autowrap has problems that borodust fixed with claw. https://github.com/borodust/claw
20:58:35
aeth
In particular, borodust seems to have removed most of the things that introduce performance penalties.
20:58:42
void_pointer
Also, if you are interfacing POSIX libraries, you have to be prepared for the sizes of things changing from Linux, Mac OSX, the various BSDs, etc.
21:00:50
void_pointer
c2ffi can be better in some cases here, like extra fields in standard structs (e.g. Mac OSX has an extra field in sockaddr that isn't on Linux)
21:03:50
void_pointer
Basically, depending on how many systems one is targeting, the build matrix for the spec files can get rather large
21:05:18
equwal
void_pointer: That sounds unpleasant. We do have lots of VM technology available and CI, so it should be possible to only manually do the process once.
21:09:00
void_pointer
That certainly does help. With Linux and most BSDs on most platforms, it should be pretty easy with VMs with or without CI. Windows' high backwards compatibility makes it fairly easy since you only need to do it for one version. Mac OSX is maybe the wild card. Oh, and of course, if one is doing smart phones, well, good luck.
21:10:35
fe[nl]ix
cffi-grovel and manually creating bindings have one advantage: you only define what you use
21:11:06
equwal
Yeah, I mentioned CI since it helps by automatically doing it when a pull request is made. What would a travis.yaml, GUIX config, or docker file look like to generate these automatically? Do we have an example to start with?
21:11:11
fe[nl]ix
you can even have a struct with 20 fields, but if you only need one you can just define that and the groveler will figure out the struct size and field offset
21:24:27
aeth
random-nick: Try its fork claw instead, then. Worst case scenario, neither work, but borodust (the fork author) is in this channel. https://github.com/borodust/claw
21:28:33
aeth
random-nick: and then there's the option of manually using cffi-grovel that fe[nl]ix said
21:49:54
void_pointer
though that is brittle, but this is the nature of many projects in their early states
21:51:21
void_pointer
unless one is of the literate programming persuasion, design first and code second, or really into making documentation as one goes; that is how it is (and sadly, some projects never get their documentation)
21:56:46
aeth
void_pointer: I have a literate programming library but it's entirely undocumented at the moment ;-)
21:57:36
aeth
void_pointer: It's a joke. If it's undocumented and documentation comes first, then it's empty, i.e. not there.
21:58:41
void_pointer
aeth: with literate programming, one does have to start somewhere to bootstrap, though that is where external documentation and comment documentation come in
0:29:58
White_Flame
z147: btw, in the vocabulary I'm around, "rule-based" systems tend to talk about production rules, not prolog (although that can be part of it)
0:56:17
z147
White_Flame, i'm going through the archive at CMU Artificial Intelligence Repository, lots to contemplate
0:58:54
White_Flame
yeah, but really it sounds like you need to define the general workflow of the software you'd like to have first, then look at tools that might deliver that. THere's an infinite rabbit hole of tech variations otherwise
1:12:21
z147
White_Flame, i usually prefer to get a fast idea with as many quick prototypes as possible
1:13:16
z147
the systems i've been exposed to were closed, vendor-specific java, with what I saw under the hood, very simple rule matching
1:22:26
White_Flame
are you looking for raw rule tech, or something that's fleshed out with a bunch of dialogs and such to interact with the humans? all the open source stuff is the former, except for maybe jboss rules
1:25:17
z147
White_Flame, i prefer to do exploratory use as part of my specification development. So i'm not limiting anything at this time.
1:25:44
z147
from the market point, i'm looking at existing systems outside of CL and what their limitations are
1:26:49
White_Flame
but if what you want is GUI-driven human interaction, that's more software written on top of those layers than rule engines themselves
1:27:43
White_Flame
the rule engines used to be called "expert system shells", in that you use them to create expert systems, so they're not immediately able to do "expert" stuff in the common case. So that's the sort of thing I'm wondering about your search
1:30:50
White_Flame
often times, there'd be a domain expert, but they wouldn't do anything with the system; the "knowledge engineer" would encode what they deal with the expert into the rule forms
1:31:15
White_Flame
some advanced systems sought to allow the domain expert to directly enter stuff, and that's a whole other system
1:31:28
z147
what happened to expert system shells, the term fell off the radar, the approach remains in other forms?
1:31:58
White_Flame
the tech went mostly into BRMS (business rules management systems), where they became less interactive
1:32:22
White_Flame
most of the stuff that I saw had you select which ruleset to use, and which data to seed it with, then it ran to completion and gave you an answer
1:32:33
White_Flame
so it ends up being a fancy function call instead of a dynamic interacting system
1:33:08
White_Flame
so you have a big Java enterprise application, that makes calls out to the BRMS to make configurable decisions
1:33:55
z147
I suppose it's called expert systems and rules management as far as current publications
1:34:00
White_Flame
which is completely different than the older style where the system would dialogue with the user, asking questions abotu stuff it didn't know
1:34:39
White_Flame
that dialoguing system is something built on top of the rule engines; it's not an implicit feature of them
1:35:13
White_Flame
or at least, not of the standard model of especially open source ones. That dialoguing was commercial special sauce
1:36:04
White_Flame
but again, the modern stuff eschews interactivity and simply crunches a result from input facts in batch