pakl

HTMs were a great theory but I never saw them function at more than 1 layer of hierarchy. So the “H” part was lacking.

Anyway since we know that any part of neocortex can be reached from any other within 3 hops, and there is more feedback connectivity than feedforward connectivity in nearly every part of neocortex, it should be called a heterarchy.

Hierarchy is a handy metaphor/mental crutch from understanding primate social organization, not necessarily how the brain works.

There are ample known facts and published theories about neuroscience that have never brought together into a coherent framework. Everyone has their pet theories and focuses just on them in isolation. Let me know when some funder is genuinely interested in putting all the pieces together instead of grandstanding on a single idea.

A few years ago Peterpaul developed a lightweight object-oriented system on top of C that was really pleasant to use[0].

No need to pass in the object explicitly, etc.

Doesn't have the greatest documentation, but has a full test suite (e.g., [1][2]).

[0] https://github.com/peterpaul/co2

[1] https://github.com/peterpaul/co2/blob/master/carbon/test/pas...

[2] https://github.com/peterpaul/co2/blob/master/carbon/test/pas...

In most B2B cases you really don’t want to self host authentication. Really.

There are plenty of identity providers out there who will worry about hashing passwords, resetting them, 2FA, etc. Most client businesses already have identities via one of those for all their employees (read: users of your APIs or apps).

Unfortunately nearly all of the open source solutions out there do exactly what you said, they start with (required) self-hosting authentication. Not helpful.

What’s more relevant to businesses is authorization using existing IdPs (shameless plug: https://github.com/DMGT-TECH/the-usher-server)

See “call-by-meaning”: http://www.vpri.org/pdf/tr2014003_callbymeaning.pdf

Think about it. A “meaning” in this usage is definitely not a longer name.

IMHO (from the viewpoint of a neuroscientist) the biological inspiration is quite measured and restrained in his work…

The problem he was proposing we solve is computing with heterogenous “machines”. This doesn’t preclude the regimented organization you are favoring, above.

Please see my other comment on call-by-meaning.

Actors solves a very different problem. Alan Kay was talking about enabling computing across heterogeneous systems.

At Alan Kay’s Viewpoints Research Institute, the problem was phrased in a more concrete form and a solution was provided — “Call by Meaning”[0].

The most succinct way I have found to state the problem is: “For example, getting the length of a string object varies significantly from one language to another... size(), count, strlen(), len(), .length, .length(), etc. How can one communicate with a computer -- or how can two computers communicate with each other -- at scale, without a common language?” [1]

The call-by-meaning solution is to refer to functions (processes, etc) not by their name, but by what they do. VPRI provided an example implementation in JavaScript[0]. I re-implemented this -- a bit more cleanly, IMHO -- in Objective C[1].

[0] http://www.vpri.org/pdf/tr2014003_callbymeaning.pdf

[1] https://github.com/plaurent/call-by-meaning-objc?tab=readme-...

There exists the Universal (Function) Approximation Theorem for neural networks — which states that they can represent/encode any function to a desired level of accuracy[0].

However there does not exist a theorem stating that those approximations can be learned (or how).

[0] https://en.m.wikipedia.org/wiki/Universal_approximation_theo...

If you think about it, for embodied agents symbol grounding isn’t really the “problem”.

Rather, embodied agents start with reference and indices. The hard problem is actually ungrounding — which takes work — to eventually get to things that approach what people typically think of “symbols”.

In an anthropological framework, social capital can be built up and exchanged for other forms of capital (including economic capital). There are even brokers who have the role of facilitating these transactions[0].

[0] https://bertrandlaurent.substack.com/p/monday-converting-soc...

The Precursor should tick your boxes, and with an FPGA-based SOC.

https://www.crowdsupply.com/sutajio-kosagi/precursor/updates...

In my experience, businesses are especially concerned with authorization — enabling product sales to customers.

They would rather not deal with identity and authentication — usernames and passwords — at all. These are already quite nicely handled to various degrees by Cogntio, Auth0, Azure Active Directory, and others.

To address minimalist authorization needs, the portfolio of companies I worked with collaborated to create The Usher[1]. The Usher is an open source authorization server in NodeJS. Worth a peek if you, too, want to focus on authorization separate from authentication.

Disclosure: I am a contributor to The Usher.

[1] https://github.com/DMGT-TECH/the-usher-server

Most implementations are focused on oAuth to establish identity, but the test of your application's security begins after authentication. The major portion is authorization i.e., verifying access to operations and data accessed with those operations.

Agreed. Authentication is quite a solved problem, the major focus for our portfolio of B2B companies is on authorization. They spend significant time on designing scopes which reflect and impact their business.

It is surprising that nearly every solution out there aims to handle both authentication and authorization. We choose to strictly separate these and delegate identity to established third parties or our customers[0].

We recently open sourced The Usher[1], our solution to part of the authorization problem. It is a minimalist server that issues access tokens based on roles and permissions looked up in a database (keyed by the identity token’s `sub` claim). Perhaps folks in this thread will find it useful!

0: https://dev.to/dmgt-tech/introducing-the-usher-an-authorizat...

1: https://github.com/DMGT-TECH/the-usher-server

In case you are looking for a way to build GNUstep for Raspberry Pi (and use GWorkspace, etc), we have build scripts here:

https://github.com/plaurent/gnustep-build

A few of us maintain scripts for building the latest GNUstep from source under Linux (desktop, PinePhone, and Raspberry Pi) here: https://github.com/plaurent/gnustep-build

Yes. I was surprised that the OA gets as close as mentioning “golden apple” but misses that the Latin “aurantium” (from pomum aurantium) would sound awfully close to “orange”.

That’s why you need to sign up for CSA Pre™. Get preauthorized for instant escalation on customer support calls.

All you have to do is answer a form with questions like: Do you know how to plug in a computer? Do you know where the power switches are on your devices? etc.

CSA Pre™ is valid for 5 years; you can initiate the renewal process to do 6 months before expiry.

Why should the fee be proportional to the price? If it’s about supporting infrastructure, take a percentage based on load on the infrastructure.

You are making a lot of incorrect statements about brains and vision. I would advise you to study some visual neuroscience.

Learning multilayer convolutional representations of statistical features is roughly equal to taking few first few layers in visual cortex and stacking them.

No, it isn't roughly equal the first few layers of visual cortex. The first few layers of visual cortex have substantial feedback connectivity from higher areas which affects the responses of even the most peripheral parts. (Citations in our arxiv preprint linked above.). Most of the brain has more feedback connectivity from elsewhere than feedforward ascending connectivity. This qualitatively affects activations.

We are essentially building a frog...

I suspect frog vision is far more robust than anything we are "essentially building".

Features seem to exist independently...

Please have a close look at some modern visual neuroscience. Or speak to an good honest electrophysiologist.

Deep convolutional networks, by design, are unable to integrate contextual and ambient information present in an image (or in preceding images) to inform how to interpret local features they use. So it's no surprise they struggle with unconstrained images. Images where ambient context varies.

It's intriguing how much focus there is on adversarial examples. You don't need adversarial examples to make a deep network fail - in a sense that's overkill. Just point the poor deep network at a sequence of images from the real world -- images from a self driving car, security camera, or webcam. You'll see it make spontaneous errors. No matter how much training data you gave it.

The field will advance when/if practitioners recognize that classifying pixel patterns in isolation isn't sufficient for robust visual perception, and adopt alternative neural network designs that can interpret what they perceive in light of (no pun intended) context and physical expectations.

It worked for our prototype.[0]

[0] https://arxiv.org/abs/1607.06854

Hi p1esk, RNNs can be more tolerant to noise because they can learn transient or dynamic attractors. If the inputs move an RNN into an attractor, small changes due to noise make little difference to the state.

Recurrence can help with robustness in some other very important ways as well.

Citations for this dates from the 80s and 90s. I don't know the best reference offhand. You could look at some old Hinton stuff if you're a fan. Lots published on this.

Feedforward CNNs cannot tolerate as much noise and real-world variability as RNNs.

Doesn’t it seem plausible that “orange” rather comes from Latin aurantium based on the root aurum for gold? (Gold can appear orange-colored.)

What about your LSTM-based model that didn’t converge in your earlier TPU benchmarks in February?

Cleaning data eliminates the driving force to develop truly autonomous algorithms.

I am a fan of libco2[1] which is a minimalist object-oriented layer on top of C.

[1] https://github.com/peterpaul/co2/tree/master/examples/my-obj...

Great question... Probably processing.org

What was the architecture of your predictive model? Was it designed to learn the underlying physical dynamics from the tons of sensor data?