def rate_graph():
    animal = 66
    session = 60  # This is August 7, 2013 run
    room_shape = [[-55, 55], [-55, 55]]
    tetrodes = range(1, 17)
    cluster_profile = 0
    bin_size = 5

    _, good_clusters = get_good_clusters(cluster_profile)

    fn, trigger_tm = load_mux(animal, session)
    vl = load_vl(animal, fn)
    cls = {tetrode: load_cl(animal, fn, tetrode) for tetrode in tetrodes}
    tpp = 1.0 * np.mean(vl["Time"][1:] - vl["Time"][:-1])

    t_cells = count_cells(vl, cls, trigger_tm, good_clusters)

    label_l = vl["Task"]

    # rates[cell, lbl, xbin, ybin] = firing rate
    rates = get_fracs(vl["xs"], vl["ys"], label_l, room_shape, bin_size, t_cells)
    rates /= tpp

    plot_rates(rates, label_l, t_cells)

    plt.show()
Example #2
0
def rate_graph():
    animal = 66
    session = 60  # This is August 7, 2013 run
    room_shape = [[-55, 55], [-55, 55]]
    tetrodes = range(1, 17)
    cluster_profile = 0
    bin_size = 5

    _, good_clusters = get_good_clusters(cluster_profile)

    fn, trigger_tm = load_mux(animal, session)
    vl = load_vl(animal, fn)
    cls = {tetrode: load_cl(animal, fn, tetrode) for tetrode in tetrodes}
    tpp = 1.0 * np.mean(vl['Time'][1:] - vl['Time'][:-1])

    t_cells = count_cells(vl, cls, trigger_tm, good_clusters)

    label_l = vl['Task']

    # rates[cell, lbl, xbin, ybin] = firing rate
    rates = get_fracs(vl['xs'], vl['ys'], label_l, room_shape, bin_size,
                      t_cells)
    rates /= tpp

    plot_rates(rates, label_l, 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()
Example #4
0
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 train(self, X, Y, room, bin_size):
        ''' Generate self.base_vec, where
            base_vec[xbin,ybin,context,:] is vector of firing rates.
            
            Assume that X is a [# examples, # cells + 2] array, where
            X[:,-2] is the x loc and X[:,-1] is y loc.
            
            room is [[xmin,xmax],[ymin,ymax]]'''
        assert (room[0][1] - room[0][0]) % bin_size == 0
        assert (room[1][1] - room[1][0]) % bin_size == 0

        # rates[cell id, lbl, xbin, ybin] = rate
        rates = fracs_from_pv(X, Y, bin_size, room)

        # Pass the rates stuff to draw before reorder indices
        if logging.getLogger().level <= 5:
            import matplotlib.pyplot as plt
            from Figures.rateGraphLib import plot_rates
            fake_t_cells = {(-1, k): 0 for k in range(rates.shape[0])}
            plot_rates(rates, Y, fake_t_cells)
            plt.show()

        self.base = rates
 def train(self, X, Y, room, bin_size):
     ''' Generate self.base_vec, where
         base_vec[xbin,ybin,context,:] is vector of firing rates.
         
         Assume that X is a [# examples, # cells + 2] array, where
         X[:,-2] is the x loc and X[:,-1] is y loc.
         
         room is [[xmin,xmax],[ymin,ymax]]'''
     assert (room[0][1]-room[0][0])%bin_size==0
     assert (room[1][1]-room[1][0])%bin_size==0
     
     # rates[cell id, lbl, xbin, ybin] = rate
     rates = fracs_from_pv(X,Y,bin_size,room)
     
     # Pass the rates stuff to draw before reorder indices
     if logging.getLogger().level <= 5:
         import matplotlib.pyplot as plt
         from Figures.rateGraphLib import plot_rates
         fake_t_cells = {(-1,k):0 for k in range(rates.shape[0])}
         plot_rates(rates,Y,fake_t_cells)
         plt.show()
     
     self.base = rates
def checkGPV():
    logging.basicConfig(level=5)
    animal = 66
    session = 60
    room_shape = [[-55, 55], [-55, 55]]
    tetrodes = [1]
    cells = range(2, 10)
    bin_size = 5
    K = 1  # Segment length used to calculate firing rates

    maxs = 10000

    assert maxs % K == 0

    #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)
    ''''''
    # For debugging purposes, make sure it's not too big
    if len(label_l) > maxs:
        vl['xs'] = vl['xs'][:maxs * 10:10]
        vl['ys'] = vl['ys'][:maxs * 10:10]
        label_l = label_l[:maxs * 10:10]
        for key in t_cells:
            tmp = np.array(t_cells[key])
            tmp = tmp[tmp < maxs]
            t_cells[key] = tmp

    for gpv in [gpv1]:

        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])

        # Debug code
        # This is only true if no points are thrown away
        if X.shape[0] * K == maxs:
            tot_spks = np.sum(
                [len(np.unique(spki)) for spki in t_cells.values()])
            assert tot_spks == np.sum(X[:, :len(t_cells)]) * K

        # GPV rates
        rates = fracs_from_pv(X, Y, bin_size, room_shape, smooth_flag=False)

        # Now get normally calculate rates
        real_rates = get_fracs(vl['xs'],
                               vl['ys'],
                               label_l,
                               room_shape,
                               bin_size,
                               t_cells,
                               smooth_flag=False)

        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()
Example #8
0
def checkGPV():
    logging.basicConfig(level=5)
    animal = 66
    session = 60 
    room_shape = [[-55,55],[-55,55]]
    tetrodes = [1]
    cells = range(2,10)
    bin_size = 5
    K =  1# Segment length used to calculate firing rates
    
    
    maxs = 10000
    
    assert maxs%K==0
    
    #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)
    
    ''''''
    # For debugging purposes, make sure it's not too big
    if len(label_l) > maxs:
        vl['xs'] = vl['xs'][:maxs*10:10]
        vl['ys'] = vl['ys'][:maxs*10:10]
        label_l = label_l[:maxs*10:10]
        for key in t_cells:
            tmp = np.array(t_cells[key])
            tmp = tmp[tmp<maxs]
            t_cells[key] = tmp
    
    for gpv in [gpv1]:
    
        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])
        
        # Debug code
        # This is only true if no points are thrown away
        if X.shape[0]*K == maxs:
            tot_spks = np.sum([len(np.unique(spki)) for spki in t_cells.values()])
            assert tot_spks == np.sum(X[:,:len(t_cells)])*K

        # GPV rates
        rates = fracs_from_pv(X,Y,bin_size,room_shape,smooth_flag=False)
        
        # Now get normally calculate rates
        real_rates = get_fracs(vl['xs'],vl['ys'],label_l,room_shape,bin_size, t_cells,smooth_flag=False)
        
        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()