Пример #1
0
    def test_expm(self):

        def f(x):
            x = x.reshape((2,2))
            return sum(expm(x))

        x = numpy.random.random(2*2)


        # forward mode

        ax = UTPM.init_jacobian(x)
        ay = f(ax)
        g1  = UTPM.extract_jacobian(ay)

        # reverse mode

        cg = CGraph()
        ax = Function(x)
        ay = f(ax)
        cg.independentFunctionList = [ax]
        cg.dependentFunctionList = [ay]

        g2 = cg.gradient(x)

        assert_array_almost_equal(g1, g2)
Пример #2
0
    def test_tracer_on_mixed_utpm_ndarray_mul(self):
        D, P = 1, 1
        A = numpy.arange(2 * 2, dtype=float).reshape(2, 2)

        x = UTPM(numpy.zeros((D, P, 2, 2)))

        def f(x):
            return sum(A * x)

        cg = CGraph()
        ax = Function(x)
        ay = f(ax)
        cg.independentFunctionList = [ax]
        cg.dependentFunctionList = [ay]

        assert_array_almost_equal(A, cg.gradient(x))
Пример #3
0
    def test_tracer_on_mixed_utpm_ndarray_mul(self):
        D, P = 1, 1
        A = numpy.arange(2 * 2, dtype=float).reshape(2, 2)

        x = UTPM(numpy.zeros((D, P, 2, 2)))

        def f(x):
            return sum(A * x)

        cg = CGraph()
        ax = Function(x)
        ay = f(ax)
        cg.independentFunctionList = [ax]
        cg.dependentFunctionList = [ay]

        assert_array_almost_equal(A, cg.gradient(x))
Пример #4
0
    def test_expm(self):
        def f(x):
            x = x.reshape((2, 2))
            return sum(expm(x))

        x = numpy.random.random(2 * 2)

        # forward mode

        ax = UTPM.init_jacobian(x)
        ay = f(ax)
        g1 = UTPM.extract_jacobian(ay)

        # reverse mode

        cg = CGraph()
        ax = Function(x)
        ay = f(ax)
        cg.independentFunctionList = [ax]
        cg.dependentFunctionList = [ay]

        g2 = cg.gradient(x)

        assert_array_almost_equal(g1, g2)
Пример #5
0
"""
This example shows that most computations can be performed by numpy functions
on arrays of UTPM objects.

Just bear in mind that is much faster use UTPM instances of matrices than numpy.ndarrays
with UTPM elements.

"""

import numpy, os
from algopy import CGraph, Function, UTPM, dot, qr, eigh, inv

N, D, P = 2, 2, 1
cg = CGraph()
x = numpy.array([Function(UTPM(numpy.random.rand(*(D, P)))) for n in range(N)])
A = numpy.outer(x, x)
A = numpy.exp(A)
y = numpy.dot(A, x)

cg.independentFunctionList = list(x)
cg.dependentFunctionList = list(y)

cg.plot(os.path.join(os.path.dirname(__file__), 'numpy_dot_graph.svg'))
# N number of cols of A
D,M,N = 2,3,3
P = M*N

# generate badly conditioned matrix A

A = UTPM(numpy.zeros((D,P,M,N)))
A.data[0,:] = numpy.random.rand(*(M,N))

for m in range(M):
    for n in range(N):
        p = m*N + n
        A.data[1,p,m,n] = 1.


cg = CGraph()
A = Function(A)
y = trace(inv(A))
cg.trace_off()

cg.independentFunctionList = [A]
cg.dependentFunctionList = [y]
    
ybar = y.x.zeros_like()
ybar.data[0,:] = 1.
cg.pullback([ybar])

# check gradient
g_forward = numpy.zeros(N*N)
g_reverse = numpy.zeros(N*N)
def eval_covariance_matrix_qr(J1, J2):
    M,N = J1.shape
    K,N = J2.shape
    Q,R = qr_full(J2.T)
    Q2 = Q[:,K:].T
    J1_tilde = dot(J1,Q2.T)
    Q,R = qr(J1_tilde)
    V = solve(R.T, Q2)
    return dot(V.T,V)


# dimensions of the involved matrices
D,P,M,N,K,Nx = 2,1,5,3,1,1

# trace the function evaluation of METHOD 1: nullspace method
cg1 = CGraph()
J1 = Function(UTPM(numpy.random.rand(*(D,P,M,N))))
J2 = Function(UTPM(numpy.random.rand(*(D,P,K,N))))
C = eval_covariance_matrix_qr(J1, J2)
y = C[0,0]
cg1.trace_off()
cg1.independentFunctionList = [J1, J2]
cg1.dependentFunctionList = [y]
print('covariance matrix: C =\n',C)

# trace the function evaluation of METHOD 2: naive method (potentially numerically unstable)
cg2 = CGraph()
J1 = Function(J1.x)
J2 = Function(J2.x)
C2 = eval_covariance_matrix_naive(J1, J2)
y = C2[0,0]
import numpy
import algopy
from algopy import CGraph, UTPM, Function

def eval_g(x, y):
    """ some vector-valued function """
    retval = algopy.zeros(3, dtype=x)
    retval[0] = algopy.sin(x**2 + y)
    retval[1] = algopy.cos(x+y) - x
    retval[2] = algopy.sin(x)**2 + algopy.cos(x)**2
    return retval

# trace the function evaluation
# and store the computational graph in cg
cg = CGraph()
ax = 3.
ay = 5.
fx = Function(ax)
fy = Function(ay)
fz = eval_g(fx, fy)
cg.independentFunctionList = [fx, fy]
cg.dependentFunctionList = [fz]

# compute Taylor series
#
#  Jx( 1. + 2.*t + 3.*t**2 + 4.*t**3 + 5.*t**5,
#      6. + 7.*t + 8.*t**2 + 9.*t**3 + 10.*t**5 )
#  Jy( 1. + 2.*t + 3.*t**2 + 4.*t**3 + 5.*t**5,
#      6. + 7.*t + 8.*t**2 + 9.*t**3 + 10.*t**5 )
#
# where
Пример #9
0
from algopy import CGraph, Function
cg = CGraph()
cg.trace_on()
x = Function(1)
y = Function(3)
z = x * y + x
cg.trace_off()
cg.independentFunctionList = [x,y]
cg.dependentFunctionList = [z]
print cg
cg.plot('example_tracer_cgraph.png')
"""

import numpy
from algopy import CGraph, Function, UTPM, dot, qr, eigh, inv, solve

# first order derivatives, one directional derivative
# D - 1 is the degree of the Taylor polynomial
# P directional derivatives at once
# M number of rows of J1
# N number of cols of J1
# K number of rows of J2 (must be smaller than N)
D,P,M,N,K,Nx = 2,1,100,3,1,1


# METHOD 1: nullspace method
cg1 = CGraph()

J1 = Function(UTPM(numpy.random.rand(*(D,P,M,N))))
J2 = Function(UTPM(numpy.random.rand(*(D,P,K,N))))


Q,R = Function.qr_full(J2.T)
Q2 = Q[:,K:].T

J1_tilde = dot(J1,Q2.T)
Q,R = qr(J1_tilde)
V = solve(R.T, Q2)
C = dot(V.T,V)
cg1.trace_off()

cg1.independentFunctionList = [J1, J2]
Пример #11
0

# create an UTPM instance
D,N,M = 2,3,2
P = 2*N

x = UTPM(numpy.zeros((D,P,2*N,1)))
x.data[0,:] = numpy.random.rand(2*N,1)
x.data[1,:,:,0] = numpy.eye(P)
y = x[N:]
x = x[:N]

# wrap the UTPM instance in a Function instance to trace all operations 
# that have x as an argument
# create a CGraph instance that to store the computational trace
cg = CGraph().trace_on()
x = Function(x)
y = Function(y)
z = f(x,y)
cg.trace_off()

# define dependent and independent variables in the computational procedure
cg.independentFunctionList = [x,y]
cg.dependentFunctionList = [z]

# Since the UTPM instrance is wrapped in a Function instance we have to access it
# by y.x. That means the Jacobian is
grad1 = z.x.data[1,:,0]

print 'forward gradient g(x) = \n', grad1
def f(x,y):
    return dot(x,y) - x*(x-y)
    
We want to compute the Hessian of that function.

"""

import numpy
from algopy import CGraph, Function, UTPM, dot, qr, eigh, inv, zeros


def f(x,N):
    return dot(x[:N],x[N:])*x[N:]  - x[:N]*(x[:N]-x[N:])
    
# create a CGraph instance that to store the computational trace
cg = CGraph()

# create an UTPM instance
D,N,M = 2,3,2
P = N

A = UTPM(numpy.zeros((D,P,M,N)))
x = UTPM(numpy.zeros((D,P,N,1)))

x.data[0,:] = numpy.random.rand(N,1)
A.data[0,:] = numpy.random.rand(M,N)

x.data[1,:,:,0] = numpy.eye(P)


x = Function(x)
Пример #13
0
sigma = 1.2
N = 35
x = numpy.random.normal(actual_mu, sigma, size = N)
mu = UTPM([[3.5],[1],[0]]) #unknown variable

print 'function evaluation =\n',logp(x,3.5,sigma)

# forward mode with ALGOPY
utp = logp(x, mu, sigma).data[:,0]
print 'function evaluation = %f\n1st directional derivative = %f\n2nd directional derivative = %f'%(utp[0], 1.*utp[1], 2.*utp[2])

# finite differences solution:
print 'finite differences derivative =\n',(logp(x,3.5+10**-8,sigma) - logp(x, 3.5, sigma))/10**-8

# trace function evaluation
cg = CGraph()
mu = Function(UTPM([[3.5],[1],[0]])) #unknown variable
out = logp(x, mu, sigma)
cg.trace_off()
cg.independentFunctionList = [mu]
cg.dependentFunctionList = [out]
cg.plot(os.path.join(os.path.dirname(os.path.realpath(__file__)),'posterior_log_probability_cgraph.png'))

# reverse mode with ALGOPY
outbar = UTPM([[1.],[0],[0]])
cg.pullback([outbar])
    
gradient =  mu.xbar.data[0,0]
Hess_vec =  mu.xbar.data[1,0]

print 'gradient = ', gradient
Пример #14
0
    return dot(x,y) - x*(x-y)
    
We want to compute the Hessian of that function.

"""

import numpy
from algopy import CGraph, Function, UTPM, dot, qr, eigh, inv, zeros


def f(x, N):
    return dot(x[:N], x[N:]) * x[N:] - x[:N] * (x[:N] - x[N:])


# create a CGraph instance that to store the computational trace
cg = CGraph()

# create an UTPM instance
D, N, M = 2, 3, 2
P = N

A = UTPM(numpy.zeros((D, P, M, N)))
x = UTPM(numpy.zeros((D, P, N, 1)))

x.data[0, :] = numpy.random.rand(N, 1)
A.data[0, :] = numpy.random.rand(M, N)

x.data[1, :, :, 0] = numpy.eye(P)

x = Function(x)
A = Function(A)
Пример #15
0
matrices can be used.
"""

import numpy
from algopy import CGraph, Function, UTPM, dot, qr, eigh, inv, solve

# first order derivatives, one directional derivative
# D - 1 is the degree of the Taylor polynomial
# P directional derivatives at once
# M number of rows of J1
# N number of cols of J1
# K number of rows of J2 (must be smaller than N)
D, P, M, N, K, Nx = 2, 1, 100, 3, 1, 1

# METHOD 1: nullspace method
cg1 = CGraph()

J1 = Function(UTPM(numpy.random.rand(*(D, P, M, N))))
J2 = Function(UTPM(numpy.random.rand(*(D, P, K, N))))

Q, R = Function.qr_full(J2.T)
Q2 = Q[:, K:].T

J1_tilde = dot(J1, Q2.T)
Q, R = qr(J1_tilde)
V = solve(R.T, Q2)
C = dot(V.T, V)
cg1.trace_off()

cg1.independentFunctionList = [J1, J2]
cg1.dependentFunctionList = [C]
Пример #16
0
"""
This example shows that most computations can be performed by numpy functions
on arrays of UTPM objects.

Just bear in mind that is much faster use UTPM instances of matrices than numpy.ndarrays
with UTPM elements.

"""

import numpy, os
from algopy import CGraph, Function, UTPM, dot, qr, eigh, inv

N,D,P = 2,2,1
cg = CGraph()
x = numpy.array([ Function(UTPM(numpy.random.rand(*(D,P)))) for n in range(N)])
A = numpy.outer(x,x)
A = numpy.exp(A)
y = numpy.dot(A,x)

cg.independentFunctionList = list(x)
cg.dependentFunctionList = list(y)

cg.plot(os.path.join(os.path.dirname(__file__),'numpy_dot_graph.svg'))
Пример #17
0
mu = UTPM([[3.5], [1], [0]])  #unknown variable

print('function evaluation =\n', logp(x, 3.5, sigma))

# forward mode with ALGOPY
utp = logp(x, mu, sigma).data[:, 0]
print(
    'function evaluation = %f\n1st directional derivative = %f\n2nd directional derivative = %f'
    % (utp[0], 1. * utp[1], 2. * utp[2]))

# finite differences solution:
print('finite differences derivative =\n',
      (logp(x, 3.5 + 10**-8, sigma) - logp(x, 3.5, sigma)) / 10**-8)

# trace function evaluation
cg = CGraph()
mu = Function(UTPM([[3.5], [1], [0]]))  #unknown variable
out = logp(x, mu, sigma)
cg.trace_off()
cg.independentFunctionList = [mu]
cg.dependentFunctionList = [out]
cg.plot(
    os.path.join(os.path.dirname(os.path.realpath(__file__)),
                 'posterior_log_probability_cgraph.png'))

# reverse mode with ALGOPY
outbar = UTPM([[1.], [0], [0]])
cg.pullback([outbar])

gradient = mu.xbar.data[0, 0]
Hess_vec = mu.xbar.data[1, 0]
# M number of rows of A
# N number of cols of A
D, M, N = 2, 3, 3
P = M * N

# generate badly conditioned matrix A

A = UTPM(numpy.zeros((D, P, M, N)))
A.data[0, :] = numpy.random.rand(*(M, N))

for m in range(M):
    for n in range(N):
        p = m * N + n
        A.data[1, p, m, n] = 1.

cg = CGraph()
A = Function(A)
y = trace(inv(A))
cg.trace_off()

cg.independentFunctionList = [A]
cg.dependentFunctionList = [y]

ybar = y.x.zeros_like()
ybar.data[0, :] = 1.
cg.pullback([ybar])

# check gradient
g_forward = numpy.zeros(N * N)
g_reverse = numpy.zeros(N * N)
Пример #19
0
from algopy import CGraph, Function
cg = CGraph()
cg.trace_on()
x = Function(1)
y = Function(3)
z = x * y + x
cg.trace_off()
cg.independentFunctionList = [x, y]
cg.dependentFunctionList = [z]
print(cg)
cg.plot('example_tracer_cgraph.png')
Пример #20
0
def eval_covariance_matrix_qr(J1, J2):
    M, N = J1.shape
    K, N = J2.shape
    Q, R = qr_full(J2.T)
    Q2 = Q[:, K:].T
    J1_tilde = dot(J1, Q2.T)
    Q, R = qr(J1_tilde)
    V = solve(R.T, Q2)
    return dot(V.T, V)


# dimensions of the involved matrices
D, P, M, N, K, Nx = 2, 1, 5, 3, 1, 1

# trace the function evaluation of METHOD 1: nullspace method
cg1 = CGraph()
J1 = Function(UTPM(numpy.random.rand(*(D, P, M, N))))
J2 = Function(UTPM(numpy.random.rand(*(D, P, K, N))))
C = eval_covariance_matrix_qr(J1, J2)
y = C[0, 0]
cg1.trace_off()
cg1.independentFunctionList = [J1, J2]
cg1.dependentFunctionList = [y]
print('covariance matrix: C =\n', C)

# trace the function evaluation of METHOD 2: naive method (potentially numerically unstable)
cg2 = CGraph()
J1 = Function(J1.x)
J2 = Function(J2.x)
C2 = eval_covariance_matrix_naive(J1, J2)
y = C2[0, 0]
c = 0.4
Msat = 1.35e5

# Eingangsgrößen
r = 2.0e-2  # m, Radius
i_hat = 20.0  # A, Strom
f = 1000.0  # Hz, Frequenz
n = 3  # Anzahl Perioden
n_p = 512  # Datenpunkte pro Periode

t = np.arange(n * n_p) / (n_p * f)  # Zeitvektor
current = i_hat * (np.sin(2 * np.pi * f * t) +
                   0.7 * np.sin(6 * np.pi * f * t + 1))  # Stromvorgabe
H = current / (2 * np.pi * r)  # Resultierende Feldvorgabe

graph = CGraph()
graph.trace_on()
x = Function([alpha, a, k, c, Msat])

# Parametervektor
p = {'alpha': x[0], 'a': x[1], 'k': x[2], 'c': x[3], 'm_sat': x[4]}

model = JilesAthertonModel.from_dict(p)
M = model.integrate_rk4(t, H)

H = H[::2]
t = t[::2]
B = mu_0 * (H + M)
dB_dt = np.zeros(np.size(B))
new = np.append([0.0], (B[1:] - B[0:-1]) / (t[1:] - t[0:-1]))

# create an UTPM instance
D, N, M = 2, 3, 2
P = 2 * N

x = UTPM(numpy.zeros((D, P, 2 * N, 1)))
x.data[0, :] = numpy.random.rand(2 * N, 1)
x.data[1, :, :, 0] = numpy.eye(P)
y = x[N:]
x = x[:N]

# wrap the UTPM instance in a Function instance to trace all operations
# that have x as an argument
# create a CGraph instance that to store the computational trace
cg = CGraph().trace_on()
x = Function(x)
y = Function(y)
z = f(x, y)
cg.trace_off()

# define dependent and independent variables in the computational procedure
cg.independentFunctionList = [x, y]
cg.dependentFunctionList = [z]

# Since the UTPM instrance is wrapped in a Function instance we have to access it
# by y.x. That means the Jacobian is
grad1 = z.x.data[1, :, 0]

print('forward gradient g(x) = \n', grad1)
Пример #23
0
import algopy
from algopy import CGraph, UTPM, Function


def eval_g(x, y):
    """ some vector-valued function """
    retval = algopy.zeros(3, dtype=x)
    retval[0] = algopy.sin(x**2 + y)
    retval[1] = algopy.cos(x + y) - x
    retval[2] = algopy.sin(x)**2 + algopy.cos(x)**2
    return retval


# trace the function evaluation
# and store the computational graph in cg
cg = CGraph()
ax = 3.
ay = 5.
fx = Function(ax)
fy = Function(ay)
fz = eval_g(fx, fy)
cg.independentFunctionList = [fx, fy]
cg.dependentFunctionList = [fz]

# compute Taylor series
#
#  Jx( 1. + 2.*t + 3.*t**2 + 4.*t**3 + 5.*t**5,
#      6. + 7.*t + 8.*t**2 + 9.*t**3 + 10.*t**5 )
#  Jy( 1. + 2.*t + 3.*t**2 + 4.*t**3 + 5.*t**5,
#      6. + 7.*t + 8.*t**2 + 9.*t**3 + 10.*t**5 )
#