eigenfoo

from collections import namedtuple

import theano
import theano.tensor as tt
import numpy as np

from pymc3.theanof import join_nonshared_inputs, gradient, CallableTensor, floatX

Hamiltonian = namedtuple("Hamiltonian", "logp, dlogp, pot")

eigenfoo

class FunctionToGenerator(ast.NodeTransformer):
    """
    This subclass traverses the AST of the user-written, decorated,
    model specification and transforms it into a generator for the
    model. Subclassing in this way is the idiomatic way to transform
    an AST.

    Specifically:
    
    1. Add `yield` keywords to all assignments

eigenfoo

class Model:
    """ pm.Model decorator. """

    def __init__(self, func):
        self.func = func

        # Introspect wrapped function, instead of the decorator class.
        functools.update_wrapper(self, func)

        # Uncompile wrapped function.

eigenfoo

@Model
def linear_regression(x):
    scale = tfd.HalfCauchy(0, 1)
    coefs = tfd.Normal(tf.zeros(x.shape[1]), 1)
    predictions = tfd.Normal(tf.linalg.matvec(x, coefs), scale)
    return predictions


linear_regression.model_generator(tf.zeros([3, 10]))  # Shape is irrelevant here

eigenfoo

def linear_regression(x):
    scale = yield tfd.HalfCauchy(0, 1)
    coefs = yield tfd.Normal(tf.zeros(x.shape[1]), 1, )
    predictions = yield tfd.Normal(tf.linalg.matvec(x, coefs), scale)
    return predictions

eigenfoo

def make_bandits(params):
    def pull(arm, size=None):
        while True:
            # Bernoulli distributed rewards
            reward = np.random.binomial(n=1, p=params[arm], size=size)
            yield reward
    
    return pull, len(params)

eigenfoo

""" Stream data from the WebSocket and update the Beta posterior parameters online. """

import tornado.ioloop
import tornado.websocket


class WebSocketClient:
    def __init__(self, io_loop):
        self.connection = None
        self.io_loop = io_loop

eigenfoo

""" Every 100ms, sample from a Bernoulli and write the value to a WebSocket. """

import random
import tornado.ioloop
import tornado.web
import tornado.websocket


class WebSocketServer(tornado.websocket.WebSocketHandler):
    """Simple WebSocket handler to serve clients."""

eigenfoo

def make_bandits(params):
    def pull(arm, size=None):
        while True:
            # Poisson distributed rewards
            reward = np.random.poisson(lam=params[arm], size=size)
            yield reward
    
    return pull, len(params)

eigenfoo

#!/bin/python

import argparse
import re
import json
import string

parser = argparse.ArgumentParser(
    description="Print a Markdown table of contents for a Jupyter notebook."
)