Deep Learning Tutorial buildbot Fail=0 Err=1 Ran=12 Skip=0 KnownFail=0 SpeedFailure=4

2 views

Skip to first unread message

li...@iro.umontreal.ca

unread,

May 18, 2013, 4:23:43 AM5/18/13

to theano-...@googlegroups.com

Summary of the output:

File "/part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py", line 93, in test_reproduce_ranzato_hinton_2010

Full output:

Sat May 18 01:58:29 EDT 2013
git version for Theano: b321e0790ac7296dd59f3b03219e483433d4bdab
git version: 3da5edbb800133e908e4f9b50373d2743b90f099
executing nosetests speed with mode=FAST_RUN
The code for file logistic_sgd.pyc ran for 10.3s
The code for file logistic_cg.pyc ran for 23.5s
The code for file mlp.pyc ran for 1.28m
The code for file convolutional_mlp.pyc ran for 1.20m
The no corruption code for file dA.pyc ran for 0.96m
The 30% corruption code for file dA.pyc ran for 0.97m
The pretraining code for file SdA.pyc ran for 2.99m
The training code for file SdA.pyc ran for 2.86m
The pretraining code for file DBN.pyc ran for 3.54m
The fine tuning code for file DBN.pyc ran for 2.80m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']
float64 times [ 10.32459545 23.49089265 76.87917304 72.69892097 116.46601439
352.98742652 381.26843739 547.49145675 187.83271337]
float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]
float64 % expected/get [ 0.99761778 1.00890163 1.01587981 1.0137702 0.99943319 0.98275455
1.00165648 1.01937664 0.99184001]
The code for file logistic_sgd.pyc ran for 11.2s
The code for file logistic_cg.pyc ran for 28.7s
The code for file mlp.pyc ran for 0.77m
The code for file convolutional_mlp.pyc ran for 1.09m
The no corruption code for file dA.pyc ran for 0.58m
The 30% corruption code for file dA.pyc ran for 0.60m
The pretraining code for file SdA.pyc ran for 1.71m
The training code for file SdA.pyc ran for 1.50m
The pretraining code for file DBN.pyc ran for 2.32m
The fine tuning code for file DBN.pyc ran for 1.50m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']
float32 times [ 11.2491045 28.76728439 46.16074109 65.83991218 71.13010263
193.18018961 230.50671101 432.89878702 179.2289536 ]
float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]
float32 % expected/get [ 1.03119319 1.02894662 1.02251391 1.01002565 0.99817092 0.98974952
0.98391929 0.9997718 0.98310009]
float64/float32 [ 0.91781488 0.8165836 1.66546661 1.10417706 1.63736604 1.82724444
1.65404485 1.26471007 1.0480043 ]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']
float64 times [ 10.32459545 23.49089265 76.87917304 72.69892097 116.46601439
352.98742652 381.26843739 547.49145675 187.83271337]
float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]
float64 % expected/get [ 0.99761778 1.00890163 1.01587981 1.0137702 0.99943319 0.98275455
1.00165648 1.01937664 0.99184001]
float32 times [ 11.2491045 28.76728439 46.16074109 65.83991218 71.13010263
193.18018961 230.50671101 432.89878702 179.2289536 ]
float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]
float32 % expected/get [ 1.03119319 1.02894662 1.02251391 1.01002565 0.99817092 0.98974952
0.98391929 0.9997718 0.98310009]
float64/float32 [ 0.91781488 0.8165836 1.66546661 1.10417706 1.63736604 1.82724444
1.65404485 1.26471007 1.0480043 ]
expected float64/float32 [ 0.91562844 0.82385253 1.69191391 1.11938181 1.63643796 1.79573279
1.65678473 1.2892159 1.03945259]
Using gpu device 0: GeForce GTX 285
The code for file logistic_sgd.pyc ran for 3.7s
The code for file logistic_cg.pyc ran for 10.2s
The code for file mlp.pyc ran for 0.48m
The code for file convolutional_mlp.pyc ran for 0.19m
The no corruption code for file dA.pyc ran for 0.19m
The 30% corruption code for file dA.pyc ran for 0.20m
The pretraining code for file SdA.pyc ran for 0.20m
The training code for file SdA.pyc ran for 0.12m
The pretraining code for file DBN.pyc ran for 0.81m
The fine tuning code for file DBN.pyc ran for 0.12m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']
gpu times [ 3.68087673 10.11330438 29.15278745 11.75949979 24.01706767
19.92680335 56.86060262 306.59525037 321.23256755]
gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]
gpu % expected/get [ 0.83584295 0.74705899 0.65147348 0.81636125 1.0047051 1.02374674
0.98486469 0.98696898 0.98184316]
float64/gpu [ 2.80492834 2.32277125 2.63711225 6.18214399 4.849302
17.71420234 6.70531827 1.78571408 0.584725 ]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']
float64 times [ 10.32459545 23.49089265 76.87917304 72.69892097 116.46601439
352.98742652 381.26843739 547.49145675 187.83271337]
float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]
float64 % expected/get [ 0.99761778 1.00890163 1.01587981 1.0137702 0.99943319 0.98275455
1.00165648 1.01937664 0.99184001]
float32 times [ 11.2491045 28.76728439 46.16074109 65.83991218 71.13010263
193.18018961 230.50671101 432.89878702 179.2289536 ]
float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]
float32 % expected/get [ 1.03119319 1.02894662 1.02251391 1.01002565 0.99817092 0.98974952
0.98391929 0.9997718 0.98310009]
gpu times [ 3.68087673 10.11330438 29.15278745 11.75949979 24.01706767
19.92680335 56.86060262 306.59525037 321.23256755]
gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]
gpu % expected/get [ 0.83584295 0.74705899 0.65147348 0.81636125 1.0047051 1.02374674
0.98486469 0.98696898 0.98184316]
float64/float32 [ 0.91781488 0.8165836 1.66546661 1.10417706 1.63736604 1.82724444
1.65404485 1.26471007 1.0480043 ]
expected float64/float32 [ 0.91562844 0.82385253 1.69191391 1.11938181 1.63643796 1.79573279
1.65678473 1.2892159 1.03945259]
float64/gpu [ 2.80492834 2.32277125 2.63711225 6.18214399 4.849302
17.71420234 6.70531827 1.78571408 0.584725 ]
expected float64/gpu [ 2.79824638 2.34344771 2.67898911 6.26727338 4.84655336
17.40871297 6.71642548 1.82031522 0.57995365]
float32/gpu [ 3.05609378 2.84449902 1.58340746 5.59887014 2.96164809 9.69448969
4.05389145 1.41195529 0.55794142]
expected float32/gpu [ 3.15142311 2.92683765 1.61905616 5.65500244 2.956231 9.59511652
3.98870201 1.41163309 0.54851225]
speed_failure_float64=0
speed_failure_float32=0
speed_failure_gpu=4
.
----------------------------------------------------------------------
Ran 1 test in 4018.430s

OK
executing nosetests with mode=FAST_RUN,floatX=float32
./part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py:68: UserWarning: The parameter 'updates' of theano.function() expects an OrderedDict, got <type 'dict'>. Using a standard dictionary here results in non-deterministic behavior. You should use an OrderedDict if you are using Python 2.7, or use a list of (shared, update) pairs. Do not just convert your dictionary to this type before the call as the conversion will still be non-deterministic.
updates=trainer.cd_updates())
EThe code for file logistic_sgd.pyc ran for 3.8s
.The code for file logistic_cg.pyc ran for 7.9s
.The code for file mlp.pyc ran for 0.16m
.The code for file convolutional_mlp.pyc ran for 0.22m
.The no corruption code for file dA.pyc ran for 0.30m
The 30% corruption code for file dA.pyc ran for 0.30m
.The pretraining code for file SdA.pyc ran for 1.72m
The training code for file SdA.pyc ran for 0.75m
.The pretraining code for file DBN.pyc ran for 2.33m
The fine tuning code for file DBN.pyc ran for 0.75m
...
======================================================================
ERROR: mcrbm.test_mcrbm.test_reproduce_ranzato_hinton_2010
----------------------------------------------------------------------
Traceback (most recent call last):
File "/opt/lisa/os/epd-7.1.2/lib/python2.7/site-packages/nose/case.py", line 187, in runTest
self.test(*self.arg)
File "/part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py", line 93, in test_reproduce_ranzato_hinton_2010
tile(imgs_fn(jj), "imgs_%06i.png" % jj)
File "/Tmp/nightly_build/Pylearn/pylearn/dataset_ops/image_patches.py", line 96, in save_filters_of_ranzato_hinton_2010
min_dynamic_range=min_dynamic_range)
File "/Tmp/nightly_build/Pylearn/pylearn/io/image_tiling.py", line 77, in tile_raster_images
raise NotImplementedError()
NotImplementedError:
-------------------- >> begin captured stdout << ---------------------
Learning...

--------------------- >> end captured stdout << ----------------------

----------------------------------------------------------------------
Ran 11 tests in 857.579s

FAILED (errors=1)
4443.73user 388.99system 1:21:20elapsed 99%CPU (0avgtext+0avgdata 1959868maxresident)k
201416inputs+2160outputs (402major+9220801minor)pagefaults 0swaps

li...@iro.umontreal.ca

unread,

May 19, 2013, 5:00:17 AM5/19/13

to theano-...@googlegroups.com

Summary of the output:

File "/part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py", line 93, in test_reproduce_ranzato_hinton_2010

Full output:

Sun May 19 02:41:38 EDT 2013

git version for Theano: b321e0790ac7296dd59f3b03219e483433d4bdab
git version: 3da5edbb800133e908e4f9b50373d2743b90f099
executing nosetests speed with mode=FAST_RUN

The code for file logistic_sgd.pyc ran for 10.1s

The code for file logistic_cg.pyc ran for 23.5s

The code for file mlp.pyc ran for 1.29m
The code for file convolutional_mlp.pyc ran for 1.21m

The no corruption code for file dA.pyc ran for 0.96m
The 30% corruption code for file dA.pyc ran for 0.97m
The pretraining code for file SdA.pyc ran for 2.99m
The training code for file SdA.pyc ran for 2.86m

The pretraining code for file DBN.pyc ran for 3.55m
The fine tuning code for file DBN.pyc ran for 2.79m

['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.08266449 23.49868727 77.74013519 72.77513862 116.91296101
352.85682631 381.93108964 543.57781172 186.60287189]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 1.02155536 1.00856698 1.00462907 1.01270848 0.99561245 0.98311829
0.9999186 1.02671593 0.99837692]
The code for file logistic_sgd.pyc ran for 11.5s
The code for file logistic_cg.pyc ran for 29.4s

The code for file mlp.pyc ran for 0.77m

The code for file convolutional_mlp.pyc ran for 1.10m

The no corruption code for file dA.pyc ran for 0.58m

The 30% corruption code for file dA.pyc ran for 0.59m

The pretraining code for file SdA.pyc ran for 1.71m

The training code for file SdA.pyc ran for 1.47m
The pretraining code for file DBN.pyc ran for 2.34m

The fine tuning code for file DBN.pyc ran for 1.50m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float32 times [ 11.50282001 29.52542424 46.3197782 66.19075036 71.02093863
191.4979353 230.96978736 431.4120996 176.53342724]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.08266449 23.49868727 77.74013519 72.77513862 116.91296101
352.85682631 381.93108964 543.57781172 186.60287189]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 1.02155536 1.00856698 1.00462907 1.01270848 0.99561245 0.98311829
0.9999186 1.02671593 0.99837692]
float32 times [ 11.50282001 29.52542424 46.3197782 66.19075036 71.02093863
191.4979353 230.96978736 431.4120996 176.53342724]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.00844836 1.00252581 1.01900315 1.0046721 0.99970518 0.99844419
0.98194661 1.00321711 0.99811125]
float64/float32 [ 0.87653849 0.79587975 1.67833565 1.09947596 1.64617595 1.84261426
1.65359762 1.25999668 1.05703988]
expected float64/float32 [ 0.8954326 0.80269803 1.68610479 1.11344863 1.63895328 1.81150778
1.65346301 1.29365866 1.05532421]

Using gpu device 0: GeForce GTX 285
The code for file logistic_sgd.pyc ran for 3.7s
The code for file logistic_cg.pyc ran for 10.2s
The code for file mlp.pyc ran for 0.48m
The code for file convolutional_mlp.pyc ran for 0.19m
The no corruption code for file dA.pyc ran for 0.19m
The 30% corruption code for file dA.pyc ran for 0.20m
The pretraining code for file SdA.pyc ran for 0.20m
The training code for file SdA.pyc ran for 0.12m
The pretraining code for file DBN.pyc ran for 0.81m
The fine tuning code for file DBN.pyc ran for 0.12m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

gpu times [ 3.68267417 10.15774274 29.02907515 11.81760979 23.99388504
19.89753723 56.79511786 300.68828893 321.35415506]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.835435 0.74379073 0.65424984 0.81234701 1.00567584 1.02525251
0.98600024 1.00635778 0.98147167]
float64/gpu [ 2.73786494 2.31337689 2.67800937 6.15819442 4.87261487
17.73369348 6.72471691 1.80777846 0.5806767 ]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.08266449 23.49868727 77.74013519 72.77513862 116.91296101
352.85682631 381.93108964 543.57781172 186.60287189]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.00844836 1.00252581 1.01900315 1.0046721 0.99970518 0.99844419
0.98194661 1.00321711 0.99811125]
gpu times [ 3.68267417 10.15774274 29.02907515 11.81760979 23.99388504
19.89753723 56.79511786 300.68828893 321.35415506]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.835435 0.74379073 0.65424984 0.81234701 1.00567584 1.02525251
0.98600024 1.00635778 0.98147167]
float64/float32 [ 0.87653849 0.79587975 1.67833565 1.09947596 1.64617595 1.84261426
1.65359762 1.25999668 1.05703988]
expected float64/float32 [ 0.8954326 0.80269803 1.68610479 1.11344863 1.63895328 1.81150778
1.65346301 1.29365866 1.05532421]
float64/gpu [ 2.73786494 2.31337689 2.67800937 6.15819442 4.87261487
17.73369348 6.72471691 1.80777846 0.5806767 ]
expected float64/gpu [ 2.79688062 2.33319553 2.69040607 6.23645571 4.85123605
17.43431843 6.72416951 1.85607495 0.57973422]
float32/gpu [ 3.12349654 2.90669148 1.59563396 5.6010269 2.95995994 9.62420289
4.06671904 1.43474859 0.54934229]
expected float32/gpu [ 3.14988497 2.91403324 1.62595604 5.62719545 2.95908728 9.60922941
3.99330098 1.43936434 0.54830472]

speed_failure_float64=0
speed_failure_float32=0
speed_failure_gpu=4
.
----------------------------------------------------------------------

Ran 1 test in 3986.729s

OK
executing nosetests with mode=FAST_RUN,floatX=float32
./part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py:68: UserWarning: The parameter 'updates' of theano.function() expects an OrderedDict, got <type 'dict'>. Using a standard dictionary here results in non-deterministic behavior. You should use an OrderedDict if you are using Python 2.7, or use a list of (shared, update) pairs. Do not just convert your dictionary to this type before the call as the conversion will still be non-deterministic.
updates=trainer.cd_updates())

EThe code for file logistic_sgd.pyc ran for 3.9s

.The code for file logistic_cg.pyc ran for 7.9s

.The code for file mlp.pyc ran for 0.15m

.The code for file convolutional_mlp.pyc ran for 0.22m

.The no corruption code for file dA.pyc ran for 0.29m

The 30% corruption code for file dA.pyc ran for 0.30m

.The pretraining code for file SdA.pyc ran for 1.68m
The training code for file SdA.pyc ran for 0.73m
.The pretraining code for file DBN.pyc ran for 2.28m
The fine tuning code for file DBN.pyc ran for 0.73m

...
======================================================================
ERROR: mcrbm.test_mcrbm.test_reproduce_ranzato_hinton_2010
----------------------------------------------------------------------
Traceback (most recent call last):
File "/opt/lisa/os/epd-7.1.2/lib/python2.7/site-packages/nose/case.py", line 187, in runTest
self.test(*self.arg)
File "/part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py", line 93, in test_reproduce_ranzato_hinton_2010
tile(imgs_fn(jj), "imgs_%06i.png" % jj)
File "/Tmp/nightly_build/Pylearn/pylearn/dataset_ops/image_patches.py", line 96, in save_filters_of_ranzato_hinton_2010
min_dynamic_range=min_dynamic_range)
File "/Tmp/nightly_build/Pylearn/pylearn/io/image_tiling.py", line 77, in tile_raster_images
raise NotImplementedError()
NotImplementedError:
-------------------- >> begin captured stdout << ---------------------
Learning...

--------------------- >> end captured stdout << ----------------------

----------------------------------------------------------------------

Ran 11 tests in 837.628s

FAILED (errors=1)
4410.36user 387.86system 1:20:30elapsed 99%CPU (0avgtext+0avgdata 1929740maxresident)k
186952inputs+2160outputs (849major+9204577minor)pagefaults 0swaps

li...@iro.umontreal.ca

unread,

May 20, 2013, 4:19:16 AM5/20/13

to theano-...@googlegroups.com

Summary of the output:

File "/part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py", line 93, in test_reproduce_ranzato_hinton_2010

Full output:

Mon May 20 01:59:04 EDT 2013

git version for Theano: b321e0790ac7296dd59f3b03219e483433d4bdab
git version: 3da5edbb800133e908e4f9b50373d2743b90f099
executing nosetests speed with mode=FAST_RUN

The code for file logistic_sgd.pyc ran for 10.0s
The code for file logistic_cg.pyc ran for 23.4s

The code for file mlp.pyc ran for 1.29m
The code for file convolutional_mlp.pyc ran for 1.21m

The no corruption code for file dA.pyc ran for 0.97m
The 30% corruption code for file dA.pyc ran for 0.98m
The pretraining code for file SdA.pyc ran for 3.00m
The training code for file SdA.pyc ran for 2.83m
The pretraining code for file DBN.pyc ran for 3.53m

The fine tuning code for file DBN.pyc ran for 2.79m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.04577541 23.40596032 77.94341636 72.82692599 117.13280797
350.80071688 380.28970408 548.83656907 183.39695144]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 1.02530662 1.0125626 1.00200894 1.01198834 0.99374379 0.98888053
1.00423439 1.0168783 1.01582932]
The code for file logistic_sgd.pyc ran for 11.4s
The code for file logistic_cg.pyc ran for 29.2s

The code for file mlp.pyc ran for 0.77m

The code for file convolutional_mlp.pyc ran for 1.09m

The no corruption code for file dA.pyc ran for 0.58m
The 30% corruption code for file dA.pyc ran for 0.59m
The pretraining code for file SdA.pyc ran for 1.71m
The training code for file SdA.pyc ran for 1.47m

The pretraining code for file DBN.pyc ran for 2.27m
The fine tuning code for file DBN.pyc ran for 1.47m

['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float32 times [ 11.43979859 29.23061538 46.39804101 65.79658365 71.10289335
191.51339746 225.05919123 424.15266299 175.88478875]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.04577541 23.40596032 77.94341636 72.82692599 117.13280797
350.80071688 380.28970408 548.83656907 183.39695144]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 1.02530662 1.0125626 1.00200894 1.01198834 0.99374379 0.98888053
1.00423439 1.0168783 1.01582932]
float32 times [ 11.43979859 29.23061538 46.39804101 65.79658365 71.10289335
191.51339746 225.05919123 424.15266299 175.88478875]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.01400387 1.01263691 1.01728433 1.01069077 0.99855289 0.99836357
1.00773489 1.02038732 1.00179215]
float64/float32 [ 0.87814268 0.80073444 1.67988593 1.10684966 1.64737049 1.83172938
1.68973194 1.29395997 1.0427107 ]
expected float64/float32 [ 0.9003655 0.81079374 1.68326072 1.12011895 1.63706418 1.81136153
1.69688693 1.31579983 1.0592161 ]

The no corruption code for file dA.pyc ran for 0.20m

The 30% corruption code for file dA.pyc ran for 0.20m
The pretraining code for file SdA.pyc ran for 0.20m
The training code for file SdA.pyc ran for 0.12m
The pretraining code for file DBN.pyc ran for 0.81m
The fine tuning code for file DBN.pyc ran for 0.12m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

gpu times [ 3.7089839 10.17006469 29.1739347 11.75526381 24.13850355
19.97447348 56.82919574 304.20338011 323.92978883]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.82950883 0.74288956 0.65100125 0.81665543 0.99965064 1.02130352
0.98540898 0.99472925 0.97366779]
float64/gpu [ 2.70849798 2.30145639 2.67167995 6.19526088 4.85252981
17.56245126 6.69180162 1.80417643 0.56616266]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.04577541 23.40596032 77.94341636 72.82692599 117.13280797
350.80071688 380.28970408 548.83656907 183.39695144]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.01400387 1.01263691 1.01728433 1.01069077 0.99855289 0.99836357
1.00773489 1.02038732 1.00179215]
gpu times [ 3.7089839 10.17006469 29.1739347 11.75526381 24.13850355
19.97447348 56.82919574 304.20338011 323.92978883]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.82950883 0.74288956 0.65100125 0.81665543 0.99965064 1.02130352
0.98540898 0.99472925 0.97366779]
float64/float32 [ 0.87814268 0.80073444 1.67988593 1.10684966 1.64737049 1.83172938
1.68973194 1.29395997 1.0427107 ]
expected float64/float32 [ 0.9003655 0.81079374 1.68326072 1.12011895 1.63706418 1.81136153
1.69688693 1.31579983 1.0592161 ]
float64/gpu [ 2.70849798 2.30145639 2.67167995 6.19526088 4.85252981
17.56245126 6.69180162 1.80417643 0.56616266]
expected float64/gpu [ 2.7770409 2.33036866 2.67704719 6.26953178 4.82217134
17.36716617 6.72013734 1.83462787 0.57512463]
float32/gpu [ 3.08434841 2.87418185 1.59039367 5.59720179 2.94562143 9.58790717
3.96027409 1.39430621 0.54297195]
expected float32/gpu [ 3.12754121 2.91050263 1.61788255 5.65704021 2.94135881 9.57221727
3.99090638 1.42273238 0.54394503]

speed_failure_float64=0
speed_failure_float32=0
speed_failure_gpu=4
.
----------------------------------------------------------------------

Ran 1 test in 3986.111s

EThe code for file logistic_sgd.pyc ran for 3.8s
.The code for file logistic_cg.pyc ran for 7.8s

.The code for file mlp.pyc ran for 0.15m
.The code for file convolutional_mlp.pyc ran for 0.22m
.The no corruption code for file dA.pyc ran for 0.29m
The 30% corruption code for file dA.pyc ran for 0.30m

.The pretraining code for file SdA.pyc ran for 1.72m
The training code for file SdA.pyc ran for 0.75m
.The pretraining code for file DBN.pyc ran for 2.32m

The fine tuning code for file DBN.pyc ran for 0.73m
...
======================================================================
ERROR: mcrbm.test_mcrbm.test_reproduce_ranzato_hinton_2010
----------------------------------------------------------------------
Traceback (most recent call last):
File "/opt/lisa/os/epd-7.1.2/lib/python2.7/site-packages/nose/case.py", line 187, in runTest
self.test(*self.arg)
File "/part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py", line 93, in test_reproduce_ranzato_hinton_2010
tile(imgs_fn(jj), "imgs_%06i.png" % jj)
File "/Tmp/nightly_build/Pylearn/pylearn/dataset_ops/image_patches.py", line 96, in save_filters_of_ranzato_hinton_2010
min_dynamic_range=min_dynamic_range)
File "/Tmp/nightly_build/Pylearn/pylearn/io/image_tiling.py", line 77, in tile_raster_images
raise NotImplementedError()
NotImplementedError:
-------------------- >> begin captured stdout << ---------------------
Learning...

--------------------- >> end captured stdout << ----------------------

----------------------------------------------------------------------

Ran 11 tests in 846.635s

FAILED (errors=1)
4413.88user 385.30system 1:20:37elapsed 99%CPU (0avgtext+0avgdata 1960136maxresident)k
175152inputs+2168outputs (389major+9243919minor)pagefaults 0swaps

li...@iro.umontreal.ca

unread,

May 22, 2013, 5:19:17 AM5/22/13

to theano-...@googlegroups.com

Summary of the output:

File "/part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py", line 93, in test_reproduce_ranzato_hinton_2010

Full output:

Wed May 22 02:58:51 EDT 2013
git version for Theano: 3a9aa1ebb0c4540d32fc4b6d7836f30b11d65fb6

git version: 3da5edbb800133e908e4f9b50373d2743b90f099
executing nosetests speed with mode=FAST_RUN

The code for file logistic_sgd.pyc ran for 10.3s
The code for file logistic_cg.pyc ran for 23.5s
The code for file mlp.pyc ran for 1.30m

The code for file convolutional_mlp.pyc ran for 1.21m

The no corruption code for file dA.pyc ran for 0.96m
The 30% corruption code for file dA.pyc ran for 0.97m

The pretraining code for file SdA.pyc ran for 3.00m

The training code for file SdA.pyc ran for 2.87m
The pretraining code for file DBN.pyc ran for 3.62m
The fine tuning code for file DBN.pyc ran for 2.80m

['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.3305769 23.53049183 78.23511481 72.92705154 116.77737784
354.45968795 386.56196475 555.31286287 185.22567868]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 0.99704016 1.00720377 0.99827296 1.01059893 0.9967684 0.97867264
0.98793993 1.00501904 1.00580007]
The code for file logistic_sgd.pyc ran for 11.3s
The code for file logistic_cg.pyc ran for 29.3s
The code for file mlp.pyc ran for 0.76m
The code for file convolutional_mlp.pyc ran for 1.08m

The no corruption code for file dA.pyc ran for 0.58m

The 30% corruption code for file dA.pyc ran for 0.60m
The pretraining code for file SdA.pyc ran for 1.68m

The training code for file SdA.pyc ran for 1.47m

The pretraining code for file DBN.pyc ran for 2.31m

The fine tuning code for file DBN.pyc ran for 1.47m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float32 times [ 11.44419312 29.35876107 45.81941199 65.28311539 70.81742477
189.19532371 226.96850014 424.39387488 176.96966815]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.3305769 23.53049183 78.23511481 72.92705154 116.77737784
354.45968795 386.56196475 555.31286287 185.22567868]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 0.99704016 1.00720377 0.99827296 1.01059893 0.9967684 0.97867264
0.98793993 1.00501904 1.00580007]
float32 times [ 11.44419312 29.35876107 45.81941199 65.28311539 70.81742477
189.19532371 226.96850014 424.39387488 176.96966815]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.01361449 1.00821693 1.03013107 1.01864011 1.00257811 1.0105958
0.99925761 1.01980737 0.99565085]
float64/float32 [ 0.90269159 0.80148109 1.70746658 1.11708902 1.64899215 1.87351189
1.70315248 1.30848463 1.04665212]
expected float64/float32 [ 0.90001976 0.80725477 1.70451773 1.12892897 1.64366327 1.83355483
1.68261234 1.31505197 1.05272277]

Using gpu device 0: GeForce GTX 285
The code for file logistic_sgd.pyc ran for 3.7s

The code for file logistic_cg.pyc ran for 10.1s

The code for file mlp.pyc ran for 0.48m
The code for file convolutional_mlp.pyc ran for 0.19m

The no corruption code for file dA.pyc ran for 0.19m

The 30% corruption code for file dA.pyc ran for 0.20m
The pretraining code for file SdA.pyc ran for 0.20m
The training code for file SdA.pyc ran for 0.12m

The pretraining code for file DBN.pyc ran for 0.82m

The fine tuning code for file DBN.pyc ran for 0.12m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

gpu times [ 3.68888378 10.0365355 29.05371261 11.76068997 23.76164293
19.78212571 56.96815801 300.41036344 323.98659229]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.83402868 0.7527732 0.65369504 0.81627864 1.01550514 1.03123397
0.98300528 1.00728882 0.97349708]
float64/gpu [ 2.80046147 2.34448349 2.69277513 6.20091608 4.91453298
17.91817993 6.78557949 1.84851433 0.57170785]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.3305769 23.53049183 78.23511481 72.92705154 116.77737784
354.45968795 386.56196475 555.31286287 185.22567868]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.01361449 1.00821693 1.03013107 1.01864011 1.00257811 1.0105958
0.99925761 1.01980737 0.99565085]
gpu times [ 3.68888378 10.0365355 29.05371261 11.76068997 23.76164293
19.78212571 56.96815801 300.41036344 323.98659229]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.83402868 0.7527732 0.65369504 0.81627864 1.01550514 1.03123397
0.98300528 1.00728882 0.97349708]
float64/float32 [ 0.90269159 0.80148109 1.70746658 1.11708902 1.64899215 1.87351189
1.70315248 1.30848463 1.04665212]
expected float64/float32 [ 0.90001976 0.80725477 1.70451773 1.12892897 1.64366327 1.83355483
1.68261234 1.31505197 1.05272277]
float64/gpu [ 2.80046147 2.34448349 2.69277513 6.20091608 4.91453298
17.91817993 6.78557949 1.84851433 0.57170785]
expected float64/gpu [ 2.79217254 2.36137261 2.68812461 6.26663913 4.89865117
17.53603253 6.70374492 1.8577921 0.5750238 ]
float32/gpu [ 3.10234581 2.92518878 1.57705876 5.55095964 2.98032527 9.56395316
3.98412917 1.41271383 0.54622528]
expected float32/gpu [ 3.14458267 2.94922486 1.62457723 5.65443015 2.98800888 9.66529092
3.98117138 1.44069597 0.54384967]

speed_failure_float64=0
speed_failure_float32=0
speed_failure_gpu=4
.
----------------------------------------------------------------------

Ran 1 test in 4010.586s

EThe code for file logistic_sgd.pyc ran for 3.9s
.The code for file logistic_cg.pyc ran for 7.9s

.The pretraining code for file SdA.pyc ran for 1.69m
The training code for file SdA.pyc ran for 0.73m
.The pretraining code for file DBN.pyc ran for 2.28m

Ran 11 tests in 839.746s

FAILED (errors=1)
4421.31user 386.25system 1:20:58elapsed 98%CPU (0avgtext+0avgdata 1966484maxresident)k
284032inputs+12488outputs (570major+9218719minor)pagefaults 0swaps

li...@iro.umontreal.ca

unread,

May 23, 2013, 5:43:59 AM5/23/13

to theano-...@googlegroups.com

Summary of the output:

File "/part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py", line 93, in test_reproduce_ranzato_hinton_2010

Full output:

Thu May 23 03:01:29 EDT 2013

git version for Theano: 3a9aa1ebb0c4540d32fc4b6d7836f30b11d65fb6
git version: 3da5edbb800133e908e4f9b50373d2743b90f099
executing nosetests speed with mode=FAST_RUN

The code for file logistic_sgd.pyc ran for 10.1s
The code for file logistic_cg.pyc ran for 23.3s
The code for file mlp.pyc ran for 1.29m
The code for file convolutional_mlp.pyc ran for 1.18m
The no corruption code for file dA.pyc ran for 0.95m
The 30% corruption code for file dA.pyc ran for 0.96m
The pretraining code for file SdA.pyc ran for 2.94m
The training code for file SdA.pyc ran for 2.80m
The pretraining code for file DBN.pyc ran for 3.52m

The fine tuning code for file DBN.pyc ran for 2.80m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.1075201 23.38249922 77.83258033 70.87922716 114.6037972
345.02508235 380.74556804 543.56464052 186.33658719]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 1.01904324 1.01357856 1.00343583 1.03979689 1.01567315 1.00543415
1.00303203 1.02674081 0.99980365]
The code for file logistic_sgd.pyc ran for 11.4s
The code for file logistic_cg.pyc ran for 29.2s
The code for file mlp.pyc ran for 0.77m

The code for file convolutional_mlp.pyc ran for 1.08m
The no corruption code for file dA.pyc ran for 0.58m

The 30% corruption code for file dA.pyc ran for 0.59m
The pretraining code for file SdA.pyc ran for 1.71m
The training code for file SdA.pyc ran for 1.49m
The pretraining code for file DBN.pyc ran for 2.32m
The fine tuning code for file DBN.pyc ran for 1.49m

['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float32 times [ 11.50772619 29.33413768 46.4060061 65.16748047 70.65116811
192.85625696 229.65583873 426.8244741 172.97830319]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.1075201 23.38249922 77.83258033 70.87922716 114.6037972
345.02508235 380.74556804 543.56464052 186.33658719]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 1.01904324 1.01357856 1.00343583 1.03979689 1.01567315 1.00543415
1.00303203 1.02674081 0.99980365]
float32 times [ 11.50772619 29.33413768 46.4060061 65.16748047 70.65116811
192.85625696 229.65583873 426.8244741 172.97830319]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.00801842 1.00906324 1.01710972 1.02044761 1.00493738 0.99141196
0.9875647 1.01399996 1.01862486]
float64/float32 [ 0.8783247 0.7971088 1.6772092 1.08764719 1.62210761 1.78902716
1.65789631 1.2735086 1.0772252 ]
expected float64/float32 [ 0.89505084 0.80793239 1.68297181 1.13093217 1.64753115 1.798749
1.6629231 1.30756326 1.07701369]

Using gpu device 0: GeForce GTX 285

The code for file logistic_sgd.pyc ran for 3.6s
The code for file logistic_cg.pyc ran for 10.2s

The code for file mlp.pyc ran for 0.48m
The code for file convolutional_mlp.pyc ran for 0.19m
The no corruption code for file dA.pyc ran for 0.19m
The 30% corruption code for file dA.pyc ran for 0.20m
The pretraining code for file SdA.pyc ran for 0.20m
The training code for file SdA.pyc ran for 0.12m
The pretraining code for file DBN.pyc ran for 0.82m
The fine tuning code for file DBN.pyc ran for 0.12m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

gpu times [ 3.63977003 10.15534115 29.15650249 11.74259329 23.98711848
19.88359404 57.03653383 299.02136135 324.25631189]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.84528277 0.74396663 0.65139047 0.81753662 1.00595953 1.02597146
0.98182684 1.01196784 0.97268731]
float64/gpu [ 2.77696668 2.30248289 2.66947589 6.03607955 4.77772256
17.35224938 6.6754682 1.81781207 0.57465832]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.1075201 23.38249922 77.83258033 70.87922716 114.6037972
345.02508235 380.74556804 543.56464052 186.33658719]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.00801842 1.00906324 1.01710972 1.02044761 1.00493738 0.99141196
0.9875647 1.01399996 1.01862486]
gpu times [ 3.63977003 10.15534115 29.15650249 11.74259329 23.98711848
19.88359404 57.03653383 299.02136135 324.25631189]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.84528277 0.74396663 0.65139047 0.81753662 1.00595953 1.02597146
0.98182684 1.01196784 0.97268731]
float64/float32 [ 0.8783247 0.7971088 1.6772092 1.08764719 1.62210761 1.78902716
1.65789631 1.2735086 1.0772252 ]
expected float64/float32 [ 0.89505084 0.80793239 1.68297181 1.13093217 1.64753115 1.798749
1.6629231 1.30756326 1.07701369]
float64/gpu [ 2.77696668 2.30248289 2.66947589 6.03607955 4.77772256
17.35224938 6.6754682 1.81781207 0.57465832]
expected float64/gpu [ 2.82984911 2.3337473 2.67864776 6.27629674 4.85260454
17.44654409 6.69570842 1.86642184 0.57454549]
float32/gpu [ 3.16166299 2.88854281 1.59161772 5.54966683 2.94537954 9.69926547
4.02646906 1.42740462 0.53346164]
expected float32/gpu [ 3.18701454 2.91472237 1.61884986 5.66314428 2.95992201 9.6159678
3.97639872 1.44738823 0.54339729]

speed_failure_float64=0
speed_failure_float32=0
speed_failure_gpu=4
.
----------------------------------------------------------------------

Ran 1 test in 3984.071s

.The code for file convolutional_mlp.pyc ran for 0.21m

.The no corruption code for file dA.pyc ran for 0.29m

The 30% corruption code for file dA.pyc ran for 0.29m
.The pretraining code for file SdA.pyc ran for 1.68m

The training code for file SdA.pyc ran for 0.73m

.The pretraining code for file DBN.pyc ran for 2.27m

Ran 11 tests in 836.396s

FAILED (errors=1)
4393.45user 385.26system 1:20:29elapsed 98%CPU (0avgtext+0avgdata 1966496maxresident)k
358232inputs+12488outputs (843major+9199440minor)pagefaults 0swaps

li...@iro.umontreal.ca

unread,

May 25, 2013, 5:25:53 AM5/25/13

to theano-...@googlegroups.com

Summary of the output:

File "/part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py", line 93, in test_reproduce_ranzato_hinton_2010

Full output:

Sat May 25 02:53:23 EDT 2013
git version for Theano: ce660543c9112cdf466c728654b42ab6cd263de4

git version: 3da5edbb800133e908e4f9b50373d2743b90f099
executing nosetests speed with mode=FAST_RUN
The code for file logistic_sgd.pyc ran for 10.1s

The code for file logistic_cg.pyc ran for 23.2s

The code for file mlp.pyc ran for 1.29m

The code for file convolutional_mlp.pyc ran for 1.19m
The no corruption code for file dA.pyc ran for 0.96m
The 30% corruption code for file dA.pyc ran for 0.98m
The pretraining code for file SdA.pyc ran for 2.95m

The training code for file SdA.pyc ran for 2.80m

The pretraining code for file DBN.pyc ran for 3.63m
The fine tuning code for file DBN.pyc ran for 2.85m

['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.12334561 23.18976045 77.68424368 71.65172172 117.53044248
345.64487934 390.33101296 544.10128045 186.44436049]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 1.0174502 1.0220028 1.00535187 1.02858659 0.9903817 1.00363124
0.97840035 1.02572815 0.99922572]

The code for file logistic_sgd.pyc ran for 11.4s
The code for file logistic_cg.pyc ran for 29.2s

The code for file mlp.pyc ran for 0.76m

The code for file convolutional_mlp.pyc ran for 1.08m
The no corruption code for file dA.pyc ran for 0.58m
The 30% corruption code for file dA.pyc ran for 0.59m
The pretraining code for file SdA.pyc ran for 1.71m

The training code for file SdA.pyc ran for 1.51m
The pretraining code for file DBN.pyc ran for 2.30m
The fine tuning code for file DBN.pyc ran for 1.47m

['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float32 times [ 11.4646349 29.29351425 45.67913222 64.96807885 70.90399718
193.49690986 226.55261374 423.22779036 174.0965023 ]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.12334561 23.18976045 77.68424368 71.65172172 117.53044248
345.64487934 390.33101296 544.10128045 186.44436049]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 1.0174502 1.0220028 1.00535187 1.02858659 0.9903817 1.00363124
0.97840035 1.02572815 0.99922572]
float32 times [ 11.4646349 29.29351425 45.67913222 64.96807885 70.90399718
193.49690986 226.55261374 423.22779036 174.0965023 ]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.01180719 1.01046258 1.03329459 1.0235796 1.00135398 0.98812948
1.00109196 1.02261716 1.01208237]
float64/float32 [ 0.88300637 0.79163463 1.7006506 1.1028758 1.65759967 1.78630697
1.72291551 1.28559913 1.07092537]
expected float64/float32 [ 0.898415 0.80905281 1.70975227 1.13440325 1.64165639 1.79279349
1.68570114 1.31867522 1.07009617]

Using gpu device 0: GeForce GTX 285

The code for file logistic_sgd.pyc ran for 3.7s

The code for file logistic_cg.pyc ran for 10.2s
The code for file mlp.pyc ran for 0.48m
The code for file convolutional_mlp.pyc ran for 0.19m
The no corruption code for file dA.pyc ran for 0.19m
The 30% corruption code for file dA.pyc ran for 0.20m
The pretraining code for file SdA.pyc ran for 0.20m
The training code for file SdA.pyc ran for 0.12m
The pretraining code for file DBN.pyc ran for 0.82m
The fine tuning code for file DBN.pyc ran for 0.12m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

gpu times [ 3.68033648 10.16232729 29.209409 11.76954198 24.03148341
19.88730597 57.4339664 303.32979894 318.91999483]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.83596565 0.74345518 0.65021062 0.81566471 1.00410241 1.02577996
0.97503278 0.99759404 0.98896277]
float64/gpu [ 2.75065763 2.28193403 2.65956232 6.08789381 4.89068612
17.38017607 6.79617024 1.79376139 0.5846117 ]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.12334561 23.18976045 77.68424368 71.65172172 117.53044248
345.64487934 390.33101296 544.10128045 186.44436049]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.01180719 1.01046258 1.03329459 1.0235796 1.00135398 0.98812948
1.00109196 1.02261716 1.01208237]
gpu times [ 3.68033648 10.16232729 29.209409 11.76954198 24.03148341
19.88730597 57.4339664 303.32979894 318.91999483]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.83596565 0.74345518 0.65021062 0.81566471 1.00410241 1.02577996
0.97503278 0.99759404 0.98896277]
float64/float32 [ 0.88300637 0.79163463 1.7006506 1.1028758 1.65759967 1.78630697
1.72291551 1.28559913 1.07092537]
expected float64/float32 [ 0.898415 0.80905281 1.70975227 1.13440325 1.64165639 1.79279349
1.68570114 1.31867522 1.07009617]
float64/gpu [ 2.75065763 2.28193403 2.65956232 6.08789381 4.89068612
17.38017607 6.79617024 1.79376139 0.5846117 ]
expected float64/gpu [ 2.79865715 2.33214296 2.67379597 6.26192592 4.84364606
17.44328772 6.64937534 1.83991155 0.58415905]
float32/gpu [ 3.11510509 2.88255962 1.56384993 5.5200176 2.95046277 9.72966927
3.94457545 1.39527271 0.54589397]
expected float32/gpu [ 3.15188573 2.91271863 1.61591767 5.65017739 2.95445765 9.61417299
3.94888276 1.42682981 0.55248966]

speed_failure_float64=0
speed_failure_float32=0
speed_failure_gpu=4
.
----------------------------------------------------------------------

Ran 1 test in 3988.351s

.The code for file logistic_cg.pyc ran for 7.8s

.The code for file mlp.pyc ran for 0.15m

.The code for file convolutional_mlp.pyc ran for 0.22m

.The no corruption code for file dA.pyc ran for 0.29m
The 30% corruption code for file dA.pyc ran for 0.29m
.The pretraining code for file SdA.pyc ran for 1.68m
The training code for file SdA.pyc ran for 0.73m

.The pretraining code for file DBN.pyc ran for 2.28m

Ran 11 tests in 841.056s

FAILED (errors=1)
4403.46user 385.78system 1:20:34elapsed 99%CPU (0avgtext+0avgdata 1960156maxresident)k
220408inputs+2168outputs (422major+9234413minor)pagefaults 0swaps

li...@iro.umontreal.ca

unread,

May 26, 2013, 7:30:35 AM5/26/13

to theano-...@googlegroups.com

Summary of the output:

File "/part/01/Tmp/nightly_build/DeepLearningTutorials/code/mcrbm/test_mcrbm.py", line 93, in test_reproduce_ranzato_hinton_2010

Full output:

Sun May 26 04:30:48 EDT 2013
git version for Theano: 413f34ac92b6d50929f7b9b4513c25ec94ef7af2

git version: 3da5edbb800133e908e4f9b50373d2743b90f099
executing nosetests speed with mode=FAST_RUN
The code for file logistic_sgd.pyc ran for 10.1s

The code for file logistic_cg.pyc ran for 23.6s
The code for file mlp.pyc ran for 1.30m

The code for file convolutional_mlp.pyc ran for 1.19m

The no corruption code for file dA.pyc ran for 0.97m
The 30% corruption code for file dA.pyc ran for 0.96m
The pretraining code for file SdA.pyc ran for 2.94m
The training code for file SdA.pyc ran for 2.81m
The pretraining code for file DBN.pyc ran for 3.58m
The fine tuning code for file DBN.pyc ran for 2.81m

['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.15311766 23.6467371 78.45909715 71.73077106 116.53713703
345.8605473 384.09433866 544.79768801 185.87533355]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 1.01446672 1.00225244 0.99542313 1.02745306 0.99882323 1.00300541
0.99428698 1.02441698 1.00228468]
The code for file logistic_sgd.pyc ran for 11.5s
The code for file logistic_cg.pyc ran for 29.3s

The code for file mlp.pyc ran for 0.76m

The code for file convolutional_mlp.pyc ran for 1.10m

The no corruption code for file dA.pyc ran for 0.58m

The 30% corruption code for file dA.pyc ran for 0.60m
The pretraining code for file SdA.pyc ran for 1.72m
The training code for file SdA.pyc ran for 1.50m

The pretraining code for file DBN.pyc ran for 2.28m

The fine tuning code for file DBN.pyc ran for 1.47m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float32 times [ 11.5655303 29.36856556 46.087183 66.34652233 71.14038396
194.2010901 225.60880685 428.27178907 175.38134432]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.15311766 23.6467371 78.45909715 71.73077106 116.53713703
345.8605473 384.09433866 544.79768801 185.87533355]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float64 % expected/get [ 1.01446672 1.00225244 0.99542313 1.02745306 0.99882323 1.00300541
0.99428698 1.02441698 1.00228468]
float32 times [ 11.5655303 29.36856556 46.087183 66.34652233 71.14038396
194.2010901 225.60880685 428.27178907 175.38134432]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.00298038 1.00788035 1.02414591 1.00231327 0.99802666 0.98454648
1.00527991 1.01057322 1.00466786]
float64/float32 [ 0.8778774 0.80517167 1.70240601 1.08115344 1.63812915 1.7809403
1.70247937 1.27208399 1.05983527]
expected float64/float32 [ 0.89057741 0.80698528 1.69461431 1.11083441 1.63620146 1.78629275
1.69275307 1.30314444 1.06225665]

Using gpu device 0: GeForce GTX 285
The code for file logistic_sgd.pyc ran for 3.7s

The code for file logistic_cg.pyc ran for 10.3s

The pretraining code for file DBN.pyc ran for 0.81m

The fine tuning code for file DBN.pyc ran for 0.12m
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

gpu times [ 3.66400051 10.23268127 29.12409735 11.75819492 24.06895399
19.87442684 56.63605714 300.90430427 317.48483944]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.83969281 0.73834362 0.65211524 0.81645185 1.00253922 1.0264447
0.9887694 1.00563533 0.99343326]
float64/gpu [ 2.77104701 2.31090332 2.69395807 6.10049174 4.84180314
17.40229039 6.7817987 1.81053471 0.58546208]

Duplicate the timing to have everything in one place
['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp', 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']

float64 times [ 10.15311766 23.6467371 78.45909715 71.73077106 116.53713703
345.8605473 384.09433866 544.79768801 185.87533355]

float64 expected [10.300000000000001, 23.699999999999999, 78.099999999999994, 73.700000000000003, 116.40000000000001, 346.89999999999998, 381.89999999999998, 558.10000000000002, 186.30000000000001]

float32 expected [11.6, 29.600000000000001, 47.200000000000003, 66.5, 71.0, 191.19999999999999, 226.80000000000001, 432.80000000000001, 176.19999999999999]

float32 % expected/get [ 1.00298038 1.00788035 1.02414591 1.00231327 0.99802666 0.98454648
1.00527991 1.01057322 1.00466786]
gpu times [ 3.66400051 10.23268127 29.12409735 11.75819492 24.06895399
19.87442684 56.63605714 300.90430427 317.48483944]

gpu expected [3.0766348799999998, 7.5552349100000002, 18.992267850000001, 9.5999999999999996, 24.130070450000002, 20.399999999999999, 56.0, 302.60000000000002, 315.39999999999998]

gpu % expected/get [ 0.83969281 0.73834362 0.65211524 0.81645185 1.00253922 1.0264447
0.9887694 1.00563533 0.99343326]
float64/float32 [ 0.8778774 0.80517167 1.70240601 1.08115344 1.63812915 1.7809403
1.70247937 1.27208399 1.05983527]
expected float64/float32 [ 0.89057741 0.80698528 1.69461431 1.11083441 1.63620146 1.78629275
1.69275307 1.30314444 1.06225665]
float64/gpu [ 2.77104701 2.31090332 2.69395807 6.10049174 4.84180314
17.40229039 6.7817987 1.81053471 0.58546208]
expected float64/gpu [ 2.81113498 2.31610849 2.68162817 6.26796889 4.83610547
17.45459141 6.74305415 1.85474249 0.58679967]
float32/gpu [ 3.15653076 2.87007528 1.58244159 5.64257718 2.95569072 9.77140582
3.98348364 1.42328236 0.55240856]
expected float32/gpu [ 3.16593842 2.89269246 1.62065109 5.65563 2.94985815 9.62040322
4.00451605 1.43833104 0.55498713]

speed_failure_float64=0
speed_failure_float32=0
speed_failure_gpu=4
.
----------------------------------------------------------------------

Ran 1 test in 4092.195s

.The code for file logistic_cg.pyc ran for 7.9s

.The code for file mlp.pyc ran for 0.15m
.The code for file convolutional_mlp.pyc ran for 0.22m
.The no corruption code for file dA.pyc ran for 0.29m

The 30% corruption code for file dA.pyc ran for 0.30m
.The pretraining code for file SdA.pyc ran for 1.73m
The training code for file SdA.pyc ran for 0.74m

.The pretraining code for file DBN.pyc ran for 2.28m

The fine tuning code for file DBN.pyc ran for 0.74m

Ran 11 tests in 878.696s

FAILED (errors=1)
4522.19user 407.98system 1:22:58elapsed 99%CPU (0avgtext+0avgdata 1960416maxresident)k
318896inputs+267432outputs (770major+15341113minor)pagefaults 0swaps

Reply all

Reply to author

Forward

0 new messages