jph00

The Future of AI Education: fast.ai Joins Forces with Answer.AI

Date: November 20, 2024
Author: Jeremy Howard
Categories: AI Education, fast.ai, Answer.AI

---

In the rapidly evolving world of artificial intelligence, the need for accessible, practical education has never been more crucial. Today, I am excited to announce that fast.ai is joining forces with Answer.AI to bring you a new era of AI education. This partnership is not just about combining resources; it's about creating a new kind of learning experience that leverages the power of AI to solve real-world problems.

VictorTaelin

HVM3's Optimal Atomic Linker (with Polarization)

Atomic linking is at the heart of HVM's implementation: it is what allows threads to collaborate towards massive parallelism. All major HVM versions started with a better atomic linker. From slow, buggy locks (HVM1), to AtomicCAS (HVM1.5), to AtomicSwap (HVM2), the algorithm became simpler and faster over the years.

On the initial HVM3 implementation, I noticed that one of the cases on the atomic linker never happened. After some reasoning, I now understand why, and

liam-fitzgerald

The future of shrubbery:

Shrubbery is back! After much navel gazing, ketamine, and other forms of introspection that are under NDA, a decision has been reached. I have decided to push my code to the public (go look at lf/persist[1]). I apologize to everyone I left in the lurch.

So what’s next?

There are a handful of minor tasks that I need to finish in order for new shrubbery to work. These will be completed and released with groundwire. This release will be the last release of shrubbery-as-agent as well as the first with the new root shrub design. What was formerly app/neo.hoon is now app/lain.hoon, as well as a “root shrub” named neo. I consider %lain to be more or less the property of the community. All PRs welcome and considered. Neo will continue to be developed in public, however it should be considered a product, rather than infrastructure. Think of %lain as the filesystem and %neo like OS X.

https://github.com/liam-fitzgerald/urbit/tree/lf/persist

MekkCyber

import torch

import triton
import triton.language as tl

def unpack_weights(packed: torch.Tensor, bits: int = 2) -> torch.Tensor:
    values_per_item = 8 // bits
    packed_shape = packed.shape

    if len(packed_shape) == 1:

joemfb

Arvo

It's important not to ignore the power of the Azimuth layer alone. Azimuth gives us 4 billion secure, convenient, transferable, cryptographically self-sovereign network endpoints.

Once two computers have secure names and secure keys, it's almost impossible to keep them from exchanging packets. Once names are scarce, it's straightforward to block undesired traffic. Azimuth is a natural foundation for any network which wants private

VictorTaelin

import Control.Monad (forM_)
import Data.Char (chr, ord)
import Debug.Trace
import Prelude hiding (LT, GT, EQ)
import System.Environment (getArgs)
import System.Exit (exitFailure)
import Text.Parsec ((<|>))
import qualified Data.Map.Strict as M
import qualified Text.Parsec as P

VictorTaelin

Fast Discrete Program Search 2

I am investigating how to use Bend (a parallel language) to accelerate Symbolic AI; in special, Discrete Program Search. Basically, think of it as an alternative to LLMs, GPTs, NNs, that is also capable of generating code, but by entirely different means. This kind of approach was never scaled with mass compute before - it wasn't possible! - but Bend changes this. So, my idea was to do it, and see where it goes.

Now, while I was implementing some candidate algorithms on Bend, I realized that, rather than mass parallelism, I could use an entirely different mechanism to speed things up: SUP Nodes. Basically, it is a feature that Bend inherited from its underlying model ("Interaction Combinators") that, in simple terms, allows us to combine multiple functions into a single superposed one, and apply them all to an argument "at the same time". In short, it allows us to call N functions at a fraction of the expected cost. Or, in simple terms: why parallelize when we can share?

A

VictorTaelin

HOC's Fast Discrete Program Search (DPS)

HOC will soon (EOY?) launch an API for our DPS solution. The interface will be simple:

• You give us a set of examples (input/output pairs)

• We'll give you a (Python?) function that models it

And that's it. It will be an universal function finder.

VictorTaelin

Higher-Order Company: Complete Historical Overview

This document is a complete historical overview of the Higher Order Company. If you want to learn anything about our background, a good way to do so is to feed this Gist into an AI (like Sonnet-3.5) and ask it any question!

My Search for a Perfect Language

It all started around 2015. I was an ambitious 21-year-old CS student who, somehow, had been programming for the last 10 years, and I had a clear goal:

I want to become the greatest programmer alive

nreHieW

"""
The 2024 Transformer (the Noam Transformer):
- RMSNorm
- GQA or some combination 
- Sliding window attention 
- Swiglu
- RoPE (Rotary Positional Embedding)

LLM Arches:
                hidden | MLP mult.   |  n_layers | rope_theta |  GQA Group Size  | GLU Act. |  ops