from abc import ABC, abstractmethod

import numpy as np

# import edward as ed

# import tensorflow as tf

# from edward.models import Normal

class FunctionApproximator(object):

pass

def positive_variable(shape=(), **kwargs):

return tf.sqrt(tf.exp(variable(shape, **kwargs)))

def variable(shape=(), init=None, loc=0., scale=.01):

# return tf.Variable(tf.zeros(shape))

def data(shape, dtype='float32'):

return tf.placeholder(dtype, shape)

# X = np.vstack([x, np.ones(len(x))]).T

from bayespy.nodes import GaussianARD, SumMultiply, Gamma

from bayespy.inference import VB

class BayesianRegression(object):

return y_hat

# class BayesianRegression(FunctionApproximator):

# """Bayesian linear regression."""

# def __init__(self, w_prior, sigma_w=100., n_iter=1000):

# super().__init__()

# if len(w_prior.shape) < 2:

# w_prior = w_prior.reshape(-1, 1)

# shape = w_prior.shape

# # Linear regression model.

# self._X = data((None, shape[0]))

# w = Normal(loc=tf.zeros(shape), scale=sigma_w)

# # Observation noise is optimized as a point estimate

# # so it doesn't have an associated distribution.

# self._sigma_y = positive_variable()

# y = Normal(loc=tf.matmul(self._X, w), scale=self._sigma_y)

# self._y_obs = tf.placeholder(tf.float32, [None, shape[1]])

# # Varitional inference.

# qw = self.qw = Normal(loc=variable(shape),

# scale=positive_variable(shape, loc=np.log(sigma_w**2).astype('float32')))

# self.inference = ed.KLpq({w: qw}, data={y: self._y_obs})

# self.inference.initialize(n_iter=n_iter, n_samples=10)

# tf.global_variables_initializer().run()

# self.w = self.qw.loc.eval()

# self.sigma_w = self.qw.scale.eval()

# self._sigma_w_T = self.sigma_w.T

# def update(self, X, y, n_iter=1):

# for _ in range(n_iter):

# info_dict = self.inference.update({self._X: X, self._y_obs: y})

# # self.inference.print_progress(info_dict)

# self.w = self.qw.loc.eval()

# self.sigma_w = self.qw.scale.eval()

# self._sigma_w_T = self.sigma_w.T

# def predict(self, x, return_var=False):

# x = np.atleast_2d(x)

# mean = x @ self.w

# if return_var:

# var = (x * self._sigma_w_T * x).sum(1)

# return mean, var

# else:

# return mean

class BayesQ(FunctionApproximator):

return mean

# class BayesQ(FunctionApproximator):

# """Bayesian linear regression."""

# def __init__(self, w_prior, sigma_w=100.):

# super().__init__()

# w_prior = np.atleast_2d(w_prior)

# state_size, n_action = w_prior.shape

# # Observed data.

# self._states = data([None, state_size])

# self._qs = data([None])

# # # Linear regression weights.

# # w = Normal(loc=tf.zeros(shape), scale=sigma_w)

# # # Each action has separate variance due to observation noise resulting

# # # from non-determinism in the environment and/or policy.

# # # This parameter is optimized as a point estimate.

# # self.sigma_y = positive_variable()

# # # Observed Q value depends on Q values of all actions and the action taken.

# # # Q = Normal(loc=tf.matmul(self._states, w), scale=self.sigma_y)

# # Q = tf.matmul(self._states, w)

# # qs = Normal(loc=tf.reduce_sum(Q * self._actions, 1),

# # scale=self.sigma_y)

# # Linear regression weights.

# weights = [Normal(loc=tf.zeros(state_size), scale=sigma_w)

# for _ in range(n_action)]

# # Each action has separate variance due to observation noise resulting

# # from non-determinism in the environment and/or policy.

# # This parameter is optimized as a point estimate.

# self.sigma_y = positive_variable()

# # qs = Normal(loc=w[self._actions])

# Q = [ed.dot(self._states, w) for w in weights]

# # Observed Q value depends on Q values of all actions and the action taken.

# # Q = Normal(loc=tf.matmul(self._states, w), scale=self.sigma_y)

# Q = tf.matmul(self._states, w)

# qs = Normal(loc=tf.reduce_sum(Q * self._actions, 1),

# scale=self.sigma_y)

# # Varitional inference.

# self.qw = [Normal(loc=variable(state_size), scale=positive_variable([]))

# for _ in range(n_action)]

# self.inference = ed.KLqp({w: self.qw}, data={qs: self._qs})

# self.inference.initialize(n_iter=100, n_samples=5)

# # tf.global_variables_initializer().run()

# # Inferred parameters.

# self.w = self.qw.loc.eval()

# self.sigma_w = self.qw.scale.eval()

# self._sigma_w_T = self.sigma_w.T

# def update(self, states, actions, qs, n_iter=1):

# for _ in range(n_iter):

# update = {self._states: states, self._actions: actions, self._qs: qs}

# info_dict = self.inference.update(update)

# self.inference.print_progress(info_dict)

# self.w = self.qw.loc.eval()

# self.sigma_w = self.qw.scale.eval()

# self._sigma_w_T = self.sigma_w.T

# def predict(self, x, return_var=False):

# mean = x @ self.w

# if return_var:

# var = (x * self._sigma_w_T * x).sum(1)

# return mean, var

# else:

# return mean

class Network(object):

self.net.compile(optimizer='rmsprop', loss='mse')

class LinearSGD(object):

return x @ self.theta