164 karma · joined January 24, 2015
https://ja.reddit.com/r/lisp/comments/9gjd0m/lisping_copylef...
I have been working on Latplan [AAAI-2018, 2,3,4,5,6], a neural-symbolic classical planning system that learns symbolic representations of noisy images and perform efficient symbolic planning in the latent space. Later, several other groups have started working in this field, like [7].
The problem with python is the lack of sequential execution speed, which is necessary for solving symbolic tasks, e.g. SAT solver, classical planning, theorem prover. At the same time, traditional languages like C++, typically used for writing solvers, are too inflexible to accommodate the workflow in machine learning. For a neural-symbolic task, personally, Lisp is best in this space (I don't try to repeat why, because there are plenty of articles on it.), with Julia being a contender.
I am also interested in adding the compile time type/shape checking on the deep learning code, since python debugging is painful (just a personal opinion -- not intending to start a war here).
By the way, I made the first prototype of this lib in 3 days, and am working on improving it for 3 month (for other ML projects).
[1] https://medium.com/@MITIBMLab/the-shared-history-and-vision-... [2] https://github.com/guicho271828/latplan [3] AAAI18 presentation at : https://asai-research-presentation.github.io/2018-2-5-aaai/ [4] AAAI18 paper : Classical Planning in Deep Latent Space: Bridging the Subsymbolic-Symbolic Boundary, https://arxiv.org/abs/1705.00154 [5] Follow-up papers (ICAPS2019) : https://arxiv.org/abs/1903.11277 [6] Follow-up papers (ICAPS2019), extension to first order logic : https://arxiv.org/abs/1902.08093 [7] Learning Plannable Representations with Causal InfoGAN, https://arxiv.org/abs/1807.09341v1
That is not a good example. Perfect traction control is beyond human limit even if the person in the driver's seat is maximally attentive.
My first guess: Normalize it. Find the largest exponent and divide all values with the exponent. This is a power-of-2 operation so would not lose any precision. Then divide all numbers by the length. Perform the same normalization again. Sum the numbers, then revert the exponent that was removed in the first step.
My second guess (backup plan): Use the interval arithmetic. I don't remember the specifics but I remember this is the safest form of floating point operations. But perhaps I should be careful about the performance penalty.
Wait, what?
[1] If you call iRobot is a venture company. It is actually 30 yrs old.
For scientific computing, no. However it is very useful in other areas such as web, agents, gui, where you have many methods to combine in many ways and OOP really suits in.
I also experienced a 5 hour delay. The worst thing was not the length of the delay, but how they handled it... they gave us nearly zero information and most passengers were frustrated by the "expected departure time" on the screen constantly being updated with no explanation.
I also believe realistically an abrupt change as a total ban on driving would not happen, and instead there will be a more gradual shift to the driverless society, which would only materialize at the time I become too old to drive. I am completely fine with it, by that time I would have enjoyed plenty of driving.
Most people don't care about what car they drive. For them driving a Prius is just fine. For petroheads driving a Prius is NOT fine. It feels as if Mac enthusiasts are forced to live forever with Windows XP, or Emacs/Vim users forced to write code with Notepad, or a mechanical keyboard user forced to live with a cheap membrane keyboard. It brings a huge disappointment to their life. For most people switching to a dull car means nothing, since they have been driving a dull car, which is not the case for them.
By the way, the more serious track day cars, without audio/AC/insurator, are painful and impossible to drive daily, in my personal experience. Especially the summer. One day I was dehydrated and could not shift properly.
> choosing which node (next state) to expand next
I know this is "heuristic search", a broader class of algorithms which includes A* and IDA* and many more. But the core selling point of IDA* is not the "heuristic search", but its compact linear-space memory usage (thus fast) compared to A*. So I did not suggested IDA* because of its heuristic search aspect.
For an efficient implementation, reversible updates are just natural and common in IDA*. Below is an excerpt from [1]. I believe this is equivalent to what you call reversible state updates.
* In-place Modification
The main source of remaining overhead in the expansion function is
the copy performed when generating each new successor (line 12 in Figure 1).
Since IDA* only considers a single node for expansion at a time, and because
our recursive implementation of depth-first search always backtracks to the
parent before considering the next successor, it is possible to avoid copying entirely.
We will use an optimization called in-place modification where the search
only uses a single state that is modified to generate each successor and
reverted upon backtracking.
[1] Burns, E. A., Hatem, M., Leighton, M. J., & Ruml, W. (2012, July). "Implementing fast heuristic search code". In Fifth Annual Symposium on Combinatorial Search.