scribu

But isn't it true for JavaScript too?

You're right, the equivalent JS script produces the same sequence of outputs.

It turns out there is a way to emulate Python's asyncio.create_task().

Python:

  await asyncio.create_task(child())

  const childTask = new Promise((resolve) => {
    setTimeout(() => child().then(resolve), 0)
  })
  await childTask

Awaiting a coroutine does not give control back to the event loop.

I think this is a subtler point than one might think on first read, which is muddled due to the poorly chosen examples.

Here's a better illustration:

  import asyncio
  
  async def child():
      print("child start")
      await asyncio.sleep(0)
      print("child end")
  
  async def parent():
      print("parent before")
      await child()        # <-- awaiting a coroutine (not a task)
      print("parent after")
  
  async def other():
      for _ in range(5):
          print("other")
          await asyncio.sleep(0)
  
  async def main():
      other_task = asyncio.create_task(other())
      parent_task = asyncio.create_task(parent())
      await asyncio.gather(other_task, parent_task)
      
  asyncio.run(main())

  other
  parent before
  child start
  other
  child end
  parent after
  other
  other
  other

Edit: clarification

ChatGPT Plus has that (used to be in the free tier too). You can toggle between versions for each of your messages with little left-right arrows.

I’m confused by the clustering step:

To find the most informative examples, we separately cluster examples labeled clickbait and examples labeled benign, which yields some overlapping clusters

How can you get overlapping clusters if the two sets of labelled examples are disjoint?

It’s interesting that they decided to move all of the architecture-specific image-to-embedding preprocessing into a separate library.

Similar to how we ended up with the huggingface/tokenizers library for text-only Tranformers.

This seems to be a system to generate better prompts to be fed into a base multimodal model.

Interesting, but title is definitely clickbait.

You could run the build process with chroot or inside Docker, so that the hardcoded paths actually resolve to a designated subdirectory.

From their Notion page:

Skywork-OR1-32B-Preview delivers the 671B-parameter Deepseek-R1 performance on math tasks (AIME24 and AIME25) and coding tasks (LiveCodeBench).

Impressive, if true: much better performance than the vanilla distills of R1.

Plus it’s a fully open-source release (including data selection and training code).

“Fill in the gaps by using context” is the hard part.

You can’t pre-bake the context into an LLM because it doesn’t exist yet. It gets created through the endless back-and-forth between programmers, designers, users etc.

The point is that you’d expect a roughly even distribution of clockwise and counterclockwise spins, not all of them to rotate in the same direction.

If the base models already have the “reasoning” capability, as they claim, then it’s not surprising that they were able to get to SOTA using a relatively negligible amount of compute for RL fine-tuning.

I love this sort of “anti-hype” research. We need more of it.

The install speed alone makes it worthwhile for me. It went from minutes to seconds.

The HN submission title is editorialized in a non-helpful way. Why beat a dead horse instead of focusing on what’s actually new in TFA?

The linked paper proposes an obvious-in-retrospect form of data augmentation: shuffle the order of the premises, so that the model can’t rely on spurious patterns. That’s kinda neat.

Would be curious to know how this stacks up against Coconut [1] which also uses latent space for reasoning.

[1] https://arxiv.org/abs/2412.06769

The repo contains only the PDF, not actual runnable code for the RL training pipeline.

Publishing a high-level description of the training algorithm is good, but it doesn't count as "open-sourcing", as commonly understood.

Nice approach!

I'm intrigued by the ability to start execution from a particular task.

One thing I like about LangGraph is the declarative state merging. In the MapReduce example, how do you guarantee that the collector.append() operation is thread-safe?

Actually, there have been attempts to do quantized backprop, but not sure how successfully.

I'm working on something like that. Feel free to email me (address in my bio).

I’m not sure about the Speed chart. I would expect gpt-4-turbo to be faster than plain gpt-4.

I understand that it's a different approach, but I would still have expected this paper to at least mention FlashAttention [1] since they both leverage flash memory.

[1] https://arxiv.org/abs/2205.14135

Sketch is another take on integrating an LLM into Pandas:

https://github.com/approximatelabs/sketch

The way I see it, the utility of theory is raising the baseline. It guides you away from dead ends, so you don't waste time on approaches that could never work.

It's necessarily high-level, so you still need to learn about specific approaches to get practical things done.

Maybe you're interpreting the words "effort" and "manipulation" too strictly. During a meditation session, the brain could still be doing the activities from the definition, even though you might not feel like you're doing much at all.

Or, conversely, perhaps during meditation you're less conscious.

NB: I'm not an expert on anything related to this.

Thanks for that. It's hard to make out acronyms like "SWAV" or "SEER" from the audio, if you're not already familiar with them.

Sure, it's zero if you ignore all the development and maintenance costs.

Plus, robots aren't necessarily better at making things. Tesla, for example, rolled back its fully automated production line because it wasn't as adaptable as humans are.

I was surprised at how large a difference getting paid every week vs every 2 weeks makes.

In what way?

I could write a webapp that simulates the stock market, declare that it contains X "shares" of Apple at Y price, and people could speculate on them, much as they do in the real stock market, all without Apple knowing or caring.

This already exists. It's called a CFD (Contract For Difference)

It does have a section on continuous probabilities at the end.

The Campfire meeting room seems interesting.

Giving remote participants a proportionate physical presence should help equal the playing field.

I think it hinges on how easy it is to set up the call, so that each face is on a separate screen.

Judges make harsher rulings when they're hungry.

Actually, that finding is highly improbable: https://nautil.us/blog/impossibly-hungry-judges