cc_lissom_oo_or_simple_rv.ty

"""
LISSOM-based orientation map with complex cell layer.

$Id: cc_lissom_oo_or.ty 8265 2008-03-26 17:09:15Z antolikjan $
"""
__version__='$Revision: 8265 $'


import numpy

from math import pi, sqrt

import param

import topo.pattern
import topo.pattern.random
import __main__
import os

from topo.sheet.lissom import LISSOM
from topo.sheet import JointNormalizingCFSheet_Continuous
from topo.sheet.optimized import NeighborhoodMask_Opt, LISSOM_Opt
from topo.sheet import GeneratorSheet
from topo.projection import CFProjection, SharedWeightCFProjection,OneToOneProjection
from topo.responsefn.optimized import CFPRF_DotProduct_opt
from topo.base.cf import CFSheet
from topo.base.boundingregion import BoundingBox
from topo.learningfn.optimized import CFPLF_Hebbian_opt, CFPLF_Trace_opt
from topo.transferfn.optimized import CFPOF_DivisiveNormalizeL1_opt
from topo.transferfn.misc import PatternCombine
from topo.transferfn.misc import HalfRectify
from topo.transferfn.misc import AttributeTrackingTF
from topo.transferfn import PiecewiseLinear,DivisiveNormalizeL1, HomeostaticMaxEnt,Sigmoid
from topo import numbergen
from topo.pattern import Gaussian
from topo.learningfn.projfn import CFPLF_Trace
from topo.base.functionfamily import CoordinateMapperFn
from contrib.jacommands import randomize_V1Simple_relative_LGN_strength,ActivityHysteresis, Translator,SimpleHomeoSigmoid, Jitterer, AddGC, SimpleHomeoLinear, Expander
from topo.numbergen import UniformRandom, BoundedNumber, ExponentialDecay

topo.sim.name = "CCSimple"

shared_params = {"a_init":14.5, "b_init":-4, "mu":0.01, "smoothing":0.0003}
shared_debug_params = {"debug_params":["a", "b"] , "avg_params":["x"], "units":[(0,0),(11,11),(23,23)]}
core_size=locals().get('CS',0.5)

num_inputs=1

dataset=locals().get('dataset',"Natural") #set the input type by choosing the dataset parameter 


if dataset=="Line":
        input= Translator(generator=topo.pattern.Line(   x=numbergen.UniformRandom(lbound=-(core_size+0.15),ubound=(core_size+0.15),seed=1023),   y=numbergen.UniformRandom(lbound=-(core_size+0.15),ubound=(core_size+0.15),seed=53),size=1.0, offset=0.5,scale=numbergen.Choice(choices=[-0.5,0.5],seed=56),bounds = BoundingBox(radius=0.8),thickness=0.04,smoothing=0.0),orientation=numbergen.UniformRandom(lbound=-pi,ubound=pi,seed=56),reset_period=locals().get('Period',10),speed=locals().get('Speed',0.02))
elif dataset=="Natural":
    import topo.pattern.image 
    input_type=topo.pattern.image.FileImage
    if locals().get('imageset',"Shouval") == 'Shouval':
            image_filenames=["/exports/work/inf_ndtc/s0570140/NEW_ENVIRONMENT/topographica/images/shouval/combined%02d.png"%(i+1) for i in xrange(25)]
            inputs=[input_type(filename=f,
                           size=10.0,  #size_normalization='original',(size=10.0)
                                        x=0,
                                        y=0,scale=locals().get('ImageScale',1.0),
                                        orientation=0)
                                for f in image_filenames]
                        
    elif locals().get('imageset',"Shouval") == 'Konig':
        image_filenames=["/exports/work/inf_ndtc/s0570140/NEW_ENVIRONMENT/topographica/images/konig/seq1/seq1-%05d.tif"%(i*10+1) for i in xrange(100)]
        print image_filenames
        inputs=[input_type(filename=f,
                        size=10.0,  #size_normalization='original',(size=10.0)
                        x=0,
                        y=0,scale=locals().get('ImageScale',1.0),
                        orientation=0)
                    for f in image_filenames]
    elif locals().get('imageset',"Shouval") == 'NPS':
        image_filenames=os.listdir("images/Planes")
        inputs=[input_type(filename="images/Planes/"+f,
                        size=10.0,  #size_normalization='original',(size=10.0)
                       x=0,
                       y=0,scale=locals().get('ImageScale',1.0),
                       orientation=0)
                    for f in image_filenames]

    input =Jitterer(generator=topo.pattern.Selector(generators=inputs),orientation=numbergen.UniformRandom(lbound=-pi,ubound=pi,seed=56),reset_period=locals().get('Period',10),jitter_magnitude=locals().get('JM',0.02),seed=5013)

disk_scale=locals().get('diskscale',0.35)
reg=locals().get('Region',1.0)

disk_scale=locals().get('diskscale',0.35)
input_type=topo.pattern.Composite
noisy_disks=input_type(operator=numpy.add,x=numbergen.UniformRandom(lbound=-reg,ubound=reg,seed=12),
             y=numbergen.UniformRandom(lbound=-reg,ubound=reg,seed=36),
             generators=[topo.pattern.Disk(
             size=0.5, aspect_ratio=1.0, scale=RingScale,
             offset=0.5,
             bounds=BoundingBox(radius=2.125), smoothing=0.1),
             topo.pattern.random.UniformRandom(offset=locals().get('rand_offset',-0.5), scale=locals().get('rand_scale',0.3))])

ring = topo.pattern.Composite(operator=numpy.add,x=numbergen.UniformRandom(lbound=-reg,ubound=reg,seed=12),
                                                            y=numbergen.UniformRandom(lbound=-reg,ubound=reg,seed=36),
                       generators=[topo.pattern.Ring(size=0.5, aspect_ratio=1.0, scale=locals().get('RingScale',0.25),thickness=locals().get('Thickness',0.01),
                                                            offset=0.0,
                                                            bounds=BoundingBox(radius=2.125), smoothing=locals().get('Smoothing',0.03)),
                                   topo.pattern.random.UniformRandom(seed=13,offset=locals().get('rand_offset',0), scale=locals().get('rand_scale',0.05))])

 

retinal_waves=Expander(generator=ring,orientation=numbergen.UniformRandom(lbound=-pi,ubound=pi,seed=56),reset_period=locals().get('Period',10),speed=locals().get('Speed',0.02))
retinal_waves1=Expander(generator=noisy_disks,orientation=numbergen.UniformRandom(lbound=-pi,ubound=pi,seed=56),reset_period=locals().get('Period',10),speed=locals().get('Speed',0.02))


zeroInput = topo.pattern.Null();


jitter  =  locals().get('Jitter',0.4)

class Jitter(CoordinateMapperFn):
    """Return the jittered x,y coordinate of the given coordinate."""
    scale =  jitter
    rand = param.Parameter(default=None)
    def __call__(self,x,y):
        return x+(self.rand()-0.5)*self.scale,y+(self.rand()-0.5)*self.scale

jitterOn = Jitter(rand =numbergen.UniformRandom(seed=1023))
jitterOff = Jitter(rand =numbergen.UniformRandom(seed=1023))

# Specify weight initialization, response function, and learning function
CFProjection.weights_generator=topo.pattern.random.UniformRandom(seed=1023)
CFProjection.cf_shape=topo.pattern.Disk(smoothing=0.0)
CFProjection.response_fn=CFPRF_DotProduct_opt()
CFProjection.learning_fn=CFPLF_Hebbian_opt()
CFProjection.weights_output_fns=[CFPOF_DivisiveNormalizeL1_opt()]



## Homeostatic stuff
#Simple
units=[(0.25,0.25),(-0.25,0.25),
       (0.25,-0.25),(-0.25,-0.25)]

if locals().get('SOF',"Homeo") == "HR":
    V1Simple_OF=HalfRectify(t=locals().get('S_treshold',0.4))
elif locals().get('SOF',"Homeo") == "Homeo":
        V1Simple_OF = SimpleHomeoSigmoid(a_init=22,b_init=-12,mu=locals().get('SMU',0.01),eta=locals().get('SETA',0.02))
elif locals().get('SOF',"Homeo") == "SimpleHomeo":
    V1Simple_OF = SimpleHomeoLinear(t_init=locals().get('STresh',0.9),alpha=locals().get('SAlpha',4),mu=locals().get('SMU',0.01),eta=locals().get('SETA',0.02))
#elif locals().get('SOF',"Homeo") == "ExpLin":
#    V1Simple_OF = ExpLinear(t=locals().get('STresh',0.9),e=locals().get('SExp',1.0))
else:
        V1Simple_OF=Sigmoid(r=22,k=-12)

if locals().get('COF',"Sigmoid") == "HR":
    V1Complex_OF=HalfRectify()
else:
        V1Complex_OF=Sigmoid(r=locals().get('r_init',14.5),k=locals().get('k_init',-3))

NN = PatternCombine(generator=topo.pattern.random.GaussianRandom(scale=locals().get('intrinsic_noise',0.0),offset=0.0),operator=numpy.add)




###########################################
# build simulation

topo.sim['Retina']=GeneratorSheet(nominal_density=48.0,
                                input_generator=input,  
                                period=1.0, phase=0.05,
                                nominal_bounds=BoundingBox(radius=core_size+0.25+0.375+0.25))

topo.sim['FakeRetina']=GeneratorSheet(nominal_density=48.0,
                                  input_generator=retinal_waves,  
                                  period=1.0, phase=0.05,
                                  nominal_bounds=BoundingBox(radius=core_size+0.25+0.25))


topo.sim['LGNOn']=LISSOM(nominal_density=locals().get('lgn_density',24.0),
                          nominal_bounds=BoundingBox(radius=core_size+0.25+0.25),
                          output_fns=[HalfRectify(t_init=locals().get('lgn_tresh',0.0))],tsettle=0,
                          measure_maps=False)

topo.sim['LGNOff']=LISSOM(nominal_density=locals().get('lgn_density',24.0),
                           nominal_bounds=BoundingBox(radius=core_size+0.25+0.25),
                           output_fns=[HalfRectify(t_init=locals().get('lgn_tresh',0.0))],tsettle=0,
                           measure_maps=False)

#topo.sim['V1Simple'] = JointNormalizingCFSheet_Continuous(nominal_density=locals().get('default_density',96.0),
topo.sim['V1Simple'] = JointNormalizingCFSheet_Continuous(nominal_density=locals().get('default_density',96.0),
                        nominal_bounds=BoundingBox(radius=core_size),
                        output_fns=[ActivityHysteresis(time_constant=0.3),NN,V1Simple_OF])

                        
topo.sim['V1Complex'] = JointNormalizingCFSheet_Continuous(nominal_density=locals().get('default_density',96.0),
                        nominal_bounds=BoundingBox(radius=core_size),
                        output_fns=[ActivityHysteresis(time_constant=0.3),V1Complex_OF])

# DoG weights for the LGN
#centerg   = Gaussian(size=0.07385,aspect_ratio=1.0,output_fns=[DivisiveNormalizeL1()])
centerg   = Gaussian(size=locals().get('LGNCenterSize',0.15),aspect_ratio=1.0,output_fns=[DivisiveNormalizeL1()])
surroundg = Gaussian(size=locals().get('LGNSurrSize',0.29540),aspect_ratio=1.0,output_fns=[DivisiveNormalizeL1()])

on_weights = topo.pattern.Composite(
    generators=[centerg,surroundg],operator=numpy.subtract)

off_weights = topo.pattern.Composite(
    generators=[surroundg,centerg],operator=numpy.subtract)

if False:
    topo.sim.connect('FakeRetina','LGNOn',delay=0.05,
                        connection_type=SharedWeightCFProjection,strength=2.33,
                        nominal_bounds_template=BoundingBox(radius=0.375),name='LGNOnAfferent1',
                        weights_generator=on_weights)
        
    topo.sim.connect('FakeRetina','LGNOff',delay = 0.05,
                        connection_type=SharedWeightCFProjection,strength=2.33,
                        nominal_bounds_template=BoundingBox(radius=0.375),name='LGNOffAfferent2',
                        weights_generator=off_weights)
else:
    topo.sim.connect('FakeRetina','LGNOn',delay=0.05,
                     connection_type=OneToOneProjection,strength=locals().get('LGNAff',0.5),
                     nominal_bounds=BoundingBox(radius=0.375),name='Afferent')
    
    topo.sim.connect('FakeRetina','LGNOff',delay = 0.05,
                     connection_type=OneToOneProjection,strength=locals().get('LGNAff',0.5),
                     nominal_bounds=BoundingBox(radius=0.375),name='Afferent')



g1 = Gaussian(aspect_ratio=1.0,scale=1.0,size=numbergen.UniformRandom(lbound=0.8,ubound=0.8,seed=56))
g1._Dynamic_time_fn = None
g2 = Gaussian(aspect_ratio=1.0,scale=1.0,size=numbergen.UniformRandom(lbound=0.8,ubound=0.8,seed=56))
g2._Dynamic_time_fn = None

#V1 Simple

LGNStr = locals().get('LGNStr',4)
inbalance = locals().get('Inbalance',0.2)

LGNOnStr = LGNStr+LGNStr*inbalance
LGNOffStr = LGNStr-LGNStr*inbalance

topo.sim.connect('LGNOn','V1Simple',delay=0.025,dest_port=('Activity','JointNormalize', 'Afferent'),
                 connection_type=CFProjection,strength=LGNOnStr,name='LGNOnAfferent',
                 weights_generator=topo.pattern.Composite(operator=numpy.multiply, 
                     generators=[g1
                 ,topo.pattern.random.UniformRandom(seed=513)]),
                 nominal_bounds_template=BoundingBox(radius=locals().get('V1Aff_size',0.27083)),
                 coord_mapper=jitterOn,apply_output_fns_init=False,
                 learning_rate=(BoundedNumber(bounds=(0.0,None),generator=
                               ExponentialDecay(starting_value = locals().get('S_lr',5),
                                                time_constant=locals().get('S_tc',12000)))))


topo.sim.connect('LGNOff','V1Simple',delay=0.025,dest_port=('Activity','JointNormalize', 'Afferent'),
                 connection_type=CFProjection,strength=LGNOffStr,name='LGNOffAfferent',
                 weights_generator=topo.pattern.Composite(operator=numpy.multiply, 
                     generators=[g2
                 ,topo.pattern.random.UniformRandom(seed=17)]),
                 nominal_bounds_template=BoundingBox(radius=locals().get('V1Aff_size',0.27083)),
                 coord_mapper=jitterOff,apply_output_fns_init=False,
                 learning_rate=(BoundedNumber(bounds=(0.0,None),generator=
                               ExponentialDecay(starting_value = locals().get('S_lr',5),
                                                time_constant=locals().get('S_tc',12000)))))


#randomize_V1Simple_relative_LGN_strength(prob=__main__.__dict__.get('CRS',0.1))

simpleLateral  =  locals().get('SL',False)
if simpleLateral:
        topo.sim.connect('V1Simple','V1Simple',delay=0.025,name='LateralExcitatory',
                        connection_type=CFProjection,strength=locals().get('SxLatExcStr',0.0),
                        weights_generator=topo.pattern.Gaussian(aspect_ratio=1.0, size=locals().get('CxLatExcSize',0.04)),
                        nominal_bounds_template=BoundingBox(radius=locals().get('CxLatExcBB',0.12)),
                        learning_rate=0.0)
        
        topo.sim.connect('V1Simple','V1Simple',delay=0.025,name='LateralInhibitory',
                        connection_type=CFProjection,strength=-locals().get('SxLatInhStr',0.0),
                        weights_generator=topo.pattern.Composite(operator=numpy.multiply, 
                            generators=[Gaussian(aspect_ratio=1.0, size=locals().get('CxLatInhSize',2*0.22917)),
                                        topo.pattern.random.UniformRandom(seed=7)]),
                        nominal_bounds_template=BoundingBox(radius=locals().get('CxLatInhBB',0.22917)),
                        learning_rate=(BoundedNumber(bounds=(0.0,None),generator=
                                    ExponentialDecay(starting_value = locals().get('LatInh_lr',0.3),
                                                        time_constant=locals().get('LatInh_tc',1600)))))



#V1 Complex

topo.sim.connect('V1Simple','V1Complex',delay=0.025,
                 connection_type=CFProjection,strength=locals().get('StoCStr',4),name='V1SimpleAfferent',
                 weights_generator=Gaussian(aspect_ratio=1.0, size=locals().get('StoCSize',0.05)),
                 nominal_bounds_template=BoundingBox(radius=locals().get('StoCBB',0.15)/2),learning_rate=locals().get('FF_lr',0.0))
                
topo.sim.connect('V1Complex','V1Simple',delay=0.025,
                 connection_type=CFProjection,strength=locals().get('FStrExc',0.1),name='V1SimpleFeedbackExc1',
                 weights_generator=Gaussian(aspect_ratio=1.0, size=18),
                 nominal_bounds_template=BoundingBox(radius=locals().get('FExcSize',0.005)/2),
                 learning_rate=0)

topo.sim.connect('V1Complex','V1Simple',delay=0.025,
                 connection_type=CFProjection,strength=locals().get('FStrInh',-0.65),name='V1SimpleFeedbackInh',
                 weights_generator=Gaussian(aspect_ratio=1.0, size=2.5),
                 nominal_bounds_template=BoundingBox(radius=locals().get('FInhSize',0.3)/2),learning_rate=0)


topo.sim.connect('V1Complex','V1Complex',delay=0.025,name='LateralExcitatory',
                 connection_type=CFProjection,strength=locals().get('CxLatExcStr',0.8),
                 weights_generator=topo.pattern.Gaussian(aspect_ratio=1.0, size=locals().get('CxLatExcSize',0.04)),
                 nominal_bounds_template=BoundingBox(radius=locals().get('CxLatExcBB',0.12)),
                 learning_rate=0.0)

topo.sim.connect('V1Complex','V1Complex',delay=0.025,name='LateralInhibitory',
                 connection_type=CFProjection,strength=-locals().get('CxLatInhStr',0.8),
                 weights_generator=topo.pattern.Composite(operator=numpy.multiply, 
                     generators=[Gaussian(aspect_ratio=1.0, size=locals().get('CxLatInhSize',2*0.22917)),
                                topo.pattern.random.UniformRandom(seed=7)]),
                 nominal_bounds_template=BoundingBox(radius=locals().get('CxLatInhBB',0.22917)),
                 learning_rate=(BoundedNumber(bounds=(0.0,None),generator=
                               ExponentialDecay(starting_value = locals().get('LatInh_lr',0.3),
                                                time_constant=locals().get('LatInh_tc',1600)))))

topo.sim.schedule_command(__main__.__dict__.get('SST',10000),"secondStage()")

def offset_tf():
        return topo.sim.time()-__main__.__dict__.get('SST',10000)

if __main__.__dict__.get('GC',True):
    AddGC()

def secondStage():
    topo.sim.connect('Retina','LGNOn',delay=0.05,
                    connection_type=SharedWeightCFProjection,strength=__main__.__dict__.get('LGNAff2',2.33),
                    nominal_bounds_template=BoundingBox(radius=0.375),name='LGNOnAfferent3',
                    weights_generator=on_weights)
    
    topo.sim.connect('Retina','LGNOff',delay = 0.05,
                    connection_type=SharedWeightCFProjection,strength=__main__.__dict__.get('LGNAff2',2.33),
                    nominal_bounds_template=BoundingBox(radius=0.375),name='LGNOffAfferent4',
                    weights_generator=off_weights)
    
    topo.sim['FakeRetina'].set_input_generator(zeroInput)
    topo.sim['LGNOn'].in_connections[0].strength=0
    topo.sim['LGNOff'].in_connections[0].strength=0
    randomize_V1Simple_relative_LGN_strength(prob=__main__.__dict__.get('CRS',0.1))
    
from topo.analysis.featureresponses import MeasureResponseCommand, FeatureMaps, SinusoidalMeasureResponseCommand
FeatureMaps.num_orientation=16
MeasureResponseCommand.scale=3.0
MeasureResponseCommand.duration=4.0
FeatureCurveCommand.num_orientation=20
FeatureCurveCommand.curve_parameters=[{"contrast":10},{"contrast":90}]