In [1]:

    

import OVFM.Model as mdl
import OVFM.FeatureMap as fm
import OVFM.DataGeneration as dg
import OVFM.Risk as rsk
import OVFM.LearningRate as lr
import OVFM.SGD as sgd
import OVFM.FISTA as fista

import numpy as np
import scipy


    

In [2]:

    

def grad_model_coord( feature, model, coord ):
    return model.Jacobian( feature.reshape( ( 1, feature.shape[ 0 ] ) ) )[ :, coord, : ]

def model_coord( feature, model, coord ):
    return model( feature.reshape( ( 1, feature.shape[ 0 ] ) ) )[ :, coord ]


    

In [3]:

    

n = 1
d = 4
D = 1000
p = 7

A = np.random.rand( p, p )
A = np.dot( A, A.T ) / np.linalg.norm( A ) ** 2

features = dg.generate_inputs( n, d, 'cube' )
model    = mdl.Model( fm.DecomposableFF( 1.0 / d, d, D, A ) )
targets  = dg.generate_outputs( features, model )

print 'Decomposable'
print 'x0 =', features[ 0, : ]
for i in xrange( 0, p ):
    print 'dh_%s/dx (x0) = ' % i, scipy.optimize.check_grad( model_coord, grad_model_coord, features[ 0, : ], model, i )


    

    




---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-3-d0ac021ec28b> in <module>()
      9 features = dg.generate_inputs( n, d, 'cube' )
     10 model    = mdl.Model( fm.DecomposableFF( 1.0 / d, d, D, A ) )
---> 11 targets  = dg.generate_outputs( features, model )
     12 
     13 print 'Decomposable'

/Library/Python/2.7/site-packages/OVFM-0.0.1-py2.7-macosx-10.10-intel.egg/OVFM/DataGeneration.pyc in generate_outputs(X, model)
     16 def generate_outputs( X, model ):
     17     model.coefs = numpy.random.normal( 0, 1, model.coefs.shape )
---> 18     return model( X )
     19 
     20 def mesh2array( X, Y ):

/Users/romainbrault/.python-eggs/OVFM-0.0.1-py2.7-macosx-10.10-intel.egg-tmp/OVFM/Model.so in OVFM.Model.Model.__call__ (OVFM/Model.c:2622)()

TypeError: Cannot convert OVFM.Model._memoryviewslice to numpy.ndarray

In [32]:

    

n = 1
d = 4
D = 1000
p = d

features = dg.generate_inputs( n, d, 'cube' )
model    = mdl.Model( fm.CurlFreeFF( 1.0 / d, d, D ) )
targets  = dg.generate_outputs( features, model )

print 'Curl Free'
print 'x0 =', features[ 0, : ]
for i in xrange( 0, p ):
    print 'dh_%s/dx (x0) = ' % i, scipy.optimize.check_grad( model_coord, grad_model_coord, features[ 0, : ], model, i )


    

    




Curl Free
x0 = [-0.58752583 -0.46407557  0.76291503 -0.89351397]
dh_0/dx (x0) =  [  4.62826095e-08   1.12843846e-08   3.07931532e-08   2.17954124e-08]
dh_1/dx (x0) =  [  4.85372873e-08   1.04709011e-07   1.85921650e-07   8.91253242e-08]
dh_2/dx (x0) =  [  1.20200120e-07   7.79344575e-09   3.42792039e-08   9.45339702e-08]
dh_3/dx (x0) =  [  7.13368452e-08   2.81642792e-10   6.19282221e-08   1.04681697e-09]

In [33]:

    

n = 1
d = 4
D = 1000
p = d

features = dg.generate_inputs( n, d, 'cube' )
model    = mdl.Model( fm.DivFreeFF( 1.0 / d, d, D ) )
targets  = dg.generate_outputs( features, model )

print 'Divergence Free'
print 'x0 =', features[ 0, : ]
for i in xrange( 0, p ):
    print 'dh_%s/dx (x0) = ' % i, scipy.optimize.check_grad( model_coord, grad_model_coord, features[ 0, : ], model, i )


    

    




Divergence Free
x0 = [ 0.73713546  0.74628677  0.70911176  0.44816926]
dh_0/dx (x0) =  [  2.57188157e-08   7.88691765e-08   9.84274174e-08   7.74698192e-08]
dh_1/dx (x0) =  [  1.29653555e-07   1.33265781e-07   1.21716060e-07   1.40857731e-07]
dh_2/dx (x0) =  [  4.40699268e-08   4.35430714e-09   1.11642846e-07   8.56255720e-08]
dh_3/dx (x0) =  [  5.50414605e-08   4.93413802e-08   1.37930308e-07   4.09588441e-09]

In [35]:

    

n = 1
d = 4
D = 1000
p = d

features = dg.generate_inputs( n, d, 'cube' )
model    = mdl.Model( fm.TransformableFF( 1.0 / d, d, D ) )
targets  = dg.generate_outputs( features, model )

print 'Transformable'
print 'x0 =', features[ 0, : ]
for i in xrange( 0, p ):
    print 'dh_%s/dx (x0) = ' % i, scipy.optimize.check_grad( model_coord, grad_model_coord, features[ 0, : ], model, i )


    

    




Transformable
x0 = [-0.00416541 -0.77111657  0.21789173 -0.58658865]
dh_0/dx (x0) =  [  5.97588135e-09   0.00000000e+00   0.00000000e+00   0.00000000e+00]
dh_1/dx (x0) =  [  0.00000000e+00   1.56810344e-07   0.00000000e+00   0.00000000e+00]
dh_2/dx (x0) =  [  0.00000000e+00   0.00000000e+00   1.06401664e-07   0.00000000e+00]
dh_3/dx (x0) =  [  0.00000000e+00   0.00000000e+00   0.00000000e+00   1.45219197e-07]

In [54]:

    

n = 1
d = 4
D = 1000
p = 4

A = 2 * np.random.rand( p, p ) - 1
A = np.dot( A, A.T ) / np.linalg.norm( A ) ** 2

P = np.zeros( ( p, d, d ) )
for i in xrange( 0, p ):
    P[ i, :, : ] = 2 * np.random.rand( d, d ) - 1

features = dg.generate_inputs( n, d, 'cube' )
model    = mdl.Model( fm.DeepTransformableFF( 1.0 / d, d, D, P, A ) )
targets  = dg.generate_outputs( features, model )

print 'Deep Transformable'
print 'x0 =', features[ 0, : ]
for i in xrange( 0, p ):
    print 'dh_%s/dx (x0) = ' % i, scipy.optimize.check_grad( model_coord, grad_model_coord, features[ 0, : ], model, i )


    

    




Deep Transformable
x0 = [-0.67565    -0.25264897 -0.38474142 -0.46388183]
dh_0/dx (x0) =  [  6.13024409e-08   5.00506149e-08   3.28583338e-09   3.83537029e-08]
dh_1/dx (x0) =  [  3.30374133e-08   7.21755108e-08   8.39003290e-08   1.33470586e-07]
dh_2/dx (x0) =  [  1.25553490e-09   6.23878849e-08   3.96402248e-08   5.99815386e-08]
dh_3/dx (x0) =  [  1.03311214e-07   1.04783616e-07   9.23145699e-08   9.43299244e-09]

In [51]:

    




    

In [ ]: