def dp_accuracy():
logging.basicConfig(level=10) # 5 for more stuff
CL = CL3
animal = 66
session = 60
room =[[-55,55],[-55,55]]
bin_size = 5
K = 50 # Segment length used to calculate firing rates
CL.delt_t = K*.02
cluster_profile = 0
label = 'Task'
cl_prof_name, good_clusters = get_good_clusters(cluster_profile)
try:
adat = try_cache('One big data structure')
correct_dp = adat[CL.name][animal][session][cl_prof_name][bin_size][label][K]
logging.info('Got data from Cache.cache.')
except:
logging.info('Calculating classifications...')
CL.delt_t=K
fn, trigger_tm = load_mux(animal, session)
vl = load_vl(animal,fn)
cls = {tetrode:load_cl(animal,fn,tetrode) for tetrode in range(1,17)}
label_l = vl['Task']
t_cells = count_cells(vl,cls,trigger_tm,good_clusters)
logging.info('About to generate population vector.')
#X, Y = gpv(vl, t_cells, label_l, K)
s=time()
X, Y = gpv(vl, t_cells, label_l, K, bin_size, room)
logging.info('%i population vectors generated in %.3f.',X.shape[0],time()-s)
Y = Y.reshape([-1])
correct_dp = check_classifier(range(X.shape[0]),range(X.shape[0]),
X, Y, CL, room, bin_size)
# Accuracy meter
plt.figure()
plt.hist(correct_dp,normed=True)
plt.xlabel('Accuracy')
tt = '%s, K: %i, ClPr: %s, Label:%s'%(CL.name,K,cl_prof_name,
label)
plt.title(tt)
msg = []
for i in [1,50,75,90,95,99]:
perc = 1.0*np.sum(correct_dp > i/100.0)/len(correct_dp)*100.0
msg.append('>%i%%: %.1f%%'%(i,perc))
msg = '\n'.join(msg)
plt.xlim([0,1])
xcoord = plt.xlim()[0] + (plt.xlim()[1]-plt.xlim()[0])*.1
ycoord = plt.ylim()[0] + (plt.ylim()[1]-plt.ylim()[0])*.5
plt.text(xcoord,ycoord,msg)
plt.show()
def gpv_rates():
logging.basicConfig(level=logging.INFO)
animal = 66
session = 60
room_shape = [[-55, 55], [-55, 55]]
tetrodes = [1]
cells = range(2, 10)
bin_size = 5
K = 50 # Segment length used to calculate firing rates
#xbins = ybins = (room_shape[0][1]-room_shape[0][0])/bin_size
good_clusters = {tetrode: cells for tetrode in tetrodes}
#good_clusters = get_good_clusters(0)
fn, trigger_tm = load_mux(animal, session)
vl = load_vl(animal, fn)
cls = {tetrode: load_cl(animal, fn, tetrode) for tetrode in tetrodes}
label_l = vl['Task']
t_cells = count_cells(vl, cls, trigger_tm, good_clusters)
logging.info('About to generate population vector.')
X, Y = gpv(vl, t_cells, label_l, K, bin_size, room_shape)
logging.info('%i population vectors generated.', X.shape[0])
Y = Y.reshape([-1])
# GPV rates
rates = fracs_from_pv(X, Y, bin_size, room_shape, smooth_flag=True)
# Now get normally calculate rates
real_rates = get_fracs(vl['xs'],
vl['ys'],
label_l,
room_shape,
bin_size,
t_cells,
smooth_flag=True)
try:
assert np.all(rates == real_rates)
except:
print 'DOESNT WORK!!'
plot_rates(rates, Y, t_cells)
plot_rates(real_rates, Y, t_cells)
plt.show()
def gpv_rates():
logging.basicConfig(level=logging.INFO)
animal = 66
session = 60
room_shape = [[-55,55],[-55,55]]
tetrodes = [1]
cells = range(2,10)
bin_size = 5
K = 50# Segment length used to calculate firing rates
#xbins = ybins = (room_shape[0][1]-room_shape[0][0])/bin_size
good_clusters = {tetrode:cells for tetrode in tetrodes}
#good_clusters = get_good_clusters(0)
fn, trigger_tm = load_mux(animal, session)
vl = load_vl(animal,fn)
cls = {tetrode:load_cl(animal,fn,tetrode) for tetrode in tetrodes}
label_l = vl['Task']
t_cells = count_cells(vl,cls,trigger_tm, good_clusters)
logging.info('About to generate population vector.')
X, Y = gpv(vl, t_cells, label_l, K, bin_size, room_shape)
logging.info('%i population vectors generated.',X.shape[0])
Y = Y.reshape([-1])
# GPV rates
rates = fracs_from_pv(X,Y,bin_size,room_shape,smooth_flag=True)
# Now get normally calculate rates
real_rates = get_fracs(vl['xs'],vl['ys'],label_l,room_shape,bin_size, t_cells,smooth_flag=True)
try:
assert np.all(rates == real_rates)
except:
print 'DOESNT WORK!!'
plot_rates(rates,Y,t_cells)
plot_rates(real_rates,Y,t_cells)
plt.show()
def view_PCA():
animal = 66
session = 60
bin_size = 5
K = 50 # Segment length used to calculate firing rates
label = 'Task'
room = [[-55, 55], [-55, 55]]
_, good_clusters = get_good_clusters(0)
xbins = (room[0][1] - [0][0]) / bin_size
ybins = (room[1][1] - [1][0]) / bin_size
fn, trigger_tm = load_mux(animal, session)
vl = load_vl(animal, fn)
cls = {tetrode: load_cl(animal, fn, tetrode) for tetrode in range(1, 17)}
if label == 'Task':
label_l = vl['Task']
else:
raise Exception('Not implemented yet.')
t_cells = count_cells(vl, cls, trigger_tm, good_clusters)
logging.info('About to generate population vector.')
#X, Y = gpv(vl, t_cells, label_l, K)
X, Y = gpv(vl, t_cells, label_l, K, bin_size, room)
pcas = np.zeros([xbins, ybins])
for xbin, ybin in product(xbins, ybins):
pca = PCA()
Xtmp = np.zeros([
X.shape[0],
])
X = pca.fit_transform(X[:, :len(t_cells)])
pcas[xbin, ybin] = pca
plt.plot(pca.explained_variance_ratio_)
print pca.components_
plt.show()
def view_PCA():
animal = 66
session = 60
bin_size = 5
K = 50 # Segment length used to calculate firing rates
label = "Task"
room = [[-55, 55], [-55, 55]]
_, good_clusters = get_good_clusters(0)
xbins = (room[0][1] - [0][0]) / bin_size
ybins = (room[1][1] - [1][0]) / bin_size
fn, trigger_tm = load_mux(animal, session)
vl = load_vl(animal, fn)
cls = {tetrode: load_cl(animal, fn, tetrode) for tetrode in range(1, 17)}
if label == "Task":
label_l = vl["Task"]
else:
raise Exception("Not implemented yet.")
t_cells = count_cells(vl, cls, trigger_tm, good_clusters)
logging.info("About to generate population vector.")
# X, Y = gpv(vl, t_cells, label_l, K)
X, Y = gpv(vl, t_cells, label_l, K, bin_size, room)
pcas = np.zeros([xbins, ybins])
for xbin, ybin in product(xbins, ybins):
pca = PCA()
Xtmp = np.zeros([X.shape[0]])
X = pca.fit_transform(X[:, : len(t_cells)])
pcas[xbin, ybin] = pca
plt.plot(pca.explained_variance_ratio_)
print pca.components_
plt.show()
fn, trigger_tm = load_mux(animal, session)
vl = load_vl(animal, fn)
cls = {tetrode: load_cl(animal, fn, tetrode) for tetrode in range(1, 17)}
''''''
# Label with task
labels = np.unique(vl['Task'])
label_is = {
contxt: np.nonzero(vl['Task'] == contxt)[0]
for contxt in labels
}
label_l = vl['Task']
t_cells = count_cells(vl, cls, trigger_tm, good_clusters)
X, Y = gpv(vl, t_cells, room_shape, bin_size, label_l, K=32)
classifier = Classifier(X, Y)
correct_dp = []
incorrect_dp = []
for i in range(len(Y)):
sbin = X[i, -1]
x = X[i, :-1]
y = Y[i, 0]
result = classifier.classify(sbin, x)
correct_dp.append(result[y])
incorrect_dp.append(result[-1 * y])
# Process
def run(Folds):
# Toggle-able parameters
#CLs = [CL2,CL6,CL5]
#CLs = [CL6, CL7]
CLs = [CL10]
Ks = np.arange(10, 200,
20) # Segment length used to calculate firing rates
# Sort of toggle-able parameters
#animal_sess_combs = [(66,60),(70,8),(70,10),(66,61)]
animal_sess_combs = [(66, 60)]
#good_trials = try_cache('Good trials')
#animal_sess_combs = [(animal,session) for animal in range(65,74)
# for session in good_trials[animal]]
bin_sizes = [5]
label = 'Task'
exceptions = []
cl_profs = [0]
# Not really toggle-able parameters
room = [[-55, 55], [-55, 55]]
cache = try_cache('One big data structure for %i folds' % (Folds, ))
adat = ({} if cache is None else cache)
for animal, session in animal_sess_combs:
fn, trigger_tm = load_mux(animal, session)
vl = load_vl(animal, fn)
cls = {
tetrode: load_cl(animal, fn, tetrode)
for tetrode in range(1, 17)
}
if label == 'Task': label_l = vl['Task']
else: raise Exception('Not implemented yet.')
for clust_prof in cl_profs:
cl_prof_name, good_clusters = get_good_clusters(clust_prof)
t_cells = count_cells(vl, cls, trigger_tm, good_clusters)
for bin_size, K in product(bin_sizes, Ks):
cached = np.zeros(len(CLs))
for CL in CLs:
i = CLs.index(CL)
try:
raise Exception
adat[CL.name][animal][session][cl_prof_name][bin_size][
label][K]
cached[i] = True
except:
cached[i] = False
if np.sum(cached) == len(CLs):
print 'Everything already cached'
continue # Everything is already cached!
logging.info('About to generate population vector.')
X, Y = gpv(vl, t_cells, label_l, K, bin_size, room)
# The main data stricture
dps = {CL: [] for CL in CLs if CL not in cached}
if Folds > 0:
kf = cross_validation.KFold(len(Y),
n_folds=Folds,
shuffle=True)
else:
kf = [(range(len(Y)), range(len(Y)))]
for train_index, test_index in kf:
logging.warning('Training/testing: %i/%i',
len(train_index), len(test_index))
for CL in CLs:
if cached[CLs.index(CL)]: continue
logging.warning('%s, %i seg, (%i, %i)', CL.name, K,
animal, session)
if (CL, clust_prof) in exceptions: continue
CL.delt_t = K
correct_dp = check_classifier(train_index, test_index,
X, Y, CL, room, bin_size)
dps[CL].extend(correct_dp.tolist())
for CL in CLs:
if cached[CLs.index(CL)]: continue
to_add = np.array(dps[CL]).reshape([-1])
add(adat, CL.name, animal, session, cl_prof_name, bin_size,
label, K, to_add)
store_in_cache('One big data structure for %i folds' % (Folds, ), adat)
def run(Folds):
# Toggle-able parameters
#CLs = [CL2,CL6,CL5]
#CLs = [CL6, CL7]
CLs = [CL10]
Ks = np.arange(10,200,20) # Segment length used to calculate firing rates
# Sort of toggle-able parameters
#animal_sess_combs = [(66,60),(70,8),(70,10),(66,61)]
animal_sess_combs = [(66,60)]
#good_trials = try_cache('Good trials')
#animal_sess_combs = [(animal,session) for animal in range(65,74)
# for session in good_trials[animal]]
bin_sizes = [5]
label = 'Task'
exceptions = []
cl_profs = [0]
# Not really toggle-able parameters
room = [[-55,55],[-55,55]]
cache = try_cache('One big data structure for %i folds'%(Folds,))
adat = ({} if cache is None else cache)
for animal, session in animal_sess_combs:
fn, trigger_tm = load_mux(animal, session)
vl = load_vl(animal,fn)
cls = {tetrode:load_cl(animal,fn,tetrode) for tetrode in range(1,17)}
if label == 'Task': label_l = vl['Task']
else: raise Exception('Not implemented yet.')
for clust_prof in cl_profs:
cl_prof_name, good_clusters = get_good_clusters(clust_prof)
t_cells = count_cells(vl,cls,trigger_tm,good_clusters)
for bin_size, K in product(bin_sizes,Ks):
cached = np.zeros(len(CLs))
for CL in CLs:
i = CLs.index(CL)
try:
raise Exception
adat[CL.name][animal][session][cl_prof_name][bin_size][label][K]
cached[i] = True
except:
cached[i] = False
if np.sum(cached) == len(CLs):
print 'Everything already cached'
continue # Everything is already cached!
logging.info('About to generate population vector.')
X, Y = gpv(vl, t_cells, label_l, K, bin_size, room)
# The main data stricture
dps = {CL:[] for CL in CLs if CL not in cached}
if Folds >0: kf = cross_validation.KFold(len(Y),n_folds=Folds,shuffle=True)
else: kf = [(range(len(Y)),range(len(Y)))]
for train_index, test_index in kf:
logging.warning('Training/testing: %i/%i',len(train_index),len(test_index))
for CL in CLs:
if cached[CLs.index(CL)]: continue
logging.warning('%s, %i seg, (%i, %i)',CL.name, K, animal, session)
if (CL,clust_prof) in exceptions: continue
CL.delt_t = K
correct_dp = check_classifier(train_index,test_index,X,Y,CL, room, bin_size)
dps[CL].extend(correct_dp.tolist())
for CL in CLs:
if cached[CLs.index(CL)]: continue
to_add = np.array(dps[CL]).reshape([-1])
add(adat, CL.name, animal, session, cl_prof_name, bin_size, label, K, to_add)
store_in_cache('One big data structure for %i folds'%(Folds,),adat)
bin_size = 8
K = 32 # Segment length used to calculate firing rates
fn, trigger_tm = load_mux(animal, session)
vl = load_vl(animal,fn)
cls = {tetrode:load_cl(animal,fn,tetrode) for tetrode in range(1,17)}
''''''
# Label with task
labels = np.unique(vl['Task'])
label_is = {contxt: np.nonzero(vl['Task']==contxt)[0] for contxt in labels}
label_l = vl['Task']
t_cells = count_cells(vl,cls,trigger_tm,good_clusters)
X, Y = gpv(vl, t_cells, room_shape, bin_size, label_l, K=32)
classifier = Classifier(X,Y)
correct_dp = []
incorrect_dp = []
for i in range(len(Y)):
sbin = X[i,-1]
x = X[i,:-1]
y = Y[i,0]
result = classifier.classify(sbin,x)
correct_dp.append(result[y])
incorrect_dp.append(result[-1*y])
# Process
