• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• kusanagi-master
  • .hgignore
  • Doxyfile
  • examples
    • run_learning_algorithm.py
    • transfer
      • cartpole_adjust.py
    • notebooks
      • evaluate_policy-Copy2.ipynb
      • gym_learn.ipynb
      • arduino_cartpole_environment.ipynb
      • kl_loss
        • task_cost_plus_kl_reg.ipynb
      • evaluate_policy.ipynb
      • plotting_test.ipynb
      • torch_experiments.ipynb
      • cartpole_learn.ipynb
    • data
    • cartpole_learn.ipynb
    • __init__.py
    • PILCO
      • double_cartpole_learn.py
      • cartpole_learn.py
      • cartpole_learn_serial.py
      • __init__.py
      • pendulum_learn.py
  • kusanagi
    • utils
      • probls.py
      • utils_.py
      • distributions.py
      • updates.py
      • __init__.py
      • extra_ops.py
    • shell
      • double_cartpole.py
      • plant.py
      • pendulum.py
      • arduino
        • cartpole
          • cartpole.ino
        • arduino.py
        • __init__.py
      • cost.py
      • evaluate_policy.py
      • double_integrator.py
      • __init__.py
      • experiment_utils.py
      • cartpole.py
    • server.py
    • ghost
      • transfer
        • trajectory_matching.py
        • __init__.py
        • kl_matching.py
      • algorithms
        • pilco.py
        • pddp.py
        • mc_pilco.py
        • __init__.py
      • regression
        • SPGP.py
        • SNRpenalty.py
        • objectives.py
        • BaseRegressor.py
        • GP.py
        • NN.py
        • nonlinearities.py
        • cov.py
        • layers.py
        • SSGP.py
        • __init__.py
      • __init__.py
      • optimizers
        • sgd_optimizer.py
        • __init__.py
        • scipy_optimizer.py
      • control
        • control_.py
        • NNPolicy.py
        • saturation.py
        • __init__.py
    • base
      • base_.py
      • ExperienceDataset.py
      • Loadable.py
      • __init__.py
    • diagnosis_tools
      • profile_learner_log.py
      • profile_learner_logs.sh
      • check_init_exp_aqua.py
      • __init__.py
      • plot_learner_profile.m
    • __init__.py
  • LICENSE
  • test
    • test_serial_plant.py
    • testNNRegression.py
    • matlab_test.m
    • __init__.py
    • testGPRegressor.py
  • cartpole_experiments.sh
  • setup.py
  • eval_cartpole.sh
  • README.md
  • double_cartpole_experiments.sh
  • .gitignore

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

def sfunc(bias, sat_func, *args, **kwargs):
    return sat_func(*args, **kwargs) + bias

def gSin(m, v, i=None, e=None):
    D = m.shape[0]
    if i is None:
        i = tt.arange(D)
    if e is None:
        e = tt.ones((D,))
    elif e.__class__ is list:
        e = tt.as_tensor_variable(np.array(e)).flatten()
    elif e.__class__ is np.array:
        e = tt.as_tensor_variable(e).flatten()

    # compute the output mean
    mi = m[i]
    vi = v[i, :][:, i]
    vii = v[i, i]
    exp_vii_h = tt.exp(-vii/2)
    M = exp_vii_h*tt.sin(mi)

    # output covariance
    vii_c = vii.dimshuffle(0, 'x')
    vii_r = vii.dimshuffle('x', 0)
    lq = -0.5*(vii_c+vii_r)
    q = tt.exp(lq)
    exp_lq_p_vi = tt.exp(lq+vi)
    exp_lq_m_vi = tt.exp(lq-vi)
    mi_c = mi.dimshuffle(0, 'x')
    mi_r = mi.dimshuffle('x', 0)
    U1 = (exp_lq_p_vi - q)*(tt.cos(mi_c-mi_r))
    U2 = (exp_lq_m_vi - q)*(tt.cos(mi_c+mi_r))

    V = 0.5*(U1 - U2)

    # inv input covariance dot input output covariance
    C = tt.diag(exp_vii_h*tt.cos(mi))

    # account for the effect of scaling the output
    M = e*M
    V = tt.outer(e, e)*V
    C = e*C

    retvars = [M, V, C]

    return retvars


def gSat(m, v=None, i=None, e=None):
    ''' Reimplementation from the PILCO matlab code. Saturates the input
    signal to -1 to 1 through the function sat(x) = (9*sin(x) +sin(3*x))/8.
    If v is not None, this function returns the output mean, covariance and
    input-output covariance for computing he joint distribution p(input,output)
    as a multivariate Gaussian.'''
    D = m.shape[0]

    if i is None:
        i = tt.arange(D)
    if e is None:
        e = tt.ones((D,))
    elif e.__class__ is list:
        e = tt.as_tensor_variable(np.array(e)).flatten()
    elif e.__class__ is np.array:
        e = tt.as_tensor_variable(e).flatten()
    e = e.astype(m.dtype)

    # if no input variance, return deterministic
    if v is None:
        return e*(9*tt.sin(m) + tt.sin(3*m))/8

    # construct joint distribution of x and 3*x
    Q = tt.vertical_stack(tt.eye(D), 3*tt.eye(D))
    ma = Q.dot(m)
    va = Q.dot(v).dot(Q.T)

    # compute the joint distribution of 9*sin(x)/8 and sin(3*x)/8
    i1 = tt.concatenate([i, i+D])
    e1 = tt.concatenate([9.0*e, e])/8.0
    M2, V2, C2 = gSin(ma, va, i1, e1)
    # get the distribution of (9*sin(x) + sin(3*x))/8
    P = tt.vertical_stack(tt.eye(D), tt.eye(D))
    # mean
    M = M2.dot(P)
    # variance
    V = P.T.dot(V2).dot(P)

    # inv input covariance dot input output covariance
    C = Q.T.dot(C2).dot(P)

    retvars = [M, V, C]

    return retvars


def tanhSat(u, e):
    return e*tt.tanh(u)


def sigmoidSat(u, e):
    return e*(2*tt.nnet.sigmoid(u)-1)


def maxSat(u, e):
    return tt.minimum(theano.tensor.maximum(u, -e), e)