albzey@gmail.com
http://www.az2000.de
https://github.com/albertz
https://twitter.com/albertzeyer
Research Scientist, PhD; Deep Learning, Speech Recognition, NLP: http://www-i6.informatik.rwth-aachen.de/~zeyer/ https://scholar.google.com/citations?user=qrh5CBEAAAAJ&hl=en
[ my public key: https://keybase.io/albertzeyer; my proof: https://keybase.io/albertzeyer/sigs/1NQp461oCwDiD4vB8HKfiZAkztYALFalSYwHFsnX8IU ]
- I think the point is that for most things, you don't need to call any external tools. Python's standard library comes already with lots of features, and there are many packages you can install.
- The first linked article was recently discussed here: RIP pthread_cancel (https://www.hackerneue.com/item?id=45233713)
In that discussion, most of the same points as in this article were already discussed, specifically some async DNS alternatives.
See also here the discussion: https://github.com/crystal-lang/crystal/issues/13619
- Which paper is that?
- This idea is often used for self-supervised learning (SSL). E.g. see DINO (https://arxiv.org/abs/2104.14294).
- The random noise is added to the model parameters, not the inputs, or not?
This reminds me of variational noise (https://www.cs.toronto.edu/~graves/nips_2011.pdf).
If it is random noise on the input, it would be like many of the SSL methods, e.g. DINO (https://arxiv.org/abs/2104.14294), right?
- > Presumably we still wouldn't enable Modules by default.
- I wonder, what LeCun wants to do is more fundamental research, i.e. where the timeline to being useful is much longer, maybe 5-10 years at least, and also much more uncertain.
How does this fit together with a startup? Would investors happily invest into this knowing not to expect anything in return for at least the next 5-10 years?
- I was looking for various options to archive my data (photos, documents, code), and have looked at Perkeep since a while, but then started using Git-Annex.
However, I regret this decision. Git-Annex is not usable anymore on my data because the amount of files has grown so much (millions) and Git-Annex is just too slow (it takes minutes up to even hours for some Git operation, and the FS is decently fast). I assume I would not have had those problems with Perkeep.
- It reminds me also of the 24 FPS discussion, which is still the standard as far as I know for cinema, even though 48 or 60 FPS are pretty standard for series, The 24 FPS give it a more cinematic feeling.
https://www.vulture.com/2019/07/motion-smoothing-is-ruining-... https://www.filmindependent.org/blog/hacking-film-24-frames-...
- I have asked about using RPython as a generic standalone language before. I think the official statement is that is was never intended to become one, and it's really a very minimal subset of Python (so basically no existing Python code will run, it would require heavy refactoring or complete rewrite), and it's only specifically those features that they currently need, and it might also be a moving target, and they don't want to give certain guarantees on stability of the language etc.
Once you consider that you anyway need to write very different kind of code for RPython, then maybe just using Nim or some other language is a better idea?
- QtCreator was a bit like the lightweight version of KDevelop for me. I didn't really needed any of the Qt features, just the C++ editor. And the C++ support was really good.
- The bug was with non-contiguous data in tensors.
I also had a very similar bug a while ago, broken gradients due to non-contiguous data for masked_select: https://github.com/pytorch/pytorch/issues/99638
In my case, it was easier to identify: I had another implementation of my loss function before that did not use masked_select. But then I thought I can be clever and use masked_select to take out the non-masked frames and calculate the loss only on those. But it wasn't working. Also, it only happened for some models, not for all. It turns out, it was always happening when the data coming out of the model was non-contiguous.
I think the bugs with non-contiguous data are not so uncommon. I wonder how much of that we still have.
- The argument is also that you could effectively DoS the system by exhausting space or inodes.
- This is Windows only.
I wonder, why don't they use Lazarus (https://www.lazarus-ide.org/)? That would also make it cross-platform, and probably gain much more interest in the project.
- Oh, I just checked, there is an active fork: https://github.com/ianBBB/boa-constructor
- Ok, this post is mostly about text-based IDEs, but I think the point mostly stands as well for IDEs in general. I'm thinking about Visual Basic or Delphi.
I think such a IDE for Python would really be helpful for beginners. Not text-based, but more like Visual Basic. But everything integrated, everything easily discoverable (that's very important!). Maybe also with such a GUI builder as in VB. And a built-in debugger. I think for the code editor, as long as it has some syntax highlighting and tab auto-complete, that would already be enough. But some easy code navigation would also be good. E.g. when you place some button on your window, and double click that button in the GUI editor, you get to the call handler code of that button.
Some time ago, a small group of people (me included) (I think from some similar HN post?) got together and we brainstormed a bit on how to implement this. But we got lost in the discussion around what GUI framework to base this on. I already forgot the options. I think we discussed about PySide, Dear PyGui, or similar. Or maybe also web-based. We couldn't really decide. And then we got distracted, and the discussion died off.
Note, Free Pascal was mentioned here. But then you should also mention Lazarus (https://www.lazarus-ide.org/), which is the same as Free Pascal but cloning Delphi. Lazarus is really great. And it is actively developed. But Object Pascal is too little known nowadays, maybe also a bit outdated.
- ICLR 2026 reviews are happening now (or soon). This paper here was accepted at ICLR 2025.
- Why not store the data directly as Arrow files, to allow for mmaping? I see F3 also supports such zero-copy mmap, and skimming through the paper, it actually seems that it uses Arrow buffers, so I wonder what is the difference to directly using Arrow files? (Arrow files is what is being used by HuggingFace datasets.)
- Long time ago, that was actually very easy on Mac, via SIMBL (https://github.com/albertz/simbl) and Afloat (https://github.com/rwu823/afloat) and you could hack around using FScriptAnywhereSIMBL (https://github.com/albertz/FScriptAnywhereSIMBL) or Pyjector (https://github.com/albertz/Pyjector).
But that doesn't work anymore since a while (I guess due to SIP).
- This sounds interesting.
I would really like to read a full research paper made out of this, which describes the method in more detail, gives some more examples, does more analysis on it, etc.
Btw, this uses LLMs on pure text-level? Why not images? Most of these patterns are easy to detect on image-level, but I assume when presented as text, it's much harder.
> LLMs are PhD-level reasoners in math and science, yet they fail at children's puzzles. How is this possible?
I think this argument is a bit flawed. Yes, you can define AGI as being better than (average) humans in every possible task. But isn't this very arbitrary? Isn't it more reasonable to expect that different intelligent systems (including animals, humans) can have different strengths, and it is unreasonable to expect that one system is really better in everything? Maybe it's more reasonable to define ASI that way, but even for ASI, if a system is already better in a majority of tasks (but not necessarily in every task), I think this should already count as ASI. Maybe really being better in every possible task is just not possible. You could design a task that is very specifically tailored for human intelligence.
- Why not use getaddrinfo_a / getaddrinfo_async_start / GetAddrInfoExW?
Or just use some standalone DNS resolve code or library (which basically replicates getaddrinfo but supports this in an async way)?
See also here the discussion: https://github.com/crystal-lang/crystal/issues/13619
- I keep my /etc under Git. When the system does changes automatically (via an update or whatever), I make a Git commit with a special distinct message, and so I can easily filter out all my own changes.
- It's funny: The article talks about GPT and diffusion in the context of technological innovations, and then getting to AI/LLMs. But "diffusion" and "GPT" have some very different meaning in the context of AI/LLMs, referring to specific kind of models.
That said, I don't really get the conclusion of the article. We should put more effort for productization of LLMs? But isn't that exactly what the big companies are trying to do already?
- I don't really need the versioning aspect too much, but sometimes I modify the photos a bit (e.g. rotating or so). But all the other things are relevant for me, like having it distributed, syncing, only partially having the data on a particular node, etc.
So, what solution would be better for that? In the end it seems that other solutions provide a similar set of features. E.g. Syncthing.
But what's the downside with Git-annex over Syncthing or other solutions?
- How much data do you have? I'm using git-annex on my photos, and that are around 100k-1M files, several TB of data, on a ZFS. In the beginning, everything was fine, but it starts to become increasingly slow, such that every operation takes several minutes (5-30 mins or so).
I wonder a bit whether that is ZFS, or git-annex, or maybe my disk, or sth else.
- I have seen such variants as well, where you actually need to install some antennas (RTK antennas?).
But that was already too much effort for me, so that's why I chose the eufy. Also, from reports that I have read, it doesn't necessarily work better with antennas. Actually, from reports that I have read, robots with camera-only had the least amount of reports where navigation was not properly working. At least that was my impression.
- Maybe 300 m^2 or so.
The eufy E15 is for up to 800 m^2. There is the eufy E18 for up to 1200 m^2.
I have seen other (more expensive, bigger) robots for much larger lawns.
My garden is relatively flat with a few bumps here and there.
You can also easily mark some areas of the lawn as always excluded so that it wont drive there.
- In my case, my lawn isn't easily accessible and also not visible from the street (because the house and garage is between the street and the garden), and I trust my neighbors. So, I think (I hope) this isn't so much an issue for my case.
I think the eufy has also an optional GPS module just for this purpose, to better track it. I don't think this GPS module has any other purpose (e.g. it would not be used for navigation). But I didn't really checked the details on this.
I have seen this a few times for such robots, that you can buy an optional GPS module for tracking.
- > The current generation of robotic lawn mowers sucks. Basically all of these bots drive in a random direction until they hit the border of the lawn, rotate for a randomized duration and repeat.
I recently (a few weeks ago) bought one. While researching on the available options (which seemed relevant to me), actually almost none of the robots work this way. Most of them systematically go through the lawn. I think from those that I checked, only the Worx Landroid does it randomly.
I was searching for some model which works without wires, because I was too lazy to set this up. Basically, in general, I wanted sth which required as little effort as possible.
I decided for eufy E15, which uses camera (no GPS, no wires, no lidar, nothing else really). And it just seems to work. It creates a map first, and then systematically goes over the lawn. I didn't really need to do anything.
(I'm not affiliated with eufy in any way. I'm just quite happy with it so far.)
That said, obviously, having an open source variant of such a robot would be even nicer (if it works)! So I'm quite happy to see such a project.
This robot here uses GPS, as far as I can see, as the sole technique for navigation and localization. From reports that I have read, GPS mostly works fine, except for some cases where it does not (where GPS coverage is not great). Camera on the other side always works (during daytime). Maybe this could be added to this project? Of course, using the camera is probably quite a bit more complicated, and more prone to errors, but overall might be more robust and reliable.
This is released under GPL.
I wonder, who is K1n9_Duk3? Does he have the rights to actually release this, and put it under GPL?
What does "reconstructed" mean? Is this disassembled? And if so, is it really ok to put this under GPL then?