def runLSCSM():
import noiseEstimation
res = contrib.dd.DB(None)
(sizex,sizey,training_inputs,training_set,validation_inputs,validation_set,ff,db_node) = contrib.JanA.dataimport.sortOutLoading(res)
raw_validation_set = db_node.data["raw_validation_set"]
num_pres,num_neurons = numpy.shape(training_set)
num_pres,kernel_size = numpy.shape(training_inputs)
size = numpy.sqrt(kernel_size)
if __main__.__dict__.get('Delay',0):
delay = __main__.__dict__.get('Delay',0)
training_set = training_set[delay:,:]
validation_set = validation_set[delay:,:]
training_inputs = training_inputs[0:-delay,:]
validation_inputs = validation_inputs[0:-delay,:]
for i in xrange(0,len(raw_validation_set)):
raw_validation_set[i] = raw_validation_set[i][delay:,:]
raw_validation_data_set=numpy.rollaxis(numpy.array(raw_validation_set),2)
to_delete = []
#to_delete = [2,3,4,5,6,9,10,11,12,13,14,18,22,26,28,29,30,31,32,34,35,36,37,41,44,50,51,54,55,57,59,60,63,65,67,68,70,71,73,74,76,79,81,82,84,86,87,88,90,91,94,95,97,98,99,100,102]
#training_set = numpy.delete(training_set, to_delete, axis = 1)
#validation_set = numpy.delete(validation_set, to_delete, axis = 1)
#for i in xrange(0,10):
# raw_validation_set[i] = numpy.delete(raw_validation_set[i], to_delete, axis = 1)
# creat history
history_set = training_set[0:-1,:]
history_validation_set = validation_set[0:-1,:]
training_set = training_set[1:,:]
validation_set = validation_set[1:,:]
training_inputs= training_inputs[1:,:]
validation_inputs= validation_inputs[1:,:]
for i in xrange(0,len(raw_validation_set)):
raw_validation_set[i] = raw_validation_set[i][1:,:]
print numpy.shape(training_inputs[0])
params={}
params["LSCSM"]=True
db_node = db_node.get_child(params)
params={}
params["Delay"] = __main__.__dict__.get('Delay',0)
params["LaplacaBias"] = __main__.__dict__.get('LaplaceBias',0.0004)
params["LGN_NUM"] = __main__.__dict__.get('LgnNum',6)
params["num_neurons"] = __main__.__dict__.get('NumNeurons',103)
params["sequential"] = __main__.__dict__.get('Sequential',False)
params["ll"] = __main__.__dict__.get('LL',True)
params["V1OF"] = __main__.__dict__.get('V1OF','Exp')
params["LGNOF"] = __main__.__dict__.get('LGNOF','Exp')
params["BalancedLGN"] = __main__.__dict__.get('BalancedLGN',True)
params["LGNTreshold"] = __main__.__dict__.get('LGNTreshold',False)
params["SecondLayer"] = __main__.__dict__.get('SecondLayer',False)
params["HiddenLayerSize"] = __main__.__dict__.get('HiddenLayerSize',1.0)
params["LogLossCoef"] = __main__.__dict__.get('LogLossCoef',1.0)
params["NegativeLgn"] = __main__.__dict__.get('NegativeLgn',True)
params["MaxW"] = __main__.__dict__.get('MaxW',5000)
params["GenerationSize"] = __main__.__dict__.get('GenerationSize',100)
params["PopulationSize"] = __main__.__dict__.get('PopulationSize',100)
params["MutationRate"] = __main__.__dict__.get('MutationRate',0.05)
params["CrossoverRate"] = __main__.__dict__.get('CrossoverRate',0.9)
params["FromWhichNeuron"] = __main__.__dict__.get('FromWhichNeuron',0)
db_node1 = db_node
db_node = db_node.get_child(params)
num_neurons=params["num_neurons"]
training_set = training_set[:,params["FromWhichNeuron"]:params["FromWhichNeuron"]+num_neurons]
validation_set = validation_set[:,params["FromWhichNeuron"]:params["FromWhichNeuron"]+num_neurons]
for i in xrange(0,len(raw_validation_set)):
raw_validation_set[i] = raw_validation_set[i][:,params["FromWhichNeuron"]:params["FromWhichNeuron"]+num_neurons]
raw_validation_data_set=numpy.rollaxis(numpy.array(raw_validation_set),2)
if __main__.__dict__.get('Sequential',False):
[K,rpi,glm,rfs]= fitLSCSMEvoSequential(numpy.mat(training_inputs),numpy.mat(training_set),params["LGN_NUM"],num_neurons)
else:
[K,rpi,glm,rfs]= fitLSCSMEvo(numpy.mat(training_inputs),numpy.mat(training_set),params["LGN_NUM"],num_neurons)
pylab.figure()
m = numpy.max(numpy.abs(rfs))
print numpy.shape(rfs)
print num_neurons*__main__.__dict__.get('HiddenLayerSize',1.0)
for i in xrange(0,num_neurons*__main__.__dict__.get('HiddenLayerSize',1.0)):
pylab.subplot(11,11,i+1)
pylab.imshow(numpy.reshape(rfs[i,0:kernel_size],(size,size)),vmin=-m,vmax=m,cmap=pylab.cm.RdBu,interpolation='nearest')
pylab.savefig('GLM_rfs.png')
pylab.figure()
m = numpy.max(numpy.abs(rpi))
for i in xrange(0,num_neurons):
pylab.subplot(11,11,i+1)
pylab.imshow(numpy.reshape(rpi[:,i],(size,size)),vmin=-m,vmax=m,cmap=pylab.cm.RdBu,interpolation='nearest')
pylab.savefig('RPI_rfs.png')
rpi_pred_act = training_inputs * rpi
rpi_pred_val_act = validation_inputs * rpi
if __main__.__dict__.get('Sequential',False):
glm_pred_act = numpy.hstack([glm[i].response(training_inputs,K[i]) for i in xrange(0,num_neurons)])
glm_pred_val_act = numpy.hstack([glm[i].response(validation_inputs,K[i]) for i in xrange(0,num_neurons)])
else:
glm_pred_act = glm.response(training_inputs,K)
glm_pred_val_act = glm.response(validation_inputs,K)
runLSCSMAnalysis(rpi_pred_act,rpi_pred_val_act,glm_pred_act,glm_pred_val_act,training_set,validation_set,num_neurons,raw_validation_data_set)
to_delete=[]
if len(raw_validation_set) != 1:
signal_power,noise_power,normalized_noise_power,training_prediction_power,validation_prediction_power,signal_power_variance = signal_power_test(raw_validation_data_set, numpy.array(training_set), numpy.array(validation_set), glm_pred_act, glm_pred_val_act)
to_delete = numpy.array(numpy.nonzero((numpy.array(normalized_noise_power) > 85) * 1.0))[0]
print 'After deleting ' , len(to_delete) , 'most noisy neurons (<15% signal to noise ratio)\n\n\n'
if len(to_delete) != num_neurons:
training_set = numpy.delete(training_set, to_delete, axis = 1)
validation_set = numpy.delete(validation_set, to_delete, axis = 1)
glm_pred_act = numpy.delete(glm_pred_act, to_delete, axis = 1)
glm_pred_val_act = numpy.delete(glm_pred_val_act, to_delete, axis = 1)
rpi_pred_act = numpy.delete(rpi_pred_act, to_delete, axis = 1)
rpi_pred_val_act = numpy.delete(rpi_pred_val_act, to_delete, axis = 1)
for i in xrange(0,len(raw_validation_set)):
raw_validation_set[i] = numpy.delete(raw_validation_set[i], to_delete, axis = 1)
raw_validation_data_set=numpy.rollaxis(numpy.array(raw_validation_set),2)
runLSCSMAnalysis(rpi_pred_act,rpi_pred_val_act,glm_pred_act,glm_pred_val_act,training_set,validation_set,num_neurons-len(to_delete),raw_validation_data_set)
db_node.add_data("Kernels",K,force=True)
db_node.add_data("LSCSM",glm,force=True)
contrib.dd.saveResults(res,normalize_path(__main__.__dict__.get('save_name','res.dat')))
def analyseGLM(
K,
rpi,
glm,
validation_inputs,
training_inputs,
validation_set,
training_set,
raw_validation_set,
history_set,
history_validation_set,
raw_history_validation_set,
db_node,
num_neurons_to_run,
):
num_pres, kernel_size = numpy.shape(training_inputs)
num_pres, num_neurons = numpy.shape(training_set)
size = numpy.sqrt(kernel_size)
# num_neurons=num_neurons_to_run
print "Thresholds:", K[:, kernel_size]
print "Alphas:", K[:, kernel_size + 1]
pylab.figure()
m = numpy.max(numpy.abs(K))
for i in xrange(0, num_neurons_to_run):
pylab.subplot(11, 11, i + 1)
pylab.imshow(
numpy.reshape(K[i, 0:kernel_size], (size, size)),
vmin=-m,
vmax=m,
cmap=pylab.cm.RdBu,
interpolation="nearest",
)
pylab.savefig(normalize_path("GLM_rfs.png"))
pylab.figure()
m = numpy.max(numpy.abs(rpi))
for i in xrange(0, num_neurons_to_run):
pylab.subplot(11, 11, i + 1)
pylab.imshow(
numpy.reshape(rpi[:, i], (size, size)), vmin=-m, vmax=m, cmap=pylab.cm.RdBu, interpolation="nearest"
)
pylab.savefig(normalize_path("RPI_rfs.png"))
rpi_pred_act = training_inputs * rpi
rpi_pred_val_act = validation_inputs * rpi
glm_pred_val_act_st = []
if not __main__.__dict__.get("Lateral", False):
if history_set != None:
glm_pred_act = glm.response(training_inputs, history_set, K)
glm_pred_val_act = glm.response(validation_inputs, numpy.mean(raw_history_validation_set, axis=0), K)
for j in xrange(0, len(raw_validation_set)):
glm_pred_val_act_st.append(glm.response(validation_inputs, raw_history_validation_set[j], K))
else:
glm_pred_act = glm.response(training_inputs, None, K)
glm_pred_val_act = glm.response(validation_inputs, None, K)
for j in xrange(0, len(raw_validation_set)):
glm_pred_val_act_st.append(glm.response(validation_inputs, None, K))
else:
if history_set != None:
print numpy.shape(history_set)
print numpy.shape(numpy.delete(training_set, [0], axis=1))
print numpy.shape(
glm.response(
training_inputs,
numpy.hstack((history_set, numpy.delete(training_set, [0], axis=1))),
numpy.array([K[0]]),
)
)
print numpy.shape(
glm.response(
training_inputs,
numpy.hstack((history_set, numpy.delete(training_set, [1], axis=1))),
numpy.array([K[1]]),
)
)
glm_pred_act = numpy.hstack(
[
glm.response(
training_inputs,
numpy.hstack((history_set, numpy.delete(training_set, [i], axis=1))),
numpy.array([K[i]]),
)
for i in xrange(0, num_neurons)
]
)
glm_pred_val_act = numpy.hstack(
[
glm.response(
validation_inputs,
numpy.hstack((history_validation_set, numpy.delete(validation_set, [i], axis=1))),
numpy.array([K[i]]),
)
for i in xrange(0, num_neurons)
]
)
for j in xrange(0, len(raw_validation_set)):
glm_pred_val_act_st.append(
numpy.hstack(
[
glm.response(
validation_inputs,
numpy.hstack(
(raw_history_validation_set[j], numpy.delete(raw_validation_set[j], [i], axis=1))
),
numpy.array([K[i]]),
)
for i in xrange(0, num_neurons)
]
)
)
else:
glm_pred_act = numpy.hstack(
[
glm.response(training_inputs, numpy.delete(training_set, [i], axis=1), numpy.array([K[i]]))
for i in xrange(0, num_neurons)
]
)
glm_pred_val_act = numpy.hstack(
[
glm.response(validation_inputs, numpy.delete(validation_set, [i], axis=1), numpy.array([K[i]]))
for i in xrange(0, num_neurons)
]
)
for j in xrange(0, len(raw_validation_set)):
glm_pred_val_act_st.append(
numpy.hstack(
[
glm.response(
validation_inputs, numpy.delete(raw_validation_set[j], [i], axis=1), numpy.array([K[i]])
)
for i in xrange(0, num_neurons)
]
)
)
ofs = run_nonlinearity_detection(numpy.mat(training_set), numpy.mat(rpi_pred_act))
rpi_pred_act_t = apply_output_function(numpy.mat(rpi_pred_act), ofs)
rpi_pred_val_act_t = apply_output_function(numpy.mat(rpi_pred_val_act), ofs)
ofs = run_nonlinearity_detection(numpy.mat(training_set), numpy.mat(glm_pred_act))
glm_pred_act_t = apply_output_function(numpy.mat(glm_pred_act), ofs)
glm_pred_val_act_t = apply_output_function(numpy.mat(glm_pred_val_act), ofs)
pylab.figure()
pylab.title("RPI")
for i in xrange(0, num_neurons_to_run):
pylab.subplot(11, 11, i + 1)
pylab.plot(rpi_pred_val_act[:, i], validation_set[:, i], "o")
pylab.savefig(normalize_path("RPI_val_relationship.png"))
pylab.figure()
pylab.title("GLM")
for i in xrange(0, num_neurons_to_run):
pylab.subplot(11, 11, i + 1)
pylab.plot(glm_pred_val_act[:, i], validation_set[:, i], "o")
pylab.savefig(normalize_path("GLM_val_relationship.png"))
pylab.figure()
pylab.title("RPI")
for i in xrange(0, num_neurons_to_run):
pylab.subplot(11, 11, i + 1)
pylab.plot(rpi_pred_val_act_t[:, i], validation_set[:, i], "o")
pylab.savefig(normalize_path("RPI_t_val_relationship.png"))
pylab.figure()
pylab.title("GLM")
for i in xrange(0, num_neurons_to_run):
pylab.subplot(11, 11, i + 1)
pylab.plot(glm_pred_val_act_t[:, i], validation_set[:, i], "o")
pylab.savefig(normalize_path("GLM_t_val_relationship.png"))
pylab.figure()
pylab.plot(
numpy.mean(numpy.power(validation_set - rpi_pred_val_act_t, 2)[:, :num_neurons_to_run], 0),
numpy.mean(numpy.power(validation_set - glm_pred_val_act, 2)[:, :num_neurons_to_run], 0),
"o",
)
pylab.hold(True)
pylab.plot([0.0, 1.0], [0.0, 1.0])
pylab.xlabel("RPI")
pylab.ylabel("GLM")
pylab.savefig(normalize_path("GLM_vs_RPI_MSE.png"))
print "\n \n RPI \n"
print "Without TF"
performance_analysis(training_set, validation_set, rpi_pred_act, rpi_pred_val_act, raw_validation_set)
print "With TF"
(
signal_power,
noise_power,
normalized_noise_power,
training_prediction_power,
rpi_validation_prediction_power,
signal_power_variance,
) = performance_analysis(training_set, validation_set, rpi_pred_act_t, rpi_pred_val_act_t, raw_validation_set)
print "\n \n GLM \n"
print "Without TF"
(
signal_power,
noise_power,
normalized_noise_power,
training_prediction_power,
glm_validation_prediction_power,
signal_power_variance,
) = performance_analysis(training_set, validation_set, glm_pred_act, glm_pred_val_act, raw_validation_set)
print "With TF"
performance_analysis(training_set, validation_set, glm_pred_act_t, glm_pred_val_act_t, raw_validation_set)
print "\n\n\nSingle trial validation set"
performance_analysis(
training_set, validation_set, glm_pred_act, numpy.mean(glm_pred_val_act_st, axis=0), raw_validation_set
)
pylab.figure()
pylab.plot(
rpi_validation_prediction_power[:num_neurons_to_run], glm_validation_prediction_power[:num_neurons_to_run], "o"
)
pylab.hold(True)
pylab.plot([0.0, 1.0], [0.0, 1.0])
pylab.xlabel("RPI")
pylab.ylabel("GLM")
pylab.savefig(normalize_path("GLM_vs_RPI_prediction_power.png"))
db_node.add_data("ReversCorrelationPredictedActivities", glm_pred_act, force=True)
db_node.add_data("ReversCorrelationPredictedActivities+TF", glm_pred_act_t, force=True)
db_node.add_data("ReversCorrelationPredictedValidationActivities", glm_pred_val_act, force=True)
db_node.add_data("ReversCorrelationPredictedValidationActivities+TF", glm_pred_val_act_t, force=True)
def analyseGLM(K,rpi,glm,validation_inputs,training_inputs,validation_set,training_set,raw_validation_set,history_set,history_validation_set,raw_history_validation_set,db_node,num_neurons_to_run):
num_pres,kernel_size = numpy.shape(training_inputs)
num_pres,num_neurons = numpy.shape(training_set)
size = numpy.sqrt(kernel_size)
#num_neurons=num_neurons_to_run
print 'Thresholds:', K[:,kernel_size]
print 'Alphas:', K[:,kernel_size+1]
pylab.figure()
m = numpy.max(numpy.abs(K))
for i in xrange(0,num_neurons_to_run):
pylab.subplot(11,11,i+1)
pylab.imshow(numpy.reshape(K[i,0:kernel_size],(size,size)),vmin=-m,vmax=m,cmap=pylab.cm.RdBu,interpolation='nearest')
pylab.savefig(normalize_path('GLM_rfs.png'))
pylab.figure()
m = numpy.max(numpy.abs(rpi))
for i in xrange(0,num_neurons_to_run):
pylab.subplot(11,11,i+1)
pylab.imshow(numpy.reshape(rpi[:,i],(size,size)),vmin=-m,vmax=m,cmap=pylab.cm.RdBu,interpolation='nearest')
pylab.savefig(normalize_path('RPI_rfs.png'))
rpi_pred_act = training_inputs * rpi
rpi_pred_val_act = validation_inputs * rpi
glm_pred_val_act_st = []
if not __main__.__dict__.get('Lateral',False):
if history_set != None:
glm_pred_act = glm.response(training_inputs,history_set,K)
glm_pred_val_act = glm.response(validation_inputs,numpy.mean(raw_history_validation_set,axis=0),K)
for j in xrange(0,len(raw_validation_set)):
glm_pred_val_act_st.append(glm.response(validation_inputs,raw_history_validation_set[j],K))
else:
glm_pred_act = glm.response(training_inputs,None,K)
glm_pred_val_act = glm.response(validation_inputs,None,K)
for j in xrange(0,len(raw_validation_set)):
glm_pred_val_act_st.append(glm.response(validation_inputs,None,K))
else:
if history_set != None:
print numpy.shape(history_set)
print numpy.shape(numpy.delete(training_set,[0],axis=1))
print numpy.shape(glm.response(training_inputs,numpy.hstack((history_set,numpy.delete(training_set,[0],axis=1))),numpy.array([K[0]])))
print numpy.shape(glm.response(training_inputs,numpy.hstack((history_set,numpy.delete(training_set,[1],axis=1))),numpy.array([K[1]])))
glm_pred_act = numpy.hstack([glm.response(training_inputs,numpy.hstack((history_set,numpy.delete(training_set,[i],axis=1))),numpy.array([K[i]])) for i in xrange(0,num_neurons)])
glm_pred_val_act = numpy.hstack([ glm.response(validation_inputs,numpy.hstack((history_validation_set,numpy.delete(validation_set,[i],axis=1))),numpy.array([K[i]])) for i in xrange(0,num_neurons)])
for j in xrange(0,len(raw_validation_set)):
glm_pred_val_act_st.append(numpy.hstack([ glm.response(validation_inputs,numpy.hstack((raw_history_validation_set[j],numpy.delete(raw_validation_set[j],[i],axis=1))),numpy.array([K[i]])) for i in xrange(0,num_neurons)]))
else:
glm_pred_act = numpy.hstack([ glm.response(training_inputs,numpy.delete(training_set,[i],axis=1),numpy.array([K[i]])) for i in xrange(0,num_neurons)])
glm_pred_val_act = numpy.hstack([ glm.response(validation_inputs,numpy.delete(validation_set,[i],axis=1),numpy.array([K[i]])) for i in xrange(0,num_neurons)])
for j in xrange(0,len(raw_validation_set)):
glm_pred_val_act_st.append(numpy.hstack([ glm.response(validation_inputs,numpy.delete(raw_validation_set[j],[i],axis=1),numpy.array([K[i]])) for i in xrange(0,num_neurons)]))
ofs = run_nonlinearity_detection(numpy.mat(training_set),numpy.mat(rpi_pred_act))
rpi_pred_act_t = apply_output_function(numpy.mat(rpi_pred_act),ofs)
rpi_pred_val_act_t = apply_output_function(numpy.mat(rpi_pred_val_act),ofs)
ofs = run_nonlinearity_detection(numpy.mat(training_set),numpy.mat(glm_pred_act))
glm_pred_act_t = apply_output_function(numpy.mat(glm_pred_act),ofs)
glm_pred_val_act_t = apply_output_function(numpy.mat(glm_pred_val_act),ofs)
pylab.figure()
pylab.title('RPI')
for i in xrange(0,num_neurons_to_run):
pylab.subplot(11,11,i+1)
pylab.plot(rpi_pred_val_act[:,i],validation_set[:,i],'o')
pylab.savefig(normalize_path('RPI_val_relationship.png'))
pylab.figure()
pylab.title('GLM')
for i in xrange(0,num_neurons_to_run):
pylab.subplot(11,11,i+1)
pylab.plot(glm_pred_val_act[:,i],validation_set[:,i],'o')
pylab.savefig(normalize_path('GLM_val_relationship.png'))
pylab.figure()
pylab.title('RPI')
for i in xrange(0,num_neurons_to_run):
pylab.subplot(11,11,i+1)
pylab.plot(rpi_pred_val_act_t[:,i],validation_set[:,i],'o')
pylab.savefig(normalize_path('RPI_t_val_relationship.png'))
pylab.figure()
pylab.title('GLM')
for i in xrange(0,num_neurons_to_run):
pylab.subplot(11,11,i+1)
pylab.plot(glm_pred_val_act_t[:,i],validation_set[:,i],'o')
pylab.savefig(normalize_path('GLM_t_val_relationship.png'))
pylab.figure()
pylab.plot(numpy.mean(numpy.power(validation_set - rpi_pred_val_act_t,2)[:,:num_neurons_to_run],0),numpy.mean(numpy.power(validation_set - glm_pred_val_act,2)[:,:num_neurons_to_run],0),'o')
pylab.hold(True)
pylab.plot([0.0,1.0],[0.0,1.0])
pylab.xlabel('RPI')
pylab.ylabel('GLM')
pylab.savefig(normalize_path('GLM_vs_RPI_MSE.png'))
print '\n \n RPI \n'
print 'Without TF'
performance_analysis(training_set,validation_set,rpi_pred_act,rpi_pred_val_act,raw_validation_set)
print 'With TF'
(signal_power,noise_power,normalized_noise_power,training_prediction_power,rpi_validation_prediction_power,signal_power_variance) = performance_analysis(training_set,validation_set,rpi_pred_act_t,rpi_pred_val_act_t,raw_validation_set)
print '\n \n GLM \n'
print 'Without TF'
(signal_power,noise_power,normalized_noise_power,training_prediction_power,glm_validation_prediction_power,signal_power_variance) = performance_analysis(training_set,validation_set,glm_pred_act,glm_pred_val_act,raw_validation_set)
print 'With TF'
performance_analysis(training_set,validation_set,glm_pred_act_t,glm_pred_val_act_t,raw_validation_set)
print '\n\n\nSingle trial validation set'
performance_analysis(training_set,validation_set,glm_pred_act,numpy.mean(glm_pred_val_act_st,axis=0),raw_validation_set)
pylab.figure()
pylab.plot(rpi_validation_prediction_power[:num_neurons_to_run],glm_validation_prediction_power[:num_neurons_to_run],'o')
pylab.hold(True)
pylab.plot([0.0,1.0],[0.0,1.0])
pylab.xlabel('RPI')
pylab.ylabel('GLM')
pylab.savefig(normalize_path('GLM_vs_RPI_prediction_power.png'))
db_node.add_data("ReversCorrelationPredictedActivities",glm_pred_act,force=True)
db_node.add_data("ReversCorrelationPredictedActivities+TF",glm_pred_act_t,force=True)
db_node.add_data("ReversCorrelationPredictedValidationActivities",glm_pred_val_act,force=True)
db_node.add_data("ReversCorrelationPredictedValidationActivities+TF",glm_pred_val_act_t,force=True)
