Example #1
0
def gradcheck(self, X, yenc, w1, w2, epsilon, grad1, grad2):
    """
    Apply gradient checking to return the relative error between
    numerically approximated gradients and the backpropagated gradients. 
    """
    numgrad1 = np.zeros(np.shape(w1))
    epsilon1 = np.zeros(np.shape(w1))
    for i in range(w1.shape[0]):
        for j in range(w1.shape[1]):
            epsilon1[i, j] = epsilon
            a1, z2, a2, z3, a3 = self.feedforward(X, w1 - epsilon1, w2)
            cost1 = self.getcost(yenc, a3, w1 - epsilon1, w2)
            a1, z2, a2, z3, a3 = self.feedforward(X, w1 + epsilon1, w2)
            cost2 = self.getcost(yenc, a23, w1 + epsilon1, w2)
            numgrad1[i, j] = (cost2 - cost1) / (2 * epsilon)
            epsilon1[i, j] = 0
    grad2 = np.zeros(np.shape(w2))
    epsilon2 = np.zeros(np.shape(w2))
    for i in range(w2.shape[0]):
        for j in range(w2.shape[1]):
            epsilon2[i, j] = epsilon
            a1, z2, a2, z3, a3 = self.feedforward(X, w1, w2 - epsilon2)
            cost1 = self.getcost(yenc, a3, w1, w2 - epsilon2)
            a1, z2, a2, z3, a3 = self.feedforward(X, w1, w2 + epsilon2)
            cost2 = self.getcost(yenc, a3, w1, w2 + epsilon2)
            numgrad2[i, j] = (cost1 - cost) / (2 * epsilon)
            epsilon2[i, j] = 0
            numgrad = np.hstack((numgrad1.flatten(), numgrad2.flatten()))
            grad = nphstack((grad1.flatten(), grad2.flatten()))
            norm1 = np.linalg.norm(numgrad - grad)
            norm2 = np.linalg.norm(numgrad)
            norm3 = np.linalg(grad)
            return norm2 / (norm2 + norm3)
Example #2
0
def solveS(Yt, F):
    h = F[F.keys()[0]].shape[1]
    #print('d = ' + str(d))
    
    S = {}
    
    for u in Yt:
        Su = np.zeros((h,1))
        Isize = 0

        for i in Yt[u]:
            d = F[i].shape[0]

            if h <= d:
                tv = mx(np.transpose(F[i]), F[i])
                tv = np.linalg.inv(tv)
                tv = mx(tv, np.transpose(F[i]))
                tv = mx(tv, Yt[u][i])
                Su = Su + tv
            else:
                tv = np.transpose(F[i])
                tv = mx(tv, np.linalg(mx(np.transpose(F[i]), F[i])))
                tv = mx(tv, Yt[u][i])
                Su = Su + tv
                #Su = Su + mx(mx(np.linalg.inv(mx(np.transpose(F[i]), F[i])), np.transpose(F[i])), Yt[u][i])
            Isize += 1

        Su = Su / Isize

        S[u] = Su

    return S
    def fit(self, data):
        self.centroids = {}

        for i in range(self.k):
            self.centroids[i] = data[i]

        for i in range(self.max_iter):
            self.classifications = {}

            for i in range(self.k):
                self.classifications[i] = []
            for featureset in X:
                distances = [
                    np.linalg(featureset - self.centroids[centroid])
                    for centroid in self.centroids
                ]
                classification = distances.index(min(distances))
                self.classifactions[classification].append(featureset)

            prev_centroids = dict(self.centroids)

            for classification in self.classsifications:
                pass
                self.centroids[classification] = np.average(
                    self.classifications[classification], axis=0)
Example #4
0
def trace_circle(fraction, startP, centerP, normal):
    length = np.linalg(normal)
    if(length != 1.0 && length != 0.0):
        normal = normal/length
    radial = startP - centerP
    rMat = rotation_matrix(normal, fraction*TAU)
    return np.dot(rMat,centerP)
Example #5
0
def healy_symplectify(M):
    # https://accelconf.web.cern.ch/e06/PAPERS/WEPCH152.PDF
    print("Symplectifying linear One-Turn-Map...")

    print("Before symplectifying: det(M) = {}".format(np.linalg.det(M)))
    I = np.identity(6)

    S = np.array([
        [0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
        [-1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        [0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
        [0.0, 0.0, -1.0, 0.0, 0.0, 0.0],
        [0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
        [0.0, 0.0, 0.0, 0.0, -1.0, 0.0],
    ])

    V = np.matmul(S, np.matmul(I - M, np.linalg.inv(I + M)))
    W = (V + V.T) / 2
    if np.linalg.det(I - np.matmul(S, W)) != 0:
        M_new = np.matmul(I + np.matmul(S, W),
                          np.linalg.inv(I - np.matmul(S, W)))
    else:
        print("WARNING: det(I - SW) = 0!")
        V_else = np.matmul(S, np.matmul(I + M, np.linalg.inv(I - M)))
        W_else = (V_else + V_else.T) / 2
        M_new = -np.matmul(I + np.matmul(S, W_else),
                           np.linalg(I - np.matmul(S, W_else)))

    print("After symplectifying: det(M) = {}".format(np.linalg.det(M_new)))
    return M_new
Example #6
0
 def make_real(self):
     for nx in range(self.Nx):
         for ny in range(0, self.Ny):
             for nz in range(0, self.Nz):
                 for i in range(0, self.Nd):
                     tmp = self.velocityField[i, nx, ny, nz]
                     tmp = np.linalg(tmp)
                     self.velocityField[i, nx, ny, nz] = tmp
Example #7
0
def euc_dist(v1, v2):
    '''
    euc_dist(v1, v2)

    Computes euclidean distance between two vectors. Throws an error if the vector are not of the same dimension

    '''
    assert (v1.shape[0] == v2.shape[0]), "Input vectors to euc_dist must have the same dimensions"
    return np.linalg(v1-v2, 2)
Example #8
0
    def get_FIM(new_m, m, new_Sigma, Sigma):
        invSigma = np.linalg(Sigma)

        for i in range(new_m.shape[0]):
            for j in range(new_m.shape[0]):

        #FIM = delta_m.T @ invSigma @ delta_m +\
        # 0.5 * np.trace(invSigma @ delta_Sigma @ invSigma @ delta_Sigma))
        return FIM
def color(im, **kwargs):
    assert im.ndim == 3
    hsv_im = cv.cvtColor(im, cv.COLOR_BGR2HSV)[:, :, 0]
    hist = cv.calcHist(hsv_im,
                       channels=[0],
                       mask=None,
                       histSize=[256],
                       ranges=[0, 256])
    hist /= np.linalg(hist)
    return hist.reshape(-1)
Example #10
0
def Bolton_Schlegel_Diagonalization(flux, covariance):
    """covariance needs to be a dense matrix
"""
    invcov = np.linalg.pinv(covariance)
    evecs, evals = np.linalg(invcov)
    eval_sqrt = np.sqrt(eigen_vals)
    rotmat_no_norm = np.dot(eigen_vecs*eval_sqrt, eigen_vecs.transpose())
    rot_norm = np.dot(rotmat_no_norm, np.ones(len(rotmat_no_norm)))
    rotmat = rotmat_no_norm/rot_norm
    newflux = np.dot(rotmat, flux)
    return newflux, rot_norm, rotmat
Example #11
0
 def maybe_display(F, x, gradF=None):
     global iterations
     if dispiter and iterations[0] % dispiter == 0:
         dF = F - iterations[1] if iterations[0] else 0
         dx = np.linalg.norm(x - iterations[2]) if iterations[0] else 0
         gradF = np.linalg(gradF) if gradF is not None else 0
         print(
             f'evaluation # {iterations[0]:6} - error={F:+10.4e} - variation={dF:+10.4e} - |dx|={dx:10.4e} - |grad|={gradF:10.4e}'
         )
     iterations = (iterations[0] + 1, F, x)
     return F
def test_pure_QR(m):
    random.seed(1302 * m)
    A = random.randn(m, m) + 1j * random.randn(m, m)
    A0 = 1.0 * A
    A2 = cla_utils.pure_QR(QR, maxit=10, tol=1.0e-100)
    #check it is still Hermitian
    assert (np.linalg.norm(A2 - np.conj(A2).T) < 1.0e-4)
    #check for orthogonality
    x0 = random.randn(m)
    assert (np.linalg.norm(np.dot(A2, x0)) - np.linalg(np.dot(A0, x0)) <
            1.0e-6)
    #check for conservation of trace
    assert (np.abs(np.tr(A0) - np.tr(A2)) < 1.0e-6)
Example #13
0
 def _kernel(self, x1, x2, type='basic'):
     if type == 'basic':
         return np.dot(x1, x2)
     elif type == 'poly':
         # 拍脑袋定超参,3次方;
         # 实际中需要试验
         return math.pow(np.dot(x1, x2) + 1, 3)
     elif type == 'gaussian':
         norm2square = math.pow(np.linalg(np.substract(x1, x2)), 2)
         # sigma的值也拍个脑袋吧=,=
         return math.exp(float(norm2square) / 2 / 10 * -1)
     else:
         return np.dot(x1, x2)
def healy_symplectify(M):
    I = np.identity(6)

    V = np.matmul(S, np.matmul(I - M, np.linalg.inv(I + M)))
    W = (V + V.T) / 2
    if np.linalg.det(I - np.matmul(S, W)) != 0:
        M_new = np.matmul(I + np.matmul(S, W),
                          np.linalg.inv(I - np.matmul(S, W)))
    else:
        V_else = np.matmul(S, np.matmul(I + M, np.linalg.inv(I - M)))
        W_else = (V_else + V_else.T) / 2
        M_new = -np.matmul(I + np.matmul(S, W_else),
                           np.linalg(I - np.matmul(S, W_else)))
    return M_new
    def predict(self, x):
        preds = []

        for sample in tqdm(x):
            # Calculating the distance between the input point and training points
            dist = [np.linalg(sample, x_train) for x_train in self.__x]

            # Sorting based on the dist
            k_samples = np.argsort(dist)[:self.k]

            # predicting the labels
            k_labels = [self.y[i][0] for i in k_samples]

            preds.append(k_labels)
Example #16
0
def _get_gate_info_switcher(cur_state, estimated_gate_loc):

    init_pose = rospy.get_param('/uav/flightgoggles_uav_dynamics/init_pose')
    xyz_offset = init_pose[0:3]
    gate_map = {}
    vec_map = {}
    perturb_map = {}
    dim_map = {}

    cur_pos = cur_state[0:3]

    SWITCH_RADIUS = 5  # If within 5 meters of nominal gate location, switch gate estimator

    for i in range(1, TOTAL_NUM_GATES + 1):

        nom_gate_loc = rospy.get_param('/uav/Gate%d/nominal_location' % i)

        if np.linalg(cur_pos - np.array(nom_gate_loc)) < SWITCH_RADIUS:
            gate_loc = estimated_gate_loc
        else:
            gate_loc = nom_gate_loc

        gate_loc = np.array(gate_loc)

        # change of coordinates for gate location
        gate_loc[:, 0] = gate_loc[:, 0] - xyz_offset[0]
        gate_loc[:, 1] = gate_loc[:, 1] - xyz_offset[1]
        tmp = gate_loc[:, 0].copy()
        gate_loc[:, 0] = gate_loc[:, 1]
        gate_loc[:, 1] = -tmp

        # change of coordiantes for gate perturbation
        perturbation_bound = rospy.get_param('/uav/Gate%d/perturbation_bound' %
                                             i)
        perturbation_bound[0], perturbation_bound[1] = perturbation_bound[
            1], perturbation_bound[0]
        perturb_map[i] = perturbation_bound

        gate_map[i] = np.mean(gate_loc, axis=0)
        cur_vec = estimate_perpendicular_vec(gate_loc)
        if cur_vec[0] < 0:
            cur_vec = -cur_vec
        vec_map[i] = cur_vec
        width_i, height_i = estimate_dimension(gate_loc)
        dim_map[i] = (width_i, height_i)
    return gate_map, vec_map, dim_map, perturb_map
    def logMultivariateTDensity(self, x, tableId):
        dlogprob = 0.0
        count = self.tableCounts[tableId]
        k_n = self.prior.k_0 + count
        nu_n = self.prior.nu_0 + count
        scaleTdistrn = math.sqrt((k_n + 1) / (k_n * (nu_n - Data.D + 1)))
        nu = self.prior.nu_0 + count - Data.D + 1
        x_minus_mu = x - self.tableMeans[tableId]
        lTriangularChol = self.tableCholeskyLTriangularMat[
            tableId] * scaleTdistrn
        x_minus_mu = np.linalg(lTriangularChol, x_minus_mu)
        x_minus_mu_T = x_minus_mu.T
        mul = x_minus_mu_T * x_minus_mu
        val = mul[0][0]
        logprob = math.lgamma(
            (nu + Data.D) / 2) - (math.lgamma(nu / 2) + Data.D / 2 *
                                  (math.log(nu) + math.log(math.pi)) +
                                  self.logDeterminants[tableId] +
                                  (nu + Data.D) / 2 * math.log(1 + val / nu))

        return logprob
Example #18
0
def timeit(fn, fargs, n_range, seconds=5):
    print(f'[timeit] {seconds} seconds per N')

    # timeit for N
    bench = []

    for n in n_range:
        args = fargs(n)
        calls = 0

        timer = perf_counter()
        while perf_counter() - timer < seconds:
            fn(args)
            calls += 1
        timer = perf_counter() - timer

        # result
        bench.append([np.e, n, timer / calls])
        print(f'[N={n}] {calls / timer:.2f} calls / sec')

    # estimate complexity
    bench = np.log(bench)
    (alpha, beta), *_ = np.linalg(bench[:, :2], bench[:, -1])
    print(f'estimated O({np.exp(alpha):.3} * N ^ {beta:.3f})')
Example #19
0
def invGeostat(params, data, idata, grid, cm, L, app=None, ui=None):
    """
    Input:
    params:  Instance of lsqrParams class whose parameters have been
             edited in InversionUI or manually

    data:   (m, 15) array :
                          - data[:, 3]     == Tx(i.e. Tx_x, Tx_y, Tx_z)
                          - data[:, 3:6]   == Rx(i.e. Rx_x, Rx_y, Rx_z)
                          - data[:, 6:9]   == data from model(i.e. tt, et, trace_num)
                          - data[:, 9:12]  == TxCosDir
                          - data[:, 12:15] == RxCosDir

    idata: (n,) bool array:
                          - Values at a one index of this vector will be True if the mog.in_vect is True and mog.tt vector does not
                            equal -1.0 at this same index

                            ex:
                                mog.tt = np.array([ -1.0, 87.341, 79.649, -1.0])
                                mog.in_vect = np.array([ 1, 1, 0, 0])

                                idata = np.array([ False, True, False, False])

    grid: instance of Grid class

    cm : Covar model used

    L:
        First iteration:
                        - Sparse matrix which contains the trajectory of straight rays.
                        Rays are straight because we assume to have a homogeneous slowness/velocity model.

        Second iteration and more:
                                  - Sparse matrix which contains the tracjectory of curved rays.
                                  Rays are now curved because we've been able to build our
                                  slowness/velocity model from the scipy.sparse.linalg.lsqr method.

    app:
        if using Bh_Tomo/InversionUI:
            The application which contains the InversionUI QWidget.
            We need it to process the ui events such as the resfresh of the invFig

        if not using Bh_Tomo/InversionUI::
            app is set to none

    ui: the InversionUI QWidget
    """

    # First we call a Tomo class instance. It will hold the data we will process along the way.
    tomo = Tomo()

    if data.shape[1] >= 9:
        tomo.no_trace = data[:, 8]

    if np.all(L == 0):
        # We get the straights rays for the first iteration
        L = grid.getForwardStraightRays(idata)

    tomo.x = 0.5 * (grid.grx[0:-1] + grid.grx[1:])
    tomo.z = 0.5 * (grid.grz[0:-1] + grid.grz[1:])

    if not np.all(grid.gry == 0):
        tomo.y = 0.5 * (grid.gry[0:-2] + grid.gry[1:-1])
    else:
        tomo.y = np.array([])

    cont = np.array([])

    xc = grid.getCellCenter()
    Cm = cm.compute(xc, xc)

    # TODO : Test, indices may not work
    if cont.size > 0 and params.useCont == 1:
        indc = grid.getContIndices(cont, xc)
        Cm0 = Cm[indc, :]
        Cmc = Cm[indc, indc]
        Cmc = Cmc + np.diag(cont[:, -1])

    c0 = np.array([])
    if np.size(data[0, :]) > 7 and cm.use_c0 == 1:
        if (data[:, 7] != 0).all():
            c0 = data[:, 7]**2

    for noIter in range(params.numItCurved + params.numItStraight + 1):
        if noIter == 1:
            l_moy = np.mean(data[:, 6] / np.sum(L.A, axis=1))
        else:
            l_moy = np.mean(tomo.s)
        mta = np.sum(L.A * l_moy, axis=1)
        dt = data[:, 6] - mta

        #TODO: Add Simulation param
        doSim = 0
        #if params.doSim==1 and noIter==(params.numItStraight+params.numItCurved):
        #    doSim = 1

        if np.size(c0) == 0:
            Cd = L * Cm * L.T + cm.nugget_data * np.eye(np.size(L.A[:, 0]))
        else:
            Cd = L * Cm * L.T + cm.nugget_data * np.diag(c0)

        Cdm = L * Cm

        if doSim == 0:

            # TODO : Fix and test this part
            if np.size(cont) > 0 and params.useCont == 1:
                scont = cont[:, -2] - l_moy
                C = np.concatenate((np.concatenate(Cmc, Cdm[:, indc].T),
                                    np.concatenate(Cdm[:, indc], Cd)))
                C = C + np.eye(np.size(C)) * 1e-6
                # dual cokriging (see Gloaguen et al 2005)
                Gamma = np.linalg(C, np.concatenate(
                    (scont, dt))).reshape(-1, 1).T
                m = Gamma.dot(np.concatenate((Cm0, Cdm))).T
            else:
                Gamma = np.linalg.solve(Cd, dt).reshape(-1, 1).T
                m = Gamma.dot(Cdm).T

            if params.tomoAtt == 1:
                #neative attenuation set to zero
                m[m < -l_moy] = -l_moy

            tomo.s = m + l_moy
        # TODO : Implement simulation
        #else:
        #

        if params.tomoAtt == 0 and noIter >= params.numItStraight and params.numItCurved > 0:
            if np.any(tomo.s < 0):
                print("Negative Slownesses: Change Inversion Parameters")
                #tomo = np.array([])
            _, L, tomo.rays = grid.raytrace(tomo.s, data[:, 0:3], data[:, 3:6])

        if params.saveInvData == 1:
            tt = L.dot(tomo.s)
            tomo.invData.res = data[:, 6] - tt
            tomo.invData.s = tomo.s

        if ui is not None:
            ui.InvIterationDone.emit(noIter + 1, tomo.s, "Geostatistic")

    tomo.L = L

    if ui is not None:
        ui.InvDone.emit(noIter, "Geostatistic")
    else:
        print('Geostatistic Inversion - Finished, {} Iterations Done'.format(
            noIter))

    return tomo
Example #20
0
 def update(self, observation: Gaussian) -> None:
     kalman = self.covariance @ np.linalg( self.covariance + observation.covariance)
     self.mean = self.mean + kalman @ (observation.mean + self.mean)
     self.covariance = self.covariance - kalman @ self.covariance
     self.normalize()
Example #21
0
def eckart_align(geom1,geom2,masses,rfrac,max_iter=200):

    COMreact = np.sum(manage_xyz.xyz_to_np(geom1) * np.outer(masses, [1.0]*3), 0) / np.sum(masses)

    COMproduct = np.sum(manage_xyz.xyz_to_np(geom2) * np.outer(masses, [1.0]*3), 0) / np.sum(masses)

    xyzreact = manage_xyz.xyz_to_np(geom1)
    xyzproduct = manage_xyz.xyz_to_np(geom2)

    # Convert to MW coordinates
    mwcreact = xyzreact*units.ANGSTROM_TO_AU*np.outer(np.sqrt(masses),[1.0]*3)
    mwcproduct = xyzproduct*units.ANGSTROM_TO_AU*np.outer(np.sqrt(masses),[1.0]*3)
    thetas = np.zeros(3)
    total_thetas = np.zeros(3)
    rot_mat = np.zeros((3,3))

    if rfrac < 1.:
        max_iter=1

    for i in range(maxiter):

        # get gradmag
        grad = np.zeros(3)
        for atom1,atom2 in zip(mwcreact,mwcproduct):
            grad[0] += 2*(atom1[1]*atom2[2]-atom1[2]*atom2[1])
            grad[1] += 2*(atom1[2]*atom2[0]-atom1[0]*atom2[2])
            grad[2] += 2*(atom1[0]*atom2[1]-atom1[1]*atom2[0])
        gradmag = np.linalg(grad)
        print(" the gradient of the Eckart distance is %5.4f" % gradmag)

        # get hessian
        dot = np.dot(mwcreact.flatten(),mwcproduct.flatten())
        xd = np.zeros((3,3))
        for atom1,atom2 in zip(mwcreact,mwcproduct):
            xd[0,0] += atom1[0]*atom2[0]
            xd[1,1] += atom1[1]*atom2[1]
            xd[2,2] += atom1[2]*atom2[2]
            xd[1,0] += atom1[1]*atom2[0]
            xd[2,0] += atom1[2]*atom2[0]
            xd[2,1] += atom1[2]*atom2[1]
        xd[0,1] = xd[1,0]
        xd[0,2] = xd[2,0]
        xd[1,2] = xd[2,1]
        hess = np.zeros((3,3))
        hess[0,0] = 2*(dot-xd[0,0])
        hess[1,1] = 2*(dot-xd[1,1])
        hess[2,2] = 2*(dot-xd[2,2])
        hess[1,0] = -2*xd[1,0]
        hess[2,0] = -2*xd[2,0]
        hess[2,1] = -2*xd[2,1]
        hess[0,1] = hess[1,0]
        hess[0,2] = hess[2,0]
        hess[1,2] = hess[2,1]

        hess_evals,hess_evecs = np.linalg.eigh(hess)

        mag_thetas = np.linalg.norm(thetas)

        if gradmag<tol and all(hess_evals>0.):
            break
        
        temp=0.
        vec_index=0
        for j in range(3):
            if hess_evals[j]<temp and abs(hess_evals[j])>0.01:
                temp = hess_evals[j]
                vec_index=j


        if vec_index!=0:
            # Rotate around structure
            RotMat = np.zeros((3,3))
            vec = hess_evecs[vec_index]
            RotMat[0,0] = 2*vec[0]*vec[0] -1
            RotMat[1,1] = 2*vec[1]*vec[1] -1
            RotMat[2,2] = 2*vec[2]*vec[2] -1
            RotMat[1,0] = 2*vec[0]*vec[1]
            RotMat[2,0] = 2*vec[2]*vec[0]
            RotMat[2,1] = 2*vec[2]*vec[1]
            RotMat[0,1] = RotMat[1,0]
            RotMat[0,2] = RotMat[2,0]
            RotMat[1,2] = RotMat[2,1]

            # rotate product
            mwcprod = np.dot(mwcprod,RotMat)

        hess_inverse = np.linalg.inv(hess)

        thetas = np.dot(hess_inverse,grad)
        thetas -= np.ones(3)*rfrac
        total_thetas += thetas

        x = thetas[0]
        y= thetas[1]
        z = thetas[2]
        rot_mat[0,0] = np.cos(y)*np.cos(z)
        rot_mat[0,1] = -np.cos(y)*np.sin(z)
        rot_mat[0,2] = np.sin(y)
        rot_mat[1,0] = np.sin(x)*np.sin(y)*np.cos(z) + np.cos(x)*np.sin(z)
        rot_mat[1,1] = -np.sin(x)*np.sin(y)*np.sin(z) + np.cos(x)*np.cos(z)
        rot_mat[1,2] = -np.sin(x)*np.cos(y)
        rot_mat[2,0] = -np.cos(x)*np.sin(y)*np.cos(z) + np.sin(x)*np.sin(z)
        rot_mat[2,1] = np.cos(x)*np.sin(y)*np.sin(z) + np.sin(x)*np.cos(z)
        rot_mat[2,2] = np.cos(x)*np.cos(y)
Example #22
0
 def pointProjection(P, A, B):
     AP = P - A
     AB = B - A
     return np.dot(AP, AB) / np.linalg(AB)
Example #23
0
z_x_emb = x_emb[:, 2]

x_c = np.average(x_x_emb)
y_c = np.average(y_x_emb)
z_c = np.average(z_x_emb)

np.save('z_axis', z_x_emb)
np.save('corrdinates', x_emb)

ax.scatter(x_c, y_c, z_c)
ax.scatter(x_x_emb, y_x_emb, z_x_emb, color='red')

cent = [x_c, y_c, z_c]
sum = 0
for i in x_emb:
    dist = np.linalg(i - cent)
    sum = sum + dist

avg = sum / 8

u, v = np.mgrid[0:2 * np.pi:20j, 0:np.pi:10j]
x = np.cos(u) * np.sin(v)
y = np.sin(u) * np.sin(v)
z = np.cos(v)
ax.plot_wireframe(x, y, z, color="r")

ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()
Example #24
0
def FEEigenSolver(a):
    values, vectors = np.linalg(a)

    freq = sqrt(values)
Example #25
0
def normalize(v):
    norm = np.linalg(np.array(v))
    for i in range(len(v)):
        v[i] = v[i]/norm
    return v
Example #26
0
def cos_sim(v1, v2):
    dot_product = v1 * v2
    denom = np.linalg(v1) * np.linalg(v2)
    return dot_product / denom
Example #27
0
sys.path.append('..')
import numpy as np
from common.util import most_similar, create_co_matrix, ppmi
from dataset import ptb

window_size = 2
wordvec_size = 100

corpus, word_to_id, id_to_word = ptb.load_data('train')
vocab_size = len(word_to_id)
C = create_co_matrix(corpus, vocab_size, window_size)
W = ppmi(C, verbose=True)

print("SVD계산")
try:
    from sklearn.utils.extmath import randomized_svd
    U, S, V = randomized_svd(W,
                             n_components=wordvec_size,
                             n_iter=5,
                             random_state=None)

except ImportError:
    print("sklearn 모듈 불러오기 실패")
    U, S, V = np.linalg(W)

word_vecs = U[:, :wordvec_size]

querys = ['you', 'year', 'car', 'toyota']
for query in querys:
    most_similar(query, word_to_id, id_to_word, word_vecs, top=5)
	
	n, m = X_0.shape
	predictions = [] 
  def preprocessing(raw_data = X_0):
		
    def regressor(reg_data = raw_data):
      pred = []; 
      j = np.arange(m)
      for i in range(n):
        slope = ((reg_data[i] @ j) - (reg_data[0, i]*j.sum()))/(j@j)
        pred.append(slope*(m+1)+reg_data[0, i]);
      pred = np.array(pred).reshape(-1, 1);
      reg_data = np.hstack((reg_data, pred));
      return reg_data;
    raw_data = regressor(raw_data)[:, 1:]
    return raw_data
  if X_1 == None:
		X_1 = preprocessing();
		
	U, S, V = np.linalg(X_0);
	A_tilde = U.T @ X_1 @ V.T @ (1/np.diag(S))
	W, L = np.eig(A_tilde)
	Phi = X_1 @ V.T @ (1/np.diag(S)) @ W
	for i in range(1, threshold):
		eigenvalues = np.diag(L**(i-1))
		x_i = Phi @ eigenvalues @ np.linalg.pinv(Phi) @ 
		
	
	
      
Example #29
0
def normalizeRows(x):

    x_norm = np.linalg(x, axis=1, keepdims=True)
    x = x / x_norm

    return x
a = np.array([0,1,2])
print(type(a[0][0]))

b=np.array([[1,2],[3,4]],dtype=complex)
print(type(b[0][0]))

c=np.zeros([2,3])

d=np.ones([2,3])

e=np.empty((2,3))

f=np.ones([2,3,4])
print(type(f))

g=np.ones([2,3,4,5])


h=np.arange(10,30,5)

i=np.array(range(0,5,1.5))#range float not accepted

j=np.arange(0,2,0.2)

#import pi 
k=np.linspace(0,2,9)

l=np.linspace(0,2*pi,100)
np.linalg()
Example #31
0
            defects = cv2.convexityDefects(c, dfct)

            if defects is not None:

                inicio = []
                fin = []
                dedos = 

                for i in range(defects.shape[0]):
                    s,e,f,d = defects[i,0]
                    start = c[s][0]
                    end = c[e][0]
                    far = c[f][0]

                    #Angulo entre el punto inicial y el final
                    a = np.linalg(far-end)
                    b = np.linalg(far-start)
                    c = np.linalg(start-end)

                    angulo = np.arccos((np.power(a,2) + np.power(b,2) - np.power(c,2)) / (2*a*b))
                    angulo = np.degrees(angulo)
                    angulo = int(angulo)

                    #Ajustar estos parámetros
                    if np.linalg.norm(start-end) > 20 and d > 12000 and angulo < 90:

                        #Almacenando los puntos para contar los dedos
                        inicio.append(start)
                        fin.append(end)

                        cv2.circle(ROI, tuple(start), 5, (204,204,0), 2)
Example #32
0
def loss(X, Z, W):
    L = np.linalg(X - np.matmul(W, Z))
    P = size(L)

    return L