rck

Everyone knows the hf leaderboard is actively being gamed (Goodhart's law strikes again), but the guy who wrote the Medium post is active in doing stuff with models, and the tutorial is (clearly) pretty good.

The claim that the pod is legal in Switzerland has been fact checked by multiple news organizations, and is false. Here's one article with lots of references that correct an initial misleading viral interview by the pod creator:

https://www.usatoday.com/story/news/factcheck/2021/12/27/fac...

This thing is illegal everywhere and has not been tested.

You're right that Aquinas would have rejected the notion that gods are software installed in the hardware of believers, but he was not a dualist - he advocated a kind of hylomorphism that doesn't map neatly onto contemporary philosophical categories:

https://en.wikipedia.org/wiki/Hylomorphism#Thomistic_hylomor...

No, there's pretty good evidence that Socrates did exist, though there is debate about what he actually believed and taught, since in Plato's later dialogues the character of Socrates typically was advancing Plato's position. See here: https://en.m.wikipedia.org/wiki/Socratic_problem

Any idea what the training data for this is? Looking at the model, it looks like it is literally just copy-paste from Karpathy's nanoGPT, so the training data is what's most interesting. Pretty amazing anyway.

I think the closest thing for pytorch is the Karpathy video:

https://www.youtube.com/watch?v=VMj-3S1tku0

There's also an old book on the internals of numpy - not sure how out of date it is though.

From one of the most successful roboticists in the world, with a healthy dose of pessimism about AI, self-driving, etc.

Related: https://future.a16z.com/its-time-to-build/

In robotics specifically, understanding how methods like QR factorization work (and fail) is necessary to debug robot code, even if roboticists rarely have to implement QR factorization from scratch.

Take a look at GTSAM, a library used widely in robotics for mapping and localization. To read the intro tutorial for the library, you need to understand most of the topics listed in the OP repo:

https://gtsam.org/tutorials/intro.html

If anything, the Michigan course doesn't cover enough, since it's missing Lie theory, which is becoming standard in robotics code these days.

It's probably legal in most of the US, but almost certainly runs afoul of the GDPR in the EU. Location data is personal data, and companies can't (in the EU and maybe CA) and shouldn't (everywhere) collect it without your consent. People should use crypto because they shouldn't trust the laws to work. But that doesn't mean we shouldn't have laws constraining personal data collection.

This is a great set of ideas for using property-based testing. I've found it useful to think of code in terms of invariants and contracts, and property-based testing lets me express those very directly in code. No other testing method comes close.

Many words, few ideas. I was hoping for an argument based on ... well, anything. There's no real criticism of the scientific support for the idea that human minds are predictive. Just some vague connections to economics and a vocabulary that suggests anti-capitalist sympathies. Your attention is better spent elsewhere.

Haven't seen anyone mention the human that almost gets hit. If the person standing in the lane (the truck's driver maybe?) hadn't stepped out of the way, the Tesla would have run him over without slowing down... Looks like multiple clear perception system failures.

Here's a tutorial on counterfactual regret minimization that does what you're looking for:

http://modelai.gettysburg.edu/2013/cfr/cfr.pdf

I started converting the Java to Python a while back, but got distracted by other work:

https://github.com/RichardKelley/cfr/blob/master/rps.py

That will learn optimal play against a fixed opponent. If you change the code to make both players use regret minimization, it should still converge.

The license seems a bit odd. It refers to software, but I can't see any software in any of the downloads - just data. Clearly the license is intended to cover the contents of the downloads, but the wording seems wrong then.

I'm not a lawyer, so maybe someone with more expertise could chime in...

Good points on the moonshots. I wouldn't rule out data centers though - for whatever reason they're getting pretty common in the Reno area: http://www.rgj.com/story/money/business/2017/02/15/switch-la...

Looks like it could be for data centers, or possibly a test track for Waymo...

The implementations look odd. A network consists of a collection of neurons, which are implemented individually as structs. The forward pass through the network is a series of nested loops, and the gradient descent implementation doesn't use backpropagation - it uses finite differences to approximate derivatives, which is known to be inefficient. Given the overall design of the library, it isn't really clear what you would use it for in practice.

I hope that future versions take inspiration from other open source machine learning libraries, which show how to use linear algebra and backpropagation and are much more effective.

That all sounds reasonable. I was surprised at how much the batch size can matter on different hardware. Maybe you've seen this post:

http://svail.github.io/rnn_perf/

It's primarily RNN-focused, but the discussion about batch sizes on GPUs is interesting.

A system like that would be surprisingly hard to build. The problem wouldn't be the ML algorithms - it would be just about everything else. A few things you need to solve robustly to build your counter:

1. The "same background" doesn't really exist for most cameras in most settings. Changes in illumination alone will make segmenting the background tricky. Moving objects in the scene will also be hard - think fountains and trees in the wind. Google for "foreground-background segmentation" to see some papers on this.

2. I haven't seen anyone use recent ML algorithms with less than high quality images. That may not matter, but it could matter a lot.

3. Extending recent ML algorithms to work with video at a high enough frame rate to be useful (10Hz at a minimum) may or may not be easy.

I'm sure that what you're proposing could be done. But I think that the number of small annoyances you'd hit would probably discourage most people who aren't treating the problem as a research exercise in Computer Vision.

The benchmarks would be a lot more useful if the context around them were more obvious. In particular, it would be nice to know if the benchmarks are for a single input, or for a batch of inputs. If for a batch, then the batch size is important too. Maybe this stuff is somewhere on their site, but it shouldn't require digging.

Without this information it's hard to make a useful comparison at all.

Plenty of good topics in here, but it's interesting to see how things have changed since 2011. From the preface:

"Although there is currently no system which can recognize even in the order of 1000 object categories (the best system can get about 60% correct on 100 categories), the fact that we pull it off seemingly effortlessly serves as a “proof of concept” that it can be done."

Does "ARM support" include bare-metal arm at all? I know there are several projects that move in that direction, but it's not obvious to me how mature they are relative to the rest of Rust (granting that everything in the ecosystem is in an early state)...

I don't know if this will start a revolution, but Structure and Interpretation of Classical Mechanics attempts to address the problem of notation in physics. The preface walks through the classical notation for the Lagrange equations and points out how inadequate that notation is. The whole book essentially makes the case that a functional notation that can be implemented (in Scheme) is better for doing physics:

http://mitpress.mit.edu/sites/default/files/titles/content/s...

It would be more interesting to see a visualization of throughput vs. problem size. That would almost certainly give a better sense of how good this approach is, and it would let us compare to other CUDA monte carlo implementations, like the one Nvidia has had on their CUDA site for years:

http://developer.download.nvidia.com/compute/cuda/2_2/sdk/we...

I think the problem isn't with the published paper - it looks like they used a trained human interviewer and recorded both humans to evaluate their descriptors. The real problem is with the PR video, which looks really impressive, but seriously oversells the capabilities of the system. Not that the problem is unique to this situation - I think a lot of the videos in AI oversell the research. It's a pity, because the research is usually very good, but by itself isn't "exciting enough for general consumption," so they add bells and whistles that have nothing to do with the science.

It looks like the research paper this is based on is here:

http://schererstefan.net/assets/files/scherer_etal_FG2013.pd...

I've only skimmed it, but the vision work looks sound, and it looks like it makes pretty essential use of the depth map from the Kinect. But I don't think there's any speech recognition going on, so that part is just acting (from both the humans and the virtual platform). I'll bet an untrained user could get the system to break pretty quickly...

Neat proof of concept, though.

I think this poll is representative of many that have touched on the issue:

http://www.gallup.com/poll/156491/americans-views-tsa-positi...

That makes sense - they were both inspired by Scheme (R is in many ways just a Lisp that uses M-expressions), but evolved to deal with immediate concerns that, in retrospect, have created difficulties as the years have gone by. It makes R and JavaScript great and frustrating at the same time.

This is all good advice. When I taught algorithms, the difference in performance between students who stepped through the algorithms by hand on small examples and students who just memorized pseudocode was tremendous.

One thing that can make "talking and writing" even more useful is to do it on a whiteboard in front of someone. Then, not only are you practicing the algorithm, you're also practicing whiteboard coding, which is useful for interviews and a lot of day-to-day technical communication.