I used to maintain a website at interesting.jemoka.com filled with interesting things which is kind of neat. That died, but I still find a bunch of things interesting and so here’s a bunch of them.

POMDPs

Holy crap I can go on forever about them. My advisor Mykel is the biggest POMDP cheerleader of the west so it kinda rubbed off on me, but the fact that the answer to life, universe, and everything is

\begin{equation} U’(b) = \max_{a}\qty[R(b,a)+\gamma \qty(\sum_{o}^{}P(o|b,a) U(b))] \end{equation}

where

\begin{equation} R(b,a) = \sum_{s}^{} R(s,a)b(s) \end{equation}

\begin{align} P(o|b,a) &= \sum_{s}^{} p(o|s,a) b(s) \\ &= \sum_{s}^{} \sum_{s’}^{} T(s’|s,a) O(o|s’,a) b(s) \end{align}

is extremely based. Think about it: isn’t everything in life composed of what you observe \(O\qty(o|s’,a)\), what’s actually happening \(T\qty(s’|s,a)\), and what gets you going \(R\qty(s,a)\)?

Emacs

So I live out of Emacs and have even given an sit-down comedy talk about it which is cool. I wrote this website via Emacs. I write all of my code via Emacs. I take notes in class using Emacs. I will probably wash my cloths in Emacs if I can.

Conversational Programming

You should not sleep on LISP, the thing that Emacs is “just an interpreter of.” The paradigm it represents named conversational programming rubbed off significantly on me.

Usually most of my development involves repeatedly running a script until it crashes and then fixing it which is very tedious if the thing you are running is a long-running training script. Instead, conversational programming invokes interrogating the values of a global state and persecuting regions of code until the values in the state matches what you expect them to be, a chunk at a time. This means that I rarely run more than like 2 lines of code at a time.

But other than LISP there’s not a lot of languages to support exploring state with such freedom. To make this work in Python I had to do some very cursèd engineering:

    def _vomit(self):
        """recursively vomit every method and attribute of self
        into a namespace for debugging.

        only useful if you are Jack and has a weird Jupyter setup.
        I apologise for the this abuse of all that's good about Python.
        """

        from types import SimpleNamespace

        ns = SimpleNamespace()

        from torch.nn import ModuleList

        buffer = [(i, self) for i in dir(self) if i[0] != "_"]
        names = []
        while len(buffer) > 0:
            member, head = buffer.pop(-1)
            attr = getattr(head, member)
            ns.__dict__[member] = attr

            def include(attr):
                for j in dir(attr):
                    if j not in names and j[0] != "_":
                        buffer.append((j, attr))
                        names.append(j)

            # some special rules for including things
            if isinstance(attr, ModuleList):
                for component in attr:
                    include(component)
            else:
                include(attr)

        return ns

Theory of CS

There’s a dude named Will Merrill who’s out there trying to prove impossibilities of transformers using TCS which I think is pretty cool. In general I think TCS gives us a pretty good structure to think about what cannot happen using a particular system, and thus what we can do to make these learning systems more powerful.

For instance did you know that (Realistic) LLMs are not super powerful?

Videos

I don’t get to make as many videos as I used to before, but here’s one I made about a cool locking system that makes zero-knowledge PCPs work.

There’s more stuff but I’m getting kinda tired writing this so I’ll come back to it later and add more gradually byeeeeeeee