Dustin Tran dustinvtran

Summary Portion

Minjae: Brief overview of the contributions of paper, summary of decomposition of the Q into k basis functions, quick derivation of the weight.
Dustin: LSQ, asymptotic, incremental update, LSPI.

Some things to reinforce:

That it's linear with respect to the parameters and not necessarily the data.
That it calculates parameters using the least squares approach (in other words, decision theory), rather than doing MLE or MAP or whatever.
That its primary advantages are: intuition, simplicity, good theoretical

	import numpy as np
	import scipy.stats
	from typing import List


	def shifty_investigator(num_trials: int,
	num_successes: int,
	p_success: float):
	p_fail = 1. - p_success
	target_p = 1. - scipy.stats.binom.cdf(n=num_trials,

	TRACE_STACK = [lambda f, args, kwargs: f(args, **kwargs)]

	@contextmanager
	def trace(tracer):
	TRACE_STACK.append(tracer)
	yield
	TRACE_STACK.pop()

	def traceable(func):
	def func_wrapped(args, *kwargs):

	import operator

	def toposort(start_node, children=operator.attrgetter('children')):
	"""Generate nodes in DAG's topological order. This guarantees
	for any edge U -> V, we always visit U before visiting V.

	This lets us play the tape via the "push" dataflow model.
	https://stackoverflow.com/questions/981027/what-are-pro-cons-of-push-pull-data-flow-models
	"""
	parent_counts = {}

	import inspect

	class LocalsCapture(object):
	def __enter__(self):
	caller_frame = inspect.currentframe().f_back
	self.local_names = set(caller_frame.f_locals)
	return self

	def __exit__(self, exc_type, exc_val, exc_tb):
	caller_frame = inspect.currentframe().f_back

	#!/usr/bin/env python
	from __future__ import absolute_import
	from __future__ import division
	from __future__ import print_function

	import edward as ed
	import matplotlib.cm as cm
	import numpy as np
	import seaborn as sns
	import tensorflow as tf

	from edward.models import RandomVariable
	from tensorflow.contrib.distributions import Distribution

	class Concrete(RandomVariable, Distribution):
	def __init__(self, args, *kwargs):
	kwargs['is_continuous'] = True
	kwargs['is_reparameterized'] = True
	super(Concrete, self).__init__(args, *kwargs)

	def _log_prob(self, value):

	# TensorFlow r0.10
	#
	# Building Graph
	#
	add_to_collection,tf.add_to_collection
	as_dtype,tf.as_dtype
	bytes,tf.bytes
	container,tf.container
	control_dependencies,tf.control_dependencies
	convert_to_tensor,tf.convert_to_tensor

	# This note is to show that TensorFlow objects are shallow copied:
	# a deep copy is not made when a class contains another class.
	#
	# This is relevant for variational parameters. For example, Inference
	# holds Variational, we train variational parameters via
	# inference.run(). We can use the original variational object as it will
	# have the trained parameters, and not just resort to using
	# inference.variational.
	# (This is probably a feature in Python in general.)
	from __future__ import print_function