def test_imageshape(): from hdl.learners import SGD whitenpatches = 100 model = ConvSparseSlowModel(imshp=(whitenpatches,1,64,64),convwhitenfiltershp=(7,7),N=16,kshp=(5,5),perc_var=100.) l = SGD(model=model,datasource='vid075-chunks',display_every=100,save_every=10000,batchsize=model.imshp[0]) print 'whitenpatches', whitenpatches print 'model.imshp', model.imshp print 'model.convwhitenfiltershp', model.convwhitenfiltershp databatch = l.get_databatch(whitenpatches) from matplotlib import pyplot as plt images = np.transpose(databatch).reshape(l.model.imshp) plt.figure(1) for ind in range(100): plt.subplot(10,10,ind) im = np.squeeze(images[ind,0,:,:]) plt.imshow(im,interpolation='nearest',cmap=plt.cm.gray) plt.axis('off') plt.draw() plt.show()
def test_3Dvideo(): from matplotlib import pyplot as plt test_name = '3Dvideo' psz = 16 l = SGD(model=SparseSlowModel(patch_sz=psz,D=6*psz*psz,N=400,T=48),datasource='3Dvideo_color',batchsize=48) batchsize = 48 databatch = l.get_databatch(batchsize) batchsize = 1000 databatch = l.get_databatch(batchsize) from hdl.config import tests_dir, tstring savepath = os.path.join(tests_dir,test_name,tstring()) if not os.path.isdir(savepath): os.makedirs(savepath) vidind = np.random.randint(l.video_buffer) video = l.videos[vidind] for tt in range(video.shape[0]): plt.figure(1) plt.clf() plt.subplot(1,2,1) frame = np.uint8(video[tt,:3,:,:].T) plt.imshow(frame,interpolation='nearest') plt.subplot(1,2,2) frame = np.uint8(video[tt,3:,:,:].T) plt.imshow(frame,interpolation='nearest') fname = os.path.join(savepath, 'vid_' + str(vidind) + '_frame_%04d'%tt + '.png') plt.savefig(fname) batchsize = 48 databatch = l.get_databatch(batchsize) for tt in range(batchsize): plt.figure(1) plt.clf() plt.subplot(1,2,1) frame_both = np.uint8(databatch[...,tt].reshape(6,l.model.patch_sz,l.model.patch_sz)).T frame = frame_both[...,:3] plt.imshow(frame,interpolation='nearest') plt.subplot(1,2,2) frame = frame_both[...,3:] plt.imshow(frame,interpolation='nearest') fname = os.path.join(savepath, 'databatch_frame_%04d'%tt + '.png') plt.savefig(fname) # test multiple loads for tt in range(1000): if not tt%100: print tt, databatch = l.get_databatch(batchsize)
def test_YouTubeFaces(): from matplotlib import pyplot as plt test_name = 'YouTubeFaces' l = SGD(model=SparseSlowModel(patch_sz=48,N=400,T=64),datasource='YouTubeFaces_aligned',batchsize=64) batchsize = 64 databatch = l.get_databatch(batchsize) batchsize = 1000 databatch = l.get_databatch(batchsize) from hdl.config import tests_dir, tstring savepath = os.path.join(tests_dir,test_name,tstring()) if not os.path.isdir(savepath): os.makedirs(savepath) vidind = int(np.floor(np.random.rand()*l.YouTubeInfo['num_videos'])) video = l.YouTubeInfo['videos'][vidind] hval = np.abs(video).max() for tt in range(video.shape[2]): plt.figure(1) plt.clf() plt.imshow(video[:,:,tt],cmap=plt.cm.gray,vmin=-hval,vmax=hval,interpolation='nearest') fname = os.path.join(savepath, 'vid_' + str(vidind) + '_frame_%04d'%tt + '.png') plt.savefig(fname) batchsize = 64 databatch = l.get_databatch(batchsize) hval = np.abs(databatch).max() for tt in range(batchsize): plt.figure(1) plt.clf() plt.imshow(databatch[...,tt].reshape(l.model.patch_sz,l.model.patch_sz),cmap=plt.cm.gray,vmin=-hval,vmax=hval,interpolation='nearest') fname = os.path.join(savepath, 'databatch_frame_%04d'%tt + '.png') plt.savefig(fname) # test multiple loads for tt in range(100): databatch = l.get_databatch(batchsize)
def setup_model(patch_sz,M,N,NN,D,T, sparse_cost,slow_cost, lam_sparse,lam_slow,lam_l2, inputmean,whitenmatrix,dewhitenmatrix,zerophasewhitenmatrix,A, datasource,batchsize): import numpy as np import theano from hdl.models import SparseSlowModel from hdl.learners import SGD global l l = SGD(model=SparseSlowModel()) l.model.patch_sz = patch_sz l.model.M = M l.model.D = D l.model.N = N l.model.NN = NN l.model.T = T l.model.sparse_cost = sparse_cost l.model.slow_cost = slow_cost l.model.inputmean = inputmean l.model.whitenmatrix = whitenmatrix l.model.dewhitenmatrix = dewhitenmatrix l.model.zerophasewhitenmatrix = zerophasewhitenmatrix l.datasource = datasource l.batchsize = batchsize old_type = type(A) l.model.A = theano.shared(A.astype(theano.config.floatX)) l.model.lam_sparse = theano.shared(getattr(np,theano.config.floatX)(lam_sparse)) l.model.lam_slow = theano.shared(getattr(np,theano.config.floatX)(lam_slow)) l.model.lam_l2 = theano.shared(getattr(np,theano.config.floatX)(lam_l2)) #l.model._reset_on_load() new_type = type(l.model.A) l.model.setup(init=False) return old_type, new_type, type(l.model.lam_sparse), l.model.lam_sparse.get_value()
def debug_convsparsenet(lam_sparse=.1,N=16,perc_var=100.,stride=1,kshp=(7,7),batchsize=4,imsz=(64,64)): from hdl.learners import SGD whitenpatches = 100 if isinstance(kshp,int): kshp = (kshp,kshp) if isinstance(stride,int): stride = (stride,stride) imszr = imsz[0] imszc = imsz[1] #model = ConvWhitenInputModel(imshp=(10,1,32,32),convwhitenfiltershp=(7,7),perc_var=100.) model = ConvSparseSlowModel(imshp=(batchsize,1,imszr,imszc),convwhitenfiltershp=(7,7),N=N,kshp=kshp,stride=stride, perc_var=perc_var,lam_sparse=lam_sparse) l = SGD(model=model,datasource='vid075-chunks',display_every=50,save_every=10000,batchsize=model.imshp[0]) print 'whitenpatches', whitenpatches print 'model.imshp', model.imshp print 'model.convwhitenfiltershp', model.convwhitenfiltershp databatch = l.get_databatch(whitenpatches) l.model.learn_whitening(databatch) l.model.setup() l.learn(iterations=10) l.model.center_basis_functions = False l.learn(iterations=10)
def test_vid075(): from matplotlib import pyplot as plt test_name = 'vid075' l = SGD(model=SparseSlowModel(patch_sz=20,N=400,T=64),datasource='vid075-chunks',batchsize=64) batchsize = 64 databatch = l.get_databatch(batchsize) batchsize = 1000 databatch = l.get_databatch(batchsize) from hdl.config import tests_dir, tstring savepath = os.path.join(tests_dir,test_name,tstring()) if not os.path.isdir(savepath): os.makedirs(savepath) vidind = np.floor(np.random.rand()*l.nvideos) hval = np.abs(l.videos[vidind,...]).max() for tt in range(l.videot): plt.figure(1) plt.clf() plt.imshow(l.videos[vidind,:,:,tt],cmap=plt.cm.gray,vmin=-hval,vmax=hval,interpolation='nearest') fname = os.path.join(savepath, 'vid_' + str(vidind) + '_frame_'+ str(tt) + '.png') plt.savefig(fname) batchsize = 64 databatch = l.get_databatch(batchsize) hval = np.abs(databatch).max() for tt in range(batchsize): plt.figure(1) plt.clf() plt.imshow(databatch[...,tt].reshape(l.model.patch_sz,l.model.patch_sz),cmap=plt.cm.gray,vmin=-hval,vmax=hval,interpolation='nearest') fname = os.path.join(savepath, 'databatch_' + str(vidind) + '_frame_'+ str(tt) + '.png') plt.savefig(fname)
import numpy as np import hdl from hdl.models import SparseSlowModel from hdl.learners import SGD from hdl.display import display_final whitenpatches = 160000 l = SGD(model=SparseSlowModel(patch_sz=2,N=8,T=16,sparse_cost='l1',slow_cost=None,perc_var=99.9), datasource='berkeleysegmentation',batchsize=16,save_every=20000,display_every=100, eta_target_maxupdate=.02) def learn_loop(l,iterations=20000): print 'Start learn_loop with %d iterations'%iterations l.learn(iterations=int(np.ceil(.9*iterations))) l.change_target(.5) l.learn(iterations=int(np.ceil(.05*iterations))) l.change_target(.5) l.learn(iterations=int(np.ceil(.05*iterations))) return l def double_model(l): newN = 2*l.model.N A = l.model.A.get_value() newA = np.zeros((A.shape[0],newN)) avgA = np.zeros_like(A) avgA[:,:-1] = .5*(A[:,:-1] + A[:,1:]) avgA[:,-1] = .5*(A[:,-1] + A[:,0])
import hdl reload(hdl) from hdl.models import ConvSparseSlowModel from hdl.learners import SGD whitenpatches = 200 patch_sz = 48 kshp = (16,16) N = 256 model = ConvSparseSlowModel(imshp=(2,1,patch_sz,patch_sz),convwhitenfiltershp=(7,7),N=N,kshp=kshp, perc_var=99.5,lam_sparse=1.0) l = SGD(model=model,datasource='YouTubeFaces_aligned',display_every=1000,batchsize=model.imshp[0]) databatch = l.get_databatch(whitenpatches) l.model.learn_whitening(databatch) l.model.setup() l.learn(iterations=100000) #l.batchsize *= 2 #l.learn(iterations=100000) l.change_target(.5) #l.batchsize *= 2 l.learn(iterations=100000) l.change_target(.5) #l.batchsize *= 2 l.learn(iterations=100000) l.change_target(.5) #l.batchsize *= 2
N = 256 kshp = (8, 8) stride = (4, 4) imsz = kshp[0] * 6 imshp = (2, 1, imsz, imsz) print "Init..." l = SGD( model=ConvSparseSlowModel( imshp=imshp, convwhitenfiltershp=convwhitenfiltershp, perc_var=perc_var, N=N, kshp=kshp, stride=stride, sparse_cost="l1", slow_cost=None, lam_sparse=1.0, ), datasource="berkeleysegmentation", batchsize=imshp[0], save_every=20000, display_every=20000, ) print "Estimate whitening..." databatch = l.get_databatch(whitenpatches) l.model.learn_whitening(databatch) l.model.setup() l.learn(iterations=100)
reload(hdl) from hdl.models import SparseSlowModel from hdl.learners import SGD, autoSGD debug_grad = False # Create auotSGD class # Create fixedSGD class # write metric evaluation # run test for all three that measures time, and loss. -> then plots loss_setsize = 10000 whitenpatches = 40000 ldefault = SGD(model=SparseSlowModel(patch_sz=16,N=256,T=1,sparse_cost='l1',slow_cost=None,u_init_method='proj'),datasource='vid075-chunks',display_every=100000,save_every=100000,batchsize=1) databatch = ldefault.get_databatch(whitenpatches) ldefault.model.learn_whitening(databatch) ldefault.model.setup() l = autoSGD(model=SparseSlowModel(patch_sz=16,N=256,T=1,sparse_cost='l1',slow_cost=None,u_init_method='proj'),datasource='vid075-chunks',display_every=100000,save_every=100000,batchsize=1) l.model.inputmean = ldefault.model.inputmean.copy() l.model.whitenmatrix = ldefault.model.whitenmatrix.copy() l.model.dewhitenmatrix = ldefault.model.dewhitenmatrix.copy() l.model.zerophasewhitenmatrix = ldefault.model.zerophasewhitenmatrix.copy() l.model.M = ldefault.model.M l.model.D = ldefault.model.D l.model.setup() l.model.A.set_value(ldefault.model.A.get_value())
import hdl reload(hdl) from hdl.models import SparseSlowModel from hdl.learners import SGD whitenpatches = 10000 l = SGD(model=SparseSlowModel(patch_sz=8,N=64,T=64,sparse_cost='l1',slow_cost=None),datasource='vid075-chunks',display_every=500,save_every=500) databatch = l.get_databatch(whitenpatches) l.model.learn_whitening(databatch) l.model.setup() l.learn()
def test_convsparsenet(lam_sparse=.1,N=16,perc_var=100.): from hdl.models import SparseSlowModel from hdl.learners import SGD whitenpatches = 1000 #model = ConvWhitenInputModel(imshp=(10,1,32,32),convwhitenfiltershp=(7,7),perc_var=100.) model = ConvSparseSlowModel(imshp=(10,1,28,28),convwhitenfiltershp=(7,7),N=N,kshp=(7,7),perc_var=perc_var,lam_sparse=lam_sparse) l = SGD(model=model,datasource='vid075-chunks',display_every=1000,save_every=10000,batchsize=model.imshp[0]) print 'whitenpatches', whitenpatches print 'model.imshp', model.imshp print 'model.convwhitenfiltershp', model.convwhitenfiltershp databatch = l.get_databatch(whitenpatches) l.model.learn_whitening(databatch) l.model.setup() l.learn(iterations=20000) l.change_target(.5) l.learn(iterations=5000) l.change_target(.5) l.learn(iterations=5000) #l.learn(iterations=160000) #l.change_target(.5) #l.learn(iterations=20000) #l.change_target(.5) #l.learn(iterations=20000) from hdl.display import display_final display_final(l.model)
def test_sparsenet_subspace(lam_sparse=1.,lam_slow=1.,N=8,perc_var=100.): from hdl.models import SparseSlowModel from hdl.learners import SGD whitenpatches = 10000 psz = 16 #model = ConvWhitenInputModel(imshp=(10,1,32,32),convwhitenfiltershp=(7,7),perc_var=100.) model = SparseSlowModel(patch_sz=psz,N=N, sparse_cost='subspacel1', perc_var=perc_var, lam_sparse=lam_sparse, lam_slow=lam_slow,T=48) l = SGD(model=model,datasource='vid075-chunks',display_every=100,save_every=10000,batchsize=model.T) print 'whitenpatches', whitenpatches databatch = l.get_databatch(whitenpatches) l.model.learn_whitening(databatch) l.model.setup() l.learn(iterations=5000) l.change_target(.5) l.learn(iterations=5000) l.change_target(.5) l.learn(iterations=5000) #l.learn(iterations=160000) #l.change_target(.5) #l.learn(iterations=20000) #l.change_target(.5) #l.learn(iterations=20000) from hdl.display import display_final display_final(l.model)
def test_convsparsenet_subspacemean(lam_sparse=1.,lam_slow=1.,N=8,ksz=16,perc_var=100.,stride=(1,1)): from hdl.models import ConvSparseSlowModel from hdl.learners import SGD whitenpatches = 1000 psz = 100#ksz*6 convwhitenfiltershp=(7,7) #model = ConvWhitenInputModel(imshp=(10,1,32,32),convwhitenfiltershp=(7,7),perc_var=100.) model = ConvSparseSlowModel(imshp=(2,1,psz,psz),convwhitenfiltershp=convwhitenfiltershp,N=N,kshp=(ksz,ksz),stride=stride, sparse_cost='subspacel1mean', perc_var=perc_var, lam_sparse=lam_sparse, lam_slow=lam_slow, mask=True, force_subspace_orthogonal=True) l = SGD(model=model,datasource='vid075-chunks',display_every=50,save_every=10000, eta_target_maxupdate=0.05, batchsize=model.imshp[0]) print 'whitenpatches', whitenpatches print 'model.imshp', model.imshp print 'model.convwhitenfiltershp', model.convwhitenfiltershp databatch = l.get_databatch(whitenpatches) l.model.learn_whitening(databatch) l.model.setup() l.learn(iterations=1000) l.model.center_basis_functions=False l.learn(iterations=9000) l.change_target(.5) l.learn(iterations=5000) l.change_target(.5) l.learn(iterations=5000) #l.learn(iterations=160000) #l.change_target(.5) #l.learn(iterations=20000) #l.change_target(.5) #l.learn(iterations=20000) from hdl.display import display_final display_final(l.model)
def test_convsparsenet(lam_sparse=.1,N=16,perc_var=100.,stride=1,kshp=(7,7),batchsize=4): from hdl.learners import SGD whitenpatches = 1000 if isinstance(kshp,int): kshp = (kshp,kshp) if isinstance(stride,int): stride = (stride,stride) imszr = 5*stride[0] + kshp[0] - 1 imszc = 5*stride[1] + kshp[1] - 1 #model = ConvWhitenInputModel(imshp=(10,1,32,32),convwhitenfiltershp=(7,7),perc_var=100.) model = ConvSparseSlowModel(imshp=(batchsize,1,imszr,imszc),convwhitenfiltershp=(7,7),N=N,kshp=kshp,stride=stride, perc_var=perc_var,lam_sparse=lam_sparse) l = SGD(model=model,datasource='vid075-chunks',display_every=50,save_every=10000,batchsize=model.imshp[0]) print 'whitenpatches', whitenpatches print 'model.imshp', model.imshp print 'model.convwhitenfiltershp', model.convwhitenfiltershp databatch = l.get_databatch(whitenpatches) l.model.learn_whitening(databatch) l.model.setup() l.learn(iterations=5000) l.model.center_basis_functions = False l.learn(iterations=15000) l.change_target(.5) l.learn(iterations=5000) l.change_target(.5) l.learn(iterations=5000) #l.learn(iterations=160000) #l.change_target(.5) #l.learn(iterations=20000) #l.change_target(.5) #l.learn(iterations=20000) from hdl.display import display_final display_final(l.model)