montebicyclelo

Fun, and enjoyed the track it uses:

https://music.youtube.com/watch?v=-tJ23mRbmps

Hmm, there's a difference between unnecessary arguments about every tiny detail, and productive arguments.

I've seen many healthy technical disagreements; often leading to new insights coming to light, assumptions being made explicit, everyone leaving with a better understanding, sometimes resulting in one party conceding, sometimes resulting in a compromise. Guess it requires a certain level of maturity / people arguing in good faith.

Then cite them as blog posts

My point is it's still useful to have a somewhat authoritative place to cite (high quality) blog post level content. arXiv has formatting requirements and doesn't go down like random personal sites.

a LaTeX PDF can launder epistemic status

True to a certain extent, although something people are aware of and they can judge the content themselves (hopefully).

Well, some blog posts are worth citing.

Isn't the directionality important. I.e. it is currently possible to run useful / great models locally, but on high end machines; and in a few years we will likely be able to run even better models on standard machines.

"why not alternative", would be better framed as, "here's a fun variation" — because both approaches are just playing around with technology, for fun / curiosity / exploration. Storing in the pixels is a fun approach, resulting in something Rube Goldberg-esque.

Ever considered second hand slightly older gens? Even M1 is still great for many use cases. E.g. often corps are selling them on Ebay, in pretty good condition.

Reminds me of this [1] HN post from 9 months ago, where the author trained a neural network to do world emulation from video recordings of their local park — you can walk around in their interactive demo [2].

I don't have access to the DeepMind demo, but from the video it looks like it takes the idea up a notch.

(I don't know the exact lineage of these ideas, but a general observation is that it's a shame that it's the norm for blog posts / indie demos to not get cited.)

[1] https://news.ycombinator.com/item?id=43798757

[2] https://madebyoll.in/posts/world_emulation_via_dnn/demo/

Originally wrote this in 2022 to improve my understanding of deep learning internals. Recently refreshed it, removing CuPy to keep it lighter and educational. (Plus modernized the stack, e.g. with uv and improved CI.)

For an example of an AI generated song that's gone viral in the last few days, getting millions of views on Spotify / Youtube, see this post from earlier today:

"Tell HN: Viral Hit Made by AI, 10M listens on Spotify last few days" [1]

[1] https://news.ycombinator.com/item?id=46600681

Yep, it is convincing. And it seems the video is performed by a human, although I did think it could be AI. They say in the description:

I couldn't resist putting a face to this gem.

After saying it is AI:

How people was touched by this version of « Papoutai » by stromae made by AI, I was also touched as y’all, as an independent Artist I wanted to put my emotions and my soul on this masterpiece

https://www.youtube.com/watch?v=bQ8GbwQV5zE

As a hobbyist, shaders is up there as one of the most fun types of programming.. Low-level / relatively simple language, often tied to a satisfying visual result. Once it clicks, it's a cool paradigm to be working in, e.g. "I am coding from the perspective of a single pixel".

    bulk_send(
        generate_expiry_email(user) 
        for user in db.getUsers() 
        if is_expired(user, date.now())
    )

Incorrect Pytorch gradients with Apple MPS backend...

Yep this kind of thing can happen. I found and reported incorrect gradients for Apple's Metal-backed tensorflow conv2d in 2021 [1].

(Pretty sure I've seen incorrect gradients with another Pytorch backend, but that was a few years ago and I don't seem to have raised an issue to refer to... )

One might think this class of errors would be caught by a test suite. Autodiff can be tested quite comprehensively against numerical differentiation [2]. (Although this example is from a much simpler lib than Pytorch, so I could be missing something.)

[1] https://github.com/apple/tensorflow_macos/issues/230

[2] https://github.com/sradc/SmallPebble/blob/2cd915c4ba72bf2d92...

Agreed, and its larger context window is fantastic. My workflow:

- Convert the whole codebase into a string

- Paste it into Gemini

- Ask a question

People seem to be very taken with "agentic" approaches were the model selects a few files to look at, but I've found it very effective and convenient just to give the model the whole codebase, and then have a conversation with it, get it to output code, modify a file, etc.

At your own risk — one place is ebay sellers with a large number of positive reviews, (and not much negative), who are selling lots of the same type of MacBook pros. My assumption is they've got a bunch of corporate laptops to sell off.

On the contrary; now might be a good time to get an M1 Max laptop. A second hand one, ex-corporate, in good condition, with 64Gb RAM, is pretty good value, compared to new laptops at the same price. It's still a fantastic CPU.

nanochat is also inspired by modded-nanoGPT

Nice synergy here, the lineage is: Karpathy's nano-GPT -> Keller Jordan's modded-nanoGPT (a speedrun of training nanoGPT) -> NanoChat

modded-nanoGPT [1] is a great project, well worth checking out, it's all about massively speeding up the training of a small GPT model.

Notably it uses the author's Muon optimizer [2], rather than AdamW, (for the linear layers).

[1] https://github.com/KellerJordan/modded-nanogpt

[2] https://kellerjordan.github.io/posts/muon/

I did the same. I was sad to lose the comments, but the ads were awful and I don't particularly want someone elses ads / tracking on my hobby site. I switched to gisqus [1], which is powered by GitHub discussions, which seems to be working ok. (The site is hosted on GH pages so seems reasonable to also use GH discussions for the comments.)

[1] https://giscus.app/

One of the simplest CRDT strategies is Last-Write-Wins (LWW):

Each update gets a timestamp (physical or logical).

When two devices write to the same field, the update with the latest timestamp wins.

Please also have a robust synced undo feature, so it's easy to undo the thing you don't want that gets written. Apps that sync often seem to be stingy about how much "undos" they store/sync (if any).

Yeah... Looks like can get about $1/hr for 10 small VMs, ($0.10 per VM).

So for $3000, that's 3000 hours, or 125 days, (if just wastefully leave them on all the time, instead of turning them on when needed).

Say you wanted to play around for a couple of hours, that's like.. $3.

(That's assuming there's no bonus for joining / free tier, too.)

I stopped using apple's notes app with an ipad pen after it lost 20 minutes of my handwritten notes when trying to sync them. (Which fits the theme of apple losing people's stuff.)

I think OP is suggesting that Apple / AMD / Intel do the work of integrating their NPUs into popular libraries like `llama.cpp`. Which might make sense. My impression is that by the time the vendors support a certain model with their NPUs the model is too old and nobody cares anyway. Whereas llama.cpp keeps up with the latest and greatest.

Although note — people are likely to be infuenced by the recent prevalence of em dash to use it more in their own writing nowadays

the Python code in the previous example is still readable

Yes, I agree with the author, list comprehensions are readible, and I'd add, practical.

it gets worse as the complexity of the logic increases

    len(list(filter(lambda line: all([abs(x) >= 1 and abs(x) <= 3 for x in line]) and (all([x > 0 for x in line]) or all([x < 0 for x in line])), diffs)))

It would be written more like:

    result = sum(my_contrived_condition(x) for line in diffs)

(Surely in any language it's possible to write very bad confusing code, using some feature of the language...)

And note:

    x = [line.split() for line in text.splitlines()]

    x = []
    for line in text.splitlines():
        x.append(line.split())

So, they are included in the normal backpropagation of the model. But there is no one-hot encoding, because, although you are correct that it is equivalent, it would be very inefficient to do it that way. You can make indexing differentiable, i.e. gradient descent flows back to the vectors that were selected, which is more efficient than a one-hot matmul.

(If you're curious about the details, there's an example of making indexing differentiable in my minimal deep learning library here: https://github.com/sradc/SmallPebble/blob/2cd915c4ba72bf2d92...)

Nice tutorial — the contextual vs static embeddings is the important point; many are familiar with word2vec (static), but contextual embeddings are more powerful for many tasks.

(However, there seems to be some serious back-button / browser history hijacking on this page.. Just scolling down the page appends a ton to my browser history, which is lame.)

I always found that badly named things did make learning harder / more jarring; especially if an explanation for the incongruous name wasn't provided.

if the weights are taken from HF then what's the implementation for

The weights are essentially a bunch of floating point numbers, (grouped into tensors). The code says what operations to do with the weights. E.g. say you load matrix W from the weights, you could do `y = W @ x`, or `y = W.T @ x`, or `y = W @ W @ x` etc.

TLDR, unexpected blank fields

policy change was inserted into the regional Spanner tables

This policy data contained unintended blank fields

Service Control... pulled in blank fields... hit null pointer causing the binaries to go into a crash loop