def compute_nfit(features): 
    IT_feats = dataset.neuronal_features[:, dataset.IT_NEURONS]
    V4_feats = dataset.neuronal_features[:, dataset.V4_NEURONS]
    spec_IT_reg = {'npc_train': 70,
               'npc_test': 10,
               'num_splits': 5,
               'npc_validate': 0,
               'metric_screen': 'regression',
               'metric_labels': None,
               'metric_kwargs': {'model_type': 'pls.PLSRegression',
                                 'model_kwargs': {'n_components':25}},
                'labelfunc': lambda x: (IT_feats, None),
                'train_q': {'var':['V3', 'V6']},
                'test_q': {'var':['V3', 'V6']},
                'split_by': 'obj'}
    spec_V4_reg = copy.deepcopy(spec_IT_reg)
    spec_V4_reg['labelfunc'] = lambda  x: (V4_feats, None)
    
    result_IT = utils.compute_metric(features, dataset, spec_IT_reg)
    print('... IT fit')
    result_V4 = utils.compute_metric(features, dataset, spec_V4_reg)
    print('... V4 fit')    

    # noise correction
    espec = (('all','','IT_regression'), spec_IT_reg)
    post_process_neural_regression_msplit(dataset, result_IT, espec, n_jobs=1)
    espec = (('all','','V4_regression'), spec_V4_reg)
    post_process_neural_regression_msplit(dataset, result_V4, espec, n_jobs=1)

    return {'IT': result_IT['noise_corrected_multi_rsquared_loss'], 'V4': result_V4['noise_corrected_multi_rsquared_loss']}
Beispiel #2
0
def get_facepackage_analysis(F, F_hvm):

    e = copy.deepcopy(reg_eval_it)
    e['metric_kwargs']['model_kwargs']['n_components'] = 25
    e['num_splits'] = 1
    e['test_q'].pop('var')
    e['npc_test'] = 1
    e['npc_train'] = 80
    resit = utils.compute_metric(F_hvm,
                                 hvm_dataset,
                                 e,
                                 attach_predictions=True,
                                 return_splits=True,
                                 attach_models=True)

    model = resit['split_results'][0]['model']
    popF = model.predict(F)
    pop_hvm = model.predict(F_hvm)

    import dldata.stimulus_sets.michael_cohen as mc
    dataset = mc.MichaelCohenFaceImagePackage()
    meta = dataset.meta
    dp = get_facepackage_dprimes(popF, pop_hvm, meta)
    dp1 = get_facepackage_dprimes(F, F_hvm, meta)

    return dp, dp1, popF, F
Beispiel #3
0
def get_neural_fit(F, n_components=None):
    e = reg_eval_it
    if n_components is not None:
        e = copy.deepcopy(e)
        e['metric_kwargs']['model_kwargs']['n_components'] = n_components
    resit = utils.compute_metric(F, hvm_dataset, e, attach_predictions=False)
    espec = (('all', '', 'IT_regression'), e)
    post_process_neural_regression_msplit(hvm_dataset, resit, espec, n_jobs=1)
    print('IT fit', 1 - resit['noise_corrected_multi_rsquared_loss'])

    e = reg_eval_IT_obj_half
    if n_components is not None:
        e = copy.deepcopy(e)
        e['metric_kwargs']['model_kwargs']['n_components'] = n_components
    resit_o = utils.compute_metric(F, hvm_dataset, e, attach_predictions=False)
    espec = (('all', '', 'IT_regression'), e)
    post_process_neural_regression_msplit(hvm_dataset,
                                          resit_o,
                                          espec,
                                          n_jobs=1)
    print('ito fit', 1 - resit_o['noise_corrected_multi_rsquared_loss'])

    e = reg_eval_IT_category_half
    if n_components is not None:
        e = copy.deepcopy(e)
        e['metric_kwargs']['model_kwargs']['n_components'] = n_components
    resit_c = utils.compute_metric(F, hvm_dataset, e, attach_predictions=False)
    espec = (('all', '', 'IT_regression'), e)
    post_process_neural_regression_msplit(hvm_dataset,
                                          resit_c,
                                          espec,
                                          n_jobs=1)

    e = reg_eval_v4
    if n_components is not None:
        e = copy.deepcopy(e)
        e['metric_kwargs']['model_kwargs']['n_components'] = n_components
    resv4 = utils.compute_metric(F, hvm_dataset, e, attach_predictions=False)
    espec = (('all', '', 'V4_regression'), e)
    post_process_neural_regression_msplit(hvm_dataset, resv4, espec, n_jobs=1)
    print('V4 fit', 1 - resv4['noise_corrected_multi_rsquared_loss'])

    return {'IT': resit, 'V4': resv4, 'IT_o': resit_o, 'IT_c': resit_c}
Beispiel #4
0
def get_fit_analysis(F):

    R = {}

    for n in [2, 5, 10, 15, 20, 25, 30]:
        fit_res = get_neural_fit(F, n_components=n)
        R[('fit_res', n)] = fit_res

        e = copy.deepcopy(reg_eval_IT_obj_half)
        e['metric_kwargs']['model_kwargs']['n_components'] = n
        e['num_splits'] = 1
        e['test_q'].pop('var')
        e['npc_test'] = 90
        resit_o = utils.compute_metric(F,
                                       hvm_dataset,
                                       e,
                                       attach_predictions=True,
                                       return_splits=True)
        pop = np.array(resit_o['split_results'][0]['test_prediction'])
        ts = np.array(resit_o['splits'][0][0]['test'])
        dpv0 = get_face_dprimes(pop, var_level='V0', inds=ts)
        dpv3 = get_face_dprimes(pop, var_level='V3', inds=ts)
        dpv6 = get_face_dprimes(pop, var_level='V6', inds=ts)
        dpall = get_face_dprimes(pop, var_level=None, inds=ts)

        thresholds = [.25, .5, .75, 1, 1.25, 1.5, 1.75, 2, 2.5, 5]
        face_selectivity_levels = {}

        def count(x, thr):
            n = len((x > thr).nonzero()[0]) * 100
            return float(n) / len(x)

        for thr in thresholds:
            face_selectivity_levels[('fitpop', None, thr)] = count(dpall, thr)
            face_selectivity_levels[('fitpop', 'V0', thr)] = count(dpv0, thr)
            face_selectivity_levels[('fitpop', 'V3', thr)] = count(dpv3, thr)
            face_selectivity_levels[('fitpop', 'V6', thr)] = count(dpv6, thr)

        face_stats = {
            'fitpop_face_dprimes_all': dpall,
            'fitpop_face_dprimes_v0': dpv0,
            'fitpop_face_dprimes_v3': dpv3,
            'fitpop_face_dprimes_v6': dpv6,
            'selectivities': face_selectivity_levels
        }

        R[('face_statistics', n)] = face_stats
    return R
def compute_perf(F, ntrain=None, ntest=5, num_splits=20, split_by='obj', var_levels=('V3', 'V6'), gridcv=False, attach_predictions=False, attach_models=False, reg_model_kwargs=None, justcat=False, model_type='svm.LinearSVC', model_kwargs=None):

    R = {}

    if model_kwargs is None:
        if gridcv:
            model_kwargs = {'GridSearchCV_params': {'C': [1e-4, 5e-4, 1e-3, 5e-3, 1e-2, 5e-2, 1e-1, 5e-1, 1e1, 5e1, 1e2, 5e2, 1e3, 5e3, 1e4, 5e4]}}
        else:
            model_kwargs = {'C':5e-3}

    basic_category_eval = {'npc_train': ntrain,
        'npc_test': ntest,
        'num_splits': num_splits,
        'npc_validate': 0,
        'metric_screen': 'classifier',
        'metric_labels': None,
        'metric_kwargs': {'model_type': model_type,
                          'model_kwargs': model_kwargs
                         },
        'labelfunc': 'category',
        'train_q': {'var': list(var_levels)},
        'test_q': {'var': list(var_levels)},
        'split_by': split_by}

    R['basic_category_result'] = utils.compute_metric(F, dataset, basic_category_eval, attach_models=attach_models, attach_predictions=attach_predictions)
    print('...finished categorization')
    if justcat:
        return R

    masks = dataset.pixel_masks

    volumes = masks.sum(1).sum(1)

    def get_axis_bb(x):
        nzx, nzy = x.nonzero()
        if len(nzx):
            return (nzy.min(), nzx.min(), nzy.max(), nzx.max())
        else:
            return (-128, -128, -128, -128)

    axis_bb = np.array(map(get_axis_bb, masks))

    get_axis_bb_ctr = lambda x: ((x[1] + x[3])/2, (x[0] + x[2])/2)

    axis_bb_ctr = np.array(map(get_axis_bb_ctr, axis_bb))

    axis_bb_sx = np.abs(axis_bb[:, 2] - axis_bb[:, 0])
    axis_bb_sy = np.abs(axis_bb[:, 3] - axis_bb[:, 1])
    axis_bb_area = axis_bb_sx * axis_bb_sy

    axis_bb_sx = np.abs(axis_bb[:, 2] - axis_bb[:, 0])
    axis_bb_sy = np.abs(axis_bb[:, 3] - axis_bb[:, 1])
    axis_bb_area = axis_bb_sx * axis_bb_sy

    borders = dataset.pixel_borders(thickness=1)
    area_bb = np.array(map(hvm.get_best_box, borders))
    area_bb[3818] = -128

    def line(a1, a2):
        if a1[0] != a2[0] and a1[1] != a2[1]:
            m = (a2[1] - a1[1]) / float(a2[0] - a1[0])
            b = a1[1] - m * a1[0]
        elif a1[1] == a2[1]:
            m = np.inf
            b = np.nan
        elif a1[0] == a2[0]:
            m = 0
            b = a1[0]
        return m, b

    def intersection(a):
        a1, a2, a3, a4 = a
        m1, b1 = line(a1, a4)
        m2, b2 = line(a2, a3)
        if not np.isinf(m1):
            if not np.isinf(m2):
                ix = (b2 - b1)/(m1 - m2)
            else:
                ix = a3[1]
            iy = m1 * ix + b1
        else:
            ix = a1[1]
            iy = m2 * ix + b2
        return ix, iy

    area_bb_ctr = np.array(map(intersection, area_bb))
    dist = lambda _b1, _b2: math.sqrt((_b1[0] - _b2[0])**2 + (_b1[1] - _b2[1])**2)
    def sminmax(a):
        a1, a2, a3, a4 = a
        s1 = dist(a1, a2)
        s2 = dist(a1, a3)
        smin = min(s1, s2)
        smax = max(s1, s2)
        return smin, smax

    area_bb_minmax = np.array(map(sminmax, area_bb))
    area_bb_area = area_bb_minmax[:, 0] * area_bb_minmax[:, 1]

    dist = lambda _b1, _b2: np.sqrt((_b1[0] - _b2[0])**2 + (_b1[1] - _b2[1])**2)

    def get_major_axis(a):
        a1, a2, a3, a4 = a
        s1 = dist(a1, a2)
        s2 = dist(a1, a3)
        if s1 > s2:
            m11 = a1
            m12 = a3
            m21 = a2
            m22 = a4
        else:
            m11 = a1
            m12 = a2
            m21 = a3
            m22 = a4

        mj1 = (m11 + m12)/2
        mj2 = (m21 + m22)/2
        return (mj1, mj2)

    def nonan(f):
        f[np.isnan(f)] = 0
        return f

    area_bb_major_axes = np.array(map(get_major_axis, area_bb))
    sin_maj = nonan((area_bb_major_axes[:, 0, 1] - area_bb_major_axes[:, 1, 1]) / dist(area_bb_major_axes[:, 0].T, area_bb_major_axes[:, 1].T))
    cos_maj = nonan((area_bb_major_axes[:, 0, 0] - area_bb_major_axes[:, 1, 0]) / dist(area_bb_major_axes[:, 0].T, area_bb_major_axes[:, 1].T))

    if reg_model_kwargs is None:
        reg_model_kwargs = {'alphas': [1e-4, 1e-3, 1e-2, 5e-2, 1e-1, 2.5e-1, 5e-1, .75e-1, 1e0, 2.5e0, 5e0, 1e1, 25, 1e2, 1e3]}

    def make_spec(f):
        x = {'npc_train': ntrain,
        'npc_test': ntest,
        'num_splits': num_splits,
        'npc_validate': 0,
        'metric_screen': 'regression',
        'metric_labels': None,
        'metric_kwargs': {'model_type': 'linear_model.RidgeCV',
                          'model_kwargs': reg_model_kwargs},
        'train_q': {'var': list(var_levels)},
        'test_q': {'var': list(var_levels)},
        'split_by': split_by}

        x['labelfunc'] = f
        return x

    volume_spec = make_spec(lambda x: (volumes, None))
    R['volume_result'] = utils.compute_metric(F, dataset, volume_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... finished volume')

    perimeters = borders.sum(1).sum(1)
    perimeter_spec = make_spec(lambda x: (perimeters, None))
    R['perimeter_result'] = utils.compute_metric(F, dataset, perimeter_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... finished perimeter')

    axis_bb_sx_spec = make_spec(lambda x: (axis_bb_sx, None))
    axis_bb_sy_spec = make_spec(lambda x: (axis_bb_sy, None))
    axis_bb_asp_spec = make_spec(lambda x: (axis_bb_sx / np.maximum(axis_bb_sy, 1e-5), None))
    axis_bb_area_spec = make_spec(lambda x: (axis_bb_area, None))

    R['axis_bb_sx_result'] = utils.compute_metric(F, dataset, axis_bb_sx_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... finished axis_bb_sx')
    R['axis_bb_sy_result'] = utils.compute_metric(F, dataset, axis_bb_sy_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... finished axis_bb_sy')
    R['axis_bb_asp_result'] = utils.compute_metric(F, dataset, axis_bb_asp_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... finished axis_bb_asp')
    R['axis_bb_area_result'] = utils.compute_metric(F, dataset, axis_bb_area_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... finished axis_bb_area')

    area_bb_smin_spec = make_spec(lambda x: (area_bb_minmax[:, 0], None))
    area_bb_smax_spec = make_spec(lambda x: (area_bb_minmax[:, 1], None))

    area_bb_asps = area_bb_minmax[:, 1]/np.maximum(area_bb_minmax[:, 0], 1e-5)
    area_bb_asp_spec = make_spec(lambda x: (area_bb_asps, None))
    area_bb_area_spec = make_spec(lambda x: (area_bb_area, None))

    sinmajs = np.abs(sin_maj)
    sinmaj_spec = make_spec(lambda x: (sinmajs, None))

    R['area_bb_smin_result'] = utils.compute_metric(F, dataset, area_bb_smin_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... area_bb_smin')
    R['area_bb_smax_result'] = utils.compute_metric(F, dataset, area_bb_smax_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... area_bb_smax')
    R['area_bb_asp_result'] = utils.compute_metric(F, dataset, area_bb_asp_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... area_bb_asp')
    R['area_bb_area_result'] = utils.compute_metric(F, dataset, area_bb_area_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... area_bb_area')
    R['sinmaj_result'] = utils.compute_metric(F, dataset, sinmaj_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... sinmaj')

    #position
    posx_spec = make_spec(lambda x: (x['ty'], None))
    posy_spec = make_spec(lambda x: (x['tz'], None))
    R['posx_result'] = utils.compute_metric(F, dataset, posx_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    R['posy_result'] = utils.compute_metric(F, dataset, posy_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)


    size_spec = make_spec(lambda x: (x ['s'], None))
    R['size_result'] = utils.compute_metric(F, dataset, size_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... size')

    masksv0 = masks[meta['var'] == 'V0'][::10]
    objs = meta['obj'][meta['var'] == 'V0'][::10]
    A = np.array([_x.nonzero()[0][[0, -1]] if _x.sum() > 0 else (0, 0) for _x in masksv0.sum(1) ])
    B = np.array([_x.nonzero()[0][[0, -1]] if _x.sum() > 0 else (0, 0) for _x in masksv0.sum(2) ])
    base_size_factors = dict(zip( objs, np.maximum(A[:, 1] - A[:, 0], B[:, 1] - B[:, 0])))
    size_factors = np.zeros(len(meta))
    for o in objs:
        inds = [meta['obj'] == o]
        size_factors[inds] = base_size_factors[o] * .01
    scaled_size  = size_factors * meta['s']
    scaled_size_spec = make_spec(lambda x: (scaled_size, None))
    R['scaled_size_result'] = utils.compute_metric(F, dataset, scaled_size_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... scaled size')

    rxy_spec = make_spec(lambda x: (x['rxy_semantic'], None))
    rxz_spec = make_spec(lambda x: (x['rxz_semantic'], None))
    ryz_spec = make_spec(lambda x: (x['ryz_semantic'], None))
    R['rxy_result'] = utils.compute_metric(F, dataset, rxy_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    R['rxz_result'] = utils.compute_metric(F, dataset, rxz_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    R['ryz_result'] = utils.compute_metric(F, dataset, ryz_spec, attach_models=attach_models, attach_predictions=attach_predictions, return_splits=False)
    print('... rotations')

    return R
Beispiel #6
0
spec_IT_reg = {'npc_train': 70,
           'npc_test': 10,
           'num_splits': 5,
           'npc_validate': 0,
           'metric_screen': 'regression',
           'metric_labels': None,
           'metric_kwargs': {'model_type': 'pls.PLSRegression',
                             'model_kwargs': {'n_components':25}},
            'labelfunc': lambda x: (IT_feats, None),
            'train_q': {'var':['V3', 'V6']},
            'test_q': {'var':['V3', 'V6']},
            'split_by': 'obj'}
#spec_V4_reg = copy.deepcopy(spec_IT_reg)
#spec_V4_reg['labelfunc'] = lambda  x: (V4_feats, None)

result_IT = utils.compute_metric(features, hvm_dataset, spec_IT_reg)
#result_V4 = utils.compute_metric(features, hvm_dataset, spec_V4_reg)

# noise correction
espec = (('all','','IT_regression'), spec_IT_reg)
post_process_neural_regression_msplit(hvm_dataset, result_IT, espec, n_jobs=1)
#espec = (('all','','V4_regression'), spec_V4_reg)
#post_process_neural_regression_msplit(hvm_dataset, result_V4, espec, n_jobs=1)

print('IT fit', result_IT['noise_corrected_multi_rsquared_loss'])
#print('V4 fit', result_V4['noise_corrected_multi_rsquared_loss'])

#result = {'IT': result_IT, 'V4': result_V4}
output_file = '/'.join(feature_file.split('/')[:-2]) + '/neural_fit/results_' + '_'.join(feature_file.split('/')[-1].split('_')[1:].split('.')[0]) + '.p'
#output_file = "/om/user/hyo/metrics/neural_spatial/dimensionality/features/neural_fit/results_" + '_'.join(feature_file.split('_')[1:])
if nfeat is not None:
Beispiel #7
0
def get_neural_fit_lasso(F):

    reg_evals_it = [{
        'labelfunc':
        functools.partial(lambda _i, x: (IT_feats[:, _i], None), i),
        'metric_kwargs': {
            'model_kwargs': {
                'alphas': [
                    1e-4, 1e-3, 1e-2, 5e-2, 1e-1, 2.5e-1, 5e-1, .75e-1, 1e0,
                    2.5e0, 5e0, 1e1, 25, 1e2, 1e3
                ]
            },
            'model_type': 'linear_model.LassoCV'
        },
        'metric_labels':
        None,
        'metric_screen':
        'regression',
        'npc_test':
        10,
        'npc_train':
        70,
        'npc_validate':
        0,
        'num_splits':
        5,
        'split_by':
        'obj',
        'test_q': {
            'var': ['V3', 'V6']
        },
        'train_q': {
            'var': ['V3', 'V6']
        }
    } for i in range(IT_feats.shape[1])]

    reg_evals_IT_obj_half = [{
        'labelfunc':
        functools.partial(lambda _i, x: (IT_feats[:, _i], None), i),
        'metric_kwargs': {
            'model_kwargs': {
                'alphas': [
                    1e-4, 1e-3, 1e-2, 5e-2, 1e-1, 2.5e-1, 5e-1, .75e-1, 1e0,
                    2.5e0, 5e0, 1e1, 25, 1e2, 1e3
                ]
            },
            'model_type': 'linear_model.LassoCV'
        },
        'metric_labels':
        None,
        'metric_screen':
        'regression',
        'npc_test':
        75,
        'npc_train':
        80,
        'npc_validate':
        0,
        'num_splits':
        5,
        'split_by':
        'obj',
        'test_q': {
            'obj': hvm.OBJECT_SET_2,
            'var': ['V3', 'V6']
        },
        'train_q': {
            'obj': hvm.OBJECT_SET_1
        },
        'var': ['V3', 'V6']
    } for i in range(IT_feats.shape[1])]

    reg_evals_IT_category_half = [{
        'labelfunc':
        functools.partial(lambda _i, x: (IT_feats[:, _i], None), i),
        'metric_kwargs': {
            'model_kwargs': {
                'alphas': [
                    1e-4, 1e-3, 1e-2, 5e-2, 1e-1, 2.5e-1, 5e-1, .75e-1, 1e0,
                    2.5e0, 5e0, 1e1, 25, 1e2, 1e3
                ]
            },
            'model_type': 'linear_model.LassoCV'
        },
        'metric_labels':
        None,
        'metric_screen':
        'regression',
        'npc_test':
        75,
        'npc_train':
        80,
        'npc_validate':
        0,
        'num_splits':
        5,
        'split_by':
        'obj',
        'train_q': {
            'category': hvm_dataset.categories[::2],
            'var': ['V3', 'V6']
        },
        'test_q': {
            'category': hvm_dataset.categories[1::2]
        },
        'var': ['V3', 'V6']
    } for i in range(IT_feats.shape[1])]

    reg_evals_v4 = [{
        'labelfunc':
        functools.partial(lambda _i, x: (V4_feats[:, _i], None), i),
        'metric_kwargs': {
            'model_kwargs': {
                'alphas': [
                    1e-4, 1e-3, 1e-2, 5e-2, 1e-1, 2.5e-1, 5e-1, .75e-1, 1e0,
                    2.5e0, 5e0, 1e1, 25, 1e2, 1e3
                ]
            },
            'model_type': 'linear_model.LassoCV'
        },
        'metric_labels':
        None,
        'metric_screen':
        'regression',
        'npc_test':
        10,
        'npc_train':
        70,
        'npc_validate':
        0,
        'num_splits':
        5,
        'split_by':
        'obj',
        'test_q': {
            'var': ['V3', 'V6']
        },
        'train_q': {
            'var': ['V3', 'V6']
        }
    } for i in range(V4_feats.shape[1])]

    resits = [
        utils.compute_metric(F, hvm_dataset, e, attach_predictions=False)
        for e in reg_evals_it
    ]
    espec = (('all', '', 'IT_regression'), e)
    resit = post_process_neural_regression_msplit_aggregate(hvm_dataset,
                                                            resits,
                                                            espec,
                                                            n_jobs=1)
    print('IT fit', 1 - resit['noise_corrected_multi_rsquared_loss'])

    resits_o = [
        utils.compute_metric(F, hvm_dataset, e, attach_predictions=False)
        for e in reg_evals_IT_obj_half
    ]
    espec = (('all', '', 'IT_regression'), e)
    resit_o = post_process_neural_regression_msplit_aggregate(hvm_dataset,
                                                              resits_o,
                                                              espec,
                                                              n_jobs=1)

    resits_c = [
        utils.compute_metric(F, hvm_dataset, e, attach_predictions=False)
        for e in reg_evals_IT_category_half
    ]
    espec = (('all', '', 'IT_regression'), e)
    resit_c = post_process_neural_regression_msplit_aggregate(hvm_dataset,
                                                              resits_c,
                                                              espec,
                                                              n_jobs=1)

    resv4s = [
        utils.compute_metric(F, hvm_dataset, e, attach_predictions=False)
        for e in reg_evals_v4
    ]
    espec = (('all', '', 'V4_regression'), e)
    resv4 = post_process_neural_regression_msplit_aggregate(hvm_dataset,
                                                            resv4s,
                                                            espec,
                                                            n_jobs=1)
    print('V4 fit', 1 - resv4['noise_corrected_multi_rsquared_loss'])
    return {'IT': resit, 'V4': resv4, 'IT_o': resit_o, 'IT_c': resit_c}
Beispiel #8
0
def hvm_analysis(F,
                 dataset,
                 ntrain=None,
                 ntest=2,
                 num_splits=20,
                 split_by='obj',
                 var_levels=('V3', 'V6'),
                 gridcv=False,
                 attach_predictions=False,
                 attach_models=False,
                 reg_model_kwargs=None,
                 justcat=False,
                 model_type='svm.LinearSVC',
                 model_kwargs=None,
                 do_centroids=True,
                 centroid_sparsity=16,
                 subordinate=True):

    meta = dataset.meta

    #    perm = np.random.RandomState(0).permutation(F.shape[1])
    #    F = F[:, perm]

    R = {}

    if model_kwargs is None:
        if gridcv:
            model_kwargs = {
                'GridSearchCV_params': {
                    'C': [
                        1e-4, 5e-4, 1e-3, 5e-3, 1e-2, 5e-2, 1e-1, 5e-1, 1e1,
                        5e1, 1e2, 5e2, 1e3, 5e3, 1e4, 5e4
                    ]
                }
            }
        else:
            model_kwargs = {'C': 5e-3}

    basic_category_eval = {
        'npc_train': ntrain,
        'npc_test': ntest,
        'num_splits': num_splits,
        'npc_validate': 0,
        'metric_screen': 'classifier',
        'metric_labels': None,
        'metric_kwargs': {
            'model_type': model_type,
            'model_kwargs': model_kwargs
        },
        'labelfunc': 'category',
        'train_q': {
            'var': list(var_levels)
        },
        'test_q': {
            'var': list(var_levels)
        },
        'split_by': split_by
    }

    categories = dataset.categories
    subordinate_evals = {}
    subordinate_evals_sparse = {}
    for c in categories:
        _spec = copy.deepcopy(basic_category_eval)
        _spec['labelfunc'] = 'obj'
        _spec['train_q']['category'] = [c]
        _spec['test_q']['category'] = [c]
        subordinate_evals[c] = _spec

    R['basic_category_result'] = utils.compute_metric(
        F,
        dataset,
        basic_category_eval,
        attach_models=attach_models,
        attach_predictions=attach_predictions)
    print('...finished categorization')
    if justcat and not subordinate:
        return R

    if split_by not in ['category']:
        R['subordinate_results'] = dict([
            (k,
             utils.compute_metric(F,
                                  dataset,
                                  v,
                                  attach_models=attach_models,
                                  attach_predictions=attach_predictions))
            for k, v in subordinate_evals.items()
        ])
        print('...finished subordinate')
    else:
        print('... no subordinate')

    if justcat:
        return R

    masks = dataset.pixel_masks

    centroids = np.array(map(meas.center_of_mass, masks))
    centroids[np.isnan(centroids[:, 0])] = -128

    volumes = masks.sum(1).sum(1)

    def get_axis_bb(x):
        nzx, nzy = x.nonzero()
        if len(nzx):
            return (nzy.min(), nzx.min(), nzy.max(), nzx.max())
        else:
            return (-128, -128, -128, -128)

    axis_bb = np.array(map(get_axis_bb, masks))

    get_axis_bb_ctr = lambda x: ((x[1] + x[3]) / 2, (x[0] + x[2]) / 2)

    axis_bb_ctr = np.array(map(get_axis_bb_ctr, axis_bb))

    axis_bb_sx = np.abs(axis_bb[:, 2] - axis_bb[:, 0])
    axis_bb_sy = np.abs(axis_bb[:, 3] - axis_bb[:, 1])
    axis_bb_area = axis_bb_sx * axis_bb_sy

    axis_bb_sx = np.abs(axis_bb[:, 2] - axis_bb[:, 0])
    axis_bb_sy = np.abs(axis_bb[:, 3] - axis_bb[:, 1])
    axis_bb_area = axis_bb_sx * axis_bb_sy

    borders = dataset.pixel_borders(thickness=1)
    area_bb = np.array(map(hvm.get_best_box, borders))
    area_bb[3818] = -128

    def line(a1, a2):
        if a1[0] != a2[0] and a1[1] != a2[1]:
            m = (a2[1] - a1[1]) / float(a2[0] - a1[0])
            b = a1[1] - m * a1[0]
        elif a1[1] == a2[1]:
            m = np.inf
            b = np.nan
        elif a1[0] == a2[0]:
            m = 0
            b = a1[0]
        return m, b

    def intersection(a):
        a1, a2, a3, a4 = a
        m1, b1 = line(a1, a4)
        m2, b2 = line(a2, a3)
        if not np.isinf(m1):
            if not np.isinf(m2):
                ix = (b2 - b1) / (m1 - m2)
            else:
                ix = a3[1]
            iy = m1 * ix + b1
        else:
            ix = a1[1]
            iy = m2 * ix + b2
        return ix, iy

    area_bb_ctr = np.array(map(intersection, area_bb))
    dist = lambda _b1, _b2: math.sqrt((_b1[0] - _b2[0])**2 +
                                      (_b1[1] - _b2[1])**2)

    def sminmax(a):
        a1, a2, a3, a4 = a
        s1 = dist(a1, a2)
        s2 = dist(a1, a3)
        smin = min(s1, s2)
        smax = max(s1, s2)
        return smin, smax

    area_bb_minmax = np.array(map(sminmax, area_bb))
    area_bb_area = area_bb_minmax[:, 0] * area_bb_minmax[:, 1]

    dist = lambda _b1, _b2: np.sqrt((_b1[0] - _b2[0])**2 +
                                    (_b1[1] - _b2[1])**2)

    def get_major_axis(a):
        a1, a2, a3, a4 = a
        s1 = dist(a1, a2)
        s2 = dist(a1, a3)
        if s1 > s2:
            m11 = a1
            m12 = a3
            m21 = a2
            m22 = a4
        else:
            m11 = a1
            m12 = a2
            m21 = a3
            m22 = a4

        mj1 = (m11 + m12) / 2
        mj2 = (m21 + m22) / 2
        return (mj1, mj2)

    def nonan(f):
        f[np.isnan(f)] = 0
        return f

    area_bb_major_axes = np.array(map(get_major_axis, area_bb))
    sin_maj = nonan(
        (area_bb_major_axes[:, 0, 1] - area_bb_major_axes[:, 1, 1]) /
        dist(area_bb_major_axes[:, 0].T, area_bb_major_axes[:, 1].T))
    cos_maj = nonan(
        (area_bb_major_axes[:, 0, 0] - area_bb_major_axes[:, 1, 0]) /
        dist(area_bb_major_axes[:, 0].T, area_bb_major_axes[:, 1].T))

    if reg_model_kwargs is None:
        reg_model_kwargs = {
            'alphas': [
                1e-4, 1e-3, 1e-2, 5e-2, 1e-1, 2.5e-1, 5e-1, .75e-1, 1e0, 2.5e0,
                5e0, 1e1, 25, 1e2, 1e3
            ]
        }

    def make_spec(f):
        x = {
            'npc_train': ntrain,
            'npc_test': ntest,
            'num_splits': num_splits,
            'npc_validate': 0,
            'metric_screen': 'regression',
            'metric_labels': None,
            'metric_kwargs': {
                'model_type': 'linear_model.RidgeCV',
                'model_kwargs': reg_model_kwargs
            },
            'train_q': {
                'var': list(var_levels)
            },
            'test_q': {
                'var': list(var_levels)
            },
            'split_by': split_by
        }

        x['labelfunc'] = f
        return x

    if do_centroids:
        distctr = lambda m, x: (np.sqrt((centroids[:, 0] - m[0])**2 +
                                        (centroids[:, 1] - m[1])**2), None)
        centroid_specs = dict([((i, j),
                                make_spec(functools.partial(distctr, (i, j))))
                               for i in np.arange(256)[::centroid_sparsity]
                               for j in np.arange(256)[::centroid_sparsity]])
        R['centroid_results'] = dict([
            (k,
             utils.compute_metric(F,
                                  dataset,
                                  centroid_specs[k],
                                  attach_models=attach_models,
                                  attach_predictions=attach_predictions,
                                  return_splits=False)) for k in centroid_specs
        ])
        print('... finished centroid')
    else:
        print('... no centroids')

    volume_spec = make_spec(lambda x: (volumes, None))
    R['volume_result'] = utils.compute_metric(
        F,
        dataset,
        volume_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... finished volume')

    perimeters = borders.sum(1).sum(1)
    perimeter_spec = make_spec(lambda x: (perimeters, None))
    R['perimeter_result'] = utils.compute_metric(
        F,
        dataset,
        perimeter_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... finished perimeter')

    axis_bb_sx_spec = make_spec(lambda x: (axis_bb_sx, None))
    axis_bb_sy_spec = make_spec(lambda x: (axis_bb_sy, None))
    axis_bb_asp_spec = make_spec(
        lambda x: (axis_bb_sx / np.maximum(axis_bb_sy, 1e-5), None))
    axis_bb_area_spec = make_spec(lambda x: (axis_bb_area, None))

    R['axis_bb_sx_result'] = utils.compute_metric(
        F,
        dataset,
        axis_bb_sx_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... finished axis_bb_sx')
    R['axis_bb_sy_result'] = utils.compute_metric(
        F,
        dataset,
        axis_bb_sy_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... finished axis_bb_sy')
    R['axis_bb_asp_result'] = utils.compute_metric(
        F,
        dataset,
        axis_bb_asp_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... finished axis_bb_asp')
    R['axis_bb_area_result'] = utils.compute_metric(
        F,
        dataset,
        axis_bb_area_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... finished axis_bb_area')

    area_bb_smin_spec = make_spec(lambda x: (area_bb_minmax[:, 0], None))
    area_bb_smax_spec = make_spec(lambda x: (area_bb_minmax[:, 1], None))

    area_bb_asps = area_bb_minmax[:, 1] / np.maximum(area_bb_minmax[:, 0],
                                                     1e-5)
    area_bb_asp_spec = make_spec(lambda x: (area_bb_asps, None))
    area_bb_area_spec = make_spec(lambda x: (area_bb_area, None))

    sinmajs = np.abs(sin_maj)
    sinmaj_spec = make_spec(lambda x: (sinmajs, None))

    R['area_bb_smin_result'] = utils.compute_metric(
        F,
        dataset,
        area_bb_smin_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... area_bb_smin')
    R['area_bb_smax_result'] = utils.compute_metric(
        F,
        dataset,
        area_bb_smax_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... area_bb_smax')
    R['area_bb_asp_result'] = utils.compute_metric(
        F,
        dataset,
        area_bb_asp_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... area_bb_asp')
    R['area_bb_area_result'] = utils.compute_metric(
        F,
        dataset,
        area_bb_area_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... area_bb_area')
    R['sinmaj_result'] = utils.compute_metric(
        F,
        dataset,
        sinmaj_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... sinmaj')

    #position
    posx_spec = make_spec(lambda x: (x['ty'], None))
    posy_spec = make_spec(lambda x: (x['tz'], None))
    R['posx_result'] = utils.compute_metric(
        F,
        dataset,
        posx_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    R['posy_result'] = utils.compute_metric(
        F,
        dataset,
        posy_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)

    size_spec = make_spec(lambda x: (x['s'], None))
    R['size_result'] = utils.compute_metric(
        F,
        dataset,
        size_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... size')

    masksv0 = masks[meta['var'] == 'V0'][::10]
    objs = meta['obj'][meta['var'] == 'V0'][::10]
    A = np.array([
        _x.nonzero()[0][[0, -1]] if _x.sum() > 0 else (0, 0)
        for _x in masksv0.sum(1)
    ])
    B = np.array([
        _x.nonzero()[0][[0, -1]] if _x.sum() > 0 else (0, 0)
        for _x in masksv0.sum(2)
    ])
    base_size_factors = dict(
        zip(objs, np.maximum(A[:, 1] - A[:, 0], B[:, 1] - B[:, 0])))
    size_factors = np.zeros(len(meta))
    for o in objs:
        inds = [meta['obj'] == o]
        size_factors[inds] = base_size_factors[o] * .01
    scaled_size = size_factors * meta['s']
    scaled_size_spec = make_spec(lambda x: (scaled_size, None))
    R['scaled_size_result'] = utils.compute_metric(
        F,
        dataset,
        scaled_size_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... scaled size')

    rxy_spec = make_spec(lambda x: (x['rxy_semantic'], None))
    rxz_spec = make_spec(lambda x: (x['rxz_semantic'], None))
    ryz_spec = make_spec(lambda x: (x['ryz_semantic'], None))
    R['rxy_result'] = utils.compute_metric(
        F,
        dataset,
        rxy_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    R['rxz_result'] = utils.compute_metric(
        F,
        dataset,
        rxz_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    R['ryz_result'] = utils.compute_metric(
        F,
        dataset,
        ryz_spec,
        attach_models=attach_models,
        attach_predictions=attach_predictions,
        return_splits=False)
    print('... rotations')

    subordinate_rxy_specs = {}
    for c in categories:
        _spec = copy.deepcopy(rxy_spec)
        _spec['train_q']['category'] = [c]
        _spec['test_q']['category'] = [c]
        subordinate_rxy_specs[c] = _spec

    subordinate_rxz_specs = {}
    for c in categories:
        _spec = copy.deepcopy(rxz_spec)
        _spec['train_q']['category'] = [c]
        _spec['test_q']['category'] = [c]
        subordinate_rxz_specs[c] = _spec

    subordinate_ryz_specs = {}
    for c in categories:
        _spec = copy.deepcopy(ryz_spec)
        _spec['train_q']['category'] = [c]
        _spec['test_q']['category'] = [c]
        subordinate_ryz_specs[c] = _spec

    if split_by not in ['category']:
        R['subordinate_rxy_results'] = dict([
            (k,
             utils.compute_metric(F,
                                  dataset,
                                  v,
                                  attach_models=attach_models,
                                  attach_predictions=attach_predictions))
            for k, v in subordinate_rxy_specs.items()
        ])
        R['subordinate_rxz_results'] = dict([
            (k,
             utils.compute_metric(F,
                                  dataset,
                                  v,
                                  attach_models=attach_models,
                                  attach_predictions=attach_predictions))
            for k, v in subordinate_rxz_specs.items()
        ])
        R['subordinate_ryz_results'] = dict([
            (k,
             utils.compute_metric(F,
                                  dataset,
                                  v,
                                  attach_models=attach_models,
                                  attach_predictions=attach_predictions))
            for k, v in subordinate_ryz_specs.items()
        ])
        print('... subordinate rotations')

    return R
Beispiel #9
0
def get_all_analysis(F):

    R = {}

    fit_res = get_neural_fit(F)
    R['fit_res'] = fit_res

    basic_res = hvm_analysis(F,
                             hvm_dataset,
                             ntrain=None,
                             ntest=5,
                             num_splits=5,
                             split_by='obj',
                             var_levels=('V3', 'V6'),
                             gridcv=False,
                             attach_predictions=False,
                             attach_models=False,
                             reg_model_kwargs=None,
                             justcat=False,
                             model_type='svm.LinearSVC',
                             model_kwargs=None,
                             do_centroids=False)
    R['basic_res'] = basic_res

    cat_v0_res = hvm_analysis(F,
                              hvm_dataset,
                              ntrain=None,
                              ntest=5,
                              num_splits=5,
                              split_by='obj',
                              var_levels=('V0', ),
                              gridcv=False,
                              attach_predictions=False,
                              attach_models=False,
                              reg_model_kwargs=None,
                              justcat=True,
                              model_type='svm.LinearSVC',
                              model_kwargs=None,
                              do_centroids=False)
    R['v0_res'] = cat_v0_res

    cat_v3_res = hvm_analysis(F,
                              hvm_dataset,
                              ntrain=None,
                              ntest=20,
                              num_splits=5,
                              split_by='obj',
                              var_levels=('V3', ),
                              gridcv=False,
                              attach_predictions=False,
                              attach_models=False,
                              reg_model_kwargs=None,
                              justcat=True,
                              model_type='svm.LinearSVC',
                              model_kwargs=None,
                              do_centroids=False)
    R['v3_res'] = cat_v3_res

    cat_v6_res = hvm_analysis(F,
                              hvm_dataset,
                              ntrain=None,
                              ntest=20,
                              num_splits=5,
                              split_by='obj',
                              var_levels=('V6', ),
                              gridcv=False,
                              attach_predictions=False,
                              attach_models=False,
                              reg_model_kwargs=None,
                              justcat=True,
                              model_type='svm.LinearSVC',
                              model_kwargs=None,
                              do_centroids=False)
    R['v6_res'] = cat_v6_res

    model_cms = [cat_v0_res['basic_category_result']['result_summary']['cms'],
                 cat_v3_res['basic_category_result']['result_summary']['cms'],
                 cat_v6_res['basic_category_result']['result_summary']['cms']] + \
                list(itertools.chain(*[[cat_v0_res['subordinate_results'][k]['result_summary']['cms'],
                                        cat_v3_res['subordinate_results'][k]['result_summary']['cms'],
                                        cat_v6_res['subordinate_results'][k]['result_summary']['cms']] for k in hvm_dataset.categories]))
    model_cms_standard = model_cms[:3] + model_cms[3 * 3:3 *
                                                   4] + model_cms[3 * 5:3 * 6]
    model_cms_basic = model_cms[:3]
    model_cms_v0 = model_cms[::3]
    model_cms_v6 = model_cms[2::3]

    conn = pm.Connection(port=22334)

    colname = 'hvm_basic_categorization_new'
    query = {}
    threshold = 0
    tr_period = 10
    get_pred = lambda x: x[0]['dataChosen']['category']
    get_actual = lambda x: x[1]['Sample']['category']

    idataquery = lambda x: x[1]['Sample']['var'] == 'V0'
    labelset = cat_v0_res['basic_category_result']['result_summary'][
        'labelset']
    human_cm_0 = get_human_cm(colname,
                              query,
                              tr_period,
                              get_pred,
                              get_actual,
                              idataquery,
                              conn,
                              labelset=labelset)

    idataquery = lambda x: x[1]['Sample']['var'] == 'V3'
    labelset = cat_v3_res['basic_category_result']['result_summary'][
        'labelset']
    human_cm_3 = get_human_cm(colname,
                              query,
                              tr_period,
                              get_pred,
                              get_actual,
                              idataquery,
                              conn,
                              labelset=labelset)

    idataquery = lambda x: x[1]['Sample']['var'] == 'V6'
    labelset = cat_v6_res['basic_category_result']['result_summary'][
        'labelset']
    human_cm_6 = get_human_cm(colname,
                              query,
                              tr_period,
                              get_pred,
                              get_actual,
                              idataquery,
                              conn,
                              labelset=labelset)

    human_cms = [human_cm_0, human_cm_3, human_cm_6]

    for cat in hvm_dataset.categories:
        colname = 'hvm_subordinate_identification_%s' % cat
        query = {}
        threshold = 0
        tr_period = 10
        get_pred = lambda x: x[0]['dataChosen']['obj']
        get_actual = lambda x: x[1]['Sample']['obj']

        idataquery = lambda x: x[1]['Sample']['var'] == 'V0'
        labelset = cat_v0_res['subordinate_results'][cat]['result_summary'][
            'labelset']
        m0 = get_human_cm(colname, query, tr_period, get_pred, get_actual,
                          idataquery, conn, labelset)

        idataquery = lambda x: x[1]['Sample']['var'] == 'V3'
        labelset = cat_v3_res['subordinate_results'][cat]['result_summary'][
            'labelset']
        m3 = get_human_cm(colname, query, tr_period, get_pred, get_actual,
                          idataquery, conn, labelset)

        idataquery = lambda x: x[1]['Sample']['var'] == 'V6'
        labelset = cat_v6_res['subordinate_results'][cat]['result_summary'][
            'labelset']
        m6 = get_human_cm(colname, query, tr_period, get_pred, get_actual,
                          idataquery, conn, labelset)

        human_cms.extend([m0, m3, m6])

    human_cms_standard = human_cms[:3] + human_cms[3 * 3:3 *
                                                   4] + human_cms[3 * 5:3 * 6]
    human_cms_basic = human_cms[:3]
    human_cms_v0 = human_cms[::3]
    human_cms_v6 = human_cms[2::3]

    C_standard = consistency_from_cms(model_cms_standard,
                                      pr(human_cms_standard))
    C_basic = consistency_from_cms(model_cms_basic, pr(human_cms_basic))
    C_all = consistency_from_cms(model_cms, pr(human_cms))
    C_v0 = consistency_from_cms(model_cms_v0, pr(human_cms_v0))
    C_v6 = consistency_from_cms(model_cms_v6, pr(human_cms_v6))

    consistency = {
        "consistency_standard": C_standard,
        "consistency_basic": C_basic,
        "consistency_all": C_all,
        "consistency_v0": C_v0,
        "consistency_v6": C_v6
    }
    R.update(consistency)

    face_dprimes_all = get_face_dprimes(F, var_level=None)
    face_dprimes_v0 = get_face_dprimes(F, var_level='V0')
    face_dprimes_v3 = get_face_dprimes(F, var_level='V3')
    face_dprimes_v6 = get_face_dprimes(F, var_level='V6')

    e = copy.deepcopy(reg_eval_IT_obj_half)
    e['num_splits'] = 1
    e['test_q'].pop('var')
    e['npc_test'] = 90
    resit_o = utils.compute_metric(F,
                                   hvm_dataset,
                                   e,
                                   attach_predictions=True,
                                   return_splits=True)
    pop = np.array(resit_o['split_results'][0]['test_prediction'])
    ts = np.array(resit_o['splits'][0][0]['test'])
    dpv0 = get_face_dprimes(pop, var_level='V0', inds=ts)
    dpv3 = get_face_dprimes(pop, var_level='V3', inds=ts)
    dpv6 = get_face_dprimes(pop, var_level='V6', inds=ts)
    dpall = get_face_dprimes(pop, var_level=None, inds=ts)

    thresholds = [.25, .5, .75, 1, 1.25, 1.5, 1.75, 2, 2.5, 5]
    face_selectivity_levels = {}

    def count(x, thr):
        n = len((x > thr).nonzero()[0]) * 100
        return float(n) / len(x)

    for thr in thresholds:
        face_selectivity_levels[(None, thr)] = count(face_dprimes_all, thr)
        face_selectivity_levels[('V0', thr)] = count(face_dprimes_v0, thr)
        face_selectivity_levels[('V3', thr)] = count(face_dprimes_v3, thr)
        face_selectivity_levels[('V6', thr)] = count(face_dprimes_v6, thr)
        face_selectivity_levels[('fitpop', None, thr)] = count(dpall, thr)
        face_selectivity_levels[('fitpop', 'V0', thr)] = count(dpv0, thr)
        face_selectivity_levels[('fitpop', 'V3', thr)] = count(dpv3, thr)
        face_selectivity_levels[('fitpop', 'V6', thr)] = count(dpv6, thr)

    face_stats = {
        'face_dprimes_all': face_dprimes_all,
        'face_dprimes_v0': face_dprimes_v0,
        'face_dprimes_v3': face_dprimes_v3,
        'face_dprimes_v6': face_dprimes_v6,
        'fitpop_face_dprimes_all': dpall,
        'fitpop_face_dprimes_v0': dpv0,
        'fitpop_face_dprimes_v3': dpv3,
        'fitpop_face_dprimes_v6': dpv6,
        'selectivities': face_selectivity_levels
    }

    R['face_statistics'] = face_stats
    return R