notebook.community

Edit and run 





In [5]:



    


import OVFM.FeatureMap as fm
import OVFM.Model as mdl
from OVFM import DataGeneration as dg
import numpy as np
import time

from bokeh.plotting import figure, output_file, output_notebook, show, VBox, HBox, vplot
from bokeh.models import Range1d



    











In [18]:



    


i_dim   = 4
nb_data = 100
exp_dim = 1000

#generate
t1 = time.clock( )
features = dg.generate_inputs( nb_data, i_dim )
print 'Generate time: ', time.clock( ) - t1

# AE = np.cov( targets.T )
sup_boundG = np.empty( 10 )

phi = fm.GaussianFF( 1, i_dim, 1 )
G = phi.kernel_exact( features )

t1 = time.clock( )
for idx_exp, exp in enumerate( np.logspace( 1, 5, 10, base = 10 ) ):
    phi = fm.GaussianFF( 1, i_dim, int( exp ) )
    OVFM_G = phi.kernel_approx( features )
    sup_boundG[ idx_exp ] = ( np.abs( OVFM_G - G ) ).max( )

print 'Approximation time: ', time.clock( ) - t1
print sup_boundDC

output_file( "KernelApproximation.html" )

p1 = figure( title="Kernel Approximation", x_axis_type='log' )

p1.line( np.logspace( 1, 5, 10, base = 10 ), sup_boundG, line_color="black", legend = 'Gaussian kernel' )

p1.xaxis.axis_label = 'D'
p1.yaxis.axis_label = 'MSE'

show( vplot( p1 ) )



    


















    






Generate time:  0.00029
Approximation time:  1.07836
[ 1.58027778  0.96672992  0.50570269  0.30807872  0.20044871  0.13905299
  0.05913743  0.0376212   0.02353505  0.01479257]

















In [19]:



    


i_dim   = 4
o_dim   = 4
nb_data = 100
exp_dim = 1000

#generate
t1 = time.clock( )
features = dg.generate_inputs( nb_data, i_dim )
print 'Generate time: ', time.clock( ) - t1

# AE = np.cov( targets.T )
sup_boundDC = np.empty( 10 )

A = np.random.rand( o_dim, o_dim )
A = np.dot( A, A.T )

phi = fm.DecomposableFF( 1, i_dim, 1, A = A )
G = phi.kernel_exact( features )

t1 = time.clock( )
for idx_exp, exp in enumerate( np.logspace( 1, 5, 10, base = 10 ) ):
    phi = fm.DecomposableFF( 1, i_dim, int( exp ), A = A )
    OVFM_G = phi.kernel_approx( features )
    sup_boundDC[ idx_exp ] = ( np.abs( OVFM_G - G ) ).max( )

print 'Approximation time: ', time.clock( ) - t1
print sup_boundDC



    


















    






Generate time:  0.000305000000001
Approximation time:  1.106397
[ 1.63807958  1.06913246  0.68026522  0.31194483  0.2363291   0.13965691
  0.08557665  0.03962442  0.02412036  0.01761957]

















In [20]:



    


dim     = 4
nb_data = 100
exp_dim = 1000

#generate
t1 = time.clock( )
features = dg.generate_inputs( nb_data, dim )
print 'Generate time: ', time.clock( ) - t1

# AE = np.cov( targets.T )
sup_boundCF = np.empty( 10 )

phi = fm.CurlFreeFF( 1, dim, 1 )
G = phi.kernel_exact( features )

t1 = time.clock( )
for idx_exp, exp in enumerate( np.logspace( 1, 5, 10, base = 10 ) ):
    phi = fm.CurlFreeFF( 1, dim, int( exp ) )
    OVFM_G = phi.kernel_approx( features )
    sup_boundCF[ idx_exp ] = ( np.abs( OVFM_G - G ) ).max( )

print 'Approximation time: ', time.clock( ) - t1
print sup_boundCF



    


















    






Generate time:  0.000337000000002
Approximation time:  7.431148
[ 2.26011562  1.23444476  1.01204171  0.4878366   0.35839826  0.20286658
  0.12551449  0.08139154  0.05460361  0.0294312 ]

















In [21]:



    


dim     = 4
nb_data = 100
exp_dim = 1000

#generate
t1 = time.clock( )
features = dg.generate_inputs( nb_data, dim )
print 'Generate time: ', time.clock( ) - t1

# AE = np.cov( targets.T )
sup_boundDF = np.empty( 10 )

phi = fm.DivFreeFF( 1, dim, 1 )
G = phi.kernel_exact( features )

t1 = time.clock( )
for idx_exp, exp in enumerate( np.logspace( 1, 5, 10, base = 10 ) ):
    phi = fm.DivFreeFF( 1, dim, int( exp ) )
    OVFM_G = phi.kernel_approx( features )
    sup_boundDF[ idx_exp ] = ( np.abs( OVFM_G - G ) ).max( )

print 'Approximation time: ', time.clock( ) - t1
print sup_boundDF



    


















    






Generate time:  0.000216999999999
Approximation time:  35.922904
[ 5.20170509  4.59251287  2.22672831  1.50650913  0.74516693  0.46532162
  0.29002833  0.19220595  0.10292043  0.07500535]

















In [22]:



    


dim     = 3
nb_data = 100
exp_dim = 1000

#generate
t1 = time.clock( )
features = dg.generate_inputs( nb_data, dim )
print 'Generate time: ', time.clock( ) - t1

# AE = np.cov( targets.T )
sup_boundTF = np.empty( 10 )

phi = fm.TransformableFF( 1, dim, 1 )
G = phi.kernel_exact( features )

t1 = time.clock( )
for idx_exp, exp in enumerate( np.logspace( 1, 5, 10, base = 10 ) ):
    phi = fm.TransformableFF( 1, dim, int( exp ) )
    OVFM_G = phi.kernel_approx( features )
    sup_boundTF[ idx_exp ] = ( np.abs( OVFM_G - G ) ).max( )

print 'Approximation time: ', time.clock( ) - t1
print sup_boundTF



    


















    






Generate time:  0.000283999999994
Approximation time:  5.135892
[ 0.13846055  0.07600645  0.18341348  0.05925324  0.0427623   0.00657957
  0.01061387  0.00407894  0.00289302  0.00231574]

















In [23]:



    


i_dim   = 4
o_dim   = 4
nb_data = 100
exp_dim = 1000

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

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

#generate
t1 = time.clock( )
features = dg.generate_inputs( nb_data, i_dim )
print 'Generate time: ', time.clock( ) - t1

# AE = np.cov( targets.T )
sup_boundDT = np.empty( 10 )

A = np.random.rand( o_dim, o_dim )
A = np.dot( A, A.T )

phi = fm.DeepTransformableFF( 1, i_dim, 1, P = P, A = A )
G = phi.kernel_exact( features )

t1 = time.clock( )
for idx_exp, exp in enumerate( np.logspace( 1, 5, 10, base = 10 ) ):
    phi = fm.DeepTransformableFF( 1, i_dim, int( exp ), P = P, A = A )
    OVFM_G = phi.kernel_approx( features )
    sup_boundDT[ idx_exp ] = ( np.abs( OVFM_G - G ) ).max( )

print 'Approximation time: ', time.clock( ) - t1
print sup_boundDT



    


















    






Generate time:  0.000303000000002
Approximation time:  28.784891
[ 0.96705526  0.58223715  0.34827971  0.23860648  0.12064077  0.10320613
  0.04904169  0.02867423  0.01848732  0.00892087]

















In [25]:



    


output_file( "KernelApproximation.html" )

p1 = figure( title="Kernel Approximation", x_axis_type='log' )

p1.square( np.logspace( 1, 5, 10, base = 10 ), sup_boundDC, line_color="blue", fill_color = None )
p1.square( np.logspace( 1, 5, 10, base = 10 ), sup_boundDT, line_color="green", fill_color = None )
p1.square( np.logspace( 1, 5, 10, base = 10 ), sup_boundCF, line_color="orange", fill_color = None )
p1.square( np.logspace( 1, 5, 10, base = 10 ), sup_boundDF, line_color="red", fill_color = None )
p1.square( np.logspace( 1, 5, 10, base = 10 ), sup_boundTF, line_color="black", fill_color = None )

p1.line( np.logspace( 1, 5, 10, base = 10 ), sup_boundDC, line_color="blue", legend = 'Decomposable' )
p1.line( np.logspace( 1, 5, 10, base = 10 ), sup_boundDT, line_color="green", legend = 'Deep Transformable' )
p1.line( np.logspace( 1, 5, 10, base = 10 ), sup_boundCF, line_color="orange", legend = 'Curl Free' )
p1.line( np.logspace( 1, 5, 10, base = 10 ), sup_boundDF, line_color="red", legend = 'Divergence Free' )
p1.line( np.logspace( 1, 5, 10, base = 10 ), sup_boundTF, line_color="black", legend = 'Transformable' )

p1.xaxis.axis_label = 'D'
p1.yaxis.axis_label = 'MSE'

show( vplot( p1 ) )



    











In [7]:



    






    











In [ ]:

Content source: RomainBrault/OVFM

Similar notebooks:

notebook.community | gallery | about