Exemplo n.º 1
0
def sparse_sift(image, fraction=1.0):
    """ sparse oriented SIFT at Harris-LaPlace and Difference of Gaussians keypoints 
        use VLFEAT vl_covdet through octave; expects a grayscale image
    """
    octave.eval("addpath ~/CC/vlfeat/vlfeat-0.9.20/toolbox")
    octave.eval("vl_setup")
    octave.push("im", image)
    octave.eval("im = single(im);")
    octave.eval(
        "[kp,sift_hl] = vl_covdet(im, 'method', 'HarrisLaplace', 'EstimateOrientation', true); "
    )
    octave.eval(
        "[kp,sift_dog] = vl_covdet(im, 'method', 'DoG', 'EstimateOrientation', true); "
    )
    octave.eval("descrs = [sift_hl, sift_dog];")
    descriptors = octave.pull("descrs")
    kp = octave.pull("kp")

    # flip from column-major to row-major
    descriptors = descriptors.T

    if fraction < 1.0:
        descriptors = random_sample(descriptors, fraction)

    return kp, descriptors
Exemplo n.º 2
0
 def set(self, expid, variables, values):
     '''
 Writes one or more variables to the workspace of the current Octave session
 '''
     n = len(variables)
     for i in range(n):
         try:
             octave.push(variables[i], values[i])
         except:
             pass
Exemplo n.º 3
0
    def fit(self, K, y):
        """Learn a low-rank kernel approximation.

        :param K: (``numpy.ndarray``) or of (``Kinterface``). The kernel to be approximated with G.

        :param y: (``numpy.ndarray``) Class labels :math:`y_i \in {-1, 1}` or regression targets.
        """

        # Convert to explicit form
        K = K[:, :]
        y = y.reshape((len(y), 1))

        # Call original implementation
        octave.push(["K", "y", "rank", "centering", "kappa", "delta", "tol"], [
            K, y, self.rank, self.centering, self.kappa, self.delta, self.tol
        ])
        octave.eval(
            "[G, P, Q, R, error1, error2, error, predicted_gain, true_gain] = csi(K, y, rank, centering, kappa, delta, tol)",
            verbose=False)
        G, P, Q, R, error1, error2, error, predicted_gain, true_gain = \
            octave.pull(["G", "P", "Q", "R", "error1", "error2", "error", "predicted_gain", "true_gain"])
        R = np.atleast_2d(np.array(R))

        # Octave indexes from 1
        P = P.ravel().astype(int) - 1

        # Resort rows to respect the order
        n, k = K.shape[0], self.rank
        self.I = self.active_set_ = list(P[:k])

        Go = np.zeros((n, k))
        Qo = np.zeros((n, k))
        Ro = np.zeros((k, k))
        km = min(k, G.shape[1])
        Go[P, :km] = G[:, :km]
        Qo[P, :km] = Q[:, :km]
        Ro[:km, :km] = R[:km, :km]
        self.G = Go[:, :self.rank]
        self.P = P[:self.rank]
        self.Q = Qo[:, :]
        self.R = Ro[:, :self.rank]
        self.error1 = error1
        self.error1 = error2
        self.error = error
        self.predicted_gain = predicted_gain
        self.true_gain = true_gain
        self.trained = True
        self.active_set_ = self.I[:self.rank]
Exemplo n.º 4
0
def plot_calibration_mapping(calibration_model,
                             min_score,
                             max_score,
                             resolution=1000,
                             file_name='calibration_mapping.png'):
    # Function for plotting what probabilities different scores get mapped to.
    # "General purpose prediction function"
    # PERHAPS ADD PROBABILITY DISTRIBUTION OF TRAINING DATA (OR TESTING?)?
    # WOULD INDICATE HOW MANY SAMPLES FALL INTO ONE BIN.
    diff = max_score - min_score
    scores = [
        min_score + i * diff / float(resolution) for i in range(resolution + 1)
    ]
    try:  # IR model
        probabilities = calibration_model.predict(scores)
    except:
        try:  # ENIR
            import rpy2.robjects as robjects
            from rpy2.robjects.packages import importr
            enir = importr('enir')
            r = robjects.r
            # Automatic conversion or numpy arrays to R-vectors
            import rpy2.robjects.numpy2ri
            rpy2.robjects.numpy2ri.activate()
            # ENIR-MODEL MIGHT NEED TO BE PUSHED TO R-ENVIRONMENT?
            probabilities = enir.enir_predict(calibration_model,
                                              robjects.FloatVector(scores))
            probabilities = np.array(probabilities)
        except:
            try:  # BBQ
                from oct2py import octave
                octave.eval("addpath('./calibration/BBQ/')", verbose=False)
                octave.push('scores', scores, verbose=False)
                octave.push('calibration_model',
                            calibration_model,
                            verbose=False)
                octave.eval(
                    'probabilities = predict(calibration_model, scores, 1)',
                    verbose=False)
                probabilities = octave.pull('probabilities', verbose=False)
                probabilities = np.array([item[0] for item in probabilities])
            except:
                pass  # Continue with BIR and WABIR? RCIR?
    # Plot score vs. probability:
    plt.plot(scores, probabilities)
    plt.title("Calibration mapping")
    plt.savefig(file_name)
    plt.gcf().clear()
Exemplo n.º 5
0
def dense_sift(image, fraction=1.0):
    """ dense SIFT
        use VLFEAT vl_phow through octave; expects a grayscale image
    """
    octave.push("im", image)
    octave.eval("im = single(im);")
    octave.eval("[kp,siftd] = vl_phow(im); ")
    descriptors = octave.pull("siftd")

    # flip from column-major to row-major
    descriptors = descriptors.T

    if fraction < 1.0:
        descriptors = random_sample(descriptors, fraction)

    return descriptors
Exemplo n.º 6
0
        # Get good trials indices
        goodtrials = np.where(df['badtrial'] == 0)[0]

        df = df.iloc[goodtrials]

        mod = sm.OLS(df["amp_['POz']_0.4-0.8"],
                     sm.add_constant(df[variable]),
                     hasconst=True).fit()

        bic_erps.loc[p, variable] = mod.bic
        bic_beta.loc[p, variable] = mod.params[variable]

bic_erps.to_csv(opj(outpath, 'bic_erps.csv'))

# Use octave to run the VBA-toolbox
octave.push('L', np.asarray(bic_erps.transpose()) * -1)
octave.addpath('/matlab/vbatoolbox')
octave.addpath('/matlab/vbatoolbox/core')
octave.addpath('/matlab/vbatoolbox/core/display')
octave.addpath('/matlab/vbatoolbox/utils')
octave.eval("options.DisplayWin = 0")
p, out = octave.eval("VBA_groupBMC(L, options)", nout=2)
# Save to plot
file = open(opj(outpath, 'erps_olsmean_VBAmodelcomp.pkl'), "wb")
pickle.dump(out, file)

# ########################################################################
# Mass univariate regression
###########################################################################

# Load model data
Exemplo n.º 7
0
                            label="Credible intervals")

    # Create reliability diagram:
    isotonic.plot_reliability_diagram(isotonic_regression_model,
                                      test_scores,
                                      test_class,
                                      file_name="./" + test_description +
                                      "/reliability_diagram" + ".png",
                                      label="Reliability diagram")

    # Naeini's model
    # Comparison to Naeini's model (it's a matlab model, using Octave).
    print(
        "Training Naeini-model. This might take a while (~20 minutes on a laptop)."
    )
    octave.push('training_scores', naeini_training_scores, verbose=False)
    octave.push('training_class', naeini_training_class, verbose=False)
    octave.eval("options.N0 = 2", verbose=False)
    octave.eval(
        "BBQ_model = build(training_scores', training_class', options)",
        verbose=False)
    # In the following, '1' indicates model averaging, as done in the paper by Naeini & al.
    octave.eval("training_bbq_prob = predict(BBQ_model, training_scores, 1)",
                verbose=False)
    training_bbq_prob = octave.pull("training_bbq_prob", verbose=False)
    training_bbq_prob = np.array([item[0] for item in training_bbq_prob])
    octave.push('test_scores', test_scores, verbose=False)
    octave.eval("test_bbq_prob = predict(BBQ_model, test_scores, 0)",
                verbose=False)
    test_bbq_prob = octave.pull("test_bbq_prob", verbose=False)
    test_bbq_prob = np.array([item[0] for item in test_bbq_prob])
Exemplo n.º 8
0
    if args.n_features_keep:
        weights = weights[..., sorted_inds_keep]

    # get the shape of the weights and make sure they satisfy certain conditions
    w_x, w_y, w_in, w_out = weights.shape

    # compute the new number of features you will have and make placeholder to store them
    nx = args.input_w - (w_x - 1)
    ny = args.input_h - (w_y - 1)
    w_out_new = (nx // args.stride_x) * (ny // args.stride_y) * w_out
    nonshared = np.zeros([args.input_w, args.input_h, w_in, w_out_new],
                         dtype=np.float64)

    # fill in the original features in the simple cell tensor
    count = 0
    for k in range(w_out):
        for i in range(0, nx, args.stride_x):
            for j in range(0, ny, args.stride_y):
                nonshared[i:i + w_x, j:j + w_y, :, count] = weights[:, :, :, k]
                count += 1

    # write the new features
    write_fpath = os.path.join(args.save_dir, os.path.split(fpath)[1])
    feat_data[0]['values'][0] = nonshared
    octave.push(['write_fpath', 'feat_data'], [write_fpath, feat_data])
    octave.eval('writepvpsharedweightfile(write_fpath, feat_data)')

logging.info('NONSHARED GRID SIZE IS {}x{}x{}.'.format(ny // args.stride_y,
                                                       nx // args.stride_x,
                                                       w_out))
Exemplo n.º 9
0
    # Create ENIR model using R:
    enir_model = enir.enir_build(
        robjects.FloatVector(training_scores.tolist()),
        robjects.BoolVector(training_class.tolist()))
    enir_prob = enir.enir_predict(enir_model,
                                  robjects.FloatVector(test_scores.tolist()))
    # Convert to numpy.array:
    enir_prob = np.array(enir_prob)
    # Kill session?

    # Create isotonic regression model
    ir_model = IsotonicRegression(y_min=0, y_max=1, out_of_bounds='clip')
    ir_model.fit(X=training_scores, y=training_class)

    # Create BBQ-model
    octave.push('training_scores', training_scores, verbose=False)
    octave.push('training_class', training_class, verbose=False)
    octave.eval('options.N0 = 2', verbose=False)
    octave.eval(
        "bbq_model = build(training_scores', training_class', options)",
        verbose=False)
    octave.push('test_scores', test_scores)
    octave.eval("test_prob = predict(bbq_model, test_scores, 1)",
                verbose=False)
    bbq_test_prob = octave.pull('test_prob', verbose=False)
    bbq_test_prob = [item[0] for item in bbq_test_prob]

    # Create RCIR model with d = .20 (?)
    # QUICK HACK TO TEST RCIR-CV INSTEAD OF RCIR WITH SOME d:
    # NOTE THAT RCIR-CV GETS _MORE_ _DATA_ THAN
    # rcir_model = isotonic.train_rcir_cv(training_scores, training_class , d=.1)
Exemplo n.º 10
0
def snmf_fhals(A, k, init='normal'):
    """
    Nonnegative Matrix Factorization.
    
    Hierarchical alternating least squares algorithm
    for computing the approximate low-rank nonnegative matrix factorization of 
    a square `(m, m)` matrix `A`. Given the target rank `k << m`, 
    the input matrix `A` is factored as `A = W Wt`. The nonnegative factor 
    matrices `W` and `Wt` are of dimension `(m, k)` and `(k, m)`, respectively.
           
    
    Parameters
    ----------
    A : array_like, shape `(m, m)`.
        Real nonnegative input matrix.
    
    k : integer, `k << m`.
        Target rank.
    
    init : str `{'normal'}`. 
        'normal' : Factor matrices are initialized with nonnegative 
                   Gaussian random numbers.
            
    tol : float, default: `tol=1e-4`.
        Tolerance of the stopping condition.
        
    maxiter : integer, default: `maxiter=100`.
        Number of iterations.   
        
    verbose : boolean, default: `verbose=False`.
        The verbosity level.        
    
    
    Returns
    -------
    W:  array_like, `(m, k)`.
        Solution to the non-negative least squares problem.
    """    
    
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # Error catching
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~     
    m, n = A.shape
    assert m == n
    
    if (A < 0).any():
        raise ValueError("Input matrix with nonnegative elements is required.")    
    
    if  A.dtype == sci.float32: 
        data_type = sci.float32
        
    elif A.dtype == sci.float64: 
        data_type = sci.float64  

    else:
        raise ValueError("A.dtype is not supported.")    
    

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                            
    # Initialization methods for factor matrices W and H
    # 'normal': nonnegative standard normal random init
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    
    if init == 'normal':
        n, _ = A.shape
        H = 2 * np.sqrt(np.mean(np.mean(A)) / k) * np.random.rand(n, k)
        maxiter = 10000
        tol = 1e-3
        alpha = np.max(H)**2
        W = H.copy()
        I_k = alpha * np.identity(k)
    else:
        raise ValueError('Initialization method is not supported.')
    #End if

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # Iterate the HALS algorithm until convergence or maxiter is reached
    # i)   Update factor matrix H and normalize columns   
    # ii)  Update low-dimensional factor matrix W
    # iii) Compute fit log( ||A-WH|| )
    #   -> break if fit <-5 or fit_change < tol
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    

    projnorm = float('inf')
    left = H.T.dot(H)
    right = A.dot(H)

    octave.push('A', A)
    octave.push('k', k)

    for niter in range(maxiter):
    	octave.push('W', W)
    	octave.push('H', H)
    	octave.push('left', left)
    	octave.push('right', right)

    	octave.eval("[W, H, left, right, violation] = symnmf_anls_iter(A, W, H, left, right, k)", verbose=False)

    	W = octave.pull("W")
    	H = octave.pull("H")
    	left = octave.pull("left")
    	right = octave.pull("right")
    	violation = octave.pull("violation")

    	if niter == 0:
    		initgrad = violation
    	else:
    		projnorm = violation

    	if projnorm < tol * initgrad:
    		break

    return H
Exemplo n.º 11
0
for frame_num, lca_fpath in enumerate(lca_fpaths):
    # read in the pvp files and get the lca features
    pvp_data = octave.readpvpfile(lca_fpath)
    weights = pvp_data[0]['values'][0]
    w_out_original = weights.shape[-1]

    # take out the current frame from the strf and add to the weights
    mouse_strfs_frame = mouse_strfs[:, :, frame_num, :]
    mouse_strfs_frame = mouse_strfs_frame[:, :, None, :]

    try:  # if shapes don't line up
        weights = np.concatenate((weights, mouse_strfs_frame), 3)
    except ValueError:
        raise

    # add the new weights back to the pvp_data structure and push to octave session
    pvp_data[0]['values'][0] = weights
    write_fpath = os.path.join(args.save_dir, os.path.split(lca_fpath)[1])
    octave.push(['pvp_data', 'write_fpath'], [pvp_data, write_fpath])

    # write the new pvp weight file
    octave.eval('writepvpsharedweightfile(write_fpath, pvp_data)')

print('[INFO] THE NEW NUMBER OF FEATURES IS {}.'.format(weights.shape[-1]))

# write out the indices for each cell in the dictionary
cell_ids = [cell_id.split('_')[1] for cell_id in cell_ids]
cell_inds = [cell_ind + w_out_original for cell_ind in cell_inds]
df = pd.DataFrame(zip(cell_ids, cell_inds), columns=['CellID', 'FeatureIndex'])
df.to_csv(os.path.join(args.save_dir, 'cell_inds.txt'), index=False)